@atlashub/smartstack-cli 3.8.0 → 3.9.0

package/templates/skills/ralph-loop/steps/step-03-commit.md

@@ -6,119 +6,44 @@ next_step: steps/step-04-check.md
 
 # Step 3: Commit Changes
 
-> **CONTEXT OPTIMIZATION:** This file is only read ONCE (first iteration).
-> After the first full iteration, ALL subsequent iterations use the COMPACT LOOP
-> in step-04-check.md section 5 which includes inline commit logic.
-> **DO NOT re-read this file for iterations > 1.**
+> **CONTEXT OPTIMIZATION:** Read ONCE (first iteration). Subsequent iterations use compact-loop.md.
 
 ## YOUR TASK:
 
-Commit the changes from the executed task, finalize task tracking in prd.json, and append to history.
+Commit changes, finalize task tracking in prd.json, append to history.
 
 ---
 
 ## EXECUTION SEQUENCE:
 
-### 0. PRE-COMMIT VALIDATION (BLOCKING)
-
-**CRITICAL: Before ANY commit, verify all tests pass.**
+### 0. Pre-Commit Validation (BLOCKING)
 
 ```bash
-# Check if test project exists
-PROJECT_NAME=$(basename $(pwd))
-TEST_PROJECT="tests/${PROJECT_NAME}.Tests.Unit"
+# Backend: build must pass
+if [ "{current_task_category}" != "frontend" ] && [ "{current_task_category}" != "i18n" ]; then
+  dotnet build --no-restore --verbosity quiet
+fi
 
-if [ -d "$TEST_PROJECT" ]; then
-  echo "Running full test suite before commit..."
+# Frontend: typecheck must pass
+if [ "{current_task_category}" = "frontend" ]; then
+  npm run typecheck
+fi
 
-  # Run ALL tests (not just current task's tests)
+# Tests: full suite if test project exists
+TEST_PROJECT="tests/$(basename $(pwd)).Tests.Unit"
+if [ -d "$TEST_PROJECT" ]; then
   dotnet test "$TEST_PROJECT" --no-build --verbosity minimal
-
-  TEST_EXIT_CODE=$?
-
-  if [ $TEST_EXIT_CODE -ne 0 ]; then
-    echo "╔════════════════════════════════════════════════════════════╗"
-    echo "║  ❌ COMMIT BLOCKED: TESTS FAILED                         ║"
-    echo "╠════════════════════════════════════════════════════════════╣"
-    echo "║  Cannot commit code when tests are failing.               ║"
-    echo "║  This prevents broken code from entering the repository.  ║"
-    echo "╠════════════════════════════════════════════════════════════╣"
-    echo "║  ACTION REQUIRED:                                          ║"
-    echo "║  1. Review test failures above                             ║"
-    echo "║  2. Fix the failing code                                   ║"
-    echo "║  3. Re-run: dotnet test                                    ║"
-    echo "║  4. Once tests pass, Ralph will commit automatically       ║"
-    echo "╚════════════════════════════════════════════════════════════╝"
-
-    # Mark task as failed (do not complete)
-    # Update prd.json
-    const prd = readJSON('.ralph/prd.json');
-    const task = prd.tasks.find(t => t.id === {current_task_id});
-    task.status = 'failed';
-    task.error = 'Pre-commit test suite failed. Cannot commit broken code.';
-    writeJSON('.ralph/prd.json', prd);
-
-    # STOP - return to step-02 to fix
-    exit 1;
+  if [ $? -ne 0 ]; then
+    echo "COMMIT BLOCKED: tests failing. Fix before committing."
+    STOP — return to step-02
   fi
-
-  echo "✅ All tests passed. Proceeding with commit..."
 fi
 ```
 
