@atlashub/smartstack-cli 3.7.0 → 3.9.0

package/templates/skills/ralph-loop/steps/step-05-report.md

@@ -1,6 +1,6 @@
 ---
 name: step-05-report
-description: Generate final report from prd.json v2 structured data
+description: Generate final report from prd.json structured data (v3 unified or v2 legacy)
 next_step: null
 ---
 
@@ -8,455 +8,156 @@ next_step: null
 
 ## YOUR TASK:
 
-Generate a comprehensive feature report using structured data from prd.json v2 (history, task metadata, file tracking).
+Generate a comprehensive feature report using structured data from prd.json.
 
 ---
 
-## EXECUTION SEQUENCE:
-
-### 1. Load Structured Data from prd.json
-
-**Read all data from the single source of truth:**
+## 1. Load Data
 
 ```javascript
 const prd = readJSON('.ralph/prd.json');
-
 const stats = {
-  feature: prd.feature,
-  status: prd.status,
-  schema: prd.$version,
-  started: prd.created,
-  completed: new Date().toISOString(),
+  feature: prd.feature, status: prd.status,
   iterations_used: prd.config.current_iteration - 1,
-  max_iterations: prd.config.max_iterations,
   tasks: {
     total: prd.tasks.length,
     completed: prd.tasks.filter(t => t.status === 'completed').length,
     failed: prd.tasks.filter(t => t.status === 'failed').length,
-    blocked: prd.tasks.filter(t => t.status === 'blocked').length,
-    skipped: prd.tasks.filter(t => t.status === 'skipped').length,
-    pending: prd.tasks.filter(t => t.status === 'pending').length
-  },
-  source: prd.source ? prd.source.type : 'direct',
-  branch: prd.metadata.branch
+    blocked: prd.tasks.filter(t => t.status === 'blocked').length
+  }
 };
 
 // Aggregate files from all tasks
-const allFilesCreated = [];
-const allFilesModified = [];
-for (const task of prd.tasks) {
-  if (task.files_changed) {
-    allFilesCreated.push(...task.files_changed.created);
-    allFilesModified.push(...task.files_changed.modified);
-  }
-}
-
-// Deduplicate
-const filesCreated = [...new Set(allFilesCreated)];
-const filesModified = [...new Set(allFilesModified)];
-
-// Calculate total duration from history
+const filesCreated = [...new Set(prd.tasks.flatMap(t => t.files_changed?.created || []))];
+const filesModified = [...new Set(prd.tasks.flatMap(t => t.files_changed?.modified || []))];
 const totalDuration = prd.history.reduce((sum, h) => sum + (h.duration_seconds || 0), 0);
 ```
 
-### 1b. Multi-Module Aggregation (if modules-queue.json exists)
-
-**Check for multi-module context:**
+### 1b. Multi-Module Aggregation
 
 ```javascript
 const queuePath = '.ralph/modules-queue.json';
-const hasQueue = fileExists(queuePath);
-
 let moduleStats = null;
-
-if (hasQueue) {
+if (fileExists(queuePath)) {
   const queue = readJSON(queuePath);
-
-  moduleStats = {
-    totalModules: queue.totalModules,
-    completedModules: queue.completedModules,
-    modules: []
-  };
-
-  // Aggregate stats from each module's prd file
+  moduleStats = { totalModules: queue.totalModules, completedModules: queue.completedModules, modules: [] };
   for (const mod of queue.modules) {
     const modPrd = readJSON(mod.prdFile);
-    const modTasks = modPrd.tasks || [];
-
-    const modData = {
-      code: mod.code,
-      status: mod.status,
-      tasks: {
-        total: modTasks.length,
-        completed: modTasks.filter(t => t.status === 'completed').length,
-        failed: modTasks.filter(t => t.status === 'failed').length,
-        blocked: modTasks.filter(t => t.status === 'blocked').length,
-        skipped: modTasks.filter(t => t.status === 'skipped').length
-      },
-      filesCreated: [],
-      filesModified: [],
-      commits: []
-    };
-
-    for (const task of modTasks) {
-      if (task.files_changed) {
-        modData.filesCreated.push(...task.files_changed.created);
-        modData.filesModified.push(...task.files_changed.modified);
-      }
-      if (task.commit_hash) {
-        modData.commits.push(task.commit_hash);
-      }
-    }
-
-    modData.filesCreated = [...new Set(modData.filesCreated)];
-    modData.filesModified = [...new Set(modData.filesModified)];
-    modData.commits = [...new Set(modData.commits)];
-
-    moduleStats.modules.push(modData);
-  }
-
-  // Merge all module files into main aggregation
-  for (const mod of moduleStats.modules) {
-    allFilesCreated.push(...mod.filesCreated);
-    allFilesModified.push(...mod.filesModified);
+    moduleStats.modules.push({
+      code: mod.code, status: mod.status,
+      tasks: { total: modPrd.tasks.length, completed: modPrd.tasks.filter(t => t.status === 'completed').length, failed: modPrd.tasks.filter(t => t.status === 'failed').length },
+      filesCreated: [...new Set(modPrd.tasks.flatMap(t => t.files_changed?.created || []))].length,
+      commits: [...new Set(modPrd.tasks.filter(t => t.commit_hash).map(t => t.commit_hash))].length
+    });
   }
 }
 ```
 
