catlog22/Claude-Code-Workflow
1
0
Fork 0
mirror of https://github.com/catlog22/Claude-Code-Workflow.git synced 2026-02-12 02:37:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: enhance test workflow with dynamic execution and flexible task generation

Browse Source 
Renamed test-gen to test-fix-gen and created new test-execute command for
dynamic iterative test-fix cycles. Improved task generation flexibility and
clarified data flow between planning and execution phases.

Key changes:
- Rename test-gen.md → test-fix-gen.md to reflect task generation purpose
- Add test-execute.md for dynamic test-fix workflow execution with CLI analysis
- Enhance test-fix-gen.md:
  * Emphasize code-developer's understanding and analysis responsibilities
  * Support flexible task count (minimum 2, expandable based on complexity)
  * Add examples for multi-module test generation scenarios
- Clarify test-execute.md data flow:
  * failure_context contains raw test output and error messages
  * fix_strategy generated by CLI tool (Gemini/Qwen) analysis
  * IMPL-001 (test generation) executes first, then IMPL-002 (test-fix cycle)

This improves workflow clarity and enables adaptive test-fix strategies for
complex projects requiring multiple test generation tasks.

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
catlog22
2025-10-17 15:54:09 +08:00
parent b62b777a95
commit 2dbc818894
2 changed files with 731 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

651
.claude/commands/workflow/test-execute.md Normal file
View File

