sdd-pipeline 1.2.4 → 1.2.7

package/lib/bundle/.claude/commands/sdd-cook.md

@@ -1,183 +1,205 @@
 ---
 # SDD Cook — Phase 4 Implementation
-# Executes tasks from MASTER-TASKS.md sequentially
-# Validates with subagents, updates task status
+# Single command for task execution
 ---
 tool: Bash
 when: always
 args: optional
-description: Phase 4 — Execute tasks from MASTER-TASKS.md sequentially. Args: [--all | --task T-XXX | --no-test | --no-review]. Validates dependencies, runs testing + code-review, updates task status.
+description: Phase 4 — Implement tasks from MASTER-TASKS.md. Args: [--all | --task T-XXX] [--dry-run]. Reads task file, shows requirements, guides implementation, marks complete.
 ---
-$ErrorActionPreference = 'Stop'
+$ErrorActionPreference = 'Continue'
 
 # ============================================================
-# SDD Cook — Phase 4 Implementation
+# SDD Cook — Unified Phase 4 Command
 # ============================================================
-# Reads MASTER-TASKS.md, executes tasks sequentially,
-# validates with subagents, updates task status
+# Usage:
+#   claude "/sdd-cook"          # Show plan, guide next task
+#   claude "/sdd-cook --all"    # Implement all pending tasks
+#   claude "/sdd-cook --task T-001"  # Implement specific task
 # ============================================================
 
 # --- Parse arguments ---
 $rawArgs = $args -join ' '
 $targetTask = ""
-$skipTest = $false
-$skipReview = $false
 $executeAll = $false
+$dryRun = $false
 
+# Parse flags
 if ($rawArgs -match "--task\s+(\S+)") {
     $targetTask = $matches[1]
 }
 if ($rawArgs -match "--all") {
     $executeAll = $true
 }