-**Additional validation for specific categories:**
-
-```javascript
-const task = prd.tasks.find(t => t.id === {current_task_id});
-
-// For backend changes: ensure build succeeds
-if (['domain', 'application', 'infrastructure', 'api'].includes(task.category)) {
-  dotnet build --no-restore --verbosity quiet
-  if ($? !== 0) {
-    echo "❌ Build failed. Cannot commit broken code.";
-    task.status = 'failed';
-    task.error = 'Build failed';
-    exit 1;
-  }
-}
-
-// For frontend changes: ensure typecheck passes
-if (task.category === 'frontend') {
-  npm run typecheck
-  if ($? !== 0) {
-    echo "❌ TypeScript errors. Cannot commit broken code.";
-    task.status = 'failed';
-    task.error = 'TypeScript compilation failed';
-    exit 1;
-  }
-}
-```
-
-**If ALL validations pass, proceed to staging.**
-
-### 1. Stage Changes
-
-**Add modified files:**
-
-```bash
-git add {files_created} {files_modified}
-
-# Also stage prd.json (already updated in step-02)
-git add .ralph/prd.json
-```
-
-**Verify staged changes:**
-
-```bash
-git status
-git diff --cached --stat
-```
-
-### 2. Create Commit
-
-**Commit with descriptive message:**
+### 1. Stage and Commit
 
 ```bash
+git add {files_created} {files_modified} .ralph/prd.json
 git commit -m "$(cat <<'EOF'
 {PREFIX}({scope}): {current_task_description}
 
@@ -129,235 +54,80 @@ Category: {current_task_category}
 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 EOF
 )"
-```
-
-**Determine commit prefix and scope:**
 
-| Category | Prefix | Scope |
-|----------|--------|-------|
-| `domain` | `feat` | entity name or module |
-| `application` | `feat` | module name |
-| `infrastructure` | `db` | migrations / config |
-| `api` | `feat` | controller name |
-| `frontend` | `feat` | component/page name |
-| `i18n` | `chore` | i18n |
-| `test` | `test` | module name |
-| `validation` | `chore` | validation |
-| `other` | `chore` | ralph |
-
-**Multi-module scope:** When `{current_module}` is set (from modules-queue.json), prefix the scope with the module code: `{PREFIX}({module}/{scope})`. Example: `feat(orders/OrderController): Create REST endpoints`.
-
-**Get commit hash:**
-```bash
 COMMIT_HASH=$(git rev-parse --short HEAD)
 ```
 
-### 3. Finalize Task in prd.json
+**Prefix mapping:**
 
-**Mark task as completed with all tracking data:**
+| Category | Prefix |
+|----------|--------|
+| domain, application, api, frontend | `feat` |
+| infrastructure | `db` |
+| i18n | `chore` |
+| test | `test` |
+| validation, other | `chore` |
+
+### 2. Finalize Task in prd.json
 
 ```javascript
 const prd = readJSON('.ralph/prd.json');
 const task = prd.tasks.find(t => t.id === {current_task_id});
 const now = new Date().toISOString();
 
-// Only mark completed if not already failed in step-02
-if (task.status !== 'failed') {
-  task.status = 'completed';
-}
+if (task.status !== 'failed') task.status = 'completed';
 task.completed_at = now;
 task.iteration = prd.config.current_iteration;
 task.commit_hash = COMMIT_HASH;
 
-// files_changed already set in step-02, but verify
-if (!task.files_changed || (!task.files_changed.created.length && !task.files_changed.modified.length)) {
-  // Fallback: extract from git diff
-  task.files_changed = {
-    created: getGitNewFiles(),    // git diff --cached --name-only --diff-filter=A
-    modified: getGitModifiedFiles() // git diff --cached --name-only --diff-filter=M
-  };
-}
-```
-
-### 4. Append to History
-
-**Add structured iteration entry:**
-
-```javascript
 prd.history.push({
-  iteration: prd.config.current_iteration,
-  task_id: task.id,
-  action: task.status,  // "completed" or "failed"
-  timestamp: now,
-  commit_hash: COMMIT_HASH,
-  duration_seconds: Math.round(
-    (new Date(now) - new Date(task.started_at)) / 1000
-  ),
-  notes: "{What was learned or accomplished during this task}"
+  iteration: prd.config.current_iteration, task_id: task.id,
+  action: task.status, timestamp: now, commit_hash: COMMIT_HASH,
+  duration_seconds: Math.round((new Date(now) - new Date(task.started_at)) / 1000),
+  notes: "{What was accomplished}"
 });
-```
 
-### 5. Increment Iteration and Update Timestamps
-
-**IMPORTANT: Increment AFTER recording the current iteration in task and history.**
-
-```javascript
 prd.config.current_iteration++;
 prd.updated_at = now;
 
-// Update top-level status
-const allCompleted = prd.tasks.every(t =>
-  t.status === 'completed' || t.status === 'skipped'
-);
-const anyFailed = prd.tasks.some(t => t.status === 'failed');
-const anyBlocked = prd.tasks.some(t => t.status === 'blocked');
-
-if (allCompleted) {
-  prd.status = 'completed';
-} else if (anyFailed || anyBlocked) {
-  prd.status = 'partial';
-} else {
-  prd.status = 'in_progress';
-}
+const allDone = prd.tasks.every(t => t.status === 'completed' || t.status === 'skipped');
+prd.status = allDone ? 'completed' : prd.tasks.some(t => t.status === 'failed' || t.status === 'blocked') ? 'partial' : 'in_progress';
 
 writeJSON('.ralph/prd.json', prd);
 ```
 