-### 1c. Extract Test Metrics (from progress.txt and test execution)
-
-**CRITICAL: Test metrics MUST be included in the final report.**
-
-```bash
-PROJECT_NAME=$(basename $(pwd))
-TEST_PROJECT="tests/${PROJECT_NAME}.Tests.Unit"
-
-testMetrics={
-  projectExists: false,
-  testsExecuted: false,
-  lastRunStatus: "unknown",
-  totalTests: 0,
-  passed: 0,
-  failed: 0,
-  skipped: 0,
-  coverage: 0,
-  duration: 0
-};
-
-if [ -d "$TEST_PROJECT" ]; then
-  testMetrics.projectExists = true;
-
-  # Extract latest test metrics from progress.txt
-  if [ -f ".ralph/progress.txt" ]; then
-    # Parse last "Test Metrics" entry
-    LAST_METRICS=$(grep -A 3 "\[Test Metrics" .ralph/progress.txt | tail -4)
-
-    # Extract values using regex
-    TOTAL=$(echo "$LAST_METRICS" | grep -oP "Total: \K\d+")
-    PASSED=$(echo "$LAST_METRICS" | grep -oP "Passed: \K\d+")
-    FAILED=$(echo "$LAST_METRICS" | grep -oP "Failed: \K\d+")
-    SKIPPED=$(echo "$LAST_METRICS" | grep -oP "Skipped: \K\d+")
-    DURATION=$(echo "$LAST_METRICS" | grep -oP "Duration: \K[\d\.]+")
-
-    if [ -n "$TOTAL" ]; then
-      testMetrics.testsExecuted = true;
-      testMetrics.totalTests = $TOTAL;
-      testMetrics.passed = $PASSED;
-      testMetrics.failed = $FAILED;
-      testMetrics.skipped = $SKIPPED;
-      testMetrics.duration = $DURATION;
-      testMetrics.lastRunStatus = [ $FAILED -eq 0 ] ? "passed" : "failed";
-    fi
-  fi
-
-  # If no metrics in progress.txt, run tests now to get final stats
-  if [ "$testMetrics.testsExecuted" = false ]; then
-    echo "Running final test suite to collect metrics...";
-    TEST_OUTPUT=$(dotnet test "$TEST_PROJECT" --no-build --verbosity minimal 2>&1);
-    TEST_EXIT_CODE=$?;
-
-    testMetrics.testsExecuted = true;
-    testMetrics.lastRunStatus = [ $TEST_EXIT_CODE -eq 0 ] ? "passed" : "failed";
-
-    # Parse test output
-    testMetrics.totalTests = parseTestCount(TEST_OUTPUT);
-    testMetrics.passed = parsePassedCount(TEST_OUTPUT);
-    testMetrics.failed = parseFailedCount(TEST_OUTPUT);
-    testMetrics.skipped = parseSkippedCount(TEST_OUTPUT);
-    testMetrics.duration = parseDuration(TEST_OUTPUT);
-  fi
-
-  # Get coverage using MCP
-  const coverageResult = mcp__smartstack__analyze_test_coverage({
-    project_path: process.cwd()
-  });
-
-  if (coverageResult && coverageResult.percentage) {
-    testMetrics.coverage = coverageResult.percentage;
-  }
-fi
-```
-
-**Store metrics for report generation:**
+### 1c. Team Results Aggregation
 
 ```javascript
-stats.tests = testMetrics;
+// If Agent Teams were used, results are already in per-module PRDs
+// Aggregate from moduleStats (same as 1b)
 ```
 
