210 lines
6.1 KiB
Markdown
210 lines
6.1 KiB
Markdown
---
|
|
description: Execute plan phase-by-phase following tasklist
|
|
---
|
|
|
|
# Implement Command
|
|
|
|
Implement a feature by following the plan and tasklist documents. This command executes an existing plan phase-by-phase, reading the plan for architectural context and the tasklist for sequential execution. Your job is to execute tasks systematically and produce working code. Work proceeds one phase at a time with human review between phases.
|
|
|
|
## Arguments
|
|
|
|
**Input**: `$ARGUMENTS`
|
|
|
|
**Expected format**: `/implement-plan {feature-name} [implementation instructions]`
|
|
|
|
**Parsing:**
|
|
|
|
- First token: feature name (must match existing plan)
|
|
- Remaining tokens: optional implementation scope or behavior
|
|
- Example: `query-command implement phase 1 and 2, then stop`
|
|
|
|
**If no feature name provided:**
|
|
|
|
1. List existing plans: `find plans/ -name "*-plan.md" -exec basename {} -plan.md \;`
|
|
2. If exactly 1 plan found: use automatically and inform user
|
|
3. If multiple plans found: present list (optionally with progress status), use AskUserQuestion to ask user to select
|
|
4. If 0 plans found: inform user and suggest running `/write-plan` first
|
|
|
|
**Feature name usage:**
|
|
`{feature-name}` is a placeholder that gets replaced with the extracted feature name throughout this command.
|
|
|
|
Example file paths:
|
|
|
|
- `plans/{feature-name}-plan.md`
|
|
- `plans/{feature-name}-tasklist.md`
|
|
|
|
## Instructions
|
|
|
|
### 1. Load Context
|
|
|
|
1. If skill `read-constitution` not loaded, load it
|
|
2. If skill `claude-workflow` not loaded, load it
|
|
|
|
---
|
|
|
|
### 2. Read Planning Documents
|
|
|
|
Read the following if they are not already loaded:
|
|
|
|
- `plans/{feature-name}-plan.md` (WHY/WHAT - architectural context)
|
|
- `plans/{feature-name}-tasklist.md` (WHEN/HOW - sequential tasks)
|
|
|
|
---
|
|
|
|
### 3. Identify Next Work
|
|
|
|
Find the first incomplete task in the first incomplete phase:
|
|
|
|
- Scan tasklist for unchecked tasks: `- [ ] [PX.Y] Task description`
|
|
- Identify current phase and task number
|
|
- If all tasks complete: inform user feature is complete
|
|
|
|
---
|
|
|
|
### 4. Execute Tasks
|
|
|
|
For each task in the current phase:
|
|
|
|
1. **Read** the task description from tasklist
|
|
2. **Implement** the task following plan guidance
|
|
3. **Test** the task according to project standards
|
|
4. **Mark complete** in `plans/{feature-name}-tasklist.md`:
|
|
- Change `- [ ] [PX.Y]` to `- [x] [PX.Y]`
|
|
|
|
Repeat until all tasks in current phase are complete.
|
|
|
|
---
|
|
|
|
### 5. Run Phase Checkpoints
|
|
|
|
After all phase tasks are marked complete:
|
|
|
|
1. Execute checkpoints sequentially (defined in tasklist)
|
|
2. Mark each checkpoint complete as it passes
|
|
3. If checkpoint fails:
|
|
- Minor issues (linting, formatting, types): fix and retry until passes or stuck
|
|
- Major issues (architectural issues, complex problems): stop, describe to user and ask user for direction.
|
|
- If stuck: ask user for guidance
|
|
4. Continue until all checkpoints pass
|
|
|
|
---
|
|
|
|
### 6. Complete Phase and Stop
|
|
|
|
When all checkpoints pass:
|
|
|
|
1. Output "Phase X Complete ✅" summary
|
|
2. Summarize what was accomplished
|
|
3. Suggest commit message if appropriate
|
|
4. **STOP for human review** - do NOT proceed to next phase
|
|
|
|
**Between phases:** Human reviews work, optionally runs `/clear` and if so continues with a new call to `/implement-plan {feature-name}` to resume.
|
|
|
|
## Example Workflow
|
|
|
|
```text
|
|
# Starting fresh
|
|
Reading plans for feature: query-command
|
|
- Plan: plans/query-command-plan.md
|
|
- Tasklist: plans/query-command-tasklist.md
|
|
|
|
Progress check: No tasks completed yet. Starting from Phase 1.
|
|
|
|
# Executing tasks
|
|
Working on [P1.1]: Set up basic module structure
|
|
[implements the task]
|
|
✓ Marked [P1.1] as complete
|
|
|
|
Working on [P1.2]: Create core data models
|
|
[implements the task]
|
|
✓ Marked [P1.2] as complete
|
|
|
|
# Phase completion
|
|
All Phase 1 tasks complete. Executing checkpoints...
|
|
|
|
Checkpoint: Self-review implementation against phase deliverable
|
|
✓ Marked checkpoint complete
|
|
|
|
Checkpoint: Code quality - ruff check src/
|
|
✓ Passed. Marked checkpoint complete
|
|
|
|
Checkpoint: Code complexity - radon cc src/
|
|
✓ Passed. Marked checkpoint complete
|
|
|
|
Phase 1 Complete! ✅
|
|
|
|
Summary of changes:
|
|
✅ Created directory structure for modular architecture
|
|
✅ Implemented core data models with Pydantic validation
|
|
✅ Added type hints and proper __init__.py exports
|
|
|
|
All checkpoints passed. Foundation layer complete following constitution principles.
|
|
|
|
Suggested commit:
|
|
feat: establish foundational architecture
|
|
|
|
Enables modular development with core models, strict type validation,
|
|
and clear module boundaries.
|
|
|
|
|
|
Stopping for review. Please approve before proceeding to Phase 2.
|
|
```
|
|
|
|
If resuming mid-feature:
|
|
|
|
```text
|
|
Progress check:
|
|
✓ Phase 1: Complete (2/2 tasks)
|
|
✓ Phase 2: Complete (4/4 tasks)
|
|
→ Phase 3: In progress (1/3 tasks)
|
|
|
|
Resuming from Phase 3, Task [P3.2]...
|
|
```
|
|
|
|
## When Tasks Are Unclear
|
|
|
|
Assess task clarity using these criteria:
|
|
|
|
**Clear (✅ - proceed with implementation):**
|
|
|
|
- Task goal is explicit
|
|
- Acceptance criteria defined or obvious
|
|
- Required files/components identified
|
|
- Approach is straightforward or documented in plan
|
|
|
|
**Minor ambiguity (⚠️ - make reasonable assumption):**
|
|
|
|
- Task goal is clear but approach has 2-3 valid options
|
|
- Some details missing but not critical to core functionality
|
|
- Can infer intent from context and plan
|
|
- Document assumption in code comments
|
|
|
|
**Major ambiguity (❌ - stop and ask):**
|
|
|
|
- Task goal is vague or has multiple interpretations
|
|
- Missing critical information (which component, what data structure, etc.)
|
|
- Approach unclear and not documented in plan
|
|
- Decision affects architecture or future phases
|
|
|
|
**Process:**
|
|
|
|
1. Read task description carefully
|
|
2. Check relevant plan sections for context
|
|
3. Assess clarity level using criteria above
|
|
4. If Major ambiguity: Use AskUserQuestion with task ID, what's unclear, which plan sections checked, and recommended approach
|
|
5. If Minor ambiguity: Proceed with documented assumption
|
|
6. If Clear: Proceed with implementation
|
|
|
|
## When Issues Arise
|
|
|
|
- Document the issue clearly
|
|
- Use AskUserQuestion for multiple valid approaches or critical decisions
|
|
- Continue with reasonable assumptions if minor
|
|
- Stop and ask if significant or affects architecture
|
|
|
|
## Code Quality
|
|
|
|
- Keep codebase runnable throughout
|
|
- Run tests after implementing functionality
|
|
- Follow constitution and project principles
|