From 7047cae356f5b90d3a3b51883877c145a007ff78 Mon Sep 17 00:00:00 2001 From: catlog22 Date: Sat, 4 Oct 2025 20:11:12 +0800 Subject: [PATCH] feat: Optimize TDD workflow with streamlined file structure and test-gen integration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## TDD Workflow Enhancements ### File Structure Optimization - **Eliminated**: TDD_PLAN.md (merged into unified IMPL_PLAN.md) - **Eliminated**: .process/TDD_TASK_BREAKDOWN.md (enhanced ANALYSIS_RESULTS.md instead) - **Unified**: Single IMPL_PLAN.md with TDD Task Chains section - **Result**: Reduced 2 files per TDD session (-33% file count) ### Test-Gen Integration - Added test coverage analysis phase (Phase 3: test-context-gather) - Integrated iterative test-fix-cycle into Green phase (IMPL tasks) - Gemini diagnosis with bug-fix template for test failures - Auto-revert safety mechanism (max_iterations protection) - Manual fix by default, optional Codex automation (--use-codex flag) ### Workflow Improvements - 6-phase TDD planning (added test coverage analysis) - ANALYSIS_RESULTS.md enhanced with TDD breakdown structure - IMPL tasks include test-fix-cycle configuration - Unified IMPL_PLAN.md structure: frontmatter + TDD Task Chains + standard sections ### Configuration - meta.max_iterations: 3 (TDD) vs 5 (test-gen) - meta.use_codex: false (default manual fixes) - workflow_type: "tdd" in IMPL_PLAN.md frontmatter ### Benefits - Eliminated redundancy (2 fewer files, 1 less Gemini call) - Context-aware TDD (not greenfield-only) - Faster feedback (test-fix-cycle in Green phase) - Autonomous recovery (auto-diagnose and fix) - Backward compatible (no breaking changes) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .claude/commands/workflow/tdd-plan.md | 152 +++++++++++-- .claude/commands/workflow/test-gen.md | 26 ++- .../workflow/tools/task-generate-tdd.md | 199 +++++++++++++----- .../workflow/tools/test-task-generate.md | 125 ++++++----- 4 files changed, 381 insertions(+), 121 deletions(-) diff --git a/.claude/commands/workflow/tdd-plan.md b/.claude/commands/workflow/tdd-plan.md index b2475e5a..36868d88 100644 --- a/.claude/commands/workflow/tdd-plan.md +++ b/.claude/commands/workflow/tdd-plan.md @@ -29,7 +29,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) 5. **Complete All Phases**: Do not return until Phase 5 completes 6. **TDD Context**: All descriptions include "TDD:" prefix -## 5-Phase Execution +## 6-Phase Execution ### Phase 1: Session Discovery **Command**: `/workflow:session:start --auto "TDD: [structured-description]"` @@ -50,12 +50,36 @@ TEST_FOCUS: [Test scenarios] **Parse**: Extract contextPath -### Phase 3: TDD Analysis +### Phase 3: Test Coverage Analysis +**Command**: `/workflow:tools:test-context-gather --session [sessionId]` + +**Purpose**: Analyze existing codebase for: +- Existing test patterns and conventions +- Current test coverage +- Related components and integration points +- Test framework detection + +**Parse**: Extract testContextPath (`.workflow/[sessionId]/.process/test-context-package.json`) + +**Benefits**: +- Makes TDD aware of existing environment +- Identifies reusable test patterns +- Prevents duplicate test creation +- Enables integration with existing tests + +### Phase 4: TDD Analysis **Command**: `/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]` -**Parse**: Verify ANALYSIS_RESULTS.md +**Note**: Generates ANALYSIS_RESULTS.md with TDD-specific structure: +- Feature list with testable requirements +- Test cases for Red phase +- Implementation requirements for Green phase +- Refactoring opportunities +- Task dependencies and execution order -### Phase 4: TDD Task Generation +**Parse**: Verify ANALYSIS_RESULTS.md contains TDD breakdown sections + +### Phase 5: TDD Task Generation **Command**: - Manual: `/workflow:tools:task-generate-tdd --session [sessionId]` - Agent: `/workflow:tools:task-generate-tdd --session [sessionId] --agent` @@ -63,12 +87,13 @@ TEST_FOCUS: [Test scenarios] **Parse**: Extract feature count, chain count, task count **Validate**: -- TDD_PLAN.md exists -- IMPL_PLAN.md exists +- IMPL_PLAN.md exists (unified plan with TDD Task Chains section) - TEST-*.json, IMPL-*.json, REFACTOR-*.json exist - TODO_LIST.md exists +- IMPL tasks include test-fix-cycle configuration +- IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter -### Phase 5: TDD Structure Validation +### Phase 6: TDD Structure Validation **Internal validation (no command)** **Validate**: @@ -76,6 +101,7 @@ TEST_FOCUS: [Test scenarios] 2. Dependencies: IMPL depends_on TEST, REFACTOR depends_on IMPL 3. Meta fields: tdd_phase correct ("red"/"green"/"refactor") 4. Agents: TEST uses @code-review-test-agent, IMPL/REFACTOR use @code-developer +5. IMPL tasks contain test-fix-cycle in flow_control for iterative Green phase **Return Summary**: ``` @@ -89,9 +115,9 @@ Structure: - Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 [...] -Plans: -- TDD Structure: .workflow/[sessionId]/TDD_PLAN.md -- Implementation: .workflow/[sessionId]/IMPL_PLAN.md +Plan: +- Unified Implementation Plan: .workflow/[sessionId]/IMPL_PLAN.md + (includes TDD Task Chains section) Next: /workflow:execute or /workflow:tdd-verify ``` @@ -99,13 +125,14 @@ Next: /workflow:execute or /workflow:tdd-verify ## TodoWrite Pattern ```javascript -// Initialize +// Initialize (6 phases now) [ - {content: "Execute session discovery", status: "in_progress", activeForm: "..."}, - {content: "Execute context gathering", status: "pending", activeForm: "..."}, - {content: "Execute TDD analysis", status: "pending", activeForm: "..."}, - {content: "Execute TDD task generation", status: "pending", activeForm: "..."}, - {content: "Validate TDD structure", status: "pending", activeForm: "..."} + {content: "Execute session discovery", status: "in_progress", activeForm: "Executing session discovery"}, + {content: "Execute context gathering", status: "pending", activeForm: "Executing context gathering"}, + {content: "Execute test coverage analysis", status: "pending", activeForm: "Executing test coverage analysis"}, + {content: "Execute TDD analysis", status: "pending", activeForm: "Executing TDD analysis"}, + {content: "Execute TDD task generation", status: "pending", activeForm: "Executing TDD task generation"}, + {content: "Validate TDD structure", status: "pending", activeForm: "Validating TDD structure"} ] // Update after each phase: mark current "completed", next "in_progress" @@ -131,3 +158,96 @@ Convert user input to TDD-structured format: - `/workflow:execute` - Execute TDD tasks - `/workflow:tdd-verify` - Verify TDD compliance - `/workflow:status` - View progress +## TDD Workflow Enhancements + +### Overview +The TDD workflow has been significantly enhanced by integrating best practices from both traditional `plan --agent` and `test-gen` workflows, creating a hybrid approach that bridges the gap between idealized TDD and real-world development complexity. + +### Key Improvements + +#### 1. Test Coverage Analysis (Phase 3) +**Adopted from test-gen workflow** + +Before planning TDD tasks, the workflow now analyzes the existing codebase: +- Detects existing test patterns and conventions +- Identifies current test coverage +- Discovers related components and integration points +- Detects test framework automatically + +**Benefits**: +- Context-aware TDD planning +- Avoids duplicate test creation +- Enables integration with existing tests +- No longer assumes greenfield scenarios + +#### 2. Iterative Green Phase with Test-Fix Cycle +**Adopted from test-gen workflow** + +IMPL (Green phase) tasks now include automatic test-fix cycle for resilient implementation: + +**Enhanced IMPL Task Flow**: +``` +1. Write minimal implementation code +2. Execute test suite +3. IF tests pass → Complete task ✅ +4. IF tests fail → Enter fix cycle: + a. Gemini diagnoses with bug-fix template + b. Apply fix (manual or Codex) + c. Retest + d. Repeat (max 3 iterations) +5. IF max iterations → Auto-revert changes 🔄 +``` + +**Benefits**: +- ✅ Faster feedback within Green phase +- ✅ Autonomous recovery from implementation errors +- ✅ Systematic debugging with Gemini +- ✅ Safe rollback prevents broken state + +#### 3. Agent-Driven Planning +**From plan --agent workflow** + +Supports action-planning-agent for more autonomous TDD planning with: +- MCP tool integration (code-index, exa) +- Memory-first principles +- Brainstorming artifact integration +- Task merging over decomposition + +### Workflow Comparison + +| Aspect | Previous | Current | +|--------|----------|---------| +| **Phases** | 5 | 6 (test coverage analysis) | +| **Context** | Greenfield assumption | Existing codebase aware | +| **Green Phase** | Single implementation | Iterative with fix cycle | +| **Failure Handling** | Manual intervention | Auto-diagnose + fix + revert | +| **Test Analysis** | None | Deep coverage analysis | +| **Feedback Loop** | Post-execution | During Green phase | + +### Migration Notes + +**Backward Compatibility**: ✅ Fully compatible +- Existing TDD workflows continue to work +- New features are additive, not breaking +- Phase 3 can be skipped if test-context-gather not available + +**Session Structure**: +``` +.workflow/WFS-xxx/ +├── IMPL_PLAN.md (unified plan with TDD Task Chains section) +├── TODO_LIST.md +├── .process/ +│ ├── context-package.json +│ ├── test-context-package.json +│ ├── ANALYSIS_RESULTS.md (enhanced with TDD breakdown) +│ └── green-fix-iteration-*.md (fix logs) +└── .task/ + ├── TEST-*.json (Red phase) + ├── IMPL-*.json (Green phase with test-fix-cycle) + └── REFACTOR-*.json (Refactor phase) +``` + +**Configuration Options** (in IMPL tasks): +- `meta.max_iterations`: Fix attempts (default: 3) +- `meta.use_codex`: Auto-fix mode (default: false) + diff --git a/.claude/commands/workflow/test-gen.md b/.claude/commands/workflow/test-gen.md index 2f5f9915..ce80edf7 100644 --- a/.claude/commands/workflow/test-gen.md +++ b/.claude/commands/workflow/test-gen.md @@ -1,11 +1,11 @@ --- name: test-gen description: Create independent test-fix workflow session by analyzing completed implementation -usage: /workflow:test-gen -argument-hint: "" +usage: /workflow:test-gen [--use-codex] +argument-hint: "[--use-codex] " examples: - /workflow:test-gen WFS-user-auth - - /workflow:test-gen WFS-api-refactor + - /workflow:test-gen --use-codex WFS-api-refactor allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) --- @@ -20,6 +20,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) - **Context-First**: Prioritizes gathering code changes and summaries from source session - **Format Reuse**: Creates standard `IMPL-*.json` task, using `meta.type: "test-fix"` for agent assignment - **Parameter Simplification**: Tools auto-detect test session type via metadata, no manual cross-session parameters needed +- **Manual First**: Default to manual fixes, use `--use-codex` flag for automated Codex fix application **Execution Flow**: 1. Initialize TodoWrite → Create test session → Parse session ID @@ -36,6 +37,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) 5. **Complete All Phases**: Do not return to user until Phase 4 completes (execution triggered separately) 6. **Track Progress**: Update TodoWrite after every phase completion 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) ## 5-Phase Execution @@ -125,9 +127,11 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) --- ### Phase 4: Generate Test Tasks -**Command**: `SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")` +**Command**: `SlashCommand(command="/workflow:tools:test-task-generate [--use-codex] --session [testSessionId]")` -**Input**: `testSessionId` from Phase 1 +**Input**: +- `testSessionId` from Phase 1 +- `--use-codex` flag (if present in original command) **Expected Behavior**: - Parse TEST_ANALYSIS_RESULTS.md from Phase 3 @@ -157,15 +161,16 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) - Task ID: `IMPL-002` - `meta.type: "test-fix"` - `meta.agent: "@test-fix-agent"` +- `meta.use_codex: true|false` (based on --use-codex flag) - `context.depends_on: ["IMPL-001"]` - `context.requirements`: Execute and fix tests - `flow_control.implementation_approach.test_fix_cycle`: Complete cycle specification - - **Cycle pattern**: test → gemini_diagnose → codex_fix_resume → retest - - **Tools configuration**: Gemini for analysis, Codex resume for fixes + - **Cycle pattern**: test → gemini_diagnose → manual_fix (or codex if --use-codex) → retest + - **Tools configuration**: Gemini for analysis with bug-fix template, manual or Codex for fixes - **Exit conditions**: Success (all pass) or failure (max iterations) - `flow_control.implementation_approach.modification_points`: 3-phase execution flow - Phase 1: Initial test execution - - Phase 2: Iterative Gemini diagnosis + Codex resume fixes + - Phase 2: Iterative Gemini diagnosis + manual/Codex fixes (based on flag) - Phase 3: Final validation and certification **TodoWrite**: Mark phase 4 completed, phase 5 in_progress @@ -188,6 +193,7 @@ Tasks Created: Test Framework: [detected framework] Test Files to Generate: [count] Max Fix Iterations: 5 +Fix Mode: [Manual|Codex Automated] (based on --use-codex flag) Next Steps: 1. Review test plan: .workflow/[testSessionId]/IMPL_PLAN.md @@ -275,8 +281,8 @@ Created in `.workflow/WFS-test-[session]/`: **IMPL-002** (@test-fix-agent): 1. Run test suite 2. Iterative fix cycle (max 5): - - Gemini diagnosis → surgical fix suggestions - - Codex applies fixes (resume mechanism) + - Gemini diagnosis with bug-fix template → surgical fix suggestions + - Manual fix application (default) OR Codex applies fixes if --use-codex flag (resume mechanism) - Retest and check regressions 3. Final validation and certification diff --git a/.claude/commands/workflow/tools/task-generate-tdd.md b/.claude/commands/workflow/tools/task-generate-tdd.md index 0990dc82..1f77da38 100644 --- a/.claude/commands/workflow/tools/task-generate-tdd.md +++ b/.claude/commands/workflow/tools/task-generate-tdd.md @@ -20,6 +20,9 @@ Generate TDD-specific task chains from analysis results with enforced Red-Green- - **Phase-Explicit**: Each task marked with Red/Green/Refactor phase - **Artifact-Aware**: Integrates brainstorming outputs - **Memory-First**: Reuse loaded documents from memory +- **Context-Aware**: Analyzes existing codebase and test patterns +- **Iterative Green Phase**: Auto-diagnose and fix test failures with Gemini + optional Codex +- **Safety-First**: Auto-revert on max iterations to prevent broken state ## Core Responsibilities - Parse analysis results and identify testable features @@ -47,32 +50,18 @@ Generate TDD-specific task chains from analysis results with enforced Red-Green- - Else: Scan `.workflow/{session_id}/.brainstorming/` directory - Detect: synthesis-specification.md, topic-framework.md, role analyses -### Phase 2: TDD Task Analysis +### Phase 2: TDD Task JSON Generation -#### Gemini TDD Breakdown -```bash -cd project-root && ~/.claude/scripts/gemini-wrapper -p " -PURPOSE: Generate TDD task breakdown with Red-Green-Refactor chains -TASK: Analyze ANALYSIS_RESULTS.md and create TDD-structured task breakdown -CONTEXT: @{.workflow/{session_id}/ANALYSIS_RESULTS.md,.workflow/{session_id}/.brainstorming/*} -EXPECTED: -- Feature list with testable requirements (identify 3-8 features) -- Test cases for each feature (Red phase) - specific test scenarios -- Implementation requirements (Green phase) - minimal code to pass -- Refactoring opportunities (Refactor phase) - quality improvements +**Input**: Use `.process/ANALYSIS_RESULTS.md` directly (enhanced with TDD structure from concept-enhanced phase) + +**Note**: The ANALYSIS_RESULTS.md now includes TDD-specific breakdown: +- Feature list with testable requirements +- Test cases for Red phase +- Implementation requirements for Green phase +- Refactoring opportunities - Task dependencies and execution order -- Focus paths for each phase -RULES: -- Each feature must have TEST → IMPL → REFACTOR chain -- Tests must define clear failure conditions -- Implementation must be minimal to pass tests -- Refactoring must maintain green tests -- Output structured markdown for task generation -- Maximum 10 features (30 total tasks) -" > .workflow/{session_id}/.process/TDD_TASK_BREAKDOWN.md -``` -### Phase 3: TDD Task JSON Generation +### Phase 3: Enhanced IMPL_PLAN.md Generation #### Task Chain Structure For each feature, generate 3 tasks with ID format: @@ -145,19 +134,23 @@ For each feature, generate 3 tasks with ID format: "meta": { "type": "feature", "agent": "@code-developer", - "tdd_phase": "green" + "tdd_phase": "green", + "max_iterations": 3, + "use_codex": false }, "context": { "requirements": [ "Implement minimal AuthService to pass TEST-1.1", "Handle valid and invalid credentials", - "Return appropriate success/error responses" + "Return appropriate success/error responses", + "If tests fail after implementation, diagnose and fix iteratively" ], "focus_paths": ["src/auth/AuthService.ts", "tests/auth/login.test.ts"], "acceptance": [ "All tests in TEST-1.1 pass", "Implementation is minimal and focused", - "No over-engineering or premature optimization" + "No over-engineering or premature optimization", + "Test failures resolved within iteration limit" ], "depends_on": ["TEST-1.1"] }, @@ -172,21 +165,83 @@ For each feature, generate 3 tasks with ID format: }, { "step": "verify_tests_failing", - "action": "Confirm tests are currently failing", + "action": "Confirm tests are currently failing (Red phase validation)", "command": "bash(npm test -- tests/auth/login.test.ts || echo 'Tests failing as expected')", "output_to": "initial_test_status", "on_error": "warn" + }, + { + "step": "load_test_context", + "action": "Load test patterns and framework info", + "command": "bash(cat .workflow/WFS-xxx/.process/test-context-package.json 2>/dev/null || echo '{}')", + "output_to": "test_context", + "on_error": "skip_optional" } ], + "implementation_approach": { + "task_description": "Write minimal code to pass tests, then enter iterative fix cycle if they still fail", + "initial_implementation": [ + "Write minimal code based on test requirements", + "Execute test suite: bash(npm test -- tests/auth/login.test.ts)", + "If tests pass → Complete task", + "If tests fail → Capture failure logs and proceed to test-fix cycle" + ], + "test_fix_cycle": { + "max_iterations": 3, + "cycle_pattern": "gemini_diagnose → manual_fix (or codex if meta.use_codex=true) → retest", + "tools": { + "diagnosis": "gemini-wrapper (MODE: analysis, uses bug-fix template)", + "fix_application": "manual (default) or codex if meta.use_codex=true", + "verification": "bash(npm test -- tests/auth/login.test.ts)" + }, + "exit_conditions": { + "success": "all_tests_pass", + "failure": "max_iterations_reached" + }, + "steps": [ + "ITERATION LOOP (max 3):", + " 1. Gemini Diagnosis:", + " bash(cd .workflow/WFS-xxx/.process && ~/.claude/scripts/gemini-wrapper --all-files -p \"", + " PURPOSE: Diagnose TDD Green phase test failure iteration [N]", + " TASK: Systematic bug analysis and fix recommendations", + " MODE: analysis", + " CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}", + " Test output: [test_failures]", + " Test requirements: [test_requirements]", + " Implementation: [focus_paths]", + " EXPECTED: Root cause analysis, code path tracing, targeted fixes", + " RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [test_failure_description]", + " Minimal surgical fixes only - stay in Green phase", + " \" > green-fix-iteration-[N]-diagnosis.md)", + " 2. Apply Fix (check meta.use_codex):", + " IF meta.use_codex=false (default): Present diagnosis to user for manual fix", + " IF meta.use_codex=true: Codex applies fix automatically", + " 3. Retest: bash(npm test -- tests/auth/login.test.ts)", + " 4. If pass → Exit loop, complete task", + " If fail → Continue to next iteration", + "IF max_iterations reached: Revert changes, report failure" + ] + } + }, "post_completion": [ { "step": "verify_tests_passing", - "action": "Confirm all tests now pass", + "action": "Confirm all tests now pass (Green phase achieved)", "command": "bash(npm test -- tests/auth/login.test.ts)", "output_to": "final_test_status", "on_error": "fail" } - ] + ], + "error_handling": { + "max_iterations_reached": { + "action": "revert_all_changes", + "commands": [ + "bash(git reset --hard HEAD)", + "bash(echo 'TDD Green phase failed: Unable to pass tests within 3 iterations' > .workflow/WFS-xxx/.process/green-phase-failure.md)" + ], + "report": "Generate failure report in .summaries/IMPL-1.1-failure-report.md" + } + } } } ``` @@ -248,19 +303,31 @@ For each feature, generate 3 tasks with ID format: } ``` -### Phase 4: TDD_PLAN.md Generation +### Phase 4: Unified IMPL_PLAN.md Generation -Generate TDD-specific plan with: -- Feature breakdown -- Red-Green-Refactor chains -- Execution order -- TDD compliance checkpoints +Generate single comprehensive IMPL_PLAN.md with: -### Phase 5: Enhanced IMPL_PLAN.md Generation +**Frontmatter**: +```yaml +--- +identifier: WFS-{session-id} +workflow_type: "tdd" +feature_count: N +task_count: 3N +tdd_chains: N +--- +``` -Generate standard IMPL_PLAN.md with TDD context reference. +**Structure**: +1. **Summary**: Project overview +2. **TDD Task Chains** (TDD-specific section): + - Visual representation of TEST → IMPL → REFACTOR chains + - Feature-by-feature breakdown with phase indicators +3. **Task Breakdown**: Standard task listing +4. **Implementation Strategy**: Execution approach +5. **Success Criteria**: Acceptance conditions -### Phase 6: TODO_LIST.md Generation +### Phase 5: TODO_LIST.md Generation Generate task list with TDD phase indicators: ```markdown @@ -270,7 +337,7 @@ Generate task list with TDD phase indicators: - [ ] **REFACTOR-1.1**: Refactor implementation (🔵 REFACTOR) [depends: IMPL-1.1] → [📋](./.task/REFACTOR-1.1.json) ``` -### Phase 7: Session State Update +### Phase 6: Session State Update Update workflow-session.json with TDD metadata: ```json @@ -285,18 +352,18 @@ Update workflow-session.json with TDD metadata: ## Output Files Structure ``` .workflow/{session-id}/ -├── IMPL_PLAN.md # Standard implementation plan -├── TDD_PLAN.md # TDD-specific plan ⭐ NEW +├── IMPL_PLAN.md # Unified plan with TDD Task Chains section ├── TODO_LIST.md # Progress tracking with TDD phases ├── .task/ │ ├── TEST-1.1.json # Red phase task -│ ├── IMPL-1.1.json # Green phase task +│ ├── IMPL-1.1.json # Green phase task (with test-fix-cycle) │ ├── REFACTOR-1.1.json # Refactor phase task │ └── ... └── .process/ - ├── ANALYSIS_RESULTS.md # Input from concept-enhanced - ├── TDD_TASK_BREAKDOWN.md # Gemini TDD breakdown ⭐ NEW - └── context-package.json # Input from context-gather + ├── ANALYSIS_RESULTS.md # Enhanced with TDD breakdown from concept-enhanced + ├── test-context-package.json # Test coverage analysis + ├── context-package.json # Input from context-gather + └── green-fix-iteration-*.md # Fix logs from Green phase ``` ## Validation Rules @@ -356,13 +423,49 @@ Structure: - Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 Plans generated: -- TDD Plan: .workflow/WFS-auth/TDD_PLAN.md -- Implementation Plan: .workflow/WFS-auth/IMPL_PLAN.md +- Unified Plan: .workflow/WFS-auth/IMPL_PLAN.md (includes TDD Task Chains section) Next: /workflow:execute or /workflow:tdd-verify ``` +## Test Coverage Analysis Integration + +The TDD workflow includes test coverage analysis (via `/workflow:tools:test-context-gather`) to: +- Detect existing test patterns and conventions +- Identify current test coverage gaps +- Discover test framework and configuration +- Enable integration with existing tests + +This makes TDD workflow context-aware instead of assuming greenfield scenarios. + +## Iterative Green Phase with Test-Fix Cycle + +IMPL (Green phase) tasks include automatic test-fix cycle: + +**Process Flow**: +1. **Initial Implementation**: Write minimal code to pass tests +2. **Test Execution**: Run test suite +3. **Success Path**: Tests pass → Complete task +4. **Failure Path**: Tests fail → Enter iterative fix cycle: + - **Gemini Diagnosis**: Analyze failures with bug-fix template + - **Fix Application**: Manual (default) or Codex (if meta.use_codex=true) + - **Retest**: Verify fix resolves failures + - **Repeat**: Up to max_iterations (default: 3) +5. **Safety Net**: Auto-revert all changes if max iterations reached + +**Key Benefits**: +- ✅ Faster feedback loop within Green phase +- ✅ Autonomous recovery from initial implementation errors +- ✅ Systematic debugging with Gemini's bug-fix template +- ✅ Safe rollback prevents broken TDD state + +## Configuration Options +- **meta.max_iterations**: Number of fix attempts (default: 3 for TDD, 5 for test-gen) +- **meta.use_codex**: Enable Codex automated fixes (default: false, manual) + ## Related Commands -- `/workflow:tdd-plan` - Orchestrates TDD workflow planning +- `/workflow:tdd-plan` - Orchestrates TDD workflow planning (6 phases) +- `/workflow:tools:test-context-gather` - Analyzes test coverage - `/workflow:execute` - Executes TDD tasks in order - `/workflow:tdd-verify` - Verifies TDD compliance +- `/workflow:test-gen` - Post-implementation test generation diff --git a/.claude/commands/workflow/tools/test-task-generate.md b/.claude/commands/workflow/tools/test-task-generate.md index a4f89448..d589f799 100644 --- a/.claude/commands/workflow/tools/test-task-generate.md +++ b/.claude/commands/workflow/tools/test-task-generate.md @@ -1,24 +1,25 @@ --- name: test-task-generate description: Generate test-fix task JSON with iterative test-fix-retest cycle specification -usage: /workflow:tools:test-task-generate --session -argument-hint: "--session WFS-test-session-id" +usage: /workflow:tools:test-task-generate [--use-codex] --session +argument-hint: "[--use-codex] --session WFS-test-session-id" examples: - /workflow:tools:test-task-generate --session WFS-test-auth + - /workflow:tools:test-task-generate --use-codex --session WFS-test-auth --- # Test Task Generation Command ## Overview -Generate specialized test-fix task JSON with comprehensive test-fix-retest cycle specification, including Gemini diagnosis and Codex resume mechanism for intelligent failure resolution. +Generate specialized test-fix task JSON with comprehensive test-fix-retest cycle specification, including Gemini diagnosis (using bug-fix template) and manual fix workflow (Codex automation only when explicitly requested). ## Core Philosophy - **Analysis-Driven Test Generation**: Use TEST_ANALYSIS_RESULTS.md from test-concept-enhanced - **Agent-Based Test Creation**: Call @code-developer agent for comprehensive test generation - **Coverage-First**: Generate all missing tests before execution - **Test Execution**: Execute complete test suite after generation -- **Gemini Diagnosis**: Use Gemini for root cause analysis and fix suggestions -- **Codex Resume**: Apply fixes using `codex exec "..." resume --last` for context continuity +- **Gemini Diagnosis**: Use Gemini for root cause analysis and fix suggestions (references bug-fix template) +- **Manual Fixes First**: Apply fixes manually by default, codex only when explicitly needed - **Iterative Refinement**: Repeat test-analyze-fix-retest cycle until all tests pass - **Surgical Fixes**: Minimal code changes, no refactoring during test fixes - **Auto-Revert**: Rollback all changes if max iterations reached @@ -26,27 +27,32 @@ Generate specialized test-fix task JSON with comprehensive test-fix-retest cycle ## Core Responsibilities - Parse TEST_ANALYSIS_RESULTS.md from test-concept-enhanced - Extract test requirements and generation strategy +- Parse `--use-codex` flag to determine fix mode (manual vs automated) - Generate test generation subtask calling @code-developer -- Generate test execution and fix cycle task JSON -- Configure Gemini diagnosis and Codex execution workflow +- Generate test execution and fix cycle task JSON with appropriate fix mode +- Configure Gemini diagnosis workflow (bug-fix template) and manual/Codex fix application - Create test-oriented IMPL_PLAN.md and TODO_LIST.md with test generation phase ## Execution Lifecycle ### Phase 1: Input Validation & Discovery -1. **Test Session Validation** +1. **Parameter Parsing** + - Parse `--use-codex` flag from command arguments + - Store flag value for IMPL-002.json generation + +2. **Test Session Validation** - Load `.workflow/{test-session-id}/workflow-session.json` - Verify `workflow_type: "test_session"` - Extract `source_session_id` from metadata -2. **Test Analysis Results Loading** +3. **Test Analysis Results Loading** - **REQUIRED**: Load `.workflow/{test-session-id}/.process/TEST_ANALYSIS_RESULTS.md` - Parse test requirements by file - Extract test generation strategy - Identify test files to create with specifications -3. **Test Context Package Loading** +4. **Test Context Package Loading** - Load `.workflow/{test-session-id}/.process/test-context-package.json` - Extract test framework configuration - Extract coverage gaps and priorities @@ -183,13 +189,15 @@ Generate **TWO task JSON files**: "agent": "@test-fix-agent", "source_session": "[sourceSessionId]", "test_framework": "jest|pytest|cargo|detected", - "max_iterations": 5 + "max_iterations": 5, + "use_codex": false // Set to true if --use-codex flag present }, "context": { "requirements": [ "Execute complete test suite (generated in IMPL-001)", - "Diagnose test failures using Gemini analysis", - "Fix failures using Codex with resume mechanism", + "Diagnose test failures using Gemini analysis with bug-fix template", + "Present fixes to user for manual application (default)", + "Use Codex ONLY if user explicitly requests automation", "Iterate until all tests pass or max iterations reached", "Revert changes if unable to fix within iteration limit" ], @@ -272,14 +280,14 @@ Generate **TWO task JSON files**: } ], "implementation_approach": { - "task_description": "Execute iterative test-fix-retest cycle using Gemini diagnosis and Codex execution", + "task_description": "Execute iterative test-fix-retest cycle using Gemini diagnosis (bug-fix template) and manual fixes (Codex only if explicitly needed)", "test_fix_cycle": { "max_iterations": 5, - "cycle_pattern": "test → gemini_diagnose → codex_fix_resume → retest", + "cycle_pattern": "test → gemini_diagnose → manual_fix (or codex if needed) → retest", "tools": { "test_execution": "bash(test_command)", - "diagnosis": "gemini-wrapper (MODE: analysis)", - "fix_application": "codex exec resume --last (MODE: write)", + "diagnosis": "gemini-wrapper (MODE: analysis, uses bug-fix template)", + "fix_application": "manual (default) or codex exec resume --last (if explicitly needed)", "verification": "bash(test_command) + regression_check" }, "exit_conditions": { @@ -303,30 +311,36 @@ Generate **TWO task JSON files**: " WHILE (tests failing AND current_iteration < max_iterations):", " current_iteration++", " ", - " STEP 2.1: Gemini Diagnosis", + " STEP 2.1: Gemini Diagnosis (using bug-fix template)", " - Prepare diagnosis context:", " * Test failure output from previous run", " * Source files from focus_paths", " * Implementation summaries from source session", - " - Execute Gemini analysis:", - " bash(cd .workflow/WFS-test-[session]/.process && ~/.claude/scripts/gemini-wrapper -p \"", + " - Execute Gemini analysis with bug-fix template:", + " bash(cd .workflow/WFS-test-[session]/.process && ~/.claude/scripts/gemini-wrapper --all-files -p \"", " PURPOSE: Diagnose test failure iteration [N] and propose minimal fix", - " TASK: Analyze test output and identify root cause with specific code change", + " TASK: Systematic bug analysis and fix recommendations for test failure", " MODE: analysis", - " CONTEXT: Test output: [test_failures]", + " CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}", + " Test output: [test_failures]", " Source files: [focus_paths]", " Implementation: [implementation_context]", - " EXPECTED: Root cause analysis with fix in format:", - " FILE: path/to/file.ts", - " FUNCTION: functionName", - " LINES: 45-52", - " CHANGE: Specific code modification to apply", - " RULES: Minimal surgical fixes only - no refactoring", - " Focus on test failure, not code quality", + " EXPECTED: Root cause analysis, code path tracing, targeted fixes", + " RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [test_failure_description]", + " Minimal surgical fixes only - no refactoring", " \" > fix-iteration-[N]-diagnosis.md)", " - Parse diagnosis → extract fix_suggestion and target_files", + " - Present fix to user for manual application (default)", " ", - " STEP 2.2: Codex Fix with Resume Mechanism", + " STEP 2.2: Apply Fix (Based on meta.use_codex Flag)", + " ", + " IF meta.use_codex = false (DEFAULT):", + " - Present Gemini diagnosis to user for manual fix", + " - User applies fix based on diagnosis recommendations", + " - Stage changes: bash(git add -A)", + " - Store fix log: .process/fix-iteration-[N]-changes.log", + " ", + " IF meta.use_codex = true (--use-codex flag present):", " - Stage current changes (if valid git repo): bash(git add -A)", " - First iteration: Start new Codex session", " codex -C [project_root] --full-auto exec \"", @@ -391,8 +405,8 @@ Generate **TWO task JSON files**: " Analyze existing test files", " Identify files without tests", " IF tests missing:", - " Generate tests using Codex", - " Verify test generation successful", + " Report to user (no automatic generation)", + " Wait for user to generate tests or request automation", " ELSE:", " Skip to Phase 1", "PHASE 1: Initial Test Execution", @@ -401,8 +415,10 @@ Generate **TWO task JSON files**: " ELSE → Store failures, proceed to Phase 2", "PHASE 2: Iterative Fix Cycle (max 5 iterations)", " LOOP (max 5 times):", - " 1. Gemini diagnoses failure → fix suggestion", - " 2. Codex applies fix (resume for continuity)", + " 1. Gemini diagnoses failure with bug-fix template → fix suggestion", + " 2. Check meta.use_codex flag:", + " - IF false (default): Present fix to user for manual application", + " - IF true (--use-codex): Codex applies fix with resume for continuity", " 3. Retest and check results", " 4. IF pass → Exit loop to Phase 3", " 5. ELSE → Continue with updated context", @@ -490,15 +506,17 @@ Diagnose and fix all test failures using iterative Gemini analysis and Codex exe ## Test-Fix-Retest Cycle - **Max Iterations**: 5 -- **Diagnosis Tool**: Gemini (analysis mode) -- **Fix Tool**: Codex (resume mechanism) +- **Diagnosis Tool**: Gemini (analysis mode with bug-fix template from bug-index.md) +- **Fix Tool**: Manual (default, meta.use_codex=false) or Codex (if --use-codex flag, meta.use_codex=true) - **Verification**: Bash test execution + regression check ### Cycle Workflow 1. **Initial Test**: Execute full suite, capture failures 2. **Iterative Fix Loop** (max 5 times): - - Gemini diagnoses failure → surgical fix suggestion - - Codex applies fix using resume for context continuity + - Gemini diagnoses failure using bug-fix template → surgical fix suggestion + - Check meta.use_codex flag: + - If false (default): Present fix to user for manual application + - If true (--use-codex): Codex applies fix with resume for context continuity - Retest and verify (check for regressions) - Continue until all pass or max iterations reached 3. **Final Validation**: Confirm all tests pass, certify code @@ -596,9 +614,17 @@ Diagnose and fix all test failures using iterative Gemini analysis and Codex exe ### Basic Usage ```bash +# Manual fix mode (default) /workflow:tools:test-task-generate --session WFS-test-auth + +# Automated Codex fix mode +/workflow:tools:test-task-generate --use-codex --session WFS-test-auth ``` +### Flag Behavior +- **No flag**: `meta.use_codex=false`, manual fixes presented to user +- **--use-codex**: `meta.use_codex=true`, Codex automatically applies fixes with resume mechanism + ## Related Commands - `/workflow:test-gen` - Creates test session and calls this tool - `/workflow:tools:context-gather` - Provides cross-session context @@ -610,15 +636,20 @@ Diagnose and fix all test failures using iterative Gemini analysis and Codex exe The `@test-fix-agent` will execute the task by following the `flow_control.implementation_approach` specification: -1. **Load task JSON**: Read complete test-fix task from `.task/IMPL-001.json` -2. **Execute pre_analysis**: Load source context, discover framework, analyze tests -3. **Phase 1**: Run initial test suite -4. **Phase 2**: If failures, enter iterative loop: - - Use Gemini for diagnosis (analysis mode) - - Use Codex resume for fixes (maintains context) +1. **Load task JSON**: Read complete test-fix task from `.task/IMPL-002.json` +2. **Check meta.use_codex**: Determine fix mode (manual or automated) +3. **Execute pre_analysis**: Load source context, discover framework, analyze tests +4. **Phase 1**: Run initial test suite +5. **Phase 2**: If failures, enter iterative loop: + - Use Gemini for diagnosis (analysis mode with bug-fix template) + - Check meta.use_codex flag: + - If false (default): Present fix suggestions to user for manual application + - If true (--use-codex): Use Codex resume for automated fixes (maintains context) - Retest and check for regressions - Repeat max 5 times -5. **Phase 3**: Generate summary and certify code -6. **Error Recovery**: Revert changes if max iterations reached +6. **Phase 3**: Generate summary and certify code +7. **Error Recovery**: Revert changes if max iterations reached -The agent uses the `codex exec "..." resume --last` pattern to maintain conversation context across multiple fix iterations, ensuring consistency and learning from previous attempts. +**Bug Diagnosis Template**: Uses bug-fix.md template as referenced in bug-index.md for systematic root cause analysis, code path tracing, and targeted fix recommendations. + +**Codex Usage**: The agent uses `codex exec "..." resume --last` pattern ONLY when meta.use_codex=true (--use-codex flag present) to maintain conversation context across multiple fix iterations, ensuring consistency and learning from previous attempts.