@atlashub/smartstack-cli 3.0.0 → 3.2.0

package/templates/skills/ralph-loop/steps/step-04-check.md

@@ -34,6 +34,97 @@ const hasBlocked   = tasksBlocked > 0;
 const hasPending   = tasksPending > 0;
 ```
 
+### 1.5. REGRESSION CHECK (MANDATORY AFTER EACH ITERATION)
+
+**CRITICAL: After EVERY task completion, run full test suite to detect regressions.**
+
+```bash
+PROJECT_NAME=$(basename $(pwd))
+TEST_PROJECT="tests/${PROJECT_NAME}.Tests.Unit"
+
+if [ -d "$TEST_PROJECT" ]; then
+  echo "🔍 Running regression check (full test suite)..."
+
+  # Run ALL tests to ensure nothing broke
+  dotnet test "$TEST_PROJECT" --no-build --verbosity minimal --logger "console;verbosity=minimal"
+
+  REGRESSION_EXIT_CODE=$?
+
+  if [ $REGRESSION_EXIT_CODE -ne 0 ]; then
+    echo "╔════════════════════════════════════════════════════════════╗"
+    echo "║  ⚠️  REGRESSION DETECTED                                  ║"
+    echo "╠════════════════════════════════════════════════════════════╣"
+    echo "║  A previously passing test is now failing.                 ║"
+    echo "║  This indicates the last change broke existing code.       ║"
+    echo "╠════════════════════════════════════════════════════════════╣"
+    echo "║  CORRECTIVE ACTION:                                        ║"
+    echo "║  1. Identify which test(s) started failing                 ║"
+    echo "║  2. Analyze what changed in last commit                    ║"
+    echo "║  3. Fix the regression                                     ║"
+    echo "║  4. Commit the fix                                         ║"
+    echo "║  5. Ralph will continue automatically                      ║"
+    echo "╚════════════════════════════════════════════════════════════╝"
+
+    // Parse test output to identify which tests failed
+    const regressionTests = parseFailedTests(testOutput);
+
+    // Log regression details to progress.txt
+    const progressEntry = `
+[REGRESSION DETECTED - Iteration ${prd.config.current_iteration}]
+Failed tests: ${regressionTests.join(', ')}
+Last completed task: ${prd.tasks.find(t => t.id === lastCompletedTaskId).description}
+Commit: ${lastCommitHash}
+
+ACTION REQUIRED: Fix regression before continuing.
+`;
+    appendToFile('.ralph/progress.txt', progressEntry);
+
+    // Mark current state as having regression
+    prd.regression_detected = {
+      iteration: prd.config.current_iteration,
+      failed_tests: regressionTests,
+      last_task: lastCompletedTaskId,
+      commit_hash: lastCommitHash
+    };
+    writeJSON('.ralph/prd.json', prd);
+
+    // Create a new task to fix the regression
+    const fixTask = {
+      id: prd.tasks.length + 1,
+      description: `Fix regression: ${regressionTests.length} test(s) failing`,
+      status: 'pending',
+      category: 'validation',
+      dependencies: [],
+      acceptance_criteria: `All tests pass: ${regressionTests.join(', ')}`,
+      started_at: null,
+      completed_at: null,
+      iteration: null,
+      commit_hash: null,
+      files_changed: { created: [], modified: [] },
+      validation: null,
+      error: null
+    };
+    prd.tasks.push(fixTask);
+    prd.updated_at = new Date().toISOString();
+    writeJSON('.ralph/prd.json', prd);
+
+    // DO NOT STOP - continue to next task (which is the fix task)
+    echo "📋 Created task ${fixTask.id}: Fix regression";
+  } else {
+    echo "✅ Regression check passed. No tests broken.";
+
+    // Update test metrics in progress.txt
+    const testStats = parseTestStats(testOutput);
+    const metricsEntry = `
+[Test Metrics - Iteration ${prd.config.current_iteration}]
+Total: ${testStats.total} | Passed: ${testStats.passed} | Failed: ${testStats.failed} | Skipped: ${testStats.skipped}
+Duration: ${testStats.duration}
+`;
+    appendToFile('.ralph/progress.txt', metricsEntry);
+  }
+fi
+```
+
 ### 2. Check Iteration Limit
 
 **If `prd.config.current_iteration` > `prd.config.max_iterations`:**
@@ -90,13 +181,25 @@ if (hasQueue) {
     queue.modules[nextIndex].status = 'in-progress';
     writeJSON(queuePath, queue);
 
+    // ✅ FIX #1: Create module transition marker
+    // This signals to step-01 that it MUST reload even on iteration > 1
+    writeJSON('.ralph/module-changed.json', {
+      fromModule: currentModule.code,
+      toModule: queue.modules[nextIndex].code,
+      timestamp: new Date().toISOString()
+    });
+
     // Mark current prd.json as completed
     prd.status = 'completed';
     prd.updated_at = new Date().toISOString();
     writeJSON('.ralph/prd.json', prd);
 
-    // Reset iteration counter for next module
-    // (preserve max_iterations from config)
+    // ✅ FIX #2: Load next module's PRD NOW and reset iteration counter
+    const nextModulePrd = readJSON(queue.modules[nextIndex].prdFile);
+    nextModulePrd.config.current_iteration = 1;
+    nextModulePrd.config.max_iterations = prd.config.max_iterations; // Preserve
+    nextModulePrd.updated_at = new Date().toISOString();
+    writeJSON('.ralph/prd.json', nextModulePrd);
 
     console.log(`
 ╔══════════════════════════════════════════════════════════════════╗