@@ -0,0 +1,651 @@
---
name: test-execute
description: Execute test-fix workflow with dynamic task generation and iterative fix cycles
argument-hint: "[--resume-session=\"session-id\"] [--max-iterations=N]"
allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*)
---
# Workflow Test-Execute Command
## Overview
Orchestrates dynamic test-fix workflow execution through iterative cycles of testing, analysis, and fixing. **Unlike standard execute, this command dynamically generates intermediate tasks** during execution based on test results and CLI analysis, enabling adaptive problem-solving.
**Resume Mode**: When called with `--resume-session` flag, skips discovery and continues from interruption point.
## Core Philosophy
### Dynamic vs Static Execution
**Standard Execute**: Pre-defined task queue → Sequential execution → Complete
**Test Execute**: Initial tasks → Test → Analyze → Generate fix tasks → Execute → Re-test → Repeat
### Iteration Loop Pattern
```
1. Execute current task (test/implement)
2. Run tests and collect results
3. If failures: CLI analysis → Generate fix tasks → Execute → Back to 2
4. If success: Mark complete → Next task
5. Repeat until all tests pass or max iterations reached
```
### Agent Coordination
- **@code-developer**: Understands requirements, generates implementations
- **@test-fix-agent**: Executes tests, applies fixes, validates results
- **CLI Tools (Gemini/Qwen)**: Analyzes failures, suggests fix strategies
## Core Rules
1. **Dynamic Task Generation**: Create intermediate fix tasks based on test failures
2. **Iterative Execution**: Repeat test-fix cycles until success or max iterations
3. **CLI-Driven Analysis**: Use Gemini/Qwen to analyze failures and plan fixes
4. **Agent Delegation**: All execution delegated to specialized agents
5. **Context Accumulation**: Each iteration builds on previous attempt context
6. **Autonomous Completion**: Continue until all tests pass without user interruption
## Core Responsibilities
- **Session Discovery**: Identify test-fix workflow sessions
- **Task Queue Management**: Maintain dynamic task queue with runtime additions
- **Test Execution**: Run tests through @test-fix-agent
- **Failure Analysis**: Use CLI tools to diagnose test failures
- **Fix Task Generation**: Create intermediate fix tasks dynamically
- **Iteration Control**: Manage fix cycles with max iteration limits
- **Context Propagation**: Pass failure context and fix history between iterations
- **Progress Tracking**: TodoWrite updates for entire iteration cycle
- **Session Auto-Complete**: Call `/workflow:session:complete` when all tests pass
## Responsibility Matrix
**Clear division of labor between orchestrator and agents:**
| Responsibility | test-execute (Orchestrator) | @test-fix-agent (Executor) |
|----------------|----------------------------|---------------------------|
| Manage iteration loop | ✅ Controls loop flow | ❌ Executes single task |
| Run CLI analysis (Gemini/Qwen) | ✅ Runs between agent tasks | ❌ Not involved |
| Generate IMPL-fix-N.json | ✅ Creates task files | ❌ Not involved |
| Run tests | ❌ Delegates to agent | ✅ Executes test command |
| Apply fixes | ❌ Delegates to agent | ✅ Modifies code |
| Detect test failures | ✅ Analyzes agent output | ✅ Reports results |
| Add tasks to queue | ✅ Manages queue | ❌ Not involved |
| Update iteration state | ✅ Maintains state files | ✅ Updates task status |
**Key Principle**: Orchestrator manages the "what" and "when"; agents execute the "how".
## Execution Lifecycle
### Phase 1: Discovery & Initialization
1. **Detect Session Type**: Identify test-fix session from `workflow_type: "test_session"`
2. **Load Session State**: Read `workflow-session.json`, `IMPL_PLAN.md`, `TODO_LIST.md`
3. **Scan Initial Tasks**: Analyze `.task/*.json` files
4. **Initialize TodoWrite**: Create task list including initial tasks
5. **Prepare Iteration Context**: Setup iteration counter and max limits
**Resume Mode**: Load existing iteration context from `.process/iteration-state.json`
### Phase 2: Task Execution Loop
**Main execution loop with dynamic task generation (executed by test-execute orchestrator):**
**Execution Order**: The workflow begins by executing IMPL-001 (test generation) first. Upon successful completion, IMPL-002 (test-fix cycle) is initiated, starting the iterative test-fix loop.
```
For each task in queue:
1. [Orchestrator] Load task JSON and context
2. [Orchestrator] Determine task type (test-gen, test-fix, fix-iteration)
3. [Orchestrator] Execute task through appropriate agent
4. [Orchestrator] Collect agent results and check exit conditions
5. If test failures detected:
a. [Orchestrator] Run CLI analysis (Gemini/Qwen)
b. [Orchestrator] Generate fix task JSON (IMPL-fix-N.json)
c. [Orchestrator] Insert fix task at front of queue
d. [Orchestrator] Continue loop
6. If test success:
a. [Orchestrator] Mark task complete
b. [Orchestrator] Update TodoWrite
c. [Orchestrator] Continue to next task
7. [Orchestrator] Check max iterations limit
```
**Note**: The orchestrator controls the loop. Agents execute individual tasks and return results.
### Phase 3: Iteration Cycle (Test-Fix Loop)
**Orchestrator-controlled iteration with agent delegation:**
#### Iteration Structure
```
Iteration N (managed by test-execute orchestrator):
├── 1. Test Execution
│ ├── [Orchestrator] Launch @test-fix-agent with test task
│ ├── [Agent] Run test suite
│ ├── [Agent] Collect failures and report back
│ └── [Orchestrator] Receive failure report
├── 2. Failure Analysis
│ ├── [Orchestrator] Run CLI tool (Gemini/Qwen)
│ ├── [CLI Tool] Analyze error messages and failure context
│ ├── [CLI Tool] Identify root causes
│ └── [CLI Tool] Generate fix strategy → saved to iteration-N-analysis.md
├── 3. Fix Task Generation
│ ├── [Orchestrator] Parse CLI analysis results
│ ├── [Orchestrator] Create IMPL-fix-N.json with:
│ │ ├── meta.agent: "@test-fix-agent"
│ │ ├── Failure context (content, not just path)
│ │ └── Fix strategy from CLI analysis
│ └── [Orchestrator] Insert into task queue (front position)
├── 4. Fix Execution
│ ├── [Orchestrator] Launch @test-fix-agent with fix task
│ ├── [Agent] Load fix strategy from task context
│ ├── [Agent] Apply fixes to code/tests
│ └── [Agent] Report completion
└── 5. Re-test
└── [Orchestrator] Return to step 1 with updated code
```
**Key**: Orchestrator runs CLI analysis between agent tasks, then generates new fix tasks.
#### Iteration Task JSON Template
```json
{
"id": "IMPL-fix-{iteration}",
"title": "Fix test failures - Iteration {N}",
"status": "pending",
"meta": {
"type": "test-fix-iteration",
"agent": "@test-fix-agent",
"iteration": N,
"parent_task": "IMPL-002",
"max_iterations": 5
},
"context": {
"requirements": [
"Fix identified test failures",
"Address root causes from analysis"
],
"failure_context": {
"failed_tests": ["test1", "test2"],
"error_messages": ["error1", "error2"],
"failure_analysis": "Raw test output and error messages",
"previous_attempts": ["iteration-1 context"]
},
"fix_strategy": {
"approach": "Generated by CLI tool (Gemini/Qwen) analysis",
"modification_points": ["file1:func1", "file2:func2"],
"expected_outcome": "All tests pass"
},
"depends_on": ["IMPL-fix-{N-1}"],
"inherited": {
"iteration_history": [...]
}
},
"flow_control": {
"pre_analysis": [
{
"step": "load_failure_context",
"command": "Read(.workflow/{session}/.process/iteration-{N-1}-failures.json)",
"output_to": "previous_failures",
"on_error": "skip_optional"
},
{
"step": "load_fix_strategy",
"command": "Read(.workflow/{session}/.process/iteration-{N}-strategy.md)",
"output_to": "fix_strategy",
"on_error": "fail"
}
],
"implementation_approach": [
{
"step": 1,
"title": "Apply fixes from strategy",
"description": "Implement fixes identified by CLI analysis",
"modification_points": "From fix_strategy",
"logic_flow": [
"Load failure context and strategy",
"Apply surgical fixes",
"Run tests",
"Validate fixes"
]
}
],
"target_files": ["from fix_strategy"],
"exit_conditions": {
"success": "all_tests_pass",
"failure": "max_iterations_reached",
"max_iterations": 5
}
}
}
```
### Phase 4: CLI Analysis Integration
**Orchestrator executes CLI analysis between agent tasks:**
#### When Test Failures Occur
1. **[Orchestrator]** Detects failures from agent output
2. **[Orchestrator]** Collects failure context from `.process/test-results.json` and logs
3. **[Orchestrator]** Runs Gemini/Qwen wrapper with failure context
4. **[CLI Tool]** Analyzes failures and generates fix strategy
5. **[Orchestrator]** Saves analysis to `.process/iteration-N-analysis.md`
6. **[Orchestrator]** Generates `IMPL-fix-N.json` with strategy content (not just path)
#### CLI Analysis Command (executed by orchestrator)
```bash
cd {project_root} && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: Analyze test failures and generate fix strategy
TASK: Review test failures and identify root causes
MODE: analysis
CONTEXT: @{test files, implementation files}
[Test failure context and requirements...]
EXPECTED: Detailed fix strategy in markdown format
RULES: Focus on minimal changes, avoid over-engineering
"
```
#### Analysis Output Structure
```markdown
# Test Failure Analysis - Iteration {N}
## Root Cause Analysis
1. **Test: test_auth_flow**
- Error: `Expected 200, got 401`
- Root Cause: Missing authentication token in request headers
- Affected Code: `src/auth/client.ts:45`
2. **Test: test_data_validation**
- Error: `TypeError: Cannot read property 'name' of undefined`
- Root Cause: Null check missing before property access
- Affected Code: `src/validators/user.ts:23`
## Fix Strategy
### Priority 1: Authentication Issue
- **File**: src/auth/client.ts
- **Function**: sendRequest (line 45)
- **Change**: Add token header: `headers['Authorization'] = 'Bearer ' + token`
- **Verification**: Run test_auth_flow
### Priority 2: Null Check
- **File**: src/validators/user.ts
- **Function**: validateUser (line 23)
- **Change**: Add check: `if (!user?.name) return false`
- **Verification**: Run test_data_validation
## Verification Plan
1. Apply fixes in order
2. Run test suite after each fix
3. Check for regressions
4. Validate all tests pass
## Risk Assessment
- Low risk: Changes are surgical and isolated
- No breaking changes expected
- Existing tests should remain green
```
### Phase 5: Task Queue Management
**Orchestrator maintains dynamic task queue with runtime insertions:**
#### Dynamic Queue Operations
```
Initial Queue: [IMPL-001, IMPL-002]
After IMPL-002 execution (test failures detected by orchestrator):
[Orchestrator] Generates IMPL-fix-1.json
[Orchestrator] Inserts at front: [IMPL-fix-1, IMPL-002-retest, ...]
After IMPL-fix-1 execution (still failures):
[Orchestrator] Generates IMPL-fix-2.json
[Orchestrator] Inserts at front: [IMPL-fix-2, IMPL-002-retest, ...]
After IMPL-fix-2 execution (success):
[Orchestrator] Continues to: [IMPL-002-complete, ...]
```
#### Queue Priority Rules (orchestrator-managed)
1. **Fix tasks**: Inserted at queue front for immediate execution
2. **Retest tasks**: Automatically scheduled after fix tasks
3. **Regular tasks**: Standard dependency order preserved
4. **Iteration limit**: Max 5 fix iterations per test task (orchestrator enforces)
### Phase 6: Completion & Session Management
#### Success Conditions
- All initial tasks completed
- All generated fix tasks completed
- All tests passing
- No pending tasks in queue
#### Completion Steps
1. **Final Validation**: Run full test suite one more time
2. **Update Session State**: Mark all tasks completed
3. **Generate Summary**: Create session completion summary
4. **Update TodoWrite**: Mark all items completed
5. **Auto-Complete**: Call `/workflow:session:complete`
#### Failure Conditions
- Max iterations reached without success
- Unrecoverable test failures
- Agent execution errors
#### Failure Handling
1. **Document State**: Save current iteration context
2. **Generate Report**: Create failure analysis report
3. **Preserve Context**: Keep all iteration logs
4. **Mark Blocked**: Update task status to blocked
5. **Return Control**: Return to user with detailed report
## TodoWrite Coordination
### TodoWrite Structure for Test-Execute
```javascript
TodoWrite({
todos: [
{
content: "Execute IMPL-001: Generate tests [code-developer]",
status: "completed",
activeForm: "Executing test generation"
},
{
content: "Execute IMPL-002: Test & Fix Cycle [test-fix-agent] [ITERATION]",
status: "in_progress",
activeForm: "Running test-fix iteration cycle"
},
{
content: " → Iteration 1: Initial test run",
status: "completed",
activeForm: "Running initial tests"
},
{
content: " → Iteration 2: Fix auth issues",
status: "in_progress",
activeForm: "Fixing authentication issues"
},
{
content: " → Iteration 3: Re-test and validate",
status: "pending",
activeForm: "Re-testing after fixes"
}
]
});
```
### TodoWrite Update Rules
1. **Initial Tasks**: Standard task list
2. **Iteration Start**: Add nested iteration item
3. **Fix Task Added**: Add fix task as nested item
4. **Iteration Complete**: Mark iteration item completed
5. **All Complete**: Mark parent task completed
## Agent Context Package
**Generated by test-execute orchestrator before launching agents.**
The orchestrator assembles this context package from:
- Task JSON file (IMPL-*.json)
- Iteration state files
- Test results and failure context
- Session metadata
This package is passed to agents via the Task tool's prompt context.
### Enhanced Context for Test-Fix Agent
```json
{
"task": { /* IMPL-fix-N.json */ },
"iteration_context": {
"current_iteration": N,
"max_iterations": 5,
"previous_attempts": [
{
"iteration": N-1,
"failures": ["test1", "test2"],
"fixes_attempted": ["fix1", "fix2"],
"result": "partial_success"
}
],
"failure_analysis": {
"source": "gemini_cli",
"analysis_file": ".process/iteration-N-analysis.md",
"fix_strategy": { /* from CLI */ }
}
},
"test_context": {
"test_framework": "jest|pytest|...",
"test_files": ["path/to/test1.test.ts"],
"test_command": "npm test",
"coverage_target": 80
},
"session": {
"workflow_dir": ".workflow/WFS-test-{session}/",
"iteration_state_file": ".process/iteration-state.json",
"test_results_file": ".process/test-results.json",
"fix_history_file": ".process/fix-history.json"
}
}
```
## File Structure
### Test-Fix Session Files
```
.workflow/WFS-test-{session}/
├── workflow-session.json # Session metadata with workflow_type
├── IMPL_PLAN.md # Test plan
├── TODO_LIST.md # Progress tracking
├── .task/
│ ├── IMPL-001.json # Test generation task
│ ├── IMPL-002.json # Initial test-fix task
│ ├── IMPL-fix-1.json # Generated: Iteration 1 fix
│ ├── IMPL-fix-2.json # Generated: Iteration 2 fix
│ └── ...
├── .summaries/
│ ├── IMPL-001-summary.md
│ ├── IMPL-002-summary.md
│ └── iteration-summaries/
│ ├── iteration-1.md
│ ├── iteration-2.md
│ └── ...
└── .process/
├── TEST_ANALYSIS_RESULTS.md # From planning phase
├── iteration-state.json # Current iteration state
├── test-results.json # Latest test results
├── test-output.log # Full test output
├── fix-history.json # All fix attempts
├── iteration-1-analysis.md # CLI analysis for iteration 1
├── iteration-1-failures.json # Failures from iteration 1
├── iteration-1-strategy.md # Fix strategy for iteration 1
├── iteration-2-analysis.md
└── ...
```
### Iteration State JSON
```json
{
"session_id": "WFS-test-user-auth",
"current_task": "IMPL-002",
"current_iteration": 2,
"max_iterations": 5,
"started_at": "2025-10-17T10:00:00Z",
"iterations": [
{
"iteration": 1,
"started_at": "2025-10-17T10:05:00Z",
"completed_at": "2025-10-17T10:15:00Z",
"test_results": {
"total": 10,
"passed": 7,
"failed": 3,
"failures": ["test1", "test2", "test3"]
},
"analysis_file": ".process/iteration-1-analysis.md",
"fix_task": "IMPL-fix-1",
"result": "partial_success"
}
],
"status": "active",
"next_action": "execute_fix_task"
}
```
## Agent Prompt Template
**Unified template for all agent tasks (orchestrator invokes with Task tool):**
```bash
Task(subagent_type="{meta.agent}",
prompt="**TASK EXECUTION: {task.title}**
## STEP 1: Load Complete Task JSON
**MANDATORY**: First load the complete task JSON from: {session.task_json_path}
cat {session.task_json_path}
**CRITICAL**: Validate all required fields present
## STEP 2: Task Context (From Loaded JSON)
**ID**: {task.id}
**Type**: {task.meta.type}
**Agent**: {task.meta.agent}
## STEP 3: Execute Task Based on Type
### For test-gen (IMPL-001):
- Generate tests based on TEST_ANALYSIS_RESULTS.md
- Follow test framework conventions
- Create test files in target_files
### For test-fix (IMPL-002):
- Run test suite: {test_command}
- Collect results to .process/test-results.json
- If failures: Save context, return to orchestrator
- If success: Mark complete
### For test-fix-iteration (IMPL-fix-N):
- Load fix strategy from context.fix_strategy (CONTENT, not path)
- Apply surgical fixes to identified files
- Run tests to verify
- If still failures: Save context with new failure data
- Update iteration state
## STEP 4: Implementation Context (From JSON)
**Requirements**: {context.requirements}
**Fix Strategy**: {context.fix_strategy} (full content provided in task JSON)
**Failure Context**: {context.failure_context}
**Iteration History**: {context.inherited.iteration_history}
## STEP 5: Flow Control Execution
If flow_control.pre_analysis exists, execute steps sequentially
## STEP 6: Agent Completion
1. Execute task following implementation_approach
2. Update task status in JSON
3. Update TODO_LIST.md
4. Generate summary in .summaries/
5. **CRITICAL**: Save results for orchestrator to analyze
**Output Requirements**:
- test-results.json: Structured test results
- test-output.log: Full test output
- iteration-state.json: Current iteration state (if applicable)
- task-summary.md: Completion summary
**Return to Orchestrator**: Agent completes and returns. Orchestrator decides next action.
"),
description="Execute {task.type} task with JSON validation")
```
**Key Points**:
- Agent executes single task and returns
- Orchestrator analyzes results and decides next step
- Fix strategy content (not path) embedded in task JSON by orchestrator
- Agent does not manage iteration loop
## Error Handling & Recovery
### Iteration Failure Scenarios
| Scenario | Handling | Recovery |
|----------|----------|----------|
| Test execution error | Log error, save context | Retry with error context |
| CLI analysis failure | Fallback to Qwen, or manual analysis | Retry analysis with different tool |
| Agent execution error | Save iteration state | Retry agent with simplified context |
| Max iterations reached | Generate failure report | Mark blocked, return to user |
| Unexpected test regression | Rollback last fix | Analyze regression, add to fix strategy |
### Recovery Procedures
#### Resume from Interruption
```bash
# Load iteration state
iteration_state=$(cat .workflow/{session}/.process/iteration-state.json)
current_iteration=$(jq -r '.current_iteration' <<< "$iteration_state")
# Determine resume point
if [[ "$(jq -r '.next_action' <<< "$iteration_state")" == "execute_fix_task" ]]; then
# Resume fix task execution
task_id="IMPL-fix-${current_iteration}"
else
# Resume test execution
task_id="IMPL-002"
fi
```
#### Rollback Failed Fix
```bash
# Revert last commit (if fixes were committed)
git revert HEAD
# Remove failed fix task
rm .workflow/{session}/.task/IMPL-fix-{N}.json
# Restore iteration state
jq '.current_iteration -= 1' iteration-state.json > temp.json
mv temp.json iteration-state.json
# Re-run analysis with additional context
# Include failure reason in next analysis
```
## Usage Examples
### Basic Usage
```bash
# Execute test-fix workflow
/workflow:test-execute
# Resume interrupted session
/workflow:test-execute --resume-session="WFS-test-user-auth"
# Set custom iteration limit
/workflow:test-execute --max-iterations=10
```
### Integration with Planning
```bash
# 1. Plan test workflow
/workflow:test-fix-gen WFS-user-auth
# 2. Execute with dynamic iteration
/workflow:test-execute
# 3. Monitor progress
/workflow:status
# 4. Resume if interrupted
/workflow:test-execute --resume-session="WFS-test-user-auth"
```
## Best Practices
1. **Set Realistic Iteration Limits**: Default 5, increase for complex fixes
2. **Commit Between Iterations**: Easier rollback if needed
3. **Monitor Iteration Logs**: Review CLI analysis for insights
4. **Incremental Fixes**: Prefer multiple small iterations over large changes
5. **Verify No Regressions**: Check all tests pass, not just previously failing ones
6. **Preserve Context**: All iteration artifacts saved for debugging
## Related Commands
- `/workflow:test-fix-gen` - Planning phase (creates initial tasks)
- `/workflow:execute` - Standard workflow execution (no dynamic iteration)
- `/workflow:status` - Check progress and iteration state
- `/workflow:session:complete` - Mark session complete (auto-called on success)
- `/task:create` - Manually create additional tasks if needed