-### 6. Update progress.txt
-
-**Append learnings to progress.txt:**
+### 3. Update progress.txt
 
+Append iteration learnings (compact):
 ```markdown
----
-
-## Iteration {current_iteration}
-
-### Task Completed
-[{current_task_id}] {current_task_description}
-Category: {current_task_category}
-Status: {task.status}
-Commit: {COMMIT_HASH}
-
-### Files Changed
-- Created: {task.files_changed.created}
-- Modified: {task.files_changed.modified}
-
-### Acceptance Criteria
-{current_task_criteria}
-Result: ✅ Met / ❌ Not met
-
-### Learnings
-{What was learned during this task}
-{Any issues encountered and how they were resolved}
-{Patterns discovered that might help future tasks}
-
-### Context for Next Task
-{What the next iteration should know}
+## Iteration {iteration} — [{id}] {description}
+Status: {status} | Commit: {hash} | Files: {count}
+Learnings: {what was learned}
 ```
 
-### 7. Commit prd.json and progress.txt Updates
-
-**Stage and commit the tracking files separately:**
+### 4. Commit Progress Files
 
 ```bash
 git add .ralph/prd.json .ralph/progress.txt
-# Also stage modules-queue.json if it exists (multi-module tracking)
 [ -f .ralph/modules-queue.json ] && git add .ralph/modules-queue.json
-
-git commit -m "$(cat <<'EOF'
-chore(ralph): update progress - task {current_task_id}/{tasks_total}
-
-Iteration {current_iteration} complete
-Status: {task.status}
-{current_module ? "Module: " + current_module : ""}
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
-EOF
-)"
+git commit -m "chore(ralph): progress — task {id}/{total}"
 ```
 
-### 8. Verify Commit
-
-**Check commit was created:**
+### 5. Verify
 
 ```bash
 git log -2 --oneline
 ```
 
-**Expected output:**
-```
-def5678 chore(ralph): update progress - task {id}/{total}
-abc1234 feat(scope): {current_task_description}
-```
-
-### 9. Log Activity (if verbose)
-
-**If {verbose_mode} = true:**
-
-Append to `.ralph/logs/{date}.log`:
-```
-[{timestamp}] TASK COMPLETED
-  Task: [{current_task_id}] {current_task_description}
-  Category: {current_task_category}
-  Status: {task.status}
-  Commit: {COMMIT_HASH}
-  Files: {file_count} changed ({created_count} created, {modified_count} modified)
-  Duration: {duration_seconds}s
-  Iteration: {current_iteration}
-  Validation: {validation_result}
-```
-
----
-
-## OUTPUT FORMAT:
-
-```
-Changes Committed:
-
-| Field | Value |
-|-------|-------|
-| Commit | {COMMIT_HASH} |
-| Task | [{current_task_id}] {current_task_description} |
-| Category | {current_task_category} |
-| Status | {task.status} |
-| Iteration | {current_iteration} |
-| Files | {file_count} changed |
-| Duration | {duration_seconds}s |
-| Validation | {validation_result} |
-
-prd.json: Task {current_task_id} → {task.status}, history entry added
-progress.txt: Iteration {current_iteration} learnings appended
-
--> Checking completion...
-```
-
 ---
 
 ## ERROR HANDLING:
 
-**If commit fails (pre-commit hook):**
-
-1. Read hook error message
-2. Fix the issue (lint, format, etc.)
-3. Stage fixes
-4. Create NEW commit (don't amend)
-5. Proceed to step-04
-
-**If prd.json write fails:**
-
-1. Log error
-2. Retry write
-3. If still fails, output error and stop
-
-**If task was failed in step-02:**
-
-1. Still commit whatever was done (partial progress)
-2. task.status remains "failed"
-3. history entry records action: "failed"
-4. step-04 will handle downstream blocking
+- **Commit fails (pre-commit hook):** Fix issue, stage, create NEW commit (don't amend)
+- **Task failed in step-02:** Still commit partial progress, status stays "failed"
 
 ---
 
 ## NEXT STEP:
 
-After commit and updates complete, proceed to `./step-04-check.md`
+After commit, proceed to `./step-04-check.md`