-### 2. Collect MCP Usage (from logs if available)
-
-**Parse from verbose logs:**
+### 1d. Test Metrics
 
 ```bash
-# Count MCP calls from log files
-MCP_CALLS=$(grep -c "\[MCP\]" .ralph/logs/*.log 2>/dev/null || echo "0")
-SMARTSTACK_CALLS=$(grep -c "mcp__smartstack" .ralph/logs/*.log 2>/dev/null || echo "0")
-CONTEXT7_CALLS=$(grep -c "mcp__context7" .ralph/logs/*.log 2>/dev/null || echo "0")
-```
-
-**Or extract from task validations:**
-
-```javascript
-const validationStats = {
-  passed: prd.tasks.filter(t => t.validation === 'passed').length,
-  failed: prd.tasks.filter(t => t.validation && t.validation.startsWith('failed')).length,
-  skipped: prd.tasks.filter(t => t.validation === null).length
-};
+TEST_PROJECT="tests/$(basename $(pwd)).Tests.Unit"
+if [ -d "$TEST_PROJECT" ]; then
+  dotnet test "$TEST_PROJECT" --no-build --verbosity minimal
+  # Parse total/passed/failed/skipped from output
+fi
 ```
 
-### 3. Generate Report File
+## 2. Generate Report
 