@@ -106,10 +209,13 @@ if (hasQueue) {
 ║  Modules: ${queue.completedModules} / ${queue.totalModules}     ║
 ╠══════════════════════════════════════════════════════════════════╣
 ║  ADVANCING TO NEXT MODULE: ${queue.modules[nextIndex].code}     ║
+║  Next module PRD loaded: ${queue.modules[nextIndex].prdFile}    ║
+║  Iteration counter reset: 1                                      ║
 ╚══════════════════════════════════════════════════════════════════╝
     `);
 
-    // Loop back to step-01 which will load next module's prd
+    // Loop back to step-01 which will detect module-changed.json
+    // and skip the "Only Read Once" rule for this transition
     // -> Proceed to step-01-task.md
     return;
   }
@@ -191,20 +297,200 @@ writeJSON('.ralph/prd.json', prd);
 
 **Proceed to step-05-report.md**
 
-### 5. More Tasks Remaining
+### 5. More Tasks Remaining — COMPACT LOOP (CRITICAL)
+
+> **MANDATORY RULE: DO NOT STOP. DO NOT WAIT FOR USER INPUT. DO NOT RE-READ STEP FILES.**
+> After the first full iteration (step-01 → step-02 → step-03 → step-04), all subsequent iterations
+> MUST use this COMPACT LOOP inline. Re-reading step files wastes context and causes the loop to stall.
+> **STOPPING THE LOOP = BUG.** Only completion, max iterations, or dead-end stop the loop.
 
 **If hasPending AND iteration < max_iterations:**
 
+Display compact progress (ONE line):
+```
+[{current_iteration}/{max_iterations}] {tasksCompleted}/{tasksTotal} done | Next: finding eligible task...
 ```
-Progress: {tasksCompleted} / {tasksTotal} tasks
-Failed: {tasksFailed}  |  Blocked: {tasksBlocked}  |  Pending: {tasksPending}
 
-Next eligible task will be determined by dependency resolution.
+**IMMEDIATELY execute the following inline loop — DO NOT re-read step files:**
+
+#### 5a. Find Next Eligible Task (inline step-01)
+
+```javascript
+const prd = readJSON('.ralph/prd.json');
+
+// Block tasks whose dependencies failed
+for (const task of prd.tasks) {
+  if (task.status !== 'pending') continue;
+  const depsBlocked = task.dependencies.some(depId => {
+    const dep = prd.tasks.find(t => t.id === depId);
+    return dep && (dep.status === 'failed' || dep.status === 'blocked');
+  });
+  if (depsBlocked) { task.status = 'blocked'; task.error = 'Blocked by failed dependency'; }
+}
 
-Continuing to next iteration...
+// Find ALL eligible tasks (dependencies met)
+const eligible = prd.tasks.filter(task => {
+  if (task.status !== 'pending') return false;
+  return task.dependencies.every(depId => {
+    const dep = prd.tasks.find(t => t.id === depId);
+    return dep && dep.status === 'completed';
+  });
+});
+
+if (eligible.length === 0) {
+  // Dead-end or all done — re-run sections 2-4 above
+  goto CHECK_COMPLETION;
+}
+
+// BATCH MODE: group eligible tasks by category, take the first group
+const firstCategory = eligible[0].category;
+const batch = eligible.filter(t => t.category === firstCategory);
+// Cap batch at 5 tasks max to keep atomic
+const tasksToExecute = batch.slice(0, 5);
+```
+
+Display:
+```
+Batch: {tasksToExecute.length} task(s) [{firstCategory}]
+  {tasksToExecute.map(t => `[${t.id}] ${t.description}`).join('\n  ')}
+```
+
+#### 5b. Execute Batch (inline step-02)
+
+**For EACH task in tasksToExecute:**
+
+1. Mark `task.status = 'in_progress'`, `task.started_at = now`
+2. ULTRA THINK: implement the task following SmartStack conventions
+   - Track files_created and files_modified per task
+3. **MANDATORY TEST-DRIVEN CYCLE (per task):**
+   ```
+   ┌─────────────────────────────────────────────────────────┐
+   │  TASK EXECUTION CYCLE (100% tests pass required)       │
+   ├─────────────────────────────────────────────────────────┤
+   │                                                         │
+   │  1. GENERATE CODE                                       │
+   │     ├─ Backend:  Entity, Service, Repository, Controller│
+   │     ├─ Frontend: Page, Component, Hook                 │
+   │     ├─ Tests:    Unit tests + Integration tests        │
+   │     └─ Docs:     Inline comments + tooltips + i18n     │
+   │                                                         │
+   │  2. COMPILE CODE                                        │
+   │     ├─ Backend:  dotnet build --no-restore             │
+   │     └─ Frontend: npm run typecheck                     │
+   │                                                         │
+   │  3. RUN TESTS (MANDATORY)                               │
+   │     ├─ Backend:  dotnet test {TestProject}             │
+   │     ├─ Frontend: npm test (if applicable)              │
+   │     └─ Security: tenant isolation + RBAC checks        │
+   │                                                         │
+   │  4. CHECK RESULT                                        │
+   │     ├─ IF 100% PASS → Mark task completed, next task   │
+   │     └─ IF ANY FAIL  → Go to step 5                     │
+   │                                                         │
+   │  5. FIX ERRORS (loop until pass)                        │
+   │     ├─ Parse test output → identify failing tests      │
+   │     ├─ Analyze root cause (stack trace, logs)          │
+   │     ├─ Fix code (NOT test - fix implementation)        │
+   │     ├─ Re-compile (step 2)                             │
+   │     └─ Re-run tests (step 3) → loop until 100% pass    │
+   │                                                         │
+   │  🎯 Goal: ZERO test failures before next task           │
+   │  📊 Coverage: 95-100% (tests auto-generated per task)   │
+   │                                                         │
+   └─────────────────────────────────────────────────────────┘
+   ```
+
+   **Implementation per task:**
+   a. Generate code + tests
+   b. Compile: `dotnet build` or `npm run typecheck`
+   c. Run tests: `dotnet test {TestProject}` or `npm test`
+   d. Parse test output → count passed/failed/skipped
+   e. IF failed > 0:
+      - Log failure details to progress.txt
+      - Analyze error (stack trace, assertion message)
+      - Fix code (modify implementation, NOT test)
+      - Re-compile
+      - Re-run tests
+      - Repeat until passed = total (100%)
+   f. IF passed = total → task.status = 'completed'
+
+4. Verify acceptance criteria
+5. If task execution failed (not tests, but code generation): set `task.status = 'failed'`, `task.error = reason`, continue to next task in batch
+
+**CATEGORY-SPECIFIC EXECUTION RULES:**
+
+**IF category = "frontend":** Follow MCP-FIRST protocol (MANDATORY):
+  1. Call `mcp__smartstack__scaffold_api_client` → generates API client + types
+  2. Call `mcp__smartstack__scaffold_routes` → updates routes inside Layout wrapper
+  3. Create pages using SmartStack components (SmartTable, EntityCard, SmartForm, SmartFilter)
+  4. CSS variables ONLY (NO `bg-blue-600`, use `bg-[var(--color-accent-600)]`)
+  5. `EntityCard` for grids, `SmartTable` for lists (NO HTML `<table>` or custom `<div>` cards)
+  6. All pages MUST have loading/error/empty states
+  7. API client uses `@/services/api/apiClient` (NOT axios)
+  8. Generate 4-language i18n (fr, en, it, de)
+  9. `npm run typecheck` MUST pass
+
+**IF category = "infrastructure":** Seed data in `Infrastructure/Persistence/Seeding/Data/{Module}/`
+
+**IF category = "api":** Controllers in `Api/Controllers/{Context}/{App}/{Entity}Controller.cs`
+
+After ALL tasks in batch executed:
+- Run `mcp__smartstack__validate_conventions` ONCE for the whole batch
+- Quick build check: `dotnet build --no-restore` (backend) or `npm run typecheck` (frontend)
+
+#### 5c. Commit Batch (inline step-03)
+
+```bash
+# Stage all changed files
+git add {all files from batch}
+git add .ralph/prd.json
+
+# Single commit for the batch
+git commit -m "$(cat <<'EOF'
+feat({scope}): [{firstCategory}] {tasksToExecute.length} tasks — {short summary}
+
+Tasks: {tasksToExecute.map(t => t.id).join(', ')} / {tasks_total}
+Iteration: {current_iteration}
+{current_module ? "Module: " + current_module : ""}
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+EOF
+)"
+
+COMMIT_HASH=$(git rev-parse --short HEAD)
+```
+
+**Finalize each task in prd.json:**
+```javascript
+for (const task of tasksToExecute) {
+  if (task.status !== 'failed') task.status = 'completed';
+  task.completed_at = now;
+  task.iteration = prd.config.current_iteration;
+  task.commit_hash = COMMIT_HASH;
+}
+prd.history.push({
+  iteration: prd.config.current_iteration,
+  task_ids: tasksToExecute.map(t => t.id),
+  action: 'batch-completed',
+  timestamp: now,
+  commit_hash: COMMIT_HASH,
+  notes: "{What was accomplished}"
+});
+prd.config.current_iteration++;
+prd.updated_at = now;
+writeJSON('.ralph/prd.json', prd);
 ```
 
-**Loop back to step-01-task.md**
+```bash
+git add .ralph/prd.json .ralph/progress.txt
+[ -f .ralph/modules-queue.json ] && git add .ralph/modules-queue.json
+git commit -m "chore(ralph): progress — iteration {current_iteration}"
+```
+
+#### 5d. Re-check Completion (loop back to section 1)
+
+**IMMEDIATELY go back to section 1 (Read Current State) of THIS step.**
+**DO NOT stop. DO NOT wait for user. DO NOT re-read step files.**
 
 ---
 
@@ -300,6 +586,16 @@ Completion Check:
 
 **Always update `prd.status` and `prd.updated_at` before proceeding.**
 
+**LOOP CONTINUATION IS MANDATORY:**
+- After the first full iteration (step-01→02→03→04), ALL subsequent iterations use the COMPACT LOOP in section 5.
+- DO NOT re-read step-01, step-02, step-03 files. You already know the instructions.
+- DO NOT stop and wait for user input between iterations.
+- DO NOT output a summary and pause. The loop is AUTONOMOUS.
+- The ONLY reasons to stop: completion, max iterations, dead-end, or user interruption.
+- Stopping for any other reason is a **BUG** that wastes user time and context.
+- **BATCH tasks of the same category** to reduce iterations (max 5 per batch).
+- Prefer compact output (1-2 lines per task) over verbose output during the loop.
+
 ---
 
 ## NEXT STEP:

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

@@ -123,6 +123,86 @@ if (hasQueue) {
 }
 ```
 
+### 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:**
+
+```javascript
+stats.tests = testMetrics;
+```
+
 ### 2. Collect MCP Usage (from logs if available)
 
 **Parse from verbose logs:**
@@ -187,6 +267,41 @@ const validationStats = {
 **Modules: {moduleStats.completedModules}/{moduleStats.totalModules} 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}
+
 ## Failed Tasks
 
 {if any failed tasks:}