From 1376dc71d9d02b93cbd3e797ac316f2ea070a388 Mon Sep 17 00:00:00 2001 From: catlog22 Date: Tue, 20 Jan 2026 11:59:06 +0800 Subject: [PATCH] =?UTF-8?q?feat(workflow):=20=E6=9B=B4=E6=96=B0=20lite-lit?= =?UTF-8?q?e-lite=20=E5=92=8C=20tdd-plan=20=E6=96=87=E6=A1=A3=EF=BC=8C?= =?UTF-8?q?=E5=A2=9E=E5=BC=BA=E6=8F=8F=E8=BF=B0=E5=92=8C=E5=B7=A5=E5=85=B7?= =?UTF-8?q?=E6=94=AF=E6=8C=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .claude/commands/workflow/lite-lite-lite.md | 46 +++++-- .claude/commands/workflow/tdd-plan.md | 141 +++++++++++++++++++- 2 files changed, 176 insertions(+), 11 deletions(-) diff --git a/.claude/commands/workflow/lite-lite-lite.md b/.claude/commands/workflow/lite-lite-lite.md index ce34b20a..e7de5238 100644 --- a/.claude/commands/workflow/lite-lite-lite.md +++ b/.claude/commands/workflow/lite-lite-lite.md @@ -1,8 +1,8 @@ --- name: workflow:lite-lite-lite -description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts, auto tool selection based on task analysis, user-driven iteration via AskUser. +description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser. argument-hint: "" -allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp__ace-tool__search_context(*) +allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__write_file(*) --- # Ultra-Lite Multi-Tool Workflow @@ -14,22 +14,23 @@ allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), mcp_ /workflow:lite-lite-lite "Refactor payment module for multi-gateway support" ``` -**Core Philosophy**: Minimal friction, maximum velocity. No files, no artifacts - just analyze and execute. +**Core Philosophy**: Minimal friction, maximum velocity. Simple tasks = no artifacts. Complex tasks = lightweight planning doc in `.workflow/.scratchpad/`. ## Overview -**Zero-artifact workflow**: Clarify → Select Tools → Multi-Mode Analysis → Decision → Direct Execution +**Complexity-aware workflow**: Clarify → Assess Complexity → Select Tools → Multi-Mode Analysis → Decision → Direct Execution -**vs multi-cli-plan**: No IMPL_PLAN.md, plan.json, synthesis.json - all state in memory. +**vs multi-cli-plan**: No IMPL_PLAN.md, plan.json, synthesis.json - state in memory or lightweight scratchpad doc for complex tasks. ## Execution Flow ``` Phase 1: Clarify Requirements → AskUser for missing details +Phase 1.5: Assess Complexity → Determine if planning doc needed Phase 2: Select Tools (CLI → Mode → Agent) → 3-step selection Phase 3: Multi-Mode Analysis → Execute with --resume chaining Phase 4: User Decision → Execute / Refine / Change / Cancel -Phase 5: Direct Execution → No plan files, immediate implementation +Phase 5: Direct Execution → No plan files (simple) or scratchpad doc (complex) ``` ## Phase 1: Clarify Requirements @@ -58,6 +59,25 @@ mcp__ace-tool__search_context({ }) ``` +## Phase 1.5: Assess Complexity + +| Level | Creates Plan Doc | Trigger Keywords | +|-------|------------------|------------------| +| **simple** | ❌ | (default) | +| **moderate** | ✅ | module, system, service, integration, multiple | +| **complex** | ✅ | refactor, migrate, security, auth, payment, database | + +```javascript +// Complexity detection (after ACE query) +const isComplex = /refactor|migrate|security|auth|payment|database/i.test(taskDescription) +const isModerate = /module|system|service|integration|multiple/i.test(taskDescription) || aceContext?.relevant_files?.length > 2 + +if (isComplex || isModerate) { + const planPath = `.workflow/.scratchpad/lite3-${taskSlug}-${dateStr}.md` + // Create planning doc with: Task, Status, Complexity, Analysis Summary, Execution Plan, Progress Log +} +``` + ## Phase 2: Select Tools ### Tool Definitions @@ -308,6 +328,8 @@ function aggregateResults(mode, results) { critiques: parseCritiques(results.find(r => r.phase === 'challenge')?.result), riskScore: calculateRiskScore(results) } } } + +// If planPath exists: update Analysis Summary & Execution Plan sections ``` ## Phase 4: User Decision @@ -348,13 +370,14 @@ AskUserQuestion({ multiSelect: false }] }) +// If planPath exists: record decision to Decisions Made table // Routing: Execute → Phase 5 | Refine → Phase 3 | Change → Phase 2 | Cancel → End ``` ## Phase 5: Direct Execution ```javascript -// No IMPL_PLAN.md, no plan.json - direct implementation +// Simple tasks: No artifacts | Complex tasks: Update scratchpad doc const executionAgents = agents.filter(a => a.canExecute) const executionTool = selectedAgent.canExecute ? selectedAgent : selectedCLIs[0] @@ -378,6 +401,7 @@ CONSTRAINTS: Follow existing patterns run_in_background: false }) } +// If planPath exists: update Status to completed/failed, append to Progress Log ``` ## TodoWrite Structure @@ -385,6 +409,7 @@ CONSTRAINTS: Follow existing patterns ```javascript TodoWrite({ todos: [ { content: "Phase 1: Clarify requirements", status: "in_progress", activeForm: "Clarifying requirements" }, + { content: "Phase 1.5: Assess complexity", status: "pending", activeForm: "Assessing complexity" }, { content: "Phase 2: Select tools", status: "pending", activeForm: "Selecting tools" }, { content: "Phase 3: Multi-mode analysis", status: "pending", activeForm: "Running analysis" }, { content: "Phase 4: User decision", status: "pending", activeForm: "Awaiting decision" }, @@ -409,16 +434,19 @@ TodoWrite({ todos: [ | Task unclear | Default to first CLI + code-developer | | Ambiguous task | Force clarification via AskUser | | Execution fails | Present error, ask user for direction | +| Plan doc write fails | Continue without doc (degrade to zero-artifact mode) | +| Scratchpad dir missing | Auto-create `.workflow/.scratchpad/` | ## Comparison with multi-cli-plan | Aspect | lite-lite-lite | multi-cli-plan | |--------|----------------|----------------| -| **Artifacts** | None | IMPL_PLAN.md, plan.json, synthesis.json | +| **Artifacts** | Conditional (scratchpad doc for complex tasks) | Always (IMPL_PLAN.md, plan.json, synthesis.json) | | **Session** | Stateless (--resume chaining) | Persistent session folder | | **Tool Selection** | 3-step (CLI → Mode → Agent) | Config-driven fixed tools | | **Analysis Modes** | 5 modes with --resume | Fixed synthesis rounds | -| **Best For** | Quick analysis, adversarial validation | Complex multi-step implementations | +| **Complexity** | Auto-detected (simple/moderate/complex) | Assumed complex | +| **Best For** | Quick analysis, simple-to-moderate tasks | Complex multi-step implementations | ## Post-Completion Expansion diff --git a/.claude/commands/workflow/tdd-plan.md b/.claude/commands/workflow/tdd-plan.md index 1b390f3a..95ceb808 100644 --- a/.claude/commands/workflow/tdd-plan.md +++ b/.claude/commands/workflow/tdd-plan.md @@ -37,6 +37,44 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*) 7. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion 8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase +## TDD Compliance Requirements + +### The Iron Law + +``` +NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST +``` + +**Enforcement Method**: +- Phase 5: `implementation_approach` includes test-first steps (Red → Green → Refactor) +- Green phase: Includes test-fix-cycle configuration (max 3 iterations) +- Auto-revert: Triggered when max iterations reached without passing tests + +**Verification**: Phase 6 validates Red-Green-Refactor structure in all generated tasks + +### TDD Compliance Checkpoint + +| Checkpoint | Validation Phase | Evidence Required | +|------------|------------------|-------------------| +| Test-first structure | Phase 5 | `implementation_approach` has 3 steps | +| Red phase exists | Phase 6 | Step 1: `tdd_phase: "red"` | +| Green phase with test-fix | Phase 6 | Step 2: `tdd_phase: "green"` + test-fix-cycle | +| Refactor phase exists | Phase 6 | Step 3: `tdd_phase: "refactor"` | + +### Core TDD Principles (from ref skills) + +**Red Flags - STOP and Reassess**: +- Code written before test +- Test passes immediately (no Red phase witnessed) +- Cannot explain why test should fail +- "Just this once" rationalization +- "Tests after achieve same goals" thinking + +**Why Order Matters**: +- Tests written after code pass immediately → proves nothing +- Test-first forces edge case discovery before implementation +- Tests-after verify what was built, not what's required + ## 6-Phase Execution (with Conflict Resolution) ### Phase 1: Session Discovery @@ -183,7 +221,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"}, {"content": "Phase 4: Conflict Resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"}, {"content": " → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"}, - {"content": " → Present conflicts to user", "status": "pending", "activeForm": "Presenting conflicts"}, + {"content": " → Log and analyze detected conflicts", "status": "pending", "activeForm": "Analyzing conflicts"}, {"content": " → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"}, {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"}, {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"} @@ -251,6 +289,13 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]") - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter - Task count ≤10 (compliance with task limit) +**Red Flag Detection** (Non-Blocking Warnings): +- Task count >10: `⚠️ High task count may indicate insufficient decomposition` +- Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration` +- Generic task names: `⚠️ Vague task names suggest unclear TDD cycles` + +**Action**: Log warnings to `.workflow/active/[sessionId]/.process/tdd-warnings.log` (non-blocking) + **TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**: @@ -302,6 +347,42 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]") 5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations 6. Task count: Total tasks ≤10 (simple + subtasks) +**Red Flag Checklist** (from TDD best practices): +- [ ] No tasks skip Red phase (`tdd_phase: "red"` exists in step 1) +- [ ] Test files referenced in Red phase (explicit paths, not placeholders) +- [ ] Green phase has test-fix-cycle with `max_iterations` configured +- [ ] Refactor phase has clear completion criteria + +**Non-Compliance Warning Format**: +``` +⚠️ TDD Red Flag: [issue description] + Task: [IMPL-N] + Recommendation: [action to fix] +``` + +**Evidence Gathering** (Before Completion Claims): + +```bash +# Verify session artifacts exist +ls -la .workflow/active/[sessionId]/{IMPL_PLAN.md,TODO_LIST.md} +ls -la .workflow/active/[sessionId]/.task/IMPL-*.json + +# Count generated artifacts +echo "IMPL tasks: $(ls .workflow/active/[sessionId]/.task/IMPL-*.json 2>/dev/null | wc -l)" + +# Sample task structure verification (first task) +jq '{id, tdd: .meta.tdd_workflow, phases: [.flow_control.implementation_approach[].tdd_phase]}' \ + "$(ls .workflow/active/[sessionId]/.task/IMPL-*.json | head -1)" +``` + +**Evidence Required Before Summary**: +| Evidence Type | Verification Method | Pass Criteria | +|---------------|---------------------|---------------| +| File existence | `ls -la` artifacts | All files present | +| Task count | Count IMPL-*.json | Count matches claims | +| TDD structure | jq sample extraction | Shows red/green/refactor | +| Warning log | Check tdd-warnings.log | Logged (may be empty) | + **Return Summary**: ``` TDD Planning complete for session: [sessionId] @@ -333,6 +414,9 @@ TDD Configuration: - Green phase includes test-fix cycle (max 3 iterations) - Auto-revert on max iterations reached +⚠️ ACTION REQUIRED: Before execution, ensure you understand WHY each Red phase test is expected to fail. + This is crucial for valid TDD - if you don't know why the test fails, you can't verify it tests the right thing. + Recommended Next Steps: 1. /workflow:action-plan-verify --session [sessionId] # Verify TDD plan quality and dependencies 2. /workflow:execute --session [sessionId] # Start TDD execution @@ -400,7 +484,7 @@ TDD Workflow Orchestrator │ IF conflict_risk ≥ medium: │ └─ /workflow:tools:conflict-resolution ← ATTACHED (3 tasks) │ ├─ Phase 4.1: Detect conflicts with CLI -│ ├─ Phase 4.2: Present conflicts to user +│ ├─ Phase 4.2: Log and analyze detected conflicts │ └─ Phase 4.3: Apply resolution strategies │ └─ Returns: conflict-resolution.json ← COLLAPSED │ ELSE: @@ -439,6 +523,34 @@ Convert user input to TDD-structured format: - **Command failure**: Keep phase in_progress, report error - **TDD validation failure**: Report incomplete chains or wrong dependencies +### TDD Warning Patterns + +| Pattern | Warning Message | Recommended Action | +|---------|----------------|-------------------| +| Task count >10 | High task count detected | Consider splitting into multiple sessions | +| Missing test-fix-cycle | Green phase lacks auto-revert | Add `max_iterations: 3` to task config | +| Red phase missing test path | Test file path not specified | Add explicit test file paths | +| Generic task names | Vague names like "Add feature" | Use specific behavior descriptions | +| No refactor criteria | Refactor phase lacks completion criteria | Define clear refactor scope | + +### Non-Blocking Warning Policy + +**All warnings are advisory** - they do not halt execution: +1. Warnings logged to `.process/tdd-warnings.log` +2. Summary displayed in Phase 6 output +3. User decides whether to address before `/workflow:execute` + +### Error Handling Quick Reference + +| Error Type | Detection | Recovery Action | +|------------|-----------|-----------------| +| Parsing failure | Empty/malformed output | Retry once, then report | +| Missing context-package | File read error | Re-run `/workflow:tools:context-gather` | +| Invalid task JSON | jq parse error | Report malformed file path | +| High task count (>10) | Count validation | Log warning, continue (non-blocking) | +| Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` | +| Phase timeout | No response | Retry phase, check CLI connectivity | + ## Related Commands **Prerequisite Commands**: @@ -458,3 +570,28 @@ Convert user input to TDD-structured format: - `/workflow:execute` - Begin TDD implementation - `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report +## Next Steps Decision Table + +| Situation | Recommended Command | Purpose | +|-----------|---------------------|---------| +| First time planning | `/workflow:action-plan-verify` | Validate task structure before execution | +| Warnings in tdd-warnings.log | Review log, refine tasks | Address Red Flags before proceeding | +| High task count warning | Consider `/workflow:session:start` | Split into focused sub-sessions | +| Ready to implement | `/workflow:execute` | Begin TDD Red-Green-Refactor cycles | +| After implementation | `/workflow:tdd-verify` | Generate TDD compliance report | +| Need to review tasks | `/workflow:status --session [id]` | Inspect current task breakdown | +| Plan needs changes | `/task:replan` | Update task JSON with new requirements | + +### TDD Workflow State Transitions + +``` +/workflow:tdd-plan + ↓ +[Planning Complete] ──→ /workflow:action-plan-verify (recommended) + ↓ +[Verified/Ready] ─────→ /workflow:execute + ↓ +[Implementation] ─────→ /workflow:tdd-verify (post-execution) + ↓ +[Quality Report] ─────→ Done or iterate +```