-if ($rawArgs -match "--no-test") {
-    $skipTest = $true
-}
-if ($rawArgs -match "--no-review") {
-    $skipReview = $true
+if ($rawArgs -match "--dry-run") {
+    $dryRun = $true
 }
 
 # ============================================================
-# STEP 1: Prerequisites Check
+# Prerequisites Check
 # ============================================================
 Write-Host ""
-Write-Host "=== SDD Cook — Phase 4 Implementation ===" -ForegroundColor Cyan
+Write-Host "========================================" -ForegroundColor Cyan
+Write-Host "  SDD Cook — Phase 4 Implementation" -ForegroundColor Cyan
+Write-Host "========================================" -ForegroundColor Cyan
 Write-Host ""
 
-# Check for task directory
-$taskDirs = Get-ChildItem -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
-if (-not $taskDirs) {
-    Write-Host "[ERROR] No task directory found (task-*-*/)." -ForegroundColor Red
-    Write-Host "Run: /sdd-tasks to generate tasks first." -ForegroundColor Yellow
+# Find task directory
+$SDD_TASKS_DIR = "sdd/tasks"
+$taskDir = $null
+
+if (Test-Path $SDD_TASKS_DIR) {
+    $taskDirs = Get-ChildItem -Path $SDD_TASKS_DIR -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
+    if ($taskDirs) {
+        $taskDir = Join-Path $SDD_TASKS_DIR ($taskDirs[0].Name)
+    }
+}
+
+if (-not $taskDir) {
+    $legacyTaskDirs = Get-ChildItem -Filter "task-*-*" -Directory -ErrorAction SilentlyContinue
+    if ($legacyTaskDirs) {
+        $taskDir = $legacyTaskDirs[0].FullName
+    }
+}
+
+if (-not $taskDir) {
+    Write-Host "[ERROR] No task directory found." -ForegroundColor Red
+    Write-Host "Run: claude `"/sdd-tasks`" first." -ForegroundColor Yellow
     exit 1
 }
 
-$taskDir = $taskDirs[0].FullName
-$taskDirName = $taskDirs[0].Name
+$taskDirName = Split-Path $taskDir -Leaf
 
-# Check MASTER-TASKS.md exists
+# Check files
 $masterTasksPath = Join-Path $taskDir "MASTER-TASKS.md"
 if (-not (Test-Path $masterTasksPath)) {
-    Write-Host "[ERROR] MASTER-TASKS.md not found: $masterTasksPath" -ForegroundColor Red
-    Write-Host "Run: /sdd-tasks to generate tasks." -ForegroundColor Yellow
+    Write-Host "[ERROR] MASTER-TASKS.md not found." -ForegroundColor Red
     exit 1
 }
 
-# Check SPEC.md exists
-if (-not (Test-Path "SPEC.md")) {
+$specFile = "sdd/SPEC.md"
+if (-not (Test-Path $specFile)) {
     Write-Host "[ERROR] SPEC.md not found." -ForegroundColor Red
-    Write-Host "Run: /sdd-spec to generate SPEC.md first." -ForegroundColor Yellow
+    Write-Host "Run: claude `"/sdd-spec`" first." -ForegroundColor Yellow
     exit 1
 }
 
-Write-Host "[OK] Prerequisites verified:" -ForegroundColor Green
-Write-Host "  - Task directory: $taskDirName" -ForegroundColor Gray
-Write-Host "  - MASTER-TASKS.md: Found" -ForegroundColor Gray
-Write-Host "  - SPEC.md: Found" -ForegroundColor Gray
+Write-Host "[OK] Prerequisites verified" -ForegroundColor Green
+Write-Host "  Task dir: $taskDirName" -ForegroundColor Gray
 Write-Host ""
 
 # ============================================================
-# STEP 2: Read MASTER-TASKS.md
+# Load Tasks
 # ============================================================
 Write-Host "--- Loading Tasks ---" -ForegroundColor Yellow
 
 $masterContent = Get-Content $masterTasksPath -Raw
 
-# Parse tasks from table
 $taskPattern = '\|\s*(T-\d+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*\[([^\]]+)\]\s*\|'
 $tasks = @()
 if ($masterContent -match $taskPattern) {
     $matches = [regex]::Matches($masterContent, $taskPattern)
     foreach ($m in $matches) {
-        $task = @{
+        $tasks += @{
             Id = $m.Groups[1].Value
             Name = $m.Groups[2].Value.Trim()
             Estimate = $m.Groups[3].Value.Trim()
             Status = $m.Groups[4].Value.Trim()
         }
-        $tasks += $task
     }
 }
 
 if ($tasks.Count -eq 0) {
-    Write-Host "[ERROR] No tasks found in MASTER-TASKS.md" -ForegroundColor Red
+    Write-Host "[ERROR] No tasks found." -ForegroundColor Red
     exit 1
 }
 
+# Helper function
+function Test-TaskComplete($status) {
+    return $status -in @("x", "X", "v", "V", "done", "completed")
+}
+
+Write-Host ""
 Write-Host "Found $($tasks.Count) tasks:" -ForegroundColor Green
+$completedCount = 0
+$pendingTasks = @()
 foreach ($t in $tasks) {
-    $statusIcon = if ($t.Status -eq "x") { "[V]" } else { "[ ]" }
-    $color = if ($t.Status -eq "x") { "Green" } else { "Gray" }
-    Write-Host "  $statusIcon $($t.Id): $($t.Name) ($($t.Estimate))" -ForegroundColor $color
+    $isComplete = Test-TaskComplete $t.Status
+    if ($isComplete) { $completedCount++ } else { $pendingTasks += $t }
+    $statusIcon = if ($isComplete) { "[V]" } else { "[ ]" }
+    $color = if ($isComplete) { "Green" } else { "Gray" }
+    Write-Host "  $statusIcon $($t.Id): $($t.Name)" -ForegroundColor $color
 }
 Write-Host ""
+Write-Host "Progress: $completedCount/$($tasks.Count) complete" -ForegroundColor Cyan
+Write-Host ""
 
 # ============================================================
-# STEP 3: Find tasks to execute
+# Select Tasks to Execute
 # ============================================================
-$pendingTasks = $tasks | Where-Object { $_.Status -ne "x" }
 $tasksToExecute = @()
 
 if ($targetTask) {
-    # Execute specific task
-    $specific = $pendingTasks | Where-Object { $_.Id -eq $targetTask }
-    if ($specific) {
-        $tasksToExecute += $specific
-        Write-Host "Executing specific task: $targetTask" -ForegroundColor Cyan
+    # Specific task
+    $task = $pendingTasks | Where-Object { $_.Id -eq $targetTask }
+    if ($task) {
+        $tasksToExecute += $task
+        Write-Host "Mode: specific - Task $targetTask" -ForegroundColor Cyan
     } else {
-        $found = $tasks | Where-Object { $_.Id -eq $targetTask }
-        if ($found) {
-            Write-Host "[WARN] Task $targetTask is already complete." -ForegroundColor Yellow
+        $existing = $tasks | Where-Object { $_.Id -eq $targetTask }
+        if ($existing) {
+            Write-Host "[INFO] Task $targetTask already complete." -ForegroundColor Green
         } else {
             Write-Host "[ERROR] Task $targetTask not found." -ForegroundColor Red
         }
         exit 0
     }
 } elseif ($executeAll) {
-    # Execute all pending in order
+    # All pending
     $tasksToExecute = $pendingTasks
-    Write-Host "Executing all pending tasks ($($tasksToExecute.Count) tasks)..." -ForegroundColor Cyan
+    Write-Host "Mode: all - $($tasksToExecute.Count) tasks" -ForegroundColor Cyan
 } else {
-    # Default: execute first pending task
+    # Interactive - next pending task
     if ($pendingTasks.Count -gt 0) {
         $tasksToExecute += $pendingTasks[0]
-        Write-Host "Executing next pending task: $($pendingTasks[0].Id)" -ForegroundColor Cyan
+        Write-Host "Mode: next pending task" -ForegroundColor Cyan
     } else {
-        Write-Host "[INFO] All tasks are complete!" -ForegroundColor Green
+        Write-Host "[INFO] All tasks complete!" -ForegroundColor Green
         Write-Host ""
-        Write-Host "Next: /sdd-converge to validate implementation" -ForegroundColor Cyan
+        Write-Host "Next: claude `"/sdd-converge`"" -ForegroundColor Cyan
         exit 0
     }
 }
 
-# ============================================================
-# STEP 4: Read task files and execute
-# ============================================================
-Write-Host ""
-Write-Host "--- Task Execution ---" -ForegroundColor Yellow
 Write-Host ""
+Write-Host "Tasks to execute: $($tasksToExecute.Count)" -ForegroundColor Green
 
-$completedCount = 0
-$totalTasks = $tasks.Count
-$completedBefore = ($tasks | Where-Object { $_.Status -eq "x" }).Count
-
+# ============================================================
+# Implement Each Task
+# ============================================================
 foreach ($task in $tasksToExecute) {
     Write-Host ""
     Write-Host "========================================" -ForegroundColor Magenta
-    Write-Host "Executing: $($task.Id) - $($task.Name)" -ForegroundColor Magenta
+    Write-Host "  Implementing: $($task.Id) - $($task.Name)" -ForegroundColor Magenta
     Write-Host "========================================" -ForegroundColor Magenta
 
     # Find task file
-    $taskFiles = Get-ChildItem -Path $taskDir -Filter "$($task.Id)-*.md" -File
+    $taskFiles = Get-ChildItem -Path $taskDir -Filter "$($task.Id)-*.md" -File -ErrorAction SilentlyContinue
+    $taskFiles = $taskFiles | Where-Object { $_.Name -ne "MASTER-TASKS.md" }
+
     if (-not $taskFiles) {
         Write-Host "[WARN] Task file not found: $($task.Id)-*.md" -ForegroundColor Yellow
-        Write-Host "Skipping $($task.Id)..." -ForegroundColor Yellow
         continue
     }
 
     $taskFile = $taskFiles[0].FullName
     $taskContent = Get-Content $taskFile -Raw
 
+    # Extract task name override
+    if ($taskContent -match '(?m)^#\s+\S+:\s*(.+)') {
+        $task.Name = $matches[1].Trim()
+    }
+
     # Parse frontmatter
     $dependsOn = @()
     if ($taskContent -match 'depends_on:\s*\[([^\]]*)\]') {
@@ -187,27 +209,9 @@ foreach ($task in $tasksToExecute) {
         }
     }
 
-    # Check dependencies
-    if ($dependsOn.Count -gt 0) {
-        Write-Host "Dependencies: $($dependsOn -join ', ')" -ForegroundColor Gray
-        $depsMet = $true
-        foreach ($dep in $dependsOn) {
-            $depTask = $tasks | Where-Object { $_.Id -eq $dep }
-            if ($depTask -and $depTask.Status -ne "x") {
-                Write-Host "[BLOCKED] $($task.Id) depends on $dep which is not complete." -ForegroundColor Red
-                $depsMet = $false
-                break
-            }
-        }
-        if (-not $depsMet) {
-            Write-Host "Skipping $($task.Id) - dependency not met." -ForegroundColor Yellow
-            continue
-        }
-    }
-
-    # Extract files to modify
+    # Extract files
     $filesToModify = @()
-    if ($taskContent -match '## Files to Modify/Create\s*\n((?:- .+\n)+)') {
+    if ($taskContent -match '(?s)## Files to (?:Modify|Create)\s*\n((?:- .+\n)+)') {
         $filesBlock = $matches[1]
         $files = $filesBlock -split '\n' | Where-Object { $_ -match '^\s*-\s+' }
         foreach ($f in $files) {
@@ -216,120 +220,98 @@ foreach ($task in $tasksToExecute) {
         }
     }
 
-    # Extract implementation steps
+    # Extract steps
     $implSteps = @()
-    if ($taskContent -match '## Implementation Steps\s*\n((?:\d+\. .+\n)+)') {
+    if ($taskContent -match '(?s)## Implementation Steps\s*\n((?:\d+\. .+\n?)+)') {
         $stepsBlock = $matches[1]
         $implSteps = $stepsBlock -split '\n' | Where-Object { $_ -match '^\d+\.' }
     }
 
-    # Extract verification checks
+    # Extract verification
     $verificationChecks = @()
-    if ($taskContent -match '## Verification\s*\n((?:- \[ \] .+\n)+)') {
+    if ($taskContent -match '(?s)## Verification\s*\n((?:- \[ \] .+\n?)+)') {
         $checksBlock = $matches[1]
         $verificationChecks = $checksBlock -split '\n' | Where-Object { $_ -match '- \[ \]' }
     }
 
-    Write-Host ""
-    Write-Host "Task Details:" -ForegroundColor Cyan
-    Write-Host "  Files: $($filesToModify -join ', ')" -ForegroundColor Gray
-    Write-Host "  Verification checks: $($verificationChecks.Count)" -ForegroundColor Gray
+    # Extract SPEC sections
+    $specSections = @()
+    if ($taskContent -match 'spec_sections:\s*\[([^\]]+)\]') {
+        $sections = $matches[1] -split ',' | ForEach-Object { $_.Trim() -replace '"', '' }
+        $specSections += $sections
+    }
 
-    # ============================================================
-    # IMPLEMENTATION
-    # ============================================================
-    Write-Host ""
-    Write-Host "--- Implementation ---" -ForegroundColor Yellow
-    Write-Host "Executing implementation for $($task.Id)..." -ForegroundColor Green
-    Write-Host ""
-    Write-Host "[HINT] To implement this task:" -ForegroundColor Cyan
-    Write-Host "  1. Read SPEC.md for requirements" -ForegroundColor Gray
-    Write-Host "  2. Read $taskFile" -ForegroundColor Gray
-    Write-Host "  3. Implement changes per steps" -ForegroundColor Gray
+    # Display requirements
     Write-Host ""
-    Write-Host "[HINT] Files to modify:" -ForegroundColor Cyan
-    foreach ($f in $filesToModify) {
-        Write-Host "  - $f" -ForegroundColor Gray
+    Write-Host "--- Requirements ---" -ForegroundColor Yellow
+
+    if ($taskContent -match '(?m)^description:\s*"([^"]+)"') {
+        Write-Host "Description: $($matches[1])" -ForegroundColor White
     }
-    Write-Host ""
-    Write-Host "[HINT] Implementation steps:" -ForegroundColor Cyan
-    foreach ($step in $implSteps) {
-        Write-Host "  $step" -ForegroundColor Gray
+
+    if ($dependsOn.Count -gt 0) {
+        Write-Host "Dependencies: $($dependsOn -join ', ')" -ForegroundColor Yellow
     }
 
-    # ============================================================
-    # TESTING (if not skipped)
-    # ============================================================
-    if (-not $skipTest) {
+    if ($filesToModify.Count -gt 0) {
         Write-Host ""
-        Write-Host "--- Testing ---" -ForegroundColor Yellow
-        Write-Host "Verification checks:" -ForegroundColor Cyan
-        foreach ($check in $verificationChecks) {
-            $checkText = $check -replace '^\s*-\s+\[ \]\s*', ''
-            Write-Host "  [ ] $checkText" -ForegroundColor Gray
+        Write-Host "Files to create/modify:" -ForegroundColor Cyan
+        foreach ($f in $filesToModify) {
+            $exists = if (Test-Path $f) { "(exists)" } else { "(new)" }
+            Write-Host "  - $f $exists" -ForegroundColor Gray
         }
+    }
+
+    if ($implSteps.Count -gt 0) {
         Write-Host ""
-        Write-Host "[HINT] Run tests and verify each check." -ForegroundColor Cyan
-        Write-Host "Mark checks complete after verification." -ForegroundColor Gray
+        Write-Host "Implementation Steps:" -ForegroundColor Cyan
+        foreach ($step in $implSteps) {
+            Write-Host "  $step" -ForegroundColor Gray
+        }
     }
 
-    # ============================================================
-    # CODE REVIEW (if not skipped)
-    # ============================================================
-    if (-not $skipReview) {
+    if ($verificationChecks.Count -gt 0) {
         Write-Host ""
-        Write-Host "--- Code Review ---" -ForegroundColor Yellow
-        Write-Host "[HINT] After implementation, run: /ck:code-review" -ForegroundColor Cyan
-        Write-Host "[HINT] Verify:" -ForegroundColor Cyan
-        Write-Host "  - Spec compliance (SPEC.md requirements met)" -ForegroundColor Gray
-        Write-Host "  - No regression in touched files" -ForegroundColor Gray
-        Write-Host "  - Code quality and patterns" -ForegroundColor Gray
+        Write-Host "Verification Checks:" -ForegroundColor Cyan
+        foreach ($check in $verificationChecks) {
+            $checkText = $check -replace '^\s*-\s+\[ \]\s*', ''
+            Write-Host "  - [ ] $checkText" -ForegroundColor Gray
+        }
     }
 
-    # ============================================================
-    # MANUAL CONFIRMATION
-    # ============================================================
+    # Implementation guidance
     Write-Host ""
-    Write-Host "========================================" -ForegroundColor Magenta
-    Write-Host "After completing $($task.Id), update status?" -ForegroundColor Yellow
-    Write-Host "========================================" -ForegroundColor Magenta
-    Write-Host ""
-    Write-Host "To mark complete, run:" -ForegroundColor Cyan
-    Write-Host '  /sdd-task-status ' + $task.Id + ' done' -ForegroundColor Gray
+    Write-Host "--- Implementation ---" -ForegroundColor Yellow
     Write-Host ""
+    Write-Host "1. Read sdd/SPEC.md (sections: $($specSections -join ', '))" -ForegroundColor White
+    Write-Host "2. Implement $($task.Name)" -ForegroundColor White
+    Write-Host "3. Verify against checks above" -ForegroundColor White
 
-    # Update MASTER-TASKS.md
-    $masterContent = Get-Content $masterTasksPath -Raw
-    $newStatus = "[x]"
-    $updatedContent = $masterContent -replace "(`|$([regex]::Escape($task.Id))`|\s)\[([ `])\](?=\s*\|)", "`$1[x]"
-    Set-Content $masterTasksPath $updatedContent -Encoding UTF8
+    if (-not $dryRun) {
+        Write-Host ""
+        Write-Host "4. Mark task complete:" -ForegroundColor White
+        Write-Host "   pwsh commands/sdd-task-status.ps1 -TaskId '$($task.Id)' -Status completed" -ForegroundColor Gray
+    }
 
-    Write-Host "[OK] Status updated in MASTER-TASKS.md" -ForegroundColor Green
-    $completedCount++
+    Write-Host ""
 }
 
 # ============================================================
-# STEP 5: Summary
+# Summary
 # ============================================================
 Write-Host ""
 Write-Host "========================================" -ForegroundColor Cyan
-Write-Host "SDD Cook Execution Complete" -ForegroundColor Cyan
+Write-Host "  Ready to implement $($tasksToExecute.Count) task(s)" -ForegroundColor Green
 Write-Host "========================================" -ForegroundColor Cyan
 Write-Host ""
-Write-Host "Tasks completed this session: $completedCount" -ForegroundColor Green
-$completedAfter = $completedBefore + $completedCount
-Write-Host "Total progress: $completedAfter / $totalTasks" -ForegroundColor Gray
 
-$remaining = $totalTasks - $completedAfter
-if ($remaining -gt 0) {
-    Write-Host "Remaining: $remaining tasks" -ForegroundColor Yellow
+if ($executeAll) {
+    Write-Host "To execute all:" -ForegroundColor White
+    Write-Host "  Run this command for each task in order" -ForegroundColor Gray
     Write-Host ""
-    Write-Host "Next: /sdd-cook --all to continue" -ForegroundColor Cyan
+    $cmdList = $tasksToExecute | ForEach-Object { "claude `"/sdd-cook --task $($_.Id)`"" }
+    Write-Host ($cmdList -join "`n") -ForegroundColor Gray
 } else {
-    Write-Host ""
-    Write-Host "[V] All tasks complete!" -ForegroundColor Green
-    Write-Host ""
-    Write-Host "Next: /sdd-converge to validate implementation" -ForegroundColor Cyan
+    Write-Host "Next: Implement task, then mark complete" -ForegroundColor White
+    Write-Host "After: claude `"/sdd-cook --all`" for remaining tasks" -ForegroundColor Gray
 }
-
-Write-Host ""