120
.claude/commands/workflow/test-gen.md → .claude/commands/workflow/test-fix-gen.md
View File

@@ -1,11 +1,11 @@
--- ---
name: test-gen name: test-fix-gen
description: Create independent test-fix workflow session by analyzing completed implementation description: Create independent test-fix workflow session by analyzing completed implementation
argument-hint: "[--use-codex] [--cli-execute] source-session-id" argument-hint: "[--use-codex] [--cli-execute] source-session-id"
allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
--- ---
# Workflow Test Generation Command (/workflow:test-gen) # Workflow Test-Fix Generation Command (/workflow:test-fix-gen)
## Coordinator Role ## Coordinator Role
@@ -24,13 +24,15 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md 3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md
4. Generate test task from analysis → Return summary 4. Generate test task from analysis → Return summary
**⚠️ Command Scope**: This command prepares test workflow artifacts only. Task execution requires separate commands.
## Core Rules ## Core Rules
1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 test session creation 1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 test session creation
2. **No Preliminary Analysis**: Do not read files or analyze before Phase 1 2. **No Preliminary Analysis**: Do not read files or analyze before Phase 1
3. **Parse Every Output**: Extract required data from each phase for next phase 3. **Parse Every Output**: Extract required data from each phase for next phase
4. **Sequential Execution**: Each phase depends on previous phase's output 4. **Sequential Execution**: Each phase depends on previous phase's output
5. **Complete All Phases**: Do not return to user until Phase 4 completes (execution triggered separately) 5. **Complete All Phases**: Do not return to user until Phase 5 completes (command ends after summary)
6. **Track Progress**: Update TodoWrite after every phase completion 6. **Track Progress**: Update TodoWrite after every phase completion
7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context 7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context
8. **Parse --use-codex Flag**: Extract flag from arguments and pass to Phase 4 (test-task-generate) 8. **Parse --use-codex Flag**: Extract flag from arguments and pass to Phase 4 (test-task-generate)
@@ -133,25 +135,36 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
**Expected Behavior**: **Expected Behavior**:
- Parse TEST_ANALYSIS_RESULTS.md from Phase 3 - Parse TEST_ANALYSIS_RESULTS.md from Phase 3
- Extract test requirements and generation strategy - Extract test requirements and generation strategy
- Generate **TWO task JSON files**: - Generate **task JSON files** (minimum 2, expandable based on complexity):
- **IMPL-001.json**: Test Generation task (calls @code-developer) - **IMPL-001.json**: Test Understanding & Generation task (calls @code-developer)
- Understand source code implementation
- Analyze test requirements from TEST_ANALYSIS_RESULTS.md
- Generate test files following existing patterns
- **IMPL-002.json**: Test Execution and Fix Cycle task (calls @test-fix-agent) - **IMPL-002.json**: Test Execution and Fix Cycle task (calls @test-fix-agent)
- **IMPL-003+**: Additional tasks if needed (e.g., per-module test generation for complex projects)
- Generate IMPL_PLAN.md with test generation and execution strategy - Generate IMPL_PLAN.md with test generation and execution strategy
- Generate TODO_LIST.md with both tasks - Generate TODO_LIST.md with all tasks
**Parse Output**: **Parse Output**:
- Verify `.workflow/[testSessionId]/.task/IMPL-001.json` exists (test generation) - Verify `.workflow/[testSessionId]/.task/IMPL-001.json` exists (test understanding & generation)
- Verify `.workflow/[testSessionId]/.task/IMPL-002.json` exists (test execution & fix) - Verify `.workflow/[testSessionId]/.task/IMPL-002.json` exists (test execution & fix)
- Verify additional `.task/IMPL-*.json` files if complex project requires multi-task breakdown
- Verify `.workflow/[testSessionId]/IMPL_PLAN.md` created - Verify `.workflow/[testSessionId]/IMPL_PLAN.md` created
- Verify `.workflow/[testSessionId]/TODO_LIST.md` created - Verify `.workflow/[testSessionId]/TODO_LIST.md` created
**Validation - IMPL-001.json (Test Generation)**: **Validation - IMPL-001.json (Test Understanding & Generation)**:
- Task ID: `IMPL-001` - Task ID: `IMPL-001`
- `meta.type: "test-gen"` - `meta.type: "test-gen"`
- `meta.agent: "@code-developer"` - `meta.agent: "@code-developer"`
- `context.requirements`: Generate tests based on TEST_ANALYSIS_RESULTS.md - `context.requirements`: Understand source implementation and generate tests
- `flow_control.pre_analysis`: Load TEST_ANALYSIS_RESULTS.md and test context - `flow_control.pre_analysis`:
- `flow_control.implementation_approach`: Test generation steps - Load TEST_ANALYSIS_RESULTS.md and test context
- Understand source code implementation patterns
- Analyze test requirements and existing test conventions
- `flow_control.implementation_approach`:
- Phase 1: Understand source code and identify test scenarios
- Phase 2: Generate test files following existing patterns
- Phase 3: Verify test completeness
- `flow_control.target_files`: Test files to create from analysis section 5 - `flow_control.target_files`: Test files to create from analysis section 5
**Validation - IMPL-002.json (Test Execution & Fix)**: **Validation - IMPL-002.json (Test Execution & Fix)**:
@@ -184,22 +197,24 @@ Source Session: [sourceSessionId]
Test Session: [testSessionId] Test Session: [testSessionId]
Tasks Created: Tasks Created:
- IMPL-001: Test Generation (@code-developer) - IMPL-001: Test Understanding & Generation (@code-developer)
- IMPL-002: Test Execution & Fix Cycle (@test-fix-agent) - IMPL-002: Test Execution & Fix Cycle (@test-fix-agent)
- [Additional tasks if applicable]
Test Framework: [detected framework] Test Framework: [detected framework]
Test Files to Generate: [count] Test Files to Generate: [count]
Max Fix Iterations: 5 Max Fix Iterations: 5
Fix Mode: [Manual|Codex Automated] (based on --use-codex flag) Fix Mode: [Manual|Codex Automated] (based on --use-codex flag)
Next Steps: Review artifacts:
1. Review test plan: .workflow/[testSessionId]/IMPL_PLAN.md - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
2. Execute workflow: /workflow:execute - Task list: .workflow/[testSessionId]/TODO_LIST.md
3. Monitor progress: /workflow:status
``` ```
**TodoWrite**: Mark phase 5 completed **TodoWrite**: Mark phase 5 completed
**Note**: Command completes here. Task execution requires separate workflow commands.
--- ---
## TodoWrite Pattern ## TodoWrite Pattern
@@ -220,21 +235,26 @@ Update status to `in_progress` when starting each phase, mark `completed` when d
## Data Flow ## Data Flow
``` **Command**: `/workflow:test-fix-gen WFS-user-auth`
/workflow:test-gen WFS-user-auth
↓ **Phase Execution**:
Phase 1: session-start → WFS-test-user-auth 1. Phase 1: session-start → WFS-test-user-auth
↓ 2. Phase 2: test-context-gather → test-context-package.json
Phase 2: test-context-gather → test-context-package.json 3. Phase 3: test-concept-enhanced → TEST_ANALYSIS_RESULTS.md
↓ 4. Phase 4: test-task-generate → IMPL-001.json + IMPL-002.json (+ additional tasks if needed)
Phase 3: test-concept-enhanced → TEST_ANALYSIS_RESULTS.md 5. Phase 5: Return summary
↓
Phase 4: test-task-generate → IMPL-001.json + IMPL-002.json **Command completes after Phase 5**
↓
Phase 5: Return summary **Artifacts Created**:
↓ - `.workflow/WFS-test-[session]/workflow-session.json`
/workflow:execute → IMPL-001 (@code-developer) → IMPL-002 (@test-fix-agent) - `.workflow/WFS-test-[session]/IMPL_PLAN.md`
``` - `.workflow/WFS-test-[session]/TODO_LIST.md`
- `.workflow/WFS-test-[session]/.task/IMPL-001.json` (test understanding & generation)
- `.workflow/WFS-test-[session]/.task/IMPL-002.json` (test execution & fix)
- `.workflow/WFS-test-[session]/.task/IMPL-*.json` (additional tasks if needed)
- `.workflow/WFS-test-[session]/.process/test-context-package.json`
- `.workflow/WFS-test-[session]/.process/TEST_ANALYSIS_RESULTS.md`
## Session Metadata ## Session Metadata
@@ -242,9 +262,16 @@ Test session includes `workflow_type: "test_session"` and `source_session_id` fo
## Task Output ## Task Output
Generates two tasks: Generates tasks (minimum 2, expandable based on complexity):
- **IMPL-001** (@code-developer): Test generation from TEST_ANALYSIS_RESULTS.md - **IMPL-001** (@code-developer): Understand source implementation and generate tests
- Analyze source code patterns
- Study test requirements from TEST_ANALYSIS_RESULTS.md
- Generate test files following conventions
- **IMPL-002** (@test-fix-agent): Test execution with iterative fix cycle (max 5 iterations) - **IMPL-002** (@test-fix-agent): Test execution with iterative fix cycle (max 5 iterations)
- **IMPL-003+** (optional): Additional tasks for complex scenarios
- Per-module test generation for large projects
- Separate integration vs unit test tasks
- Specialized test types (performance, security, etc.)
See `/workflow:tools:test-task-generate` for complete task JSON schemas. See `/workflow:tools:test-task-generate` for complete task JSON schemas.
@@ -264,16 +291,24 @@ Created in `.workflow/WFS-test-[session]/`:
- `workflow-session.json` - Session metadata - `workflow-session.json` - Session metadata
- `.process/test-context-package.json` - Coverage analysis - `.process/test-context-package.json` - Coverage analysis
- `.process/TEST_ANALYSIS_RESULTS.md` - Test requirements - `.process/TEST_ANALYSIS_RESULTS.md` - Test requirements
- `.task/IMPL-001.json` - Test generation task - `.task/IMPL-001.json` - Test understanding & generation task
- `.task/IMPL-002.json` - Test execution & fix task - `.task/IMPL-002.json` - Test execution & fix task
- `.task/IMPL-*.json` - Additional tasks (if complex project requires breakdown)
- `IMPL_PLAN.md` - Test plan - `IMPL_PLAN.md` - Test plan
- `TODO_LIST.md` - Task checklist - `TODO_LIST.md` - Task checklist
## Agent Execution ## Agent Execution
**IMPL-001** (@code-developer): **IMPL-001** (@code-developer):
- Generates test files based on TEST_ANALYSIS_RESULTS.md 1. **Understand Phase**:
- Follows existing test patterns and conventions - Analyze source code implementation patterns
- Study test requirements from TEST_ANALYSIS_RESULTS.md
- Identify test scenarios and edge cases
2. **Generation Phase**:
- Generate test files following existing patterns and conventions
- Ensure test coverage aligns with requirements
3. **Verification Phase**:
- Verify test completeness and correctness
**IMPL-002** (@test-fix-agent): **IMPL-002** (@test-fix-agent):
1. Run test suite 1. Run test suite
@@ -283,19 +318,24 @@ Created in `.workflow/WFS-test-[session]/`:
- Retest and check regressions - Retest and check regressions
3. Final validation and certification 3. Final validation and certification
**IMPL-003+** (optional, @code-developer or specialized agents):
- Additional task execution based on specific requirements
- May involve different test types or module-specific generation
See `/workflow:tools:test-task-generate` for detailed specifications. See `/workflow:tools:test-task-generate` for detailed specifications.
## Best Practices ## Best Practices
1. Run after implementation complete (ensure source session has summaries) 1. Run after implementation complete (ensure source session has summaries)
2. Commit implementation changes before test-gen 2. Commit implementation changes before running test-fix-gen
3. Monitor execution with `/workflow:status` 3. Review generated IMPL_PLAN.md before proceeding with execution
4. Review iteration logs in `.process/fix-iteration-*` 4. Monitor iteration logs in `.process/fix-iteration-*`
## Related Commands ## Related Commands
- `/workflow:tools:test-context-gather` - Phase 2 (coverage analysis) - `/workflow:tools:test-context-gather` - Phase 2 (coverage analysis)
- `/workflow:tools:test-concept-enhanced` - Phase 3 (Gemini test analysis) - `/workflow:tools:test-concept-enhanced` - Phase 3 (Gemini test analysis)
- `/workflow:tools:test-task-generate` - Phase 4 (task generation) - `/workflow:tools:test-task-generate` - Phase 4 (task generation)
- `/workflow:execute` - Execute workflow - `/workflow:test-execute` - Execute test-fix workflow with dynamic iteration
- `/workflow:execute` - Execute standard workflow tasks
- `/workflow:status` - Check progress - `/workflow:status` - Check progress