romfast/auto-build
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: Complete rewrite of progress tracking system (v1.0.9)

Browse Source 
The /ab:build command was executing tasks but not tracking progress.
This rewrite enforces dual progress tracking in BOTH status.json AND plan.md.

Key changes:

build.md - Complete restructure:
- Step-by-step execution workflow (like migrate.md)
- Step 4d MANDATORY: Update both status.json and plan.md
- User confirmation required between tasks
- Visual Progress Tracker table in plan template

planner.md - New plan template:
- Progress Tracker table at top with ⬜/✅ indicators
- Each task has `- **Status**: ⬜ Pending` field
- Status header shows overall progress

coder.md - Dual file updates:
- 5a: Update status.json (currentTask, tasksCompleted, history)
- 5b: Update plan.md Progress Tracker (⬜ Pending → ✅ Done)

Benefits:
- Visual progress in plan.md (human readable)
- JSON progress in status.json (programmatic)
- Redundancy ensures progress is never lost
- Team can see exactly which tasks are complete

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Marius Mutu
2025-12-22 21:20:48 +02:00
parent e8a371d0a3
commit 6dc644d9fb
6 changed files with 357 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.claude-plugin/marketplace.json
View File

@@ -11,7 +11,7 @@
"name": "ab", "name": "ab",
"source": "./plugin", "source": "./plugin",
"description": "Spec-driven build orchestration with git worktree isolation and session memory", "description": "Spec-driven build orchestration with git worktree isolation and session memory",
"version": "1.0.7", "version": "1.0.9",
"keywords": ["build", "spec", "automation", "worktree", "qa"] "keywords": ["build", "spec", "automation", "worktree", "qa"]
} }
] ]

38
CHANGELOG.md
View File

@@ -2,6 +2,44 @@
All notable changes to Auto-Build plugin. All notable changes to Auto-Build plugin.
## [1.0.9] - 2024-12-22
### Fixed
- **Complete rewrite of progress tracking system** - now enforced at every step
- Progress is tracked in BOTH status.json AND plan.md (dual tracking)
- Plan now includes visual Progress Tracker table with ⬜/✅ status indicators
### Changed
- **build.md**: Complete restructure with step-by-step execution workflow
- Step 4d now MANDATORY updates both status.json and plan.md
- Added Progress Tracker table format in plan template
- User confirmation required between tasks
- **planner.md**: New plan.md template with Progress Tracker table
- Each task now has `- **Status**: ⬜ Pending` field
- Table at top shows all tasks with status columns
- **coder.md**: Step 5 now requires updating both files
- 5a: Update status.json with currentTask, tasksCompleted
- 5b: Update plan.md Progress Tracker (⬜→✅)
### Why This Matters
- Visual progress tracking in plan.md (can see at a glance)
- JSON progress in status.json (for programmatic access)
- Both files updated = redundancy and visibility
- Team members can see exactly which tasks are done
## [1.0.8] - 2024-12-22
### Fixed
- **`/ab:build` now properly tracks task progress in status.json**
- Added explicit "MANDATORY" progress tracking instructions in build.md
- Added status.json update step to coder agent
- Progress is now visible for team collaboration (currentTask, history entries)
### Changed
- build.md: Added "CRITICAL: Progress Tracking Requirements" section
- build.md: Detailed "Step 4c: MANDATORY - Update Progress After Task Completion"
- coder.md: New "Step 5: Update Progress (MANDATORY)" before reporting changes
## [1.0.7] - 2024-12-22 ## [1.0.7] - 2024-12-22
### Fixed ### Fixed

2
plugin/.claude-plugin/plugin.json
View File