-**Write to `.ralph/reports/{feature-slug}.md`:**
+Write to `.ralph/reports/{feature-slug}.md`:
 
 ```markdown
 # Feature Report: {feature}
 
 ## Summary
-
 | Field | Value |
 |-------|-------|
-| **Status** | {status} |
-| **Started** | {started} |
-| **Completed** | {completed} |
-| **Iterations** | {iterations_used} / {max_iterations} |
-| **Branch** | {branch} |
-| **Source** | {source} |
-| **Schema** | {schema} |
-
-## Task Progress
-
-| # | Task | Category | Status | Iteration | Duration | Commit |
-|---|------|----------|--------|-----------|----------|--------|
-{for each task in prd.tasks:}
-| {id} | {description} | {category} | {status_emoji} | {iteration || '-'} | {duration}s | {commit_hash || '-'} |
-{end for}
-
-**Summary: {completed}/{total} completed, {failed} failed, {blocked} blocked, {skipped} skipped**
+| Status | {status} |
+| Iterations | {iterations_used} / {max} |
+| Branch | {branch} |
+| Duration | {totalDuration}s ({min} min) |
+
+## Tasks
+| # | Task | Category | Status | Commit |
+|---|------|----------|--------|--------|
+{for each task:}
+| {id} | {description} | {category} | {status_emoji} | {commit_hash} |
 
-{status_emoji mapping: completed=✅, failed=❌, blocked=🚫, skipped=⏭️, pending=⏳}
+**{completed}/{total} completed, {failed} failed, {blocked} blocked**
 
 {if moduleStats:}
-## Module Progress
+## Modules
+| Module | Status | Tasks | Completed | Failed | Files | Commits |
+|--------|--------|-------|-----------|--------|-------|---------|
+{for each mod:}
+| {code} | {status} | {total} | {completed} | {failed} | {filesCreated} | {commits} |
 
-| Module | Status | Tasks | Completed | Failed | Files Created | Files Modified | Commits |
-|--------|--------|-------|-----------|--------|---------------|----------------|---------|
-{for each mod in moduleStats.modules:}
-| {mod.code} | {mod.status} | {mod.tasks.total} | {mod.tasks.completed} | {mod.tasks.failed} | {mod.filesCreated.length} | {mod.filesModified.length} | {mod.commits.length} |
-{end for}
-
-**Modules: {moduleStats.completedModules}/{moduleStats.totalModules} completed**
+**{completedModules}/{totalModules} modules completed**
 {end if}
 
 ## Test Metrics
-
-{if testMetrics.projectExists:}
 | Metric | Value |
 |--------|-------|
-| **Test Project** | ✅ `{TEST_PROJECT}` |
-| **Tests Executed** | {testMetrics.testsExecuted ? '✅ Yes' : '❌ No'} |
-| **Last Run Status** | {testMetrics.lastRunStatus === 'passed' ? '✅ PASSED' : testMetrics.lastRunStatus === 'failed' ? '❌ FAILED' : '⚠️ UNKNOWN'} |
-| **Total Tests** | {testMetrics.totalTests} |
-| **Passed** | ✅ {testMetrics.passed} |
-| **Failed** | ❌ {testMetrics.failed} |
-| **Skipped** | ⏭️ {testMetrics.skipped} |
-| **Coverage** | {testMetrics.coverage}% {testMetrics.coverage >= 80 ? '✅' : testMetrics.coverage >= 60 ? '⚠️' : '❌'} |
-| **Duration** | {testMetrics.duration}s |
-
-{if testMetrics.failed > 0:}
-⚠️ **WARNING:** Some tests are failing. The module is NOT production-ready.
-{end if}
-
-{if testMetrics.coverage < 80:}
-⚠️ **WARNING:** Test coverage is below 80% minimum. Consider adding more tests.
-{end if}
-
-{else:}
-❌ **No test project found.** Tests were not created for this module.
-
-**RECOMMENDATION:** Create a test project and add comprehensive tests before deploying to production.
-
-Suggested command:
-```bash
-dotnet new xunit -n {PROJECT_NAME}.Tests.Unit -o tests/{PROJECT_NAME}.Tests.Unit
-dotnet sln add tests/{PROJECT_NAME}.Tests.Unit
-```
-{end if}
+| Tests Executed | {yes/no} |
+| Status | {passed/failed} |
+| Total | {n} | Passed | {n} | Failed | {n} |
+| Coverage | {n}% |
 
 ## Failed Tasks
+{table of failed tasks with error messages, or "None"}
 
-{if any failed tasks:}
-| # | Task | Error |
-|---|------|-------|
-{for each failed task:}
-| {id} | {description} | {error} |
-{end for}
-{else:}
-No failed tasks.
-{end if}
-
-## Blocked Tasks
-
-{if any blocked tasks:}
-| # | Task | Blocked By | Error |
-|---|------|------------|-------|
-{for each blocked task:}
-| {id} | {description} | Tasks {dependencies} | {error} |
-{end for}
-{else:}
-No blocked tasks.
-{end if}
-
-## Iteration History
-
-{for each entry in prd.history:}
-### Iteration {iteration} — Task [{task_id}]
-- **Action**: {action}
-- **Timestamp**: {timestamp}
-- **Commit**: {commit_hash}
-- **Duration**: {duration_seconds}s
-- **Notes**: {notes}
-
-{end for}
-
-## MCP Validation Results
+## Files
+- Created: {filesCreated.length}
+- Modified: {filesModified.length}
 
-| Task | Category | Validation |
-|------|----------|------------|
-{for each task:}
-| [{id}] {description} | {category} | {validation || 'N/A'} |
-{end for}
-
-## Files Created ({filesCreated.length})
-
-{if filesCreated.length > 0:}
-{for each file:}
-- `{file}`
-{end for}
-{else:}
-- (none)
-{end if}
-
-## Files Modified ({filesModified.length})
-
-{if filesModified.length > 0:}
-{for each file:}
-- `{file}`
-{end for}
-{else:}
-- (none)
-{end if}
-
-## Git Commits
-
-{for each unique commit_hash in tasks:}
-`{commit_hash}` {commit message from task description}
-{end for}
-
-## Metadata
-
-| Field | Value |
-|-------|-------|
-| CLI Version | {prd.metadata.cli_version} |
-| Branch | {prd.metadata.branch} |
-| Project | {prd.metadata.project_path} |
-| MCP SmartStack | {prd.metadata.mcp_servers.smartstack ? '✅' : '❌'} |
-| MCP Context7 | {prd.metadata.mcp_servers.context7 ? '✅' : '❌'} |
-| Total Duration | {totalDuration}s ({Math.round(totalDuration/60)} min) |
+## Commits
+{unique commits list}
 
 ---
-*Auto-generated by Ralph Loop v2 — SmartStack CLI*
+*Auto-generated by Ralph Loop — SmartStack CLI*
 ```
 
