Compare commits
24 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Timmy
|
3595df4d9d | ||
 dave
|
5d84100c41 | ||
|
dave
|
dd436ad186 | ||
|
dave
|
b811b9188f | ||
|
dave
|
9935311c35 | ||
|
dave
|
be0036922a | ||
|
dave
|
361f9dff0d | ||
|
dave
|
fc160b5c5f | ||
|
dave
|
9092b8a2c9 | ||
|
dave
|
dfe3d96313 | ||
|
dave
|
bcefa6a25d | ||
|
dave
|
50bfeddcb5 | ||
|
dave
|
8e6b8ef338 | ||
|
dave
|
d363eb63e2 | ||
|
dave
|
422cec370d | ||
|
dave
|
973b7d6f72 | ||
|
dave
|
49b78f3642 | ||
|
dave
|
93576e3f83 | ||
|
dave
|
dd7f71dd87 | ||
|
dave
|
9a8492c72f | ||
|
dave
|
ac9bdde164 | ||
|
dave
|
0b2ec64c74 | ||
|
dave
|
fe0a032e8e | ||
|
dave
|
eff8f6a6a6 |
+9
-4
@@ -9,16 +9,21 @@
|
||||
|
||||
When you start a new session with this project:
|
||||
|
||||
1. **Check for MCP Tools:** Read `.mcp.json` to discover the MCP server endpoint. Then list available tools by calling:
|
||||
1. **Check Setup Wizard:** Call `wizard_status` to check if project setup is complete. If the wizard is not complete, guide the user through the remaining steps. Important rules for the wizard flow:
|
||||
- **Be conversational.** Don't show tool names, step numbers, or raw wizard output to the user.
|
||||
- **On projects with existing code:** Read the codebase and generate each file, then show the user what you wrote and ask if it looks right.
|
||||
- **On bare projects with no code:** Ask the user what they want to build, what language/framework they plan to use, and generate files from their answers.
|
||||
- Use `wizard_generate` to create content, show it to the user, then call `wizard_confirm` (they approve), `wizard_retry` (they want changes), or `wizard_skip` (they want to skip this step).
|
||||
2. **Check for MCP Tools:** Read `.mcp.json` to discover the MCP server endpoint. Then list available tools by calling:
|
||||
```bash
|
||||
curl -s "$(jq -r '.mcpServers["storkit"].url' .mcp.json)" \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
|
||||
```
|
||||
This returns the full tool catalog (create stories, spawn agents, record tests, manage worktrees, etc.). Familiarize yourself with the available tools before proceeding. These tools allow you to directly manipulate the workflow and spawn subsidiary agents without manual file manipulation.
|
||||
2. **Read Context:** Check `.story_kit/specs/00_CONTEXT.md` for high-level project goals.
|
||||
3. **Read Stack:** Check `.story_kit/specs/tech/STACK.md` for technical constraints and patterns.
|
||||
4. **Check Work Items:** Look at `.story_kit/work/1_backlog/` and `.story_kit/work/2_current/` to see what work is pending.
|
||||
3. **Read Context:** Check `.storkit/specs/00_CONTEXT.md` for high-level project goals.
|
||||
4. **Read Stack:** Check `.storkit/specs/tech/STACK.md` for technical constraints and patterns.
|
||||
5. **Check Work Items:** Look at `.storkit/work/1_backlog/` and `.storkit/work/2_current/` to see what work is pending.
|
||||
|
||||
|
||||
---
|
||||
|
||||
+114
-48
@@ -63,30 +63,52 @@ system_prompt = "You are a full-stack engineer working autonomously in a git wor
|
||||
[[agent]]
|
||||
name = "qa-2"
|
||||
stage = "qa"
|
||||
role = "Reviews coder work in worktrees: runs quality gates, generates testing plans, and reports findings."
|
||||
role = "Reviews coder work in worktrees: runs quality gates, verifies acceptance criteria, and reports findings."
|
||||
model = "sonnet"
|
||||
max_turns = 40
|
||||
max_budget_usd = 4.00
|
||||
prompt = """You are the QA agent for story {{story_id}}. Your job is to review the coder's work in the worktree and produce a structured QA report.
|
||||
prompt = """You are the QA agent for story {{story_id}}. Your job is to verify the coder's work satisfies the story's acceptance criteria and produce a structured QA report.
|
||||
|
||||
Read CLAUDE.md first, then .story_kit/README.md to understand the dev process.
|
||||
|
||||
## Your Workflow
|
||||
|
||||
### 1. Code Quality Scan
|
||||
- Run `git diff master...HEAD --stat` to see what files changed
|
||||
- Run `git diff master...HEAD` to review the actual changes for obvious coding mistakes (unused imports, dead code, unhandled errors, hardcoded values)
|
||||
- Run `cargo clippy --all-targets --all-features` and note any warnings
|
||||
### 0. Read the Story
|
||||
- Read the story file at `.storkit/work/3_qa/{{story_id}}.md`
|
||||
- Extract every acceptance criterion (the `- [ ]` checkbox lines)
|
||||
- Keep this list in mind for Step 3
|
||||
|
||||
### 1. Deterministic Gates (Prerequisites)
|
||||
Run these first — if any fail, reject immediately without proceeding to AC review:
|
||||
- Run `cargo clippy --all-targets --all-features` — must show 0 errors, 0 warnings
|
||||
- Run `cargo test` and verify all tests pass
|
||||
- If a `frontend/` directory exists:
|
||||
- Run `npm run build` and note any TypeScript errors
|
||||
- Run `npx @biomejs/biome check src/` and note any linting issues
|
||||
- Run `npm test` and verify all frontend tests pass
|
||||
|
||||
### 2. Test Verification
|
||||
- Run `cargo test` and verify all tests pass
|
||||
- If `frontend/` exists: run `npm test` and verify all frontend tests pass
|
||||
- Review test quality: look for tests that are trivial or don't assert meaningful behavior
|
||||
### 2. Code Change Review
|
||||
- Run `git diff master...HEAD --stat` to see what files changed
|
||||
- Run `git diff master...HEAD` to review the actual changes
|
||||
- Flag any incomplete implementations:
|
||||
- `todo!()`, `unimplemented!()`, `panic!()` used as stubs
|
||||
- Placeholder strings like "TODO", "FIXME", "not implemented"
|
||||
- Empty match arms or arms that just return `Default::default()`
|
||||
- Hardcoded values where real logic is expected
|
||||
- Note any obvious coding mistakes (unused imports, dead code, unhandled errors)
|
||||
|
||||
### 3. Manual Testing Support
|
||||
### 3. Acceptance Criteria Review
|
||||
For each AC extracted in Step 0:
|
||||
- Review the diff and test files to determine if the code addresses this AC
|
||||
- PASS: describe specifically how the code addresses it (which file/function/test)
|
||||
- FAIL: explain exactly what is missing or incorrect
|
||||
|
||||
An AC fails if:
|
||||
- No code change or test relates to it
|
||||
- The implementation is stubbed out (todo!/unimplemented!)
|
||||
- A test exists but doesn't actually assert the behaviour described
|
||||
|
||||
### 4. Manual Testing Support (only if all gates PASS and all ACs PASS)
|
||||
- Build the server: run `cargo build` and note success/failure
|
||||
- If build succeeds: find a free port (try 3010-3020) and attempt to start the server
|
||||
- Generate a testing plan including:
|
||||
@@ -95,8 +117,8 @@ Read CLAUDE.md first, then .story_kit/README.md to understand the dev process.
|
||||
- curl commands to exercise relevant API endpoints
|
||||
- Kill the test server when done: `pkill -f 'target.*storkit' || true` (NEVER use `pkill -f storkit` — it kills the vite dev server)
|
||||
|
||||
### 4. Produce Structured Report
|
||||
Print your QA report to stdout before your process exits. The server will automatically run acceptance gates. Use this format:
|
||||
### 5. Produce Structured Report and Verdict
|
||||
Print your QA report to stdout. Then call `approve_qa` or `reject_qa` via the MCP tool based on the overall result. Use this format:
|
||||
|
||||
```
|
||||
## QA Report for {{story_id}}
|
||||
@@ -105,27 +127,38 @@ Print your QA report to stdout before your process exits. The server will automa
|
||||
- clippy: PASS/FAIL (details)
|
||||
- TypeScript build: PASS/FAIL/SKIP (details)
|
||||
- Biome lint: PASS/FAIL/SKIP (details)
|
||||
- Code review findings: (list any issues found, or "None")
|
||||
|
||||
### Test Verification
|
||||
- cargo test: PASS/FAIL (N tests)
|
||||
- npm test: PASS/FAIL/SKIP (N tests)
|
||||
- Test quality issues: (list any trivial/weak tests, or "None")
|
||||
- Incomplete implementations: (list any todo!/unimplemented!/stubs found, or "None")
|
||||
- Other code review findings: (list any issues found, or "None")
|
||||
|
||||
### Acceptance Criteria Review
|
||||
- AC: <criterion text>
|
||||
Result: PASS/FAIL
|
||||
Evidence: <how the code addresses it, or what is missing>
|
||||
|
||||
(repeat for each AC)
|
||||
|
||||
### Manual Testing Plan
|
||||
- Server URL: http://localhost:PORT (or "Build failed")
|
||||
- Pages to visit: (list)
|
||||
- Things to check: (list)
|
||||
- curl commands: (list)
|
||||
- Server URL: http://localhost:PORT (or "Skipped — gate/AC failure" or "Build failed")
|
||||
- Pages to visit: (list, or "N/A")
|
||||
- Things to check: (list, or "N/A")
|
||||
- curl commands: (list, or "N/A")
|
||||
|
||||
### Overall: PASS/FAIL
|
||||
Reason: (summary of why it passed or the primary reason it failed)
|
||||
```
|
||||
|
||||
After printing the report:
|
||||
- If Overall is PASS: call `approve_qa(story_id='{{story_id}}')` via MCP
|
||||
- If Overall is FAIL: call `reject_qa(story_id='{{story_id}}', notes='<concise reason>')` via MCP so the coder knows exactly what to fix
|
||||
|
||||
## Rules
|
||||
- Do NOT modify any code — read-only review only
|
||||
- If the server fails to start, still provide the testing plan with curl commands
|
||||
- The server automatically runs acceptance gates when your process exits"""
|
||||
system_prompt = "You are a QA agent. Your job is read-only: review code quality, run tests, try to start the server, and produce a structured QA report. Do not modify code. The server automatically runs acceptance gates when your process exits."
|
||||
- Gates must pass before AC review — a gate failure is an automatic reject
|
||||
- If any AC is not met, the overall result is FAIL
|
||||
- Always call approve_qa or reject_qa — never leave the story without a verdict"""
|
||||
system_prompt = "You are a QA agent. Your job is read-only: run quality gates, verify each acceptance criterion against the diff, and produce a structured QA report. Always call approve_qa or reject_qa via MCP to record your verdict. Do not modify code."
|
||||
|
||||
[[agent]]
|
||||
name = "coder-opus"
|
||||
@@ -140,30 +173,52 @@ system_prompt = "You are a senior full-stack engineer working autonomously in a
|
||||
[[agent]]
|
||||
name = "qa"
|
||||
stage = "qa"
|
||||
role = "Reviews coder work in worktrees: runs quality gates, generates testing plans, and reports findings."
|
||||
role = "Reviews coder work in worktrees: runs quality gates, verifies acceptance criteria, and reports findings."
|
||||
model = "sonnet"
|
||||
max_turns = 40
|
||||
max_budget_usd = 4.00
|
||||
prompt = """You are the QA agent for story {{story_id}}. Your job is to review the coder's work in the worktree and produce a structured QA report.
|
||||
prompt = """You are the QA agent for story {{story_id}}. Your job is to verify the coder's work satisfies the story's acceptance criteria and produce a structured QA report.
|
||||
|
||||
Read CLAUDE.md first, then .story_kit/README.md to understand the dev process.
|
||||
|
||||
## Your Workflow
|
||||
|
||||
### 1. Code Quality Scan
|
||||
- Run `git diff master...HEAD --stat` to see what files changed
|
||||
- Run `git diff master...HEAD` to review the actual changes for obvious coding mistakes (unused imports, dead code, unhandled errors, hardcoded values)
|
||||
- Run `cargo clippy --all-targets --all-features` and note any warnings
|
||||
### 0. Read the Story
|
||||
- Read the story file at `.storkit/work/3_qa/{{story_id}}.md`
|
||||
- Extract every acceptance criterion (the `- [ ]` checkbox lines)
|
||||
- Keep this list in mind for Step 3
|
||||
|
||||
### 1. Deterministic Gates (Prerequisites)
|
||||
Run these first — if any fail, reject immediately without proceeding to AC review:
|
||||
- Run `cargo clippy --all-targets --all-features` — must show 0 errors, 0 warnings
|
||||
- Run `cargo test` and verify all tests pass
|
||||
- If a `frontend/` directory exists:
|
||||
- Run `npm run build` and note any TypeScript errors
|
||||
- Run `npx @biomejs/biome check src/` and note any linting issues
|
||||
- Run `npm test` and verify all frontend tests pass
|
||||
|
||||
### 2. Test Verification
|
||||
- Run `cargo test` and verify all tests pass
|
||||
- If `frontend/` exists: run `npm test` and verify all frontend tests pass
|
||||
- Review test quality: look for tests that are trivial or don't assert meaningful behavior
|
||||
### 2. Code Change Review
|
||||
- Run `git diff master...HEAD --stat` to see what files changed
|
||||
- Run `git diff master...HEAD` to review the actual changes
|
||||
- Flag any incomplete implementations:
|
||||
- `todo!()`, `unimplemented!()`, `panic!()` used as stubs
|
||||
- Placeholder strings like "TODO", "FIXME", "not implemented"
|
||||
- Empty match arms or arms that just return `Default::default()`
|
||||
- Hardcoded values where real logic is expected
|
||||
- Note any obvious coding mistakes (unused imports, dead code, unhandled errors)
|
||||
|
||||
### 3. Manual Testing Support
|
||||
### 3. Acceptance Criteria Review
|
||||
For each AC extracted in Step 0:
|
||||
- Review the diff and test files to determine if the code addresses this AC
|
||||
- PASS: describe specifically how the code addresses it (which file/function/test)
|
||||
- FAIL: explain exactly what is missing or incorrect
|
||||
|
||||
An AC fails if:
|
||||
- No code change or test relates to it
|
||||
- The implementation is stubbed out (todo!/unimplemented!)
|
||||
- A test exists but doesn't actually assert the behaviour described
|
||||
|
||||
### 4. Manual Testing Support (only if all gates PASS and all ACs PASS)
|
||||
- Build the server: run `cargo build` and note success/failure
|
||||
- If build succeeds: find a free port (try 3010-3020) and attempt to start the server
|
||||
- Generate a testing plan including:
|
||||
@@ -172,8 +227,8 @@ Read CLAUDE.md first, then .story_kit/README.md to understand the dev process.
|
||||
- curl commands to exercise relevant API endpoints
|
||||
- Kill the test server when done: `pkill -f 'target.*storkit' || true` (NEVER use `pkill -f storkit` — it kills the vite dev server)
|
||||
|
||||
### 4. Produce Structured Report
|
||||
Print your QA report to stdout before your process exits. The server will automatically run acceptance gates. Use this format:
|
||||
### 5. Produce Structured Report and Verdict
|
||||
Print your QA report to stdout. Then call `approve_qa` or `reject_qa` via the MCP tool based on the overall result. Use this format:
|
||||
|
||||
```
|
||||
## QA Report for {{story_id}}
|
||||
@@ -182,27 +237,38 @@ Print your QA report to stdout before your process exits. The server will automa
|
||||
- clippy: PASS/FAIL (details)
|
||||
- TypeScript build: PASS/FAIL/SKIP (details)
|
||||
- Biome lint: PASS/FAIL/SKIP (details)
|
||||
- Code review findings: (list any issues found, or "None")
|
||||
|
||||
### Test Verification
|
||||
- cargo test: PASS/FAIL (N tests)
|
||||
- npm test: PASS/FAIL/SKIP (N tests)
|
||||
- Test quality issues: (list any trivial/weak tests, or "None")
|
||||
- Incomplete implementations: (list any todo!/unimplemented!/stubs found, or "None")
|
||||
- Other code review findings: (list any issues found, or "None")
|
||||
|
||||
### Acceptance Criteria Review
|
||||
- AC: <criterion text>
|
||||
Result: PASS/FAIL
|
||||
Evidence: <how the code addresses it, or what is missing>
|
||||
|
||||
(repeat for each AC)
|
||||
|
||||
### Manual Testing Plan
|
||||
- Server URL: http://localhost:PORT (or "Build failed")
|
||||
- Pages to visit: (list)
|
||||
- Things to check: (list)
|
||||
- curl commands: (list)
|
||||
- Server URL: http://localhost:PORT (or "Skipped — gate/AC failure" or "Build failed")
|
||||
- Pages to visit: (list, or "N/A")
|
||||
- Things to check: (list, or "N/A")
|
||||
- curl commands: (list, or "N/A")
|
||||
|
||||
### Overall: PASS/FAIL
|
||||
Reason: (summary of why it passed or the primary reason it failed)
|
||||
```
|
||||
|
||||
After printing the report:
|
||||
- If Overall is PASS: call `approve_qa(story_id='{{story_id}}')` via MCP
|
||||
- If Overall is FAIL: call `reject_qa(story_id='{{story_id}}', notes='<concise reason>')` via MCP so the coder knows exactly what to fix
|
||||
|
||||
## Rules
|
||||
- Do NOT modify any code — read-only review only
|
||||
- If the server fails to start, still provide the testing plan with curl commands
|
||||
- The server automatically runs acceptance gates when your process exits"""
|
||||
system_prompt = "You are a QA agent. Your job is read-only: review code quality, run tests, try to start the server, and produce a structured QA report. Do not modify code. The server automatically runs acceptance gates when your process exits."
|
||||
- Gates must pass before AC review — a gate failure is an automatic reject
|
||||
- If any AC is not met, the overall result is FAIL
|
||||
- Always call approve_qa or reject_qa — never leave the story without a verdict"""
|
||||
system_prompt = "You are a QA agent. Your job is read-only: run quality gates, verify each acceptance criterion against the diff, and produce a structured QA report. Always call approve_qa or reject_qa via MCP to record your verdict. Do not modify code."
|
||||
|
||||
[[agent]]
|
||||
name = "mergemaster"
|
||||
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
---
|
||||
name: "Setup wizard interviews user on bare projects with no existing code"
|
||||
---
|
||||
|
||||
# Story 433: Setup wizard interviews user on bare projects with no existing code
|
||||
|
||||
## User Story
|
||||
|
||||
As a developer starting a brand new project from an empty directory, I want the setup wizard to ask me what I'm building and what tech stack I plan to use, so that it can generate meaningful CONTEXT.md and STACK.md without any codebase to analyze.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] wizard_generate detects when the project directory has no source code files
|
||||
- [ ] On bare projects, the wizard asks the user what they want to build instead of trying to analyze code
|
||||
- [ ] Wizard asks about intended tech stack, frameworks, and language choices
|
||||
- [ ] Conversation continues until the user confirms the generated CONTEXT.md captures their intent
|
||||
- [ ] STACK.md is generated from the user's stated tech choices rather than from codebase detection
|
||||
- [ ] script/test and script/release are generated with appropriate stubs for the stated stack
|
||||
- [ ] The interview flow works via both MCP tools (Claude Code terminal) and bot commands (Matrix/WhatsApp/Slack)
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
---
|
||||
name: "Wizard auto-checks completion on first conversation"
|
||||
---
|
||||
|
||||
# Story 434: Wizard auto-checks completion on first conversation
|
||||
|
||||
## User Story
|
||||
|
||||
As a developer opening Claude Code on a storkit project for the first time, I want the wizard to automatically check if setup is complete and prompt me through remaining steps, so I don't have to know to ask for it.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] Scaffolded CLAUDE.md includes an IMPORTANT instruction telling Claude to call wizard_status on first conversation
|
||||
- [ ] If wizard is incomplete, Claude guides the user through remaining steps without being asked
|
||||
- [ ] If wizard is already complete, no wizard prompt appears — Claude behaves normally
|
||||
- [ ] Works on both existing projects with code and bare projects with no code
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
---
|
||||
name: "Unblock command handles all stuck states not just blocked flag"
|
||||
---
|
||||
|
||||
# Story 435: Unblock command handles all stuck states not just blocked flag
|
||||
|
||||
## User Story
|
||||
|
||||
As a project owner, I want the unblock command to clear any stuck state on a story — not just the blocked flag — so that I have a single command to unstick stories regardless of why they're stuck.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] Unblock clears merge_failure field in addition to blocked flag
|
||||
- [ ] Unblock clears review_hold field
|
||||
- [ ] Unblock reports which fields were cleared in the confirmation message
|
||||
- [ ] Unblock works on stories in any pipeline stage (backlog, current, qa, merge, done)
|
||||
- [ ] If no stuck state is found (no blocked, merge_failure, or review_hold), returns a clear message saying so
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
---
|
||||
name: "Unify story stuck states into a single status field"
|
||||
---
|
||||
|
||||
# Refactor 436: Unify story stuck states into a single status field
|
||||
|
||||
## Current State
|
||||
|
||||
- TBD
|
||||
|
||||
## Desired State
|
||||
|
||||
Replace the separate blocked, merge_failure, and review_hold front matter fields with a single status field (e.g. status: blocked, status: merge_failure, status: review_hold). Simplifies the unblock command, auto-assign checks, and pipeline advance logic.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] Replace blocked: true, merge_failure: string, and review_hold: true with a single status: field in story front matter
|
||||
- [ ] Auto-assign checks a single field instead of three separate ones
|
||||
- [ ] Pipeline advance and lifecycle code reads/writes the unified status field
|
||||
- [ ] Unblock command clears the status field regardless of which stuck state it was
|
||||
- [ ] retry_count remains a separate field (it's a counter, not a state)
|
||||
- [ ] Migration: existing stories with old fields are handled gracefully on read
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
---
|
||||
name: "QA agent reviews code changes against acceptance criteria"
|
||||
---
|
||||
|
||||
# Story 431: QA agent reviews code changes against acceptance criteria
|
||||
|
||||
## User Story
|
||||
|
||||
As a project owner, I want the QA agent to actually verify that the coder's implementation matches the story's acceptance criteria, so that incomplete or incorrect work is caught before merge.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] QA agent reads the story's acceptance criteria before reviewing code
|
||||
- [ ] QA agent reads the full diff against master to understand what changed
|
||||
- [ ] For each AC, QA agent verifies the code addresses it and explains how
|
||||
- [ ] QA agent flags incomplete implementations: todo!(), unimplemented!(), missing match arms, placeholder values
|
||||
- [ ] QA agent checks that new code has corresponding test coverage
|
||||
- [ ] QA agent produces a structured report: each AC with pass/fail and explanation
|
||||
- [ ] If any AC is not met, QA rejects the story with a clear reason so the coder can fix it
|
||||
- [ ] Deterministic gates (clippy, tests) still run as a prerequisite before the AC review
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
---
|
||||
name: "Complete setup wizard with MCP tools and agent-driven file generation"
|
||||
agent: "coder-opus"
|
||||
---
|
||||
|
||||
# Story 432: Complete setup wizard with MCP tools and agent-driven file generation
|
||||
|
||||
## User Story
|
||||
|
||||
As a developer running storkit init on a new project, I want the setup wizard to walk me through each step interactively — generating files, letting me review them, and confirming before moving on — so that my project is correctly configured without manual file editing.
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [ ] MCP tool wizard_status returns the current wizard state: which step is active, which are done/skipped/pending
|
||||
- [ ] MCP tool wizard_generate triggers the agent to read the codebase and generate content for the current step (CONTEXT.md, STACK.md, script/test, script/release, script/test_coverage)
|
||||
- [ ] MCP tool wizard_confirm confirms the current step and advances to the next
|
||||
- [ ] MCP tool wizard_skip skips the current step and advances to the next
|
||||
- [ ] MCP tool wizard_retry re-generates content for the current step if the user isn't happy with it
|
||||
- [ ] Bot command setup shows wizard progress and the current step with instructions
|
||||
- [ ] Bot command setup confirm / setup skip / setup retry drive the wizard from chat
|
||||
- [ ] Generated files are written to disk only after user confirmation, not during generation preview
|
||||
- [ ] The wizard works from Claude Code terminal via MCP tools without requiring the web UI or chat bot
|
||||
- [ ] Existing files (especially CLAUDE.md) are never overwritten — wizard appends or skips
|
||||
|
||||
## Out of Scope
|
||||
|
||||
- TBD
|
||||
Generated
+1
-1
@@ -4019,7 +4019,7 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
|
||||
|
||||
[[package]]
|
||||
name = "storkit"
|
||||
version = "0.8.0"
|
||||
version = "0.8.1"
|
||||
dependencies = [
|
||||
"async-stream",
|
||||
"async-trait",
|
||||
|
||||
@@ -1,6 +1,37 @@
|
||||
# Storkit
|
||||
|
||||
A story-driven development server that manages work items, spawns coding agents, and runs them through a pipeline from backlog to done. Ships as a single Rust binary with an embedded React frontend. Communicates via Matrix, WhatsApp, and Slack bot transports, and exposes MCP tools for programmatic access.
|
||||
A story-driven development server that manages work items, spawns coding agents, and runs them through a pipeline from backlog to done. Ships as a single Rust binary with an embedded React frontend.
|
||||
|
||||
## Getting started with Claude Code
|
||||
|
||||
1. Download the storkit binary (or build from source — see below).
|
||||
|
||||
2. From your project directory, scaffold and start the server:
|
||||
|
||||
```bash
|
||||
storkit init --port 3000
|
||||
```
|
||||
|
||||
This creates a `.storkit/` directory with the pipeline structure, `project.toml`, and `.mcp.json`. The `.mcp.json` file lets Claude Code discover storkit's MCP tools automatically.
|
||||
|
||||
3. Open a Claude Code session in the same project directory. Claude will pick up the MCP tools from `.mcp.json`.
|
||||
|
||||
4. Tell Claude: "help me set up this project with storkit." Claude will walk you through the setup wizard — generating project context, tech stack docs, and test/release scripts. Review each step and confirm or ask to retry.
|
||||
|
||||
Once setup is complete, Claude can create stories, start agents, check status, and manage the full pipeline via MCP tools — no commands to memorize.
|
||||
|
||||
## Web UI
|
||||
|
||||
Storkit also ships an embedded React frontend. Once the server is running, open `http://localhost:3000` to see the pipeline board, agent status, and chat interface.
|
||||
|
||||
## Chat transports
|
||||
|
||||
Storkit can be controlled via bot commands in **Matrix**, **WhatsApp**, and **Slack**. Configure a transport in `.storkit/bot.toml` — see the example files:
|
||||
|
||||
- `.storkit/bot.toml.matrix.example`
|
||||
- `.storkit/bot.toml.whatsapp-meta.example`
|
||||
- `.storkit/bot.toml.whatsapp-twilio.example`
|
||||
- `.storkit/bot.toml.slack.example`
|
||||
|
||||
## Prerequisites
|
||||
|
||||
@@ -49,7 +80,11 @@ Configuration lives in `.storkit/project.toml`. See `.storkit/bot.toml.*.example
|
||||
Requires a Gitea API token in `.env` (`GITEA_TOKEN=your_token`).
|
||||
|
||||
```bash
|
||||
script/release 0.6.1
|
||||
script/release 0.7.1
|
||||
```
|
||||
|
||||
This bumps version in `Cargo.toml` and `package.json`, builds macOS arm64 and Linux amd64 binaries, tags the repo, and publishes a Gitea release with changelog and binaries attached.
|
||||
|
||||
## License
|
||||
|
||||
GPL-3.0. See [LICENSE](LICENSE).
|
||||
|
||||
Generated
+2
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "living-spec-standalone",
|
||||
"version": "0.8.0",
|
||||
"version": "0.8.1",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "living-spec-standalone",
|
||||
"version": "0.8.0",
|
||||
"version": "0.8.1",
|
||||
"dependencies": {
|
||||
"@types/react-syntax-highlighter": "^15.5.13",
|
||||
"react": "^19.1.0",
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "living-spec-standalone",
|
||||
"private": true,
|
||||
"version": "0.8.0",
|
||||
"version": "0.8.1",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "storkit"
|
||||
version = "0.8.0"
|
||||
version = "0.8.1"
|
||||
edition = "2024"
|
||||
build = "build.rs"
|
||||
|
||||
|
||||
@@ -247,7 +247,7 @@ pub(crate) fn run_squash_merge(
|
||||
.output()
|
||||
.map_err(|e| format!("Failed to check merge diff: {e}"))?;
|
||||
let changed_files = String::from_utf8_lossy(&diff_check.stdout);
|
||||
let has_code_changes = changed_files.lines().any(|f| !f.starts_with(".storkit/"));
|
||||
let has_code_changes = changed_files.lines().any(|f| !f.starts_with(".storkit/work/"));
|
||||
if !has_code_changes {
|
||||
all_output.push_str(
|
||||
"=== Merge commit contains only .storkit/ file moves, no code changes ===\n",
|
||||
@@ -419,9 +419,10 @@ pub(crate) fn run_squash_merge(
|
||||
}
|
||||
|
||||
// Verify HEAD commit has actual code changes (not an empty cherry-pick).
|
||||
// Exclude .storkit/ so that story-file-only commits don't pass this check.
|
||||
// Exclude .storkit/work/ (pipeline file moves) but keep .storkit/project.toml
|
||||
// and other config files which are legitimate deliverables.
|
||||
let diff_stat = Command::new("git")
|
||||
.args(["diff", "--stat", "HEAD~1..HEAD", "--", ".", ":(exclude).storkit"])
|
||||
.args(["diff", "--stat", "HEAD~1..HEAD", "--", ".", ":(exclude).storkit/work"])
|
||||
.current_dir(project_root)
|
||||
.output()
|
||||
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
|
||||
|
||||
@@ -13,6 +13,7 @@ mod help;
|
||||
pub(crate) mod loc;
|
||||
mod move_story;
|
||||
mod overview;
|
||||
mod setup;
|
||||
mod show;
|
||||
mod status;
|
||||
mod timer;
|
||||
@@ -177,9 +178,62 @@ pub fn commands() -> &'static [BotCommand] {
|
||||
description: "Show stories merged to master since the last release tag",
|
||||
handler: unreleased::handle_unreleased,
|
||||
},
|
||||
BotCommand {
|
||||
name: "setup",
|
||||
description: "Show setup wizard progress; or `setup confirm` / `setup skip` / `setup retry` to drive the wizard from chat",
|
||||
handler: setup::handle_setup,
|
||||
},
|
||||
]
|
||||
}
|
||||
|
||||
/// Like [`try_handle_command`] but returns `(plain_body, html_body)`.
|
||||
///
|
||||
/// The plain body is unchanged Markdown text suitable for the Matrix `body`
|
||||
/// field (non-HTML clients). The HTML body is suitable for `formatted_body`.
|
||||
///
|
||||
/// The pipeline-status command (no args) injects Matrix `<font data-mx-color>`
|
||||
/// tags on the traffic-light dots. All other commands produce HTML by running
|
||||
/// the plain body through pulldown-cmark.
|
||||
pub fn try_handle_command_with_html(
|
||||
dispatch: &CommandDispatch<'_>,
|
||||
message: &str,
|
||||
) -> Option<(String, String)> {
|
||||
let command_text = strip_bot_mention(message, dispatch.bot_name, dispatch.bot_user_id);
|
||||
let trimmed = command_text.trim();
|
||||
if !trimmed.is_empty() {
|
||||
let (cmd_name, args) = match trimmed.split_once(char::is_whitespace) {
|
||||
Some((c, a)) => (c, a.trim()),
|
||||
None => (trimmed, ""),
|
||||
};
|
||||
// Only the no-arg status variant shows the pipeline with traffic-light
|
||||
// dots; `status <number>` is a triage dump that needs no colour tags.
|
||||
if cmd_name.eq_ignore_ascii_case("status") && args.is_empty() {
|
||||
let body = status::build_pipeline_status(dispatch.project_root, dispatch.agents);
|
||||
let html = status::build_pipeline_status_html(dispatch.project_root, dispatch.agents);
|
||||
return Some((body, html));
|
||||
}
|
||||
}
|
||||
// Generic path: plain text body → Markdown-to-HTML.
|
||||
let body = try_handle_command(dispatch, message)?;
|
||||
let html = plain_to_html(&body);
|
||||
Some((body, html))
|
||||
}
|
||||
|
||||
/// Convert a Markdown string to HTML using the same options as the Matrix
|
||||
/// transport's `markdown_to_html` helper.
|
||||
fn plain_to_html(markdown: &str) -> String {
|
||||
use pulldown_cmark::{Options, Parser, html};
|
||||
let normalized = crate::chat::util::normalize_line_breaks(markdown);
|
||||
let options = Options::ENABLE_TABLES
|
||||
| Options::ENABLE_FOOTNOTES
|
||||
| Options::ENABLE_STRIKETHROUGH
|
||||
| Options::ENABLE_TASKLISTS;
|
||||
let parser = Parser::new_ext(&normalized, options);
|
||||
let mut out = String::new();
|
||||
html::push_html(&mut out, parser);
|
||||
out
|
||||
}
|
||||
|
||||
/// Try to match a user message against a registered bot command.
|
||||
///
|
||||
/// The message is expected to be the raw body text (e.g., `"@timmy help"`).
|
||||
|
||||
@@ -0,0 +1,266 @@
|
||||
//! Handler for the `setup` bot command.
|
||||
//!
|
||||
//! Drives the setup wizard from any chat transport (Matrix, Slack, WhatsApp).
|
||||
//!
|
||||
//! Usage:
|
||||
//! - `setup` — show wizard progress and current step instructions
|
||||
//! - `setup confirm` — confirm the current step (writes staged content to disk)
|
||||
//! - `setup skip` — skip the current step
|
||||
//! - `setup retry` — discard staged content and reset the current step
|
||||
|
||||
use super::CommandContext;
|
||||
use crate::http::mcp::wizard_tools::{is_script_step, step_output_path, write_if_missing};
|
||||
use crate::io::wizard::{format_wizard_state, StepStatus, WizardState};
|
||||
|
||||
pub(super) fn handle_setup(ctx: &CommandContext) -> Option<String> {
|
||||
let sub = ctx.args.trim().to_ascii_lowercase();
|
||||
|
||||
match sub.as_str() {
|
||||
"" => Some(wizard_status_reply(ctx)),
|
||||
"confirm" => Some(wizard_confirm_reply(ctx)),
|
||||
"skip" => Some(wizard_skip_reply(ctx)),
|
||||
"retry" => Some(wizard_retry_reply(ctx)),
|
||||
_ => Some(format!(
|
||||
"Unknown sub-command `{sub}`. Usage: `setup`, `setup confirm`, `setup skip`, `setup retry`."
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Compose a status reply for the `setup` command (no args).
|
||||
fn wizard_status_reply(ctx: &CommandContext) -> String {
|
||||
match WizardState::load(ctx.project_root) {
|
||||
Some(state) => format_wizard_state(&state),
|
||||
None => {
|
||||
"No setup wizard active. Run `storkit init` in the project root to begin.".to_string()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Confirm the current wizard step, writing any staged content to disk.
|
||||
fn wizard_confirm_reply(ctx: &CommandContext) -> String {
|
||||
let root = ctx.project_root;
|
||||
let mut state = match WizardState::load(root) {
|
||||
Some(s) => s,
|
||||
None => return "No wizard active.".to_string(),
|
||||
};
|
||||
if state.completed {
|
||||
return "Wizard is already complete.".to_string();
|
||||
}
|
||||
|
||||
let idx = state.current_step_index();
|
||||
let step = state.steps[idx].step;
|
||||
let content = state.steps[idx].content.clone();
|
||||
|
||||
// Write content to disk (only if a file path exists and the file is absent).
|
||||
let write_msg =
|
||||
if let (Some(c), Some(ref path)) = (&content, step_output_path(root, step)) {
|
||||
let executable = is_script_step(step);
|
||||
match write_if_missing(path, c, executable) {
|
||||
Ok(true) => format!(" File written: `{}`.", path.display()),
|
||||
Ok(false) => format!(" File `{}` already exists — skipped.", path.display()),
|
||||
Err(e) => return format!("Error: {e}"),
|
||||
}
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
|
||||
if let Err(e) = state.confirm_step(step) {
|
||||
return format!("Cannot confirm step: {e}");
|
||||
}
|
||||
if let Err(e) = state.save(root) {
|
||||
return format!("Failed to save wizard state: {e}");
|
||||
}
|
||||
|
||||
if state.completed {
|
||||
format!(
|
||||
"Step '{}' confirmed.{write_msg}\n\nSetup wizard complete!",
|
||||
step.label()
|
||||
)
|
||||
} else {
|
||||
let next = &state.steps[state.current_step_index()];
|
||||
format!(
|
||||
"Step '{}' confirmed.{write_msg}\n\nNext: {} — run `wizard_generate` to begin.",
|
||||
step.label(),
|
||||
next.step.label()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Skip the current wizard step without writing any file.
|
||||
fn wizard_skip_reply(ctx: &CommandContext) -> String {
|
||||
let root = ctx.project_root;
|
||||
let mut state = match WizardState::load(root) {
|
||||
Some(s) => s,
|
||||
None => return "No wizard active.".to_string(),
|
||||
};
|
||||
if state.completed {
|
||||
return "Wizard is already complete.".to_string();
|
||||
}
|
||||
|
||||
let idx = state.current_step_index();
|
||||
let step = state.steps[idx].step;
|
||||
|
||||
if let Err(e) = state.skip_step(step) {
|
||||
return format!("Cannot skip step: {e}");
|
||||
}
|
||||
if let Err(e) = state.save(root) {
|
||||
return format!("Failed to save wizard state: {e}");
|
||||
}
|
||||
|
||||
if state.completed {
|
||||
format!(
|
||||
"Step '{}' skipped. Setup wizard complete!",
|
||||
step.label()
|
||||
)
|
||||
} else {
|
||||
let next = &state.steps[state.current_step_index()];
|
||||
format!(
|
||||
"Step '{}' skipped.\n\nNext: {} — run `wizard_generate` to begin.",
|
||||
step.label(),
|
||||
next.step.label()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Discard staged content and reset the current step to pending.
|
||||
fn wizard_retry_reply(ctx: &CommandContext) -> String {
|
||||
let root = ctx.project_root;
|
||||
let mut state = match WizardState::load(root) {
|
||||
Some(s) => s,
|
||||
None => return "No wizard active.".to_string(),
|
||||
};
|
||||
if state.completed {
|
||||
return "Wizard is already complete.".to_string();
|
||||
}
|
||||
|
||||
let idx = state.current_step_index();
|
||||
let step = state.steps[idx].step;
|
||||
|
||||
if let Some(s) = state.steps.iter_mut().find(|s| s.step == step) {
|
||||
s.status = StepStatus::Pending;
|
||||
s.content = None;
|
||||
}
|
||||
if let Err(e) = state.save(root) {
|
||||
return format!("Failed to save wizard state: {e}");
|
||||
}
|
||||
|
||||
format!(
|
||||
"Step '{}' reset to pending. Run `wizard_generate` to regenerate content.",
|
||||
step.label()
|
||||
)
|
||||
}
|
||||
|
||||
// ── tests ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::io::wizard::WizardState;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use tempfile::TempDir;
|
||||
|
||||
fn make_ctx<'a>(
|
||||
args: &'a str,
|
||||
project_root: &'a std::path::Path,
|
||||
agents: &'a Arc<crate::agents::AgentPool>,
|
||||
ambient_rooms: &'a Arc<Mutex<HashSet<String>>>,
|
||||
) -> CommandContext<'a> {
|
||||
CommandContext {
|
||||
bot_name: "Bot",
|
||||
args,
|
||||
project_root,
|
||||
agents,
|
||||
ambient_rooms,
|
||||
room_id: "!test:example.com",
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_no_wizard_returns_helpful_message() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4000));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("storkit init"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_with_wizard_shows_status() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".storkit")).unwrap();
|
||||
WizardState::init_if_missing(dir.path());
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4001));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("Setup wizard"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_skip_advances_wizard() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".storkit")).unwrap();
|
||||
WizardState::init_if_missing(dir.path());
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4002));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("skip", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("skipped"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.current_step_index(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_confirm_advances_wizard() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".storkit")).unwrap();
|
||||
WizardState::init_if_missing(dir.path());
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4003));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("confirm", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("confirmed"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.current_step_index(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_retry_resets_step() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".storkit")).unwrap();
|
||||
WizardState::init_if_missing(dir.path());
|
||||
// Stage some content first.
|
||||
{
|
||||
let mut state = WizardState::load(dir.path()).unwrap();
|
||||
state.set_step_status(
|
||||
crate::io::wizard::WizardStep::Context,
|
||||
crate::io::wizard::StepStatus::AwaitingConfirmation,
|
||||
Some("content".to_string()),
|
||||
);
|
||||
state.save(dir.path()).unwrap();
|
||||
}
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4004));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("retry", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("reset"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(
|
||||
state.steps[1].status,
|
||||
crate::io::wizard::StepStatus::Pending
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn setup_unknown_sub_command_returns_usage() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let agents = Arc::new(crate::agents::AgentPool::new_test(4005));
|
||||
let rooms = Arc::new(Mutex::new(HashSet::new()));
|
||||
let ctx = make_ctx("foobar", dir.path(), &agents, &rooms);
|
||||
let result = handle_setup(&ctx).unwrap();
|
||||
assert!(result.contains("Unknown sub-command"));
|
||||
assert!(result.contains("Usage"));
|
||||
}
|
||||
}
|
||||
@@ -122,6 +122,34 @@ fn read_stage_items(
|
||||
items
|
||||
}
|
||||
|
||||
/// Build the HTML `formatted_body` for the pipeline status with Matrix colour
|
||||
/// tags on the traffic-light dots.
|
||||
///
|
||||
/// Converts the plain-text pipeline status (Markdown) to HTML via
|
||||
/// pulldown-cmark and wraps each traffic-light character in a
|
||||
/// `<font data-mx-color="#rrggbb">` tag so Matrix clients display them in
|
||||
/// colour.
|
||||
pub(super) fn build_pipeline_status_html(project_root: &std::path::Path, agents: &AgentPool) -> String {
|
||||
use pulldown_cmark::{Options, Parser, html};
|
||||
|
||||
let plain = build_pipeline_status(project_root, agents);
|
||||
let normalized = crate::chat::util::normalize_line_breaks(&plain);
|
||||
let options = Options::ENABLE_TABLES
|
||||
| Options::ENABLE_FOOTNOTES
|
||||
| Options::ENABLE_STRIKETHROUGH
|
||||
| Options::ENABLE_TASKLISTS;
|
||||
let parser = Parser::new_ext(&normalized, options);
|
||||
let mut html_out = String::new();
|
||||
html::push_html(&mut html_out, parser);
|
||||
|
||||
// Wrap each traffic-light character with a Matrix colour tag.
|
||||
html_out
|
||||
.replace('\u{2717}', "<font data-mx-color=\"#cc0000\">\u{2717}</font>") // ✗ blocked
|
||||
.replace('\u{25D1}', "<font data-mx-color=\"#ffaa00\">\u{25D1}</font>") // ◑ throttled
|
||||
.replace('\u{25CF}', "<font data-mx-color=\"#00cc00\">\u{25CF}</font>") // ● running
|
||||
.replace('\u{25CB}', "<font data-mx-color=\"#888888\">\u{25CB}</font>") // ○ idle
|
||||
}
|
||||
|
||||
/// Build the full pipeline status text formatted for Matrix (markdown).
|
||||
pub(super) fn build_pipeline_status(project_root: &std::path::Path, agents: &AgentPool) -> String {
|
||||
// Build a map from story_id → active AgentInfo for quick lookup.
|
||||
@@ -444,6 +472,81 @@ mod tests {
|
||||
|
||||
// -- traffic_light_dot --------------------------------------------------
|
||||
|
||||
// -- build_pipeline_status_html (colored dots) --------------------------
|
||||
|
||||
#[test]
|
||||
fn html_status_colors_idle_dot_grey() {
|
||||
use std::io::Write;
|
||||
use tempfile::TempDir;
|
||||
|
||||
let tmp = TempDir::new().unwrap();
|
||||
let stage_dir = tmp.path().join(".storkit/work/2_current");
|
||||
std::fs::create_dir_all(&stage_dir).unwrap();
|
||||
|
||||
let story_path = stage_dir.join("42_story_idle.md");
|
||||
let mut f = std::fs::File::create(&story_path).unwrap();
|
||||
writeln!(f, "---\nname: Idle Story\n---\n").unwrap();
|
||||
|
||||
let agents = AgentPool::new_test(3000);
|
||||
let html = build_pipeline_status_html(tmp.path(), &agents);
|
||||
|
||||
assert!(
|
||||
html.contains("<font data-mx-color=\"#888888\">\u{25CB}</font>"),
|
||||
"idle dot should be grey (#888888): {html}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn html_status_colors_blocked_dot_red() {
|
||||
use std::io::Write;
|
||||
use tempfile::TempDir;
|
||||
|
||||
let tmp = TempDir::new().unwrap();
|
||||
let stage_dir = tmp.path().join(".storkit/work/2_current");
|
||||
std::fs::create_dir_all(&stage_dir).unwrap();
|
||||
|
||||
let story_path = stage_dir.join("42_story_blocked.md");
|
||||
let mut f = std::fs::File::create(&story_path).unwrap();
|
||||
writeln!(f, "---\nname: Blocked Story\nblocked: true\n---\n").unwrap();
|
||||
|
||||
let agents = AgentPool::new_test(3000);
|
||||
let html = build_pipeline_status_html(tmp.path(), &agents);
|
||||
|
||||
assert!(
|
||||
html.contains("<font data-mx-color=\"#cc0000\">\u{2717}</font>"),
|
||||
"blocked dot should be red (#cc0000): {html}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn html_status_plain_text_body_unchanged() {
|
||||
use std::io::Write;
|
||||
use tempfile::TempDir;
|
||||
|
||||
let tmp = TempDir::new().unwrap();
|
||||
let stage_dir = tmp.path().join(".storkit/work/2_current");
|
||||
std::fs::create_dir_all(&stage_dir).unwrap();
|
||||
|
||||
let story_path = stage_dir.join("42_story_idle.md");
|
||||
let mut f = std::fs::File::create(&story_path).unwrap();
|
||||
writeln!(f, "---\nname: Idle Story\n---\n").unwrap();
|
||||
|
||||
let agents = AgentPool::new_test(3000);
|
||||
let plain = build_pipeline_status(tmp.path(), &agents);
|
||||
|
||||
// Plain text must still use bare Unicode dots (no HTML tags).
|
||||
assert!(
|
||||
plain.contains('\u{25CB}'),
|
||||
"plain text should have bare Unicode idle dot: {plain}"
|
||||
);
|
||||
assert!(
|
||||
!plain.contains("data-mx-color"),
|
||||
"plain text must not contain HTML colour attributes: {plain}"
|
||||
);
|
||||
}
|
||||
|
||||
// -- traffic_light_dot --------------------------------------------------
|
||||
|
||||
#[test]
|
||||
fn dot_idle_when_no_agent() {
|
||||
assert_eq!(traffic_light_dot(false, false, false), "\u{25CB} "); // ○
|
||||
|
||||
@@ -98,16 +98,28 @@ pub(crate) fn unblock_by_path(path: &Path, story_id: &str) -> String {
|
||||
|
||||
let story_name = meta.name.as_deref().unwrap_or(story_id).to_string();
|
||||
|
||||
if meta.blocked != Some(true) {
|
||||
let has_blocked = meta.blocked == Some(true);
|
||||
let has_merge_failure = meta.merge_failure.is_some();
|
||||
|
||||
if !has_blocked && !has_merge_failure {
|
||||
return format!(
|
||||
"**{story_name}** ({story_id}) is not blocked. Nothing to unblock."
|
||||
);
|
||||
}
|
||||
|
||||
// Clear the blocked flag (reads + writes the file).
|
||||
// Clear the blocked flag if present.
|
||||
if has_blocked {
|
||||
if let Err(e) = clear_front_matter_field(path, "blocked") {
|
||||
return format!("Failed to clear blocked flag on **{story_id}**: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
// Clear merge_failure if present.
|
||||
if has_merge_failure {
|
||||
if let Err(e) = clear_front_matter_field(path, "merge_failure") {
|
||||
return format!("Failed to clear merge_failure on **{story_id}**: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
// Reset retry_count to 0 (re-read the updated file, modify, write).
|
||||
let updated_contents = match std::fs::read_to_string(path) {
|
||||
@@ -119,7 +131,10 @@ pub(crate) fn unblock_by_path(path: &Path, story_id: &str) -> String {
|
||||
return format!("Failed to reset retry_count on **{story_id}**: {e}");
|
||||
}
|
||||
|
||||
format!("Unblocked **{story_name}** ({story_id}). Retry count reset to 0.")
|
||||
let mut cleared = Vec::new();
|
||||
if has_blocked { cleared.push("blocked"); }
|
||||
if has_merge_failure { cleared.push("merge_failure"); }
|
||||
format!("Unblocked **{story_name}** ({story_id}). Cleared: {}. Retry count reset to 0.", cleared.join(", "))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
@@ -186,10 +186,9 @@ pub(super) async fn on_room_message(
|
||||
ambient_rooms: &ctx.ambient_rooms,
|
||||
room_id: &room_id_str,
|
||||
};
|
||||
if let Some(response) = super::super::commands::try_handle_command(&dispatch, &user_message) {
|
||||
if let Some((response, response_html)) = super::super::commands::try_handle_command_with_html(&dispatch, &user_message) {
|
||||
slog!("[matrix-bot] Handled bot command from {sender}");
|
||||
let html = markdown_to_html(&response);
|
||||
if let Ok(msg_id) = ctx.transport.send_message(&room_id_str, &response, &html).await
|
||||
if let Ok(msg_id) = ctx.transport.send_message(&room_id_str, &response, &response_html).await
|
||||
&& let Ok(event_id) = msg_id.parse()
|
||||
{
|
||||
ctx.bot_sent_event_ids.lock().await.insert(event_id);
|
||||
|
||||
@@ -14,8 +14,9 @@ pub mod git_tools;
|
||||
pub mod merge_tools;
|
||||
pub mod qa_tools;
|
||||
pub mod shell_tools;
|
||||
pub mod story_tools;
|
||||
pub mod status_tools;
|
||||
pub mod story_tools;
|
||||
pub mod wizard_tools;
|
||||
|
||||
/// Returns true when the Accept header includes text/event-stream.
|
||||
fn wants_sse(req: &Request) -> bool {
|
||||
@@ -1164,6 +1165,51 @@ fn handle_tools_list(id: Option<Value>) -> JsonRpcResponse {
|
||||
},
|
||||
"required": ["file_path"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "wizard_status",
|
||||
"description": "Return the current setup wizard state: which step is active, and which are done/skipped/pending. Use this to inspect progress before calling wizard_generate, wizard_confirm, wizard_skip, or wizard_retry.",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "wizard_generate",
|
||||
"description": "Drive content generation for the current wizard step. Call with no arguments to mark the step as 'generating' and receive a hint about what to produce. Call again with a 'content' argument (the full file body you generated) to stage it for review. Content is NOT written to disk until wizard_confirm is called.",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"content": {
|
||||
"type": "string",
|
||||
"description": "The generated file content to stage for the current step. Omit to receive a generation hint and mark the step as generating."
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "wizard_confirm",
|
||||
"description": "Confirm the current wizard step: writes any staged content to disk (only if the target file does not already exist) and advances to the next step. Existing files are never overwritten.",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "wizard_skip",
|
||||
"description": "Skip the current wizard step without writing any file. Use when a step does not apply to this project.",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "wizard_retry",
|
||||
"description": "Discard any staged content for the current wizard step and reset it to pending so it can be regenerated. Use when the generated content needs improvement.",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
}
|
||||
}
|
||||
]
|
||||
}),
|
||||
@@ -1258,6 +1304,12 @@ async fn handle_tools_call(
|
||||
"status" => status_tools::tool_status(&args, ctx).await,
|
||||
// File line count
|
||||
"loc_file" => diagnostics::tool_loc_file(&args, ctx),
|
||||
// Setup wizard tools
|
||||
"wizard_status" => wizard_tools::tool_wizard_status(ctx),
|
||||
"wizard_generate" => wizard_tools::tool_wizard_generate(&args, ctx),
|
||||
"wizard_confirm" => wizard_tools::tool_wizard_confirm(ctx),
|
||||
"wizard_skip" => wizard_tools::tool_wizard_skip(ctx),
|
||||
"wizard_retry" => wizard_tools::tool_wizard_retry(ctx),
|
||||
_ => Err(format!("Unknown tool: {tool_name}")),
|
||||
};
|
||||
|
||||
@@ -1376,7 +1428,7 @@ mod tests {
|
||||
assert!(names.contains(&"git_log"));
|
||||
assert!(names.contains(&"status"));
|
||||
assert!(names.contains(&"loc_file"));
|
||||
assert_eq!(tools.len(), 51);
|
||||
assert_eq!(tools.len(), 56);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -0,0 +1,521 @@
|
||||
//! MCP tool implementations for the interactive setup wizard.
|
||||
//!
|
||||
//! These tools allow Claude Code (and other MCP clients) to drive the setup
|
||||
//! wizard entirely from the terminal without requiring the web UI or chat bot.
|
||||
//!
|
||||
//! Typical flow:
|
||||
//! 1. `wizard_status` — inspect current state
|
||||
//! 2. `wizard_generate` — read the codebase and call again with `content` to
|
||||
//! stage generated text for review
|
||||
//! 3. `wizard_confirm` — write staged content to disk and advance the wizard
|
||||
//! 4. `wizard_skip` — skip a step that does not apply
|
||||
//! 5. `wizard_retry` — discard staged content and regenerate from scratch
|
||||
|
||||
use crate::http::context::AppContext;
|
||||
use crate::io::wizard::{StepStatus, WizardState, WizardStep, format_wizard_state};
|
||||
use serde_json::Value;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
// ── helpers ───────────────────────────────────────────────────────────────────
|
||||
|
||||
/// Return the filesystem path (relative to `project_root`) for a step's output.
|
||||
///
|
||||
/// Returns `None` for `Scaffold` since that step has no single output file — it
|
||||
/// creates the full `.storkit/` directory structure and is handled by
|
||||
/// `storkit init` before the server starts.
|
||||
pub(crate) fn step_output_path(project_root: &Path, step: WizardStep) -> Option<std::path::PathBuf> {
|
||||
match step {
|
||||
WizardStep::Context => Some(
|
||||
project_root
|
||||
.join(".storkit")
|
||||
.join("specs")
|
||||
.join("00_CONTEXT.md"),
|
||||
),
|
||||
WizardStep::Stack => Some(
|
||||
project_root
|
||||
.join(".storkit")
|
||||
.join("specs")
|
||||
.join("tech")
|
||||
.join("STACK.md"),
|
||||
),
|
||||
WizardStep::TestScript => Some(project_root.join("script").join("test")),
|
||||
WizardStep::ReleaseScript => Some(project_root.join("script").join("release")),
|
||||
WizardStep::TestCoverage => Some(project_root.join("script").join("test_coverage")),
|
||||
WizardStep::Scaffold => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn is_script_step(step: WizardStep) -> bool {
|
||||
matches!(
|
||||
step,
|
||||
WizardStep::TestScript | WizardStep::ReleaseScript | WizardStep::TestCoverage
|
||||
)
|
||||
}
|
||||
|
||||
/// Write `content` to `path` only when the file does not already exist.
|
||||
///
|
||||
/// Existing files (including `CLAUDE.md`) are never overwritten — the wizard
|
||||
/// appends or skips per the acceptance criteria. For script steps the file is
|
||||
/// also made executable after writing.
|
||||
pub(crate) fn write_if_missing(path: &Path, content: &str, executable: bool) -> Result<bool, String> {
|
||||
if path.exists() {
|
||||
return Ok(false); // already present — skip silently
|
||||
}
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| format!("Failed to create directory {}: {e}", parent.display()))?;
|
||||
}
|
||||
fs::write(path, content)
|
||||
.map_err(|e| format!("Failed to write {}: {e}", path.display()))?;
|
||||
|
||||
if executable {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let mut perms = fs::metadata(path)
|
||||
.map_err(|e| format!("Failed to read permissions: {e}"))?
|
||||
.permissions();
|
||||
perms.set_mode(0o755);
|
||||
fs::set_permissions(path, perms)
|
||||
.map_err(|e| format!("Failed to set permissions: {e}"))?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Serialise a `WizardStep` to its snake_case string (e.g. `"test_script"`).
|
||||
fn step_slug(step: WizardStep) -> String {
|
||||
serde_json::to_value(step)
|
||||
.ok()
|
||||
.and_then(|v| v.as_str().map(String::from))
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
// ── MCP tool handlers ─────────────────────────────────────────────────────────
|
||||
|
||||
/// `wizard_status` — return current wizard state as a human-readable summary.
|
||||
pub(super) fn tool_wizard_status(ctx: &AppContext) -> Result<String, String> {
|
||||
let root = ctx.state.get_project_root()?;
|
||||
let state =
|
||||
WizardState::load(&root).ok_or("No wizard active. Run `storkit init` to begin setup.")?;
|
||||
Ok(format_wizard_state(&state))
|
||||
}
|
||||
|
||||
/// `wizard_generate` — mark the current step as generating or stage content.
|
||||
///
|
||||
/// Call with no `content` argument to mark the step as `Generating` and
|
||||
/// receive a hint describing what to generate. Call again with a `content`
|
||||
/// argument (the generated file body) to stage it for review; the step will
|
||||
/// transition to `AwaitingConfirmation`. Content is **not** written to disk
|
||||
/// until `wizard_confirm` is called.
|
||||
pub(super) fn tool_wizard_generate(args: &Value, ctx: &AppContext) -> Result<String, String> {
|
||||
let root = ctx.state.get_project_root()?;
|
||||
let mut state = WizardState::load(&root).ok_or("No wizard active.")?;
|
||||
|
||||
if state.completed {
|
||||
return Ok("Wizard is already complete.".to_string());
|
||||
}
|
||||
|
||||
let current_idx = state.current_step_index();
|
||||
let step = state.steps[current_idx].step;
|
||||
|
||||
// If content is provided, stage it for confirmation.
|
||||
if let Some(content) = args.get("content").and_then(|v| v.as_str()) {
|
||||
state.set_step_status(
|
||||
step,
|
||||
StepStatus::AwaitingConfirmation,
|
||||
Some(content.to_string()),
|
||||
);
|
||||
state
|
||||
.save(&root)
|
||||
.map_err(|e| format!("Failed to save wizard state: {e}"))?;
|
||||
return Ok(format!(
|
||||
"Content staged for '{}'. Run `wizard_confirm` to write it to disk, `wizard_retry` to regenerate, or `wizard_skip` to skip.",
|
||||
step.label()
|
||||
));
|
||||
}
|
||||
|
||||
// No content provided — mark as generating and return a hint.
|
||||
state.set_step_status(step, StepStatus::Generating, None);
|
||||
state
|
||||
.save(&root)
|
||||
.map_err(|e| format!("Failed to save wizard state: {e}"))?;
|
||||
|
||||
let hint = generation_hint(step, &root);
|
||||
let slug = step_slug(step);
|
||||
|
||||
Ok(format!(
|
||||
"Step '{}' marked as generating.\n\n{hint}\n\nOnce you have the content, call `wizard_generate` again with a `content` argument (or PUT /wizard/step/{slug}/content). Then call `wizard_confirm` to write it to disk.",
|
||||
step.label(),
|
||||
))
|
||||
}
|
||||
|
||||
/// Return true if the project directory has no meaningful source files.
|
||||
fn is_bare_project(project_root: &Path) -> bool {
|
||||
let dominated_by_storkit = std::fs::read_dir(project_root)
|
||||
.ok()
|
||||
.map(|entries| {
|
||||
let names: Vec<String> = entries
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| e.file_name().to_string_lossy().to_string())
|
||||
.collect();
|
||||
// A bare project only has storkit scaffolding and no real code
|
||||
names.iter().all(|n| {
|
||||
n.starts_with('.')
|
||||
|| n == "CLAUDE.md"
|
||||
|| n == "LICENSE"
|
||||
|| n == "README.md"
|
||||
|| n == "script"
|
||||
|| n == "store.json"
|
||||
})
|
||||
})
|
||||
.unwrap_or(true);
|
||||
dominated_by_storkit
|
||||
}
|
||||
|
||||
/// Return a generation hint for a step based on the project root.
|
||||
fn generation_hint(step: WizardStep, project_root: &Path) -> String {
|
||||
let bare = is_bare_project(project_root);
|
||||
|
||||
match step {
|
||||
WizardStep::Context => {
|
||||
if bare {
|
||||
"This is a bare project with no existing code. Ask the user what they want \
|
||||
to build — the project's purpose, goals, target users, and key features. \
|
||||
Then generate `.storkit/specs/00_CONTEXT.md` from their answers covering:\n\
|
||||
- High-level goal of the project\n\
|
||||
- Core features\n\
|
||||
- Domain concepts and entities\n\
|
||||
- Glossary of abbreviations and technical terms".to_string()
|
||||
} else {
|
||||
"Read the project source tree and generate a `.storkit/specs/00_CONTEXT.md` describing:\n\
|
||||
- High-level goal of the project\n\
|
||||
- Core features\n\
|
||||
- Domain concepts and entities\n\
|
||||
- Glossary of abbreviations and technical terms".to_string()
|
||||
}
|
||||
}
|
||||
WizardStep::Stack => {
|
||||
if bare {
|
||||
"This is a bare project with no existing code. Ask the user what language, \
|
||||
frameworks, and tools they plan to use. Then generate `.storkit/specs/tech/STACK.md` \
|
||||
from their answers covering:\n\
|
||||
- Language, frameworks, and runtimes\n\
|
||||
- Coding standards and linting rules\n\
|
||||
- Quality gates (commands that must pass before merging)\n\
|
||||
- Approved libraries and their purpose".to_string()
|
||||
} else {
|
||||
"Read the project source tree and generate a `.storkit/specs/tech/STACK.md` describing:\n\
|
||||
- Language, frameworks, and runtimes\n\
|
||||
- Coding standards and linting rules\n\
|
||||
- Quality gates (commands that must pass before merging)\n\
|
||||
- Approved libraries and their purpose".to_string()
|
||||
}
|
||||
}
|
||||
WizardStep::TestScript => {
|
||||
let has_cargo = project_root.join("Cargo.toml").exists();
|
||||
let has_pkg = project_root.join("package.json").exists();
|
||||
let has_pnpm = project_root.join("pnpm-lock.yaml").exists();
|
||||
let mut cmds = Vec::new();
|
||||
if has_cargo {
|
||||
cmds.push("cargo nextest run");
|
||||
}
|
||||
if has_pkg {
|
||||
cmds.push(if has_pnpm { "pnpm test" } else { "npm test" });
|
||||
}
|
||||
if cmds.is_empty() {
|
||||
"Generate a `script/test` shell script (#!/usr/bin/env bash, set -euo pipefail) that runs the project's test suite.".to_string()
|
||||
} else {
|
||||
format!(
|
||||
"Generate a `script/test` shell script (#!/usr/bin/env bash, set -euo pipefail) that runs: {}",
|
||||
cmds.join(", ")
|
||||
)
|
||||
}
|
||||
}
|
||||
WizardStep::ReleaseScript => {
|
||||
"Generate a `script/release` shell script (#!/usr/bin/env bash, set -euo pipefail) that builds and releases the project (e.g. `cargo build --release` or `npm run build`).".to_string()
|
||||
}
|
||||
WizardStep::TestCoverage => {
|
||||
"Generate a `script/test_coverage` shell script (#!/usr/bin/env bash, set -euo pipefail) that generates a test coverage report (e.g. `cargo llvm-cov nextest` or `npm run coverage`).".to_string()
|
||||
}
|
||||
WizardStep::Scaffold => "Scaffold step is handled automatically by `storkit init`.".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// `wizard_confirm` — confirm the current step and write its content to disk.
|
||||
///
|
||||
/// If the step has staged content, the content is written to its target file
|
||||
/// (only if that file does not already exist — existing files are never
|
||||
/// overwritten). The step is then marked as `Confirmed` and the wizard
|
||||
/// advances to the next pending step.
|
||||
pub(super) fn tool_wizard_confirm(ctx: &AppContext) -> Result<String, String> {
|
||||
let root = ctx.state.get_project_root()?;
|
||||
let mut state = WizardState::load(&root).ok_or("No wizard active.")?;
|
||||
|
||||
if state.completed {
|
||||
return Ok("Wizard is already complete.".to_string());
|
||||
}
|
||||
|
||||
let current_idx = state.current_step_index();
|
||||
let step = state.steps[current_idx].step;
|
||||
let content = state.steps[current_idx].content.clone();
|
||||
|
||||
// Write content to disk (only if a file path exists and the file is absent).
|
||||
let write_msg = if let (Some(c), Some(ref path)) = (&content, step_output_path(&root, step)) {
|
||||
let executable = is_script_step(step);
|
||||
match write_if_missing(path, c, executable)? {
|
||||
true => format!(" File written: `{}`.", path.display()),
|
||||
false => format!(" File `{}` already exists — skipped.", path.display()),
|
||||
}
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
|
||||
state
|
||||
.confirm_step(step)
|
||||
.map_err(|e| format!("Cannot confirm step: {e}"))?;
|
||||
state
|
||||
.save(&root)
|
||||
.map_err(|e| format!("Failed to save wizard state: {e}"))?;
|
||||
|
||||
let next_idx = state.current_step_index();
|
||||
if state.completed {
|
||||
Ok(format!(
|
||||
"Step '{}' confirmed.{write_msg}\n\nSetup wizard complete! All steps done.",
|
||||
step.label()
|
||||
))
|
||||
} else {
|
||||
let next = &state.steps[next_idx];
|
||||
Ok(format!(
|
||||
"Step '{}' confirmed.{write_msg}\n\nNext: {} — run `wizard_generate` to begin.",
|
||||
step.label(),
|
||||
next.step.label()
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// `wizard_skip` — skip the current step without writing any file.
|
||||
pub(super) fn tool_wizard_skip(ctx: &AppContext) -> Result<String, String> {
|
||||
let root = ctx.state.get_project_root()?;
|
||||
let mut state = WizardState::load(&root).ok_or("No wizard active.")?;
|
||||
|
||||
if state.completed {
|
||||
return Ok("Wizard is already complete.".to_string());
|
||||
}
|
||||
|
||||
let current_idx = state.current_step_index();
|
||||
let step = state.steps[current_idx].step;
|
||||
|
||||
state
|
||||
.skip_step(step)
|
||||
.map_err(|e| format!("Cannot skip step: {e}"))?;
|
||||
state
|
||||
.save(&root)
|
||||
.map_err(|e| format!("Failed to save wizard state: {e}"))?;
|
||||
|
||||
let next_idx = state.current_step_index();
|
||||
if state.completed {
|
||||
Ok(format!(
|
||||
"Step '{}' skipped. Setup wizard complete!",
|
||||
step.label()
|
||||
))
|
||||
} else {
|
||||
let next = &state.steps[next_idx];
|
||||
Ok(format!(
|
||||
"Step '{}' skipped.\n\nNext: {} — run `wizard_generate` to begin.",
|
||||
step.label(),
|
||||
next.step.label()
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// `wizard_retry` — discard staged content and reset the current step to
|
||||
/// `Pending` so it can be regenerated.
|
||||
pub(super) fn tool_wizard_retry(ctx: &AppContext) -> Result<String, String> {
|
||||
let root = ctx.state.get_project_root()?;
|
||||
let mut state = WizardState::load(&root).ok_or("No wizard active.")?;
|
||||
|
||||
if state.completed {
|
||||
return Ok("Wizard is already complete.".to_string());
|
||||
}
|
||||
|
||||
let current_idx = state.current_step_index();
|
||||
let step = state.steps[current_idx].step;
|
||||
|
||||
// Clear content and reset to pending.
|
||||
if let Some(s) = state.steps.iter_mut().find(|s| s.step == step) {
|
||||
s.status = StepStatus::Pending;
|
||||
s.content = None;
|
||||
}
|
||||
state
|
||||
.save(&root)
|
||||
.map_err(|e| format!("Failed to save wizard state: {e}"))?;
|
||||
|
||||
Ok(format!(
|
||||
"Step '{}' reset to pending. Run `wizard_generate` to regenerate content.",
|
||||
step.label()
|
||||
))
|
||||
}
|
||||
|
||||
// ── tests ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::http::context::AppContext;
|
||||
use tempfile::TempDir;
|
||||
|
||||
fn setup(dir: &TempDir) -> AppContext {
|
||||
let root = dir.path().to_path_buf();
|
||||
std::fs::create_dir_all(root.join(".storkit")).unwrap();
|
||||
WizardState::init_if_missing(&root);
|
||||
AppContext::new_test(root)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_status_returns_state() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
let result = tool_wizard_status(&ctx).unwrap();
|
||||
assert!(result.contains("Setup wizard"));
|
||||
assert!(result.contains("context"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_status_no_wizard_returns_error() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".storkit")).unwrap();
|
||||
let ctx = AppContext::new_test(dir.path().to_path_buf());
|
||||
assert!(tool_wizard_status(&ctx).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_generate_marks_generating() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
let result = tool_wizard_generate(&serde_json::json!({}), &ctx).unwrap();
|
||||
assert!(result.contains("generating"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.steps[1].status, StepStatus::Generating);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_generate_with_content_stages_content() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
let result = tool_wizard_generate(
|
||||
&serde_json::json!({"content": "# My Project"}),
|
||||
&ctx,
|
||||
)
|
||||
.unwrap();
|
||||
assert!(result.contains("staged"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.steps[1].status, StepStatus::AwaitingConfirmation);
|
||||
assert_eq!(state.steps[1].content.as_deref(), Some("# My Project"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_confirm_writes_file_and_advances() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
// Stage content for Context step.
|
||||
tool_wizard_generate(
|
||||
&serde_json::json!({"content": "# Context content"}),
|
||||
&ctx,
|
||||
)
|
||||
.unwrap();
|
||||
let result = tool_wizard_confirm(&ctx).unwrap();
|
||||
assert!(result.contains("confirmed"));
|
||||
// File should now exist.
|
||||
let context_path = dir
|
||||
.path()
|
||||
.join(".storkit")
|
||||
.join("specs")
|
||||
.join("00_CONTEXT.md");
|
||||
assert!(context_path.exists());
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(&context_path).unwrap(),
|
||||
"# Context content"
|
||||
);
|
||||
// Wizard should have advanced.
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.steps[1].status, StepStatus::Confirmed);
|
||||
assert_eq!(state.current_step_index(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_confirm_does_not_overwrite_existing_file() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
// Pre-create the specs directory and file.
|
||||
let specs_dir = dir.path().join(".storkit").join("specs");
|
||||
std::fs::create_dir_all(&specs_dir).unwrap();
|
||||
let context_path = specs_dir.join("00_CONTEXT.md");
|
||||
std::fs::write(&context_path, "original content").unwrap();
|
||||
|
||||
// Stage and confirm — existing file should NOT be overwritten.
|
||||
tool_wizard_generate(
|
||||
&serde_json::json!({"content": "new content"}),
|
||||
&ctx,
|
||||
)
|
||||
.unwrap();
|
||||
let result = tool_wizard_confirm(&ctx).unwrap();
|
||||
assert!(result.contains("already exists"));
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(&context_path).unwrap(),
|
||||
"original content"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_skip_advances_wizard() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
let result = tool_wizard_skip(&ctx).unwrap();
|
||||
assert!(result.contains("skipped"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.steps[1].status, StepStatus::Skipped);
|
||||
assert_eq!(state.current_step_index(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_retry_resets_to_pending() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
// Stage content first.
|
||||
tool_wizard_generate(
|
||||
&serde_json::json!({"content": "some content"}),
|
||||
&ctx,
|
||||
)
|
||||
.unwrap();
|
||||
let result = tool_wizard_retry(&ctx).unwrap();
|
||||
assert!(result.contains("reset"));
|
||||
let state = WizardState::load(dir.path()).unwrap();
|
||||
assert_eq!(state.steps[1].status, StepStatus::Pending);
|
||||
assert!(state.steps[1].content.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wizard_complete_returns_done_message() {
|
||||
let dir = TempDir::new().unwrap();
|
||||
let ctx = setup(&dir);
|
||||
// Skip all remaining steps.
|
||||
for _ in 0..5 {
|
||||
tool_wizard_skip(&ctx).unwrap();
|
||||
}
|
||||
let result = tool_wizard_status(&ctx).unwrap();
|
||||
assert!(result.contains("complete"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn format_wizard_state_shows_all_steps() {
|
||||
let mut state = WizardState::default();
|
||||
state.steps[0].status = StepStatus::Confirmed;
|
||||
let output = format_wizard_state(&state);
|
||||
assert!(output.contains("✓"));
|
||||
assert!(output.contains("Scaffold"));
|
||||
assert!(output.contains("← current"));
|
||||
}
|
||||
}
|
||||
@@ -57,7 +57,11 @@ The permission system validates the entire command string, and chained commands
|
||||
won't match allow rules like `Bash(git *)`. Use separate Bash calls instead — \
|
||||
parallel calls work fine.\n\
|
||||
\n\
|
||||
Read .storkit/README.md to see our dev process.\n";
|
||||
Read .storkit/README.md to see our dev process.\n\
|
||||
\n\
|
||||
IMPORTANT: On your first conversation, call `wizard_status` to check if \
|
||||
project setup is complete. If not, read .storkit/README.md for the full \
|
||||
setup wizard instructions and guide the user through it conversationally.\n";
|
||||
|
||||
const STORY_KIT_CLAUDE_SETTINGS: &str = r#"{
|
||||
"permissions": {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
@@ -190,6 +191,67 @@ impl WizardState {
|
||||
}
|
||||
}
|
||||
|
||||
/// Format a `WizardState` as a human-readable Markdown summary for display in
|
||||
/// bot messages and MCP responses.
|
||||
pub fn format_wizard_state(state: &WizardState) -> String {
|
||||
let total = state.steps.len();
|
||||
let current_idx = state.current_step_index();
|
||||
|
||||
let header = if state.completed {
|
||||
format!("**Setup wizard — complete** ({total}/{total} steps done)")
|
||||
} else {
|
||||
format!("**Setup wizard — step {}/{}**", current_idx + 1, total)
|
||||
};
|
||||
|
||||
let mut lines = vec![header, String::new()];
|
||||
|
||||
for (i, step) in state.steps.iter().enumerate() {
|
||||
let marker = match step.status {
|
||||
StepStatus::Confirmed => "✓",
|
||||
StepStatus::Skipped => "~",
|
||||
StepStatus::Generating => "⟳",
|
||||
StepStatus::AwaitingConfirmation => "?",
|
||||
StepStatus::Pending => "○",
|
||||
};
|
||||
let is_current = !state.completed && i == current_idx;
|
||||
let suffix = if is_current { " ← current" } else { "" };
|
||||
let status_str = serde_json::to_value(&step.status)
|
||||
.ok()
|
||||
.and_then(|v| v.as_str().map(String::from))
|
||||
.unwrap_or_default();
|
||||
lines.push(format!(
|
||||
" {} {} ({}){suffix}",
|
||||
marker,
|
||||
step.step.label(),
|
||||
status_str
|
||||
));
|
||||
}
|
||||
|
||||
if state.completed {
|
||||
lines.push(String::new());
|
||||
lines.push("All steps done. Your project is fully configured.".to_string());
|
||||
} else {
|
||||
let current = &state.steps[current_idx];
|
||||
lines.push(String::new());
|
||||
lines.push(format!("**Current:** {}", current.step.label()));
|
||||
let hint = match current.status {
|
||||
StepStatus::Pending => {
|
||||
"Ready to generate. Proceed by calling wizard_generate.".to_string()
|
||||
}
|
||||
StepStatus::Generating => "Generating content…".to_string(),
|
||||
StepStatus::AwaitingConfirmation => {
|
||||
"Content ready for review. Show it to the user and ask if they're happy with it. Then call wizard_confirm, wizard_retry, or wizard_skip based on their response.".to_string()
|
||||
}
|
||||
StepStatus::Confirmed | StepStatus::Skipped => String::new(),
|
||||
};
|
||||
if !hint.is_empty() {
|
||||
lines.push(hint);
|
||||
}
|
||||
}
|
||||
|
||||
lines.join("\n")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
+151
-120
@@ -32,72 +32,78 @@ use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::broadcast;
|
||||
|
||||
/// What the first CLI argument means.
|
||||
/// Parsed CLI arguments.
|
||||
#[derive(Debug, PartialEq)]
|
||||
enum CliDirective {
|
||||
/// `--help` / `-h`
|
||||
Help,
|
||||
/// `--version` / `-V`
|
||||
Version,
|
||||
/// `init [PATH]` — scaffold and start the setup wizard.
|
||||
Init,
|
||||
/// An unrecognised flag (starts with `-`).
|
||||
UnknownFlag(String),
|
||||
/// A positional path argument.
|
||||
Path,
|
||||
/// No arguments at all.
|
||||
None,
|
||||
struct CliArgs {
|
||||
/// Value from `--port <VALUE>` flag, if supplied.
|
||||
port: Option<u16>,
|
||||
/// Positional project path argument, if supplied.
|
||||
path: Option<String>,
|
||||
/// Whether the `init` subcommand was given.
|
||||
init: bool,
|
||||
}
|
||||
|
||||
/// Inspect the raw CLI arguments and return the directive they imply.
|
||||
fn classify_cli_args(args: &[String]) -> CliDirective {
|
||||
match args.first().map(String::as_str) {
|
||||
None => CliDirective::None,
|
||||
Some("--help" | "-h") => CliDirective::Help,
|
||||
Some("--version" | "-V") => CliDirective::Version,
|
||||
Some("init") => CliDirective::Init,
|
||||
Some(a) if a.starts_with('-') => CliDirective::UnknownFlag(a.to_string()),
|
||||
Some(_) => CliDirective::Path,
|
||||
/// Parse CLI arguments into `CliArgs`, or exit early for `--help` / `--version`.
|
||||
fn parse_cli_args(args: &[String]) -> Result<CliArgs, String> {
|
||||
let mut port: Option<u16> = None;
|
||||
let mut path: Option<String> = None;
|
||||
let mut init = false;
|
||||
let mut i = 0;
|
||||
|
||||
while i < args.len() {
|
||||
match args[i].as_str() {
|
||||
"--help" | "-h" => {
|
||||
print_help();
|
||||
std::process::exit(0);
|
||||
}
|
||||
"--version" | "-V" => {
|
||||
println!("storkit {}", env!("CARGO_PKG_VERSION"));
|
||||
std::process::exit(0);
|
||||
}
|
||||
"--port" => {
|
||||
i += 1;
|
||||
if i >= args.len() {
|
||||
return Err("--port requires a value".to_string());
|
||||
}
|
||||
match args[i].parse::<u16>() {
|
||||
Ok(p) => port = Some(p),
|
||||
Err(_) => return Err(format!("invalid port value: '{}'", args[i])),
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve the optional positional path argument (everything after the binary
|
||||
/// name) into an absolute `PathBuf`. Returns `None` when no argument was
|
||||
/// supplied so that the caller can fall back to the auto-detect behaviour.
|
||||
fn parse_project_path_arg(args: &[String], cwd: &std::path::Path) -> Option<PathBuf> {
|
||||
args.first().map(|s| io::fs::resolve_cli_path(cwd, s))
|
||||
a if a.starts_with("--port=") => {
|
||||
let val = &a["--port=".len()..];
|
||||
match val.parse::<u16>() {
|
||||
Ok(p) => port = Some(p),
|
||||
Err(_) => return Err(format!("invalid port value: '{val}'")),
|
||||
}
|
||||
}
|
||||
"init" => {
|
||||
init = true;
|
||||
}
|
||||
a if a.starts_with('-') => {
|
||||
return Err(format!("unknown option: {a}"));
|
||||
}
|
||||
a => {
|
||||
if path.is_some() {
|
||||
return Err(format!("unexpected argument: {a}"));
|
||||
}
|
||||
path = Some(a.to_string());
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), std::io::Error> {
|
||||
let app_state = Arc::new(SessionState::default());
|
||||
let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
|
||||
let store = Arc::new(
|
||||
JsonFileStore::from_path(PathBuf::from("store.json")).map_err(std::io::Error::other)?,
|
||||
);
|
||||
Ok(CliArgs { port, path, init })
|
||||
}
|
||||
|
||||
let port = resolve_port();
|
||||
|
||||
// Collect CLI args, skipping the binary name (argv[0]).
|
||||
let cli_args: Vec<String> = std::env::args().skip(1).collect();
|
||||
|
||||
// Handle CLI flags before treating anything as a project path.
|
||||
let is_init = matches!(classify_cli_args(&cli_args), CliDirective::Init);
|
||||
match classify_cli_args(&cli_args) {
|
||||
CliDirective::Help => {
|
||||
println!("storkit [PATH]");
|
||||
println!("storkit init [PATH]");
|
||||
fn print_help() {
|
||||
println!("storkit [OPTIONS] [PATH]");
|
||||
println!("storkit init [OPTIONS] [PATH]");
|
||||
println!();
|
||||
println!("Serve a storkit project.");
|
||||
println!();
|
||||
println!("USAGE:");
|
||||
println!(" storkit [PATH]");
|
||||
println!(" storkit init [PATH]");
|
||||
println!();
|
||||
println!("COMMANDS:");
|
||||
println!(
|
||||
" init Scaffold a new .storkit/ project and start the interactive setup wizard."
|
||||
);
|
||||
println!(" init Scaffold a new .storkit/ project and start the interactive setup wizard.");
|
||||
println!();
|
||||
println!("ARGS:");
|
||||
println!(
|
||||
@@ -108,27 +114,42 @@ async fn main() -> Result<(), std::io::Error> {
|
||||
println!("OPTIONS:");
|
||||
println!(" -h, --help Print this help and exit");
|
||||
println!(" -V, --version Print the version and exit");
|
||||
std::process::exit(0);
|
||||
println!(" --port <PORT> Port to listen on (default: 3001). Persisted to project.toml.");
|
||||
}
|
||||
CliDirective::Version => {
|
||||
println!("storkit {}", env!("CARGO_PKG_VERSION"));
|
||||
std::process::exit(0);
|
||||
|
||||
/// Resolve the optional positional path argument into an absolute `PathBuf`.
|
||||
fn resolve_path_arg(path_str: Option<&str>, cwd: &std::path::Path) -> Option<PathBuf> {
|
||||
path_str.map(|s| io::fs::resolve_cli_path(cwd, s))
|
||||
}
|
||||
CliDirective::UnknownFlag(flag) => {
|
||||
eprintln!("error: unknown option: {flag}");
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), std::io::Error> {
|
||||
let app_state = Arc::new(SessionState::default());
|
||||
let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
|
||||
let store = Arc::new(
|
||||
JsonFileStore::from_path(PathBuf::from("store.json")).map_err(std::io::Error::other)?,
|
||||
);
|
||||
|
||||
// Collect CLI args, skipping the binary name (argv[0]).
|
||||
let raw_args: Vec<String> = std::env::args().skip(1).collect();
|
||||
|
||||
let cli = match parse_cli_args(&raw_args) {
|
||||
Ok(args) => args,
|
||||
Err(msg) => {
|
||||
eprintln!("error: {msg}");
|
||||
eprintln!("Run 'storkit --help' for usage.");
|
||||
std::process::exit(1);
|
||||
}
|
||||
CliDirective::Init | CliDirective::Path | CliDirective::None => {}
|
||||
}
|
||||
|
||||
// For `storkit init [PATH]`, the path argument follows "init".
|
||||
let explicit_path = if is_init {
|
||||
parse_project_path_arg(&cli_args[1..], &cwd)
|
||||
} else {
|
||||
parse_project_path_arg(&cli_args, &cwd)
|
||||
};
|
||||
|
||||
let is_init = cli.init;
|
||||
let explicit_path = resolve_path_arg(cli.path.as_deref(), &cwd);
|
||||
|
||||
// Port resolution: CLI flag > project.toml (loaded later) > default.
|
||||
// Use the CLI port for scaffolding .mcp.json; final port is resolved
|
||||
// after the project root is known.
|
||||
let port = cli.port.unwrap_or_else(resolve_port);
|
||||
|
||||
// When a path is given explicitly on the CLI, it must already exist as a
|
||||
// directory. We do not create directories from the command line.
|
||||
if let Some(ref path) = explicit_path {
|
||||
@@ -611,96 +632,106 @@ name = "coder"
|
||||
.unwrap_or_else(|e| panic!("Invalid project.toml: {e}"));
|
||||
}
|
||||
|
||||
// ── classify_cli_args ─────────────────────────────────────────────────
|
||||
// ── parse_cli_args ─────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn classify_none_when_no_args() {
|
||||
assert_eq!(classify_cli_args(&[]), CliDirective::None);
|
||||
fn parse_no_args() {
|
||||
let result = parse_cli_args(&[]).unwrap();
|
||||
assert_eq!(result.port, None);
|
||||
assert_eq!(result.path, None);
|
||||
assert!(!result.init);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_help_long() {
|
||||
assert_eq!(
|
||||
classify_cli_args(&["--help".to_string()]),
|
||||
CliDirective::Help
|
||||
);
|
||||
fn parse_unknown_flag_is_error() {
|
||||
let args = vec!["--serve".to_string()];
|
||||
assert!(parse_cli_args(&args).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_help_short() {
|
||||
assert_eq!(classify_cli_args(&["-h".to_string()]), CliDirective::Help);
|
||||
fn parse_path_only() {
|
||||
let args = vec!["/some/path".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert_eq!(result.path, Some("/some/path".to_string()));
|
||||
assert_eq!(result.port, None);
|
||||
assert!(!result.init);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_version_long() {
|
||||
assert_eq!(
|
||||
classify_cli_args(&["--version".to_string()]),
|
||||
CliDirective::Version
|
||||
);
|
||||
fn parse_port_flag() {
|
||||
let args = vec!["--port".to_string(), "4000".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert_eq!(result.port, Some(4000));
|
||||
assert_eq!(result.path, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_version_short() {
|
||||
assert_eq!(
|
||||
classify_cli_args(&["-V".to_string()]),
|
||||
CliDirective::Version
|
||||
);
|
||||
fn parse_port_equals_syntax() {
|
||||
let args = vec!["--port=5000".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert_eq!(result.port, Some(5000));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_unknown_flag() {
|
||||
assert_eq!(
|
||||
classify_cli_args(&["--serve".to_string()]),
|
||||
CliDirective::UnknownFlag("--serve".to_string())
|
||||
);
|
||||
fn parse_port_with_path() {
|
||||
let args = vec!["--port".to_string(), "4200".to_string(), "/some/path".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert_eq!(result.port, Some(4200));
|
||||
assert_eq!(result.path, Some("/some/path".to_string()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classify_path() {
|
||||
assert_eq!(
|
||||
classify_cli_args(&["/some/path".to_string()]),
|
||||
CliDirective::Path
|
||||
);
|
||||
fn parse_port_missing_value_is_error() {
|
||||
let args = vec!["--port".to_string()];
|
||||
assert!(parse_cli_args(&args).is_err());
|
||||
}
|
||||
|
||||
// ── parse_project_path_arg ────────────────────────────────────────────
|
||||
#[test]
|
||||
fn parse_port_invalid_value_is_error() {
|
||||
let args = vec!["--port".to_string(), "abc".to_string()];
|
||||
assert!(parse_cli_args(&args).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_project_path_arg_none_when_no_args() {
|
||||
fn parse_init_subcommand() {
|
||||
let args = vec!["init".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert!(result.init);
|
||||
assert_eq!(result.path, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_init_with_path_and_port() {
|
||||
let args = vec!["init".to_string(), "--port".to_string(), "3000".to_string(), "/my/project".to_string()];
|
||||
let result = parse_cli_args(&args).unwrap();
|
||||
assert!(result.init);
|
||||
assert_eq!(result.port, Some(3000));
|
||||
assert_eq!(result.path, Some("/my/project".to_string()));
|
||||
}
|
||||
|
||||
// ── resolve_path_arg ────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn resolve_path_arg_none_when_no_path() {
|
||||
let cwd = PathBuf::from("/home/user/project");
|
||||
let result = parse_project_path_arg(&[], &cwd);
|
||||
let result = resolve_path_arg(None, &cwd);
|
||||
assert!(result.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_project_path_arg_returns_path_for_absolute_arg() {
|
||||
fn resolve_path_arg_returns_path_for_absolute_arg() {
|
||||
let cwd = PathBuf::from("/home/user/project");
|
||||
let args = vec!["/some/absolute/path".to_string()];
|
||||
let result = parse_project_path_arg(&args, &cwd).unwrap();
|
||||
// Absolute path returned as-is (canonicalize may fail, fallback used)
|
||||
let result = resolve_path_arg(Some("/some/absolute/path"), &cwd).unwrap();
|
||||
assert!(
|
||||
result.ends_with("absolute/path") || result == PathBuf::from("/some/absolute/path")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_project_path_arg_resolves_dot_to_cwd() {
|
||||
fn resolve_path_arg_resolves_dot_to_cwd() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let cwd = tmp.path().to_path_buf();
|
||||
let args = vec![".".to_string()];
|
||||
let result = parse_project_path_arg(&args, &cwd).unwrap();
|
||||
// "." relative to an existing cwd should canonicalize to the cwd itself
|
||||
let result = resolve_path_arg(Some("."), &cwd).unwrap();
|
||||
assert_eq!(result, cwd.canonicalize().unwrap_or(cwd));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_project_path_arg_resolves_relative_path() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let cwd = tmp.path().to_path_buf();
|
||||
let subdir = cwd.join("myproject");
|
||||
std::fs::create_dir_all(&subdir).unwrap();
|
||||
let args = vec!["myproject".to_string()];
|
||||
let result = parse_project_path_arg(&args, &cwd).unwrap();
|
||||
assert_eq!(result, subdir.canonicalize().unwrap_or(subdir));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user