@@ -1,7 +1,7 @@
{ {
"name": "ab", "name": "ab",
"description": "Auto-Build: Spec-driven build orchestration with worktree isolation and session memory", "description": "Auto-Build: Spec-driven build orchestration with worktree isolation and session memory",
"version": "1.0.7", "version": "1.0.9",
"author": { "author": {
"name": "ROA2WEB Team" "name": "ROA2WEB Team"
} }

51
plugin/agents/coder.md
View File

@@ -68,13 +68,62 @@ After coding:
- Verify changes match completion criteria - Verify changes match completion criteria
- Ensure no unintended side effects - Ensure no unintended side effects
### 5. Report Changes ### 5. Update Progress (MANDATORY)
**After completing the task, you MUST update BOTH files:**
#### 5a. Update status.json
Read and update `.auto-build/specs/{feature-name}/status.json`:
```json
{
"status": "IMPLEMENTING",
"currentTask": {N+1},
"tasksCompleted": {N},
"totalTasks": {TOTAL},
"updated": "{ISO timestamp}",
"history": [
...existing...,
{"status": "IMPLEMENTING", "at": "{timestamp}", "task": {N}, "title": "{title}", "completed": true}
]
}
```
#### 5b. Update plan.md Progress Tracker
Edit `.auto-build/specs/{feature-name}/plan.md` to mark task complete:
1. In the Progress Tracker table, change:
```
| {N} | {Task title} | ⬜ Pending | |
```
to:
```
| {N} | {Task title} | ✅ Done | {timestamp} |
```
2. In the task section, change:
```
- **Status**: ⬜ Pending
```
to:
```
- **Status**: ✅ Done ({timestamp})
```
**Both updates are MANDATORY. Skipping them breaks team collaboration and progress tracking.**
### 6. Report Changes
Provide a summary: Provide a summary:
```markdown ```markdown
## Task Completed: [Task Title] ## Task Completed: [Task Title]
### Progress Updated
- status.json updated: currentTask = {N+1}
- History entry added for task {N}
### Changes Made ### Changes Made
#### `path/to/file1.ts` #### `path/to/file1.ts`

76
plugin/agents/planner.md
View File

@@ -66,56 +66,54 @@ Create a plan.md with this structure:
```markdown ```markdown
# Implementation Plan: {feature-name} # Implementation Plan: {feature-name}
**Status**: 🔄 In Progress
**Created**: {timestamp}
**Total Tasks**: {N}
## Progress Tracker
| # | Task | Status | Completed |
|---|------|--------|-----------|
| 1 | {Task 1 title} | ⬜ Pending | |
| 2 | {Task 2 title} | ⬜ Pending | |
| 3 | {Task 3 title} | ⬜ Pending | |
| ... | ... | ... | |
## Overview ## Overview
[Brief summary of the implementation approach] [Brief summary of the implementation approach]
## Task Order ## Tasks
1. Task 1 (no dependencies)
2. Task 2 (depends on 1)
3. Task 3 (depends on 1)
4. Task 4 (depends on 2, 3)
...
## Detailed Tasks
--- ---
### Task 1: [Clear Title] ### Task 1: [Clear Title]
**Objective**: [One sentence describing what this task accomplishes] - **Status**: ⬜ Pending
- **Objective**: [One sentence describing what this task accomplishes]
**Files**: - **Files**:
- `path/to/file1.ts` - [what to do] - `path/to/file1.ts` - [what to do]
- `path/to/file2.ts` - [what to do] - `path/to/file2.ts` - [what to do]
- **Steps**:
**Steps**: 1. [Specific step 1]
1. [Specific step 1] 2. [Specific step 2]
2. [Specific step 2] 3. [Specific step 3]
3. [Specific step 3] - **Dependencies**: None
- **Completion Criteria**:
**Dependencies**: None - [ ] [How to verify this task is done]
**Completion Criteria**:
- [ ] [How to verify this task is done]
**Patterns to Follow**:
- See `existing/similar/file.ts` for reference
--- ---
### Task 2: [Clear Title] ### Task 2: [Clear Title]
**Objective**: [One sentence] - **Status**: ⬜ Pending
- **Objective**: [One sentence]
**Files**: - **Files**:
- `path/to/file3.ts` - [what to do] - `path/to/file3.ts` - [what to do]
- **Steps**:
**Steps**: 1. [Specific step 1]
1. [Specific step 1] 2. [Specific step 2]
2. [Specific step 2] - **Dependencies**: Task 1
- **Completion Criteria**:
**Dependencies**: Task 1 - [ ] [Verification method]
**Completion Criteria**:
- [ ] [Verification method]
--- ---
[Continue for all tasks...] [Continue for all tasks...]

374
plugin/commands/build.md
View File

@@ -5,212 +5,298 @@ argument-hint: <feature-name>
# Build Feature from Specification # Build Feature from Specification
Orchestrate the complete implementation of a feature using its specification. This is the core command that coordinates planning, coding, and progress tracking. Orchestrate the complete implementation of a feature using its specification.
## IMPORTANT: Execute This Workflow Step-by-Step
When this command is invoked, you MUST follow each step in order. After each task completion, you MUST update both status.json AND plan.md before proceeding.
## Input ## Input
- **Feature name**: $ARGUMENTS (required, must match existing spec) - **Feature name**: $ARGUMENTS (required, must match existing spec)
## Prerequisites ## Step 1: Load and Validate
- Spec must exist at `.auto-build/specs/{feature-name}/spec.md` Execute immediately:
- Status must be `SPEC_COMPLETE` or `PLANNING_COMPLETE` or `IMPLEMENTING`
## Workflow 1. Read the spec file:
```
.auto-build/specs/{feature-name}/spec.md
```
### 1. Load Specification 2. Read the status file:
```
.auto-build/specs/{feature-name}/status.json
```
- Read `.auto-build/specs/{feature-name}/spec.md` 3. Read the plan file (if exists):
- Read `.auto-build/specs/{feature-name}/status.json` ```
- Validate spec exists and is complete .auto-build/specs/{feature-name}/plan.md
- If status is `IMPLEMENTING`, resume from current task ```
### 2. Offer Worktree (for new builds) 4. Check status and determine next action:
- If `SPEC_COMPLETE` → Go to Step 2 (Worktree offer) then Step 3 (Planning)
- If `PLANNING_COMPLETE` → Go to Step 4 (Implementation)
- If `IMPLEMENTING` → Resume from `currentTask` in status.json
If status is `SPEC_COMPLETE`: ## Step 2: Offer Worktree (Only if SPEC_COMPLETE)
Ask the user:
``` ```
This feature may modify multiple files. This feature may modify multiple files.
Create an isolated git worktree? (recommended for larger features) Create an isolated git worktree? (recommended for larger features)
[Yes] [No] [Yes] [No]
``` ```
If yes: If **Yes**:
- Run: `bash ${CLAUDE_PLUGIN_ROOT}/scripts/worktree-create.sh {feature-name}` 1. Run: `bash ${CLAUDE_PLUGIN_ROOT}/scripts/worktree-create.sh {feature-name}`
- Update status.json with worktree path 2. Update status.json with worktree path
- Display next steps: 3. Display:
``` ```
════════════════════════════════════════════════════════════════ ════════════════════════════════════════════════════════════════
WORKTREE CREATED WORKTREE CREATED - ACTION REQUIRED
════════════════════════════════════════════════════════════════ ════════════════════════════════════════════════════════════════
✅ Worktree created at: ../ab-worktrees/{project}-{feature-name}/ ✅ Worktree: ../ab-worktrees/{project}-{feature-name}/
✅ Branch: feature/ab-{feature-name} ✅ Branch: feature/ab-{feature-name}
⚠️ NEXT STEPS: ⚠️ YOU MUST NOW:
1. Open a NEW VSCode window in the worktree:
1. Open NEW VSCode window:
code ../ab-worktrees/{project}-{feature-name}/ code ../ab-worktrees/{project}-{feature-name}/
2. In the NEW window, continue the build: 2. In the NEW window, run:
/ab:build {feature-name} /ab:build {feature-name}
────────────────────────────────────────────────────────────────
Note: Specs and plans in .auto-build/ are already available in
the worktree (they're in git). No symlinks needed!
════════════════════════════════════════════════════════════════ ════════════════════════════════════════════════════════════════
``` ```
4. **STOP** - Do not continue. Wait for user to switch directories.
- **STOP HERE** - Do not proceed with implementation in the current directory If **No**: Continue to Step 3.
- The user must switch to the worktree directory first
### 3. Planning Phase ## Step 3: Create Plan (Only if SPEC_COMPLETE)
**If status is `PLANNING_COMPLETE`** (plan already exists): 1. Update status.json:
- Skip directly to Implementation Loop (step 4) ```json
- This happens when resuming in a worktree after plan was created in main repo {
"status": "PLANNING",
"updated": "{ISO timestamp}"
}
```
**If status is `SPEC_COMPLETE`**: 2. Load memory context:
- Read `.auto-build/memory/patterns.json` (if exists)
- Read `.auto-build/memory/gotchas.json` (if exists)
1. Load memory context (if exists): 3. Create plan.md with this structure:
- Read `.auto-build/memory/patterns.json`
- Read `.auto-build/memory/gotchas.json`
2. Launch **planner** agent with:
- The complete spec.md content
- Relevant patterns from memory
- Instruction to create ordered implementation tasks
3. The planner creates `.auto-build/specs/{feature-name}/plan.md`:
```markdown ```markdown
# Implementation Plan: {feature-name} # Implementation Plan: {feature-name}
## Progress Tracker
| Task | Status | Completed |
|------|--------|-----------|
| Task 1: {title} | ⬜ Pending | |
| Task 2: {title} | ⬜ Pending | |
| ... | | |
## Tasks ## Tasks
### Task 1: [Title] ### Task 1: {Title}
**Files**: file1.ts, file2.ts - **Status**: ⬜ Pending
**Description**: What to do - **Files**: file1.ts, file2.ts
**Dependencies**: None - **Description**: What to do
- **Dependencies**: None
### Task 2: [Title] ### Task 2: {Title}
**Files**: file3.ts - **Status**: ⬜ Pending
**Description**: What to do - **Files**: file3.ts
**Dependencies**: Task 1 - **Description**: What to do
- **Dependencies**: Task 1
... ...
``` ```
4. Update status to `PLANNING_COMPLETE` 4. Update status.json:
```json
### 4. Implementation Loop {
"status": "PLANNING_COMPLETE",
For each task in plan.md: "totalTasks": {number of tasks},
"currentTask": 1,
1. Update status to `IMPLEMENTING`, set `currentTask` "updated": "{ISO timestamp}",
"history": [..., {"status": "PLANNING_COMPLETE", "at": "{timestamp}"}]
2. Display task info: }
```
Task 3/7: Add API endpoint for user stats
Files: src/api/users.ts, src/types/user.ts
``` ```
3. Launch **coder** agent with: 5. Continue to Step 4.
- Current task details
- Spec context
- Relevant patterns from memory
- Files to modify
4. After coder completes: ## Step 4: Implementation Loop
- Update status.json with task progress
- Ask: "Continue to next task? [Yes] [No] [Skip]"
5. Repeat until all tasks complete **FOR EACH TASK, execute these sub-steps in order:**
### 5. Completion ### 4a. Display Task Banner
When all tasks done:
- Update status to `IMPLEMENTATION_COMPLETE`
- Display summary:
```
Build complete: {feature-name}
Tasks completed: 7/7
Files modified: 12
Next steps:
- Run QA review: /ab:qa-review
- Or test manually and save learnings: /ab:memory-save
```
## State Machine
``` ```
SPEC_COMPLETE ════════════════════════════════════════════════════════════════
| TASK {N}/{TOTAL}: {Task Title}
v ════════════════════════════════════════════════════════════════
PLANNING (planner agent running) Status: Starting...
| Files: {list of files}
v ────────────────────────────────────────────────────────────────
PLANNING_COMPLETE
|
v
IMPLEMENTING (coder agent loop)
|
+---> [user skips/aborts] ---> PAUSED
|
v
IMPLEMENTATION_COMPLETE
|
v
[/ab:qa-review] ---> QA_REVIEW ---> COMPLETE
``` ```
## Resume Logic ### 4b. Update Status to In-Progress
If status is already `IMPLEMENTING`:
- Read `currentTask` from status.json
- Ask: "Resume from task {n}/{total}? [Yes] [Restart] [Cancel]"
- If yes: Continue from that task
- If restart: Reset to task 1
## Status JSON During Build
Write to `.auto-build/specs/{feature-name}/status.json`:
```json ```json
{ {
"feature": "user-dashboard", "feature": "{feature-name}",
"status": "IMPLEMENTING", "status": "IMPLEMENTING",
"currentTask": 3, "currentTask": {N},
"totalTasks": 7, "totalTasks": {TOTAL},
"worktree": "../ab-worktrees/project-user-dashboard/", "updated": "{ISO timestamp}",
"created": "2025-01-15T10:00:00Z",
"updated": "2025-01-15T14:30:00Z",
"history": [ "history": [
{"status": "SPEC_COMPLETE", "at": "..."}, ...existing...,
{"status": "PLANNING_COMPLETE", "at": "..."}, {"status": "IMPLEMENTING", "at": "{timestamp}", "task": {N}, "started": true}
{"status": "IMPLEMENTING", "at": "...", "task": 1},
{"status": "IMPLEMENTING", "at": "...", "task": 2},
{"status": "IMPLEMENTING", "at": "...", "task": 3}
] ]
} }
``` ```
### 4c. Execute Task
Implement the task according to plan.md specifications.
### 4d. MANDATORY: Update Progress Files
**After completing each task, you MUST execute these updates before doing anything else:**
**Update 1 - status.json:**
Write to `.auto-build/specs/{feature-name}/status.json`:
```json
{
"feature": "{feature-name}",
"status": "IMPLEMENTING",
"currentTask": {N+1},
"totalTasks": {TOTAL},
"updated": "{ISO timestamp}",
"tasksCompleted": {N},
"history": [
...existing...,
{"status": "IMPLEMENTING", "at": "{timestamp}", "task": {N}, "title": "{title}", "completed": true}
]
}
```
**Update 2 - plan.md Progress Tracker:**
Edit the plan.md file to update the task status:
- Change `⬜ Pending` to `✅ Done` for the completed task
- Add completion timestamp
Example edit in plan.md:
```markdown
## Progress Tracker
| Task | Status | Completed |
|------|--------|-----------|
| Task 1: Setup | ✅ Done | 2025-01-15 14:30 |
| Task 2: API | ⬜ Pending | |
```
And in the task section:
```markdown
### Task 1: Setup
- **Status**: ✅ Done (2025-01-15 14:30)
```
### 4e. Display Completion and Confirm
```
════════════════════════════════════════════════════════════════
✅ TASK {N}/{TOTAL} COMPLETED: {Task Title}
════════════════════════════════════════════════════════════════
Progress: {N}/{TOTAL} tasks done ({percentage}%)
Next task: {N+1}. {Next Task Title}
Continue to next task? [Yes] [No] [Skip]
```
Wait for user confirmation before proceeding to next task.
### 4f. Repeat
Go back to 4a for the next task until all tasks are complete.
## Step 5: Build Complete
When all tasks are done:
1. Update status.json:
```json
{
"status": "IMPLEMENTATION_COMPLETE",
"currentTask": {TOTAL},
"totalTasks": {TOTAL},
"tasksCompleted": {TOTAL},
"updated": "{ISO timestamp}",
"history": [..., {"status": "IMPLEMENTATION_COMPLETE", "at": "{timestamp}"}]
}
```
2. Update plan.md header:
```markdown
# Implementation Plan: {feature-name}
**Status**: ✅ COMPLETE
**Completed**: {timestamp}
```
3. Display summary:
```
════════════════════════════════════════════════════════════════
BUILD COMPLETE: {feature-name}
════════════════════════════════════════════════════════════════
✅ Tasks completed: {TOTAL}/{TOTAL}
📁 Files modified: {count}
⏱️ Duration: {time}
NEXT STEPS:
1. Test the implementation
2. Run QA review: /ab:qa-review
3. Save learnings: /ab:memory-save
════════════════════════════════════════════════════════════════
```
## Resume Logic
If status is `IMPLEMENTING` with `currentTask > 1`:
1. Display:
```
════════════════════════════════════════════════════════════════
RESUMING BUILD: {feature-name}
════════════════════════════════════════════════════════════════
Previous progress: {tasksCompleted}/{TOTAL} tasks completed
Resume from: Task {currentTask}
[Resume] [Restart from Task 1] [Cancel]
```
2. If Resume: Continue from Step 4 at task {currentTask}
3. If Restart: Reset currentTask to 1, continue from Step 4
## Why Progress Tracking Matters
- **Team collaboration**: Other developers can see progress and continue your work
- **Resume capability**: If interrupted, you can pick up where you left off
- **Visibility**: Users can check /ab:status to see current progress
- **History**: Complete audit trail of implementation
## Error Handling ## Error Handling
- If coder fails on a task: Mark task as failed, ask user to continue or fix manually - **Task fails**: Mark task as failed in history, ask user to fix manually or skip
- If worktree creation fails: Continue without worktree, warn user - **Spec not found**: Display "Spec not found. Create with: /ab:spec {name}"
- If spec not found: "Spec not found. Create with: /ab:spec {name}" - **Plan not found but PLANNING_COMPLETE**: Re-run planning phase
## Note on Team Collaboration
Since specs and plans are stored in `.auto-build/` (committed to git), any team member can:
1. Clone the repo and see existing specs/plans
2. Continue implementation from where another developer left off
3. Share memory (patterns, gotchas) with the team
After making progress, commit changes to share with team:
```bash
git add .auto-build/
git commit -m "build: {feature-name} - completed task X/Y"
```