-### 4. Finalize prd.json
-
-**Set final status (if not already set by step-04):**
+## 3. Finalize
 
 ```javascript
 prd.updated_at = new Date().toISOString();
 writeJSON('.ralph/prd.json', prd);
 ```
 
-### 5. Display Final Summary
+## 4. Display Summary
 
 ```
-╔══════════════════════════════════════════════════════════════════╗
-║                    RALPH LOOP COMPLETE                           ║
-╠══════════════════════════════════════════════════════════════════╣
-║  Feature:    {feature}                                           ║
-║  Status:     {status}                                            ║
-║  Iterations: {iterations_used}                                   ║
-║  Tasks:      {completed}/{total} completed                       ║
-║              {failed} failed, {blocked} blocked                  ║
-║  {moduleStats ? "Modules: " + moduleStats.completedModules + "/" + moduleStats.totalModules + " completed" : ""} ║
-╠══════════════════════════════════════════════════════════════════╣
-║  Files Created:  {filesCreated.length}                           ║
-║  Files Modified: {filesModified.length}                          ║
-║  Commits:        {unique_commits.length}                         ║
-║  Duration:       {totalDuration}s ({minutes} min)                ║
-╠══════════════════════════════════════════════════════════════════╣
-║  Report saved to:                                                ║
-║  .ralph/reports/{feature-slug}.md                                ║
-╚══════════════════════════════════════════════════════════════════╝
+RALPH LOOP COMPLETE
+Feature: {feature} | Status: {status}
+Iterations: {n} | Tasks: {completed}/{total}
+{moduleStats ? `Modules: ${completedModules}/${totalModules}` : ""}
+Files: {created} created, {modified} modified
+Report: .ralph/reports/{slug}.md
 ```
 
-### 6. Output Completion (if applicable)
-
-**If prd.status === 'completed' and not already output:**
+## 5. Completion Promise (if applicable)
 
 ```
 <promise>{completion_promise}</promise>
 ```
 
----
-
-## CLEANUP SUGGESTIONS:
-
-**Suggest to user:**
+## 6. Next Steps
 
 ```
-Next steps:
-1. Review report: .ralph/reports/{feature-slug}.md
+1. Review report: .ralph/reports/{slug}.md
 2. Run full test suite: dotnet test
 3. Create PR: /gitflow pr
-4. Clean up Ralph files: rm -rf .ralph/ (optional)
+4. Clean up: rm -rf .ralph/ (optional)
 ```
 
 ---
 
-## SUCCESS CRITERIA:
-
-- Report generated in `.ralph/reports/` with ALL structured data from prd.json
-- Task progress table with categories, status, iterations, and commits
-- Failed/blocked tasks documented with error messages
-- Iteration history from `history[]` included
-- File lists from task-level tracking (not git log)
-- Metadata section with execution context
-- Duration calculated from history entries
-- Final summary displayed
-- prd.json `status` and `updated_at` finalized
-- **Multi-module:** Per-module statistics table included (if modules-queue.json exists)
-- **Multi-module:** Cross-module file and commit aggregation
-
-## COMPLETION:
-
 Ralph loop complete. No more steps.