agent-state-machine 2.5.0 → 2.6.0

package/templates/project-builder/workflow.js

@@ -13,7 +13,6 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import {
   writeMarkdownFile,
-  writeImplementationFiles,
   isApproval,
   renderRoadmapMarkdown,
   renderTasksMarkdown,
@@ -26,13 +25,19 @@ import {
   getQuickFixAttempts,
   incrementQuickFixAttempts,
   resetQuickFixAttempts,
-  detectTestFramework
+  detectTestFramework,
+  getProjectFiles,
+  createGitCommit,
+  ensureGitRepo
 } from './scripts/workflow-helpers.js';
 import {
   createInteraction,
   parseResponse,
   formatInteractionPrompt as formatPrompt
 } from './scripts/interaction-helpers.js';
+import { validateProjectChanges } from './scripts/validate-changes.js';
+import { autoFixValidationIssues, rollbackFile } from './scripts/safeguard-recovery.js';
+import runSanityChecks from './scripts/sanity-runner.js';
 
 // Derive workflow directory dynamically
 const __filename = fileURLToPath(import.meta.url);
@@ -49,48 +54,6 @@ const C = {
   yellow: '\x1b[33m'
 };
 
-function applyFixesToImplementation(originalImplementation, fixes) {
-  if (!originalImplementation || !Array.isArray(fixes) || fixes.length === 0) {
-    return originalImplementation;
-  }
-
-  const updated = { ...originalImplementation };
-  const container = updated.implementation ? { ...updated.implementation } : updated;
-  const files = Array.isArray(container.files) ? [...container.files] : [];
-
-  for (const fix of fixes) {
-    if (!fix?.path || !fix?.code) {
-      console.warn(`  [Fix] Skipping invalid fix entry: ${JSON.stringify(fix)}`);
-      continue;
-    }
-    if (fix.operation && fix.operation !== 'replace') {
-      console.warn(`  [Fix] Unsupported operation "${fix.operation}" for ${fix.path}`);
-      continue;
-    }
-
-    const existingIndex = files.findIndex((file) => file.path === fix.path);
-    const nextFile = {
-      ...(existingIndex >= 0 ? files[existingIndex] : {}),
-      path: fix.path,
-      code: fix.code,
-      purpose: fix.purpose || (existingIndex >= 0 ? files[existingIndex].purpose : 'Updated by code-fixer')
-    };
-
-    if (existingIndex >= 0) {
-      files[existingIndex] = nextFile;
-    } else {
-      files.push(nextFile);
-    }
-  }
-
-  if (updated.implementation) {
-    updated.implementation = { ...container, files };
-    return updated;
-  }
-
-  return { ...updated, files };
-}
-
 // ============================================
 // MAIN WORKFLOW
 // ============================================
@@ -98,6 +61,13 @@ function applyFixesToImplementation(originalImplementation, fixes) {
 export default async function () {
   console.log('Starting Project Builder Workflow...\n');
 
+  // Ensure git repo exists for commit tracking
+  const runtime = getCurrentRuntime();
+  const gitResult = ensureGitRepo(runtime.workflowConfig.projectRoot);
+  if (gitResult.initialized) {
+    console.log('  [Git] Initialized new repository\n');
+  }
+
   // ============================================
   // PHASE 1: PROJECT INTAKE
   // ============================================
@@ -128,7 +98,7 @@ export default async function () {
   // 1. Scope Clarification
   if (!memory.scopeClarified) {
     console.log('--- Scope Clarification ---');
-    const scopeResult = await agent('scope-clarifier', {
+    const scopeResult = await agent('intake-scope', {
       projectDescription: memory.projectDescription
     });
     memory.scope = scopeResult;
@@ -138,7 +108,7 @@ export default async function () {
   // 2. Requirements Clarification
   if (!memory.requirementsClarified) {
     console.log('--- Requirements Clarification ---');
-    const reqResult = await agent('requirements-clarifier', {
+    const reqResult = await agent('intake-requirements', {
       projectDescription: memory.projectDescription,
       scope: memory.scope
     });
@@ -149,7 +119,7 @@ export default async function () {
   // 3. Assumptions Clarification
   if (!memory.assumptionsClarified) {
     console.log('--- Assumptions Clarification ---');
-    const assumeResult = await agent('assumptions-clarifier', {
+    const assumeResult = await agent('intake-assumptions', {
       projectDescription: memory.projectDescription,
       scope: memory.scope,
       requirements: memory.requirements
@@ -161,7 +131,7 @@ export default async function () {
   // 4. Security Clarification
   if (!memory.securityClarified) {
     console.log('--- Security Clarification ---');
-    const secResult = await agent('security-clarifier', {
+    const secResult = await agent('intake-security', {
       projectDescription: memory.projectDescription,
       scope: memory.scope,
       requirements: memory.requirements,
@@ -181,7 +151,7 @@ export default async function () {
   if (!memory.roadmapApproved) {
     // Generate roadmap as JSON
     if (!memory.roadmap) {
-      const roadmapResult = await agent('roadmap-generator', {
+      const roadmapResult = await agent('plan-roadmap', {
         projectDescription: memory.projectDescription,
         scope: memory.scope,
         requirements: memory.requirements,
@@ -218,7 +188,7 @@ export default async function () {
       } else {
         const feedback = reviewResponse.customText || reviewResponse.text || reviewResponse.raw || reviewRaw;
         // Regenerate roadmap with feedback
-        const updatedRoadmap = await agent('roadmap-generator', {
+        const updatedRoadmap = await agent('plan-roadmap', {
           projectDescription: memory.projectDescription,
           scope: memory.scope,
           requirements: memory.requirements,
@@ -256,7 +226,7 @@ export default async function () {
     // Generate task list for this phase (as JSON)
     if (!memory[tasksApprovedKey]) {
       if (!memory[tasksKey]) {
-        const taskResult = await agent('task-planner', {
+        const taskResult = await agent('plan-tasks', {
           projectDescription: memory.projectDescription,
           scope: memory.scope,
           requirements: memory.requirements,
@@ -292,7 +262,7 @@ export default async function () {
           console.log(`Phase ${i + 1} task list approved!\n`);
         } else {
           const feedback = taskReview.customText || taskReview.text || taskReview.raw || taskReviewRaw;
-          const updatedTasks = await agent('task-planner', {
+          const updatedTasks = await agent('plan-tasks', {
             projectDescription: memory.projectDescription,
             scope: memory.scope,
             requirements: memory.requirements,
@@ -347,11 +317,10 @@ export default async function () {
         if (stage === TASK_STAGES.PENDING || stage === TASK_STAGES.SECURITY_PRE) {
           if (!getTaskData(i, taskId, 'security_pre')) {
             console.log('    > Security pre-review...');
-            const securityPreReview = await agent('security-reviewer', {
+            const securityPreReview = await agent('pre-code-security', {
               task: task,
               phase: phase,
               scope: memory.scope,
-              stage: 'pre-implementation',
               feedback: feedback
             });
             setTaskData(i, taskId, 'security_pre', securityPreReview);
@@ -364,7 +333,7 @@ export default async function () {
         if (stage === TASK_STAGES.TEST_PLANNING) {
           if (!getTaskData(i, taskId, 'tests')) {
             console.log('    > Test planning...');
-            const testPlan = await agent('test-planner', {
+            const testPlan = await agent('pre-code-tests', {
               task: task,
               phase: phase,
               requirements: memory.requirements,
@@ -381,22 +350,51 @@ export default async function () {
         if (stage === TASK_STAGES.IMPLEMENTING) {
           if (!getTaskData(i, taskId, 'code')) {
             console.log('    > Code implementation...');
-            const implementation = await agent('code-writer', {
+            const projectRoot = getCurrentRuntime().workflowConfig.projectRoot;
+            const implementation = await agent('code-write', {
               task: task,
               phase: phase,
               requirements: memory.requirements,
               testPlan: getTaskData(i, taskId, 'tests'),
               securityConsiderations: getTaskData(i, taskId, 'security_pre'),
+              projectFiles: getProjectFiles(projectRoot),
               feedback: feedback
             });
             setTaskData(i, taskId, 'code', implementation);
+
+            // Validate project changes after code-write
+            const filesWritten = implementation?.implementation?.filesWritten || implementation?.filesWritten || [];
+            const modifiedPaths = filesWritten.map(f => f.path);
+            const validation = validateProjectChanges(projectRoot, { modified: modifiedPaths });
+
+            if (!validation.valid) {
+              console.log(`    > Validation issues: ${validation.violations.join(', ')}`);
+
+              // Try auto-fix
+              const fixed = autoFixValidationIssues(projectRoot, validation.violations);
+              if (fixed.length > 0) {
+                console.log(`    > Auto-fixed: ${fixed.join(', ')}`);
+              }
+
+              // Re-validate
+              const recheck = validateProjectChanges(projectRoot, { modified: modifiedPaths });
+              if (!recheck.valid) {
+                console.log('    > Auto-fix failed, rolling back package.json...');
+                const rollbackResult = rollbackFile(projectRoot, 'package.json');
+                if (rollbackResult.success) {
+                  console.log('    > Rolled back package.json');
+                } else {
+                  console.log(`    > Rollback failed: ${rollbackResult.error}`);
+                }
+              }
+            }
           }
 
-          // Write implementation files to disk
+          // Files are written directly by the agent using native file tools
           const implementation = getTaskData(i, taskId, 'code');
           if (implementation) {
-            console.log('    > Writing files to disk...');
-            writeImplementationFiles(implementation);
+            const filesWrittenCount = (implementation?.implementation?.filesWritten || implementation?.filesWritten || []).length;
+            console.log(`    > Agent wrote ${filesWrittenCount} file(s) to disk`);
           }
 
           setTaskStage(i, taskId, TASK_STAGES.CODE_REVIEW);
@@ -407,14 +405,83 @@ export default async function () {
         if (stage === TASK_STAGES.CODE_REVIEW) {
           if (!getTaskData(i, taskId, 'review')) {
             console.log('    > Code review...');
-            const codeReview = await agent('code-reviewer', {
-              task: task,
-              implementation: getTaskData(i, taskId, 'code'),
-              testPlan: getTaskData(i, taskId, 'tests'),
+            const impl = getTaskData(i, taskId, 'code');
+            const filesWritten = impl?.implementation?.filesWritten || impl?.filesWritten || [];
+            const codeReview = await agent('post-code-review', {
+              task: { title: task.title, description: task.description },
+              filesToReview: filesWritten.map(f => f.path),
+              implementationSummary: impl?.implementation?.summary || impl?.summary || 'See files on disk',
               feedback: feedback
             });
             setTaskData(i, taskId, 'review', codeReview);
           }
+
+          // Check for code review issues and let user decide
+          const review = getTaskData(i, taskId, 'review');
+          const hasIssues = review?.issues?.length > 0 || review?.requiredChanges?.length > 0;
+
+          if (hasIssues && !review.approved && !getTaskData(i, taskId, 'review_decision')) {
+            const issuesList = [
+              ...(review.requiredChanges || []).map(c => `[REQUIRED] ${c}`),
+              ...(review.issues || [])
+                .filter(iss => iss.severity === 'critical' || iss.severity === 'major')
+                .map(iss => `[${iss.severity?.toUpperCase() || 'ISSUE'}] ${iss.location || 'general'}: ${iss.description}`)
+            ];
+
+            if (issuesList.length > 0) {
+              const reviewChoice = createInteraction('choice', `phase-${i + 1}-task-${taskId}-review-issues`, {
+                prompt: `Code review issues for "${task.title}":\n\n${issuesList.join('\n')}\n\nHow would you like to proceed?`,
+                options: [
+                  { key: 'fix', label: 'Fix issues', description: 'Run code-fixer to address these issues' },
+                  { key: 'ignore', label: 'Ignore and continue', description: 'Proceed to security review despite issues' },
+                  { key: 'reimplement', label: 'Reimplement', description: 'Start implementation from scratch' }
+                ],
+                allowCustom: true
+              });
+
+              const reviewRaw = await askHuman(formatPrompt(reviewChoice), {
+                slug: reviewChoice.slug,
+                interaction: reviewChoice
+              });
+              const reviewDecision = await parseResponse(reviewChoice, reviewRaw);
+              setTaskData(i, taskId, 'review_decision', reviewDecision.selectedKey);
+
+              if (reviewDecision.selectedKey === 'fix') {
+                console.log('    > Fixing code review issues...');
+                const implForFix = getTaskData(i, taskId, 'code');
+                const filesForFix = implForFix?.implementation?.filesWritten || implForFix?.filesWritten || [];
+                const fixerResult = await agent('post-code-fix', {
+                  task: { title: task.title },
+                  reviewIssues: review.issues,
+                  requiredChanges: review.requiredChanges,
+                  filePaths: filesForFix.map(f => f.path)
+                });
+
+                // Agent writes files directly, just update metadata if fixes were applied
+                if (fixerResult?.fixesApplied?.length > 0) {
+                  console.log(`    > Fixed ${fixerResult.fixesApplied.length} file(s)`);
+                }
+
+                // Clear review to re-run it
+                setTaskData(i, taskId, 'review', null);
+                setTaskData(i, taskId, 'review_decision', null);
+                t--;
+                continue;
+              }
+
+              if (reviewDecision.selectedKey === 'reimplement') {
+                clearPartialTaskData(i, taskId, ['security_pre', 'tests']);
+                setTaskData(i, taskId, 'review', null);
+                setTaskData(i, taskId, 'review_decision', null);
+                setTaskStage(i, taskId, TASK_STAGES.IMPLEMENTING);
+                t--;
+                continue;
+              }
+
+              // 'ignore' falls through to next stage
+            }
+          }
+
           setTaskStage(i, taskId, TASK_STAGES.SECURITY_POST);
           stage = TASK_STAGES.SECURITY_POST;
         }
@@ -423,11 +490,11 @@ export default async function () {
         if (stage === TASK_STAGES.SECURITY_POST) {
           if (!getTaskData(i, taskId, 'security_post')) {
             console.log('    > Final security check...');
-            const securityPostReview = await agent('security-reviewer', {
-              task: task,
-              phase: phase,
-              implementation: getTaskData(i, taskId, 'code'),
-              stage: 'post-implementation',
+            const implForSecurity = getTaskData(i, taskId, 'code');
+            const filesForSecurity = implForSecurity?.implementation?.filesWritten || implForSecurity?.filesWritten || [];
+            const securityPostReview = await agent('post-code-security', {
+              task: { title: task.title, description: task.description },
+              filePaths: filesForSecurity.map(f => f.path),
               feedback: feedback
             });
             setTaskData(i, taskId, 'security_post', securityPostReview);
@@ -439,10 +506,11 @@ export default async function () {
         // 6. Sanity check generation & execution
         if (stage === TASK_STAGES.SANITY_CHECK) {
           const testFramework = detectTestFramework();
-          const executableChecks = await agent('sanity-checker', {
-            task: task,
-            implementation: getTaskData(i, taskId, 'code'),
-            testPlan: getTaskData(i, taskId, 'tests'),
+          const implForSanity = getTaskData(i, taskId, 'code');
+          const filesForSanity = implForSanity?.implementation?.filesWritten || implForSanity?.filesWritten || [];
+          const executableChecks = await agent('verify-sanity', {
+            task: { title: task.title, sanityCheck: task.sanityCheck },
+            filePaths: filesForSanity.map(f => f.path),
             testFramework
           });
           setTaskData(i, taskId, 'sanity_checks', executableChecks);
@@ -478,10 +546,11 @@ export default async function () {
           const action = sanityResponse.selectedKey;
 
           if (action === 'auto') {
-            const results = await agent('sanity-runner', {
+            const results = await runSanityChecks({
               checks: executableChecks.checks,
               setup: executableChecks.setup,
-              teardown: executableChecks.teardown
+              teardown: executableChecks.teardown,
+              _config: { projectRoot: getCurrentRuntime().workflowConfig.projectRoot }
             });
             setTaskData(i, taskId, 'sanity_results', results);
 
@@ -533,30 +602,21 @@ export default async function () {
 
               if (failResponse.selectedKey === 'quickfix') {
                 console.log('    > Running quick fix...');
-                const fixerResult = await agent('code-fixer', {
-                  task: task,
-                  originalImplementation: getTaskData(i, taskId, 'code'),
-                  sanityCheckResults: {
-                    summary: results.summary,
-                    results: results.results,
-                    checks: executableChecks.checks
-                  },
-                  testPlan: getTaskData(i, taskId, 'tests'),
+                const implForQuickFix = getTaskData(i, taskId, 'code');
+                const filesForQuickFix = implForQuickFix?.implementation?.filesWritten || implForQuickFix?.filesWritten || [];
+                const failedChecksList = results.results.filter(r => r.status === 'failed');
+                const fixerResult = await agent('post-code-fix', {
+                  task: { title: task.title },
+                  failedChecks: failedChecksList.map(c => ({ id: c.id, error: c.error, output: c.output })),
+                  filePaths: filesForQuickFix.map(f => f.path),
                   previousAttempts: quickFixAttempts
                 });
 
-                const fixes = fixerResult?.fixes || [];
-                const fixFiles = fixes
-                  .filter((fix) => fix?.path && fix?.code && (!fix.operation || fix.operation === 'replace'))
-                  .map((fix) => ({ path: fix.path, code: fix.code }));
-
-                if (fixFiles.length > 0) {
-                  console.log('    > Applying fixes to disk...');
-                  writeImplementationFiles({ files: fixFiles });
+                // Agent writes files directly
+                if (fixerResult?.fixesApplied?.length > 0) {
+                  console.log(`    > Fixed ${fixerResult.fixesApplied.length} file(s)`);
                 }
 
-                const updatedImplementation = applyFixesToImplementation(getTaskData(i, taskId, 'code'), fixes);
-                setTaskData(i, taskId, 'code', updatedImplementation);
                 incrementQuickFixAttempts(i, taskId);
                 setTaskData(i, taskId, 'sanity_checks', null);
                 setTaskData(i, taskId, 'sanity_results', null);
@@ -590,6 +650,32 @@ export default async function () {
             task.stage = 'completed';
             memory[tasksKey] = tasks;
             writeMarkdownFile(STATE_DIR, `phase-${i + 1}-tasks.md`, renderTasksMarkdown(i + 1, phase.title, tasks));
+
+            // Git commit for completed task
+            const implForCommit = getTaskData(i, taskId, 'code');
+            const filesForCommit = implForCommit?.implementation?.filesWritten || implForCommit?.filesWritten || [];
+            if (filesForCommit.length > 0) {
+              console.log('    > Generating commit message...');
+              const commitMsg = await agent('verify-commit-msg', {
+                task: { title: task.title, description: task.description },
+                filesWritten: filesForCommit
+              });
+              const runtime = getCurrentRuntime();
+              const fullMessage = commitMsg.scope
+                ? `${commitMsg.type}(${commitMsg.scope}): ${commitMsg.message}\n\n${commitMsg.body || ''}`
+                : `${commitMsg.type}: ${commitMsg.message}\n\n${commitMsg.body || ''}`;
+              const commitResult = createGitCommit(
+                runtime.workflowConfig.projectRoot,
+                fullMessage.trim(),
+                filesForCommit.map(f => f.path)
+              );
+              if (commitResult.success) {
+                console.log(`    > Committed: ${commitResult.hash}`);
+              } else {
+                console.log(`    > Commit skipped: ${commitResult.error}`);
+              }
+            }
+
             console.log(`    Task ${t + 1} confirmed complete!\n`);
           } else if (action === 'skip') {
             resetQuickFixAttempts(i, taskId);
@@ -598,6 +684,32 @@ export default async function () {
             task.stage = 'completed';
             memory[tasksKey] = tasks;
             writeMarkdownFile(STATE_DIR, `phase-${i + 1}-tasks.md`, renderTasksMarkdown(i + 1, phase.title, tasks));
+
+            // Git commit for completed task (skipped verification)
+            const implForCommitSkip = getTaskData(i, taskId, 'code');
+            const filesForCommitSkip = implForCommitSkip?.implementation?.filesWritten || implForCommitSkip?.filesWritten || [];
+            if (filesForCommitSkip.length > 0) {
+              console.log('    > Generating commit message...');
+              const commitMsgSkip = await agent('verify-commit-msg', {
+                task: { title: task.title, description: task.description },
+                filesWritten: filesForCommitSkip
+              });
+              const runtimeSkip = getCurrentRuntime();
+              const fullMessageSkip = commitMsgSkip.scope
+                ? `${commitMsgSkip.type}(${commitMsgSkip.scope}): ${commitMsgSkip.message}\n\n${commitMsgSkip.body || ''}`
+                : `${commitMsgSkip.type}: ${commitMsgSkip.message}\n\n${commitMsgSkip.body || ''}`;
+              const commitResultSkip = createGitCommit(
+                runtimeSkip.workflowConfig.projectRoot,
+                fullMessageSkip.trim(),
+                filesForCommitSkip.map(f => f.path)
+              );
+              if (commitResultSkip.success) {
+                console.log(`    > Committed: ${commitResultSkip.hash}`);
+              } else {
+                console.log(`    > Commit skipped: ${commitResultSkip.error}`);
+              }
+            }
+
             console.log(`    Task ${t + 1} confirmed complete!\n`);
           } else {
             setTaskStage(i, taskId, TASK_STAGES.AWAITING_APPROVAL);
@@ -628,6 +740,32 @@ export default async function () {
             task.stage = 'completed';
             memory[tasksKey] = tasks;
             writeMarkdownFile(STATE_DIR, `phase-${i + 1}-tasks.md`, renderTasksMarkdown(i + 1, phase.title, tasks));
+
+            // Git commit for manually approved task
+            const implForCommitManual = getTaskData(i, taskId, 'code');
+            const filesForCommitManual = implForCommitManual?.implementation?.filesWritten || implForCommitManual?.filesWritten || [];
+            if (filesForCommitManual.length > 0) {
+              console.log('    > Generating commit message...');
+              const commitMsgManual = await agent('verify-commit-msg', {
+                task: { title: task.title, description: task.description },
+                filesWritten: filesForCommitManual
+              });
+              const runtimeManual = getCurrentRuntime();
+              const fullMessageManual = commitMsgManual.scope
+                ? `${commitMsgManual.type}(${commitMsgManual.scope}): ${commitMsgManual.message}\n\n${commitMsgManual.body || ''}`
+                : `${commitMsgManual.type}: ${commitMsgManual.message}\n\n${commitMsgManual.body || ''}`;
+              const commitResultManual = createGitCommit(
+                runtimeManual.workflowConfig.projectRoot,
+                fullMessageManual.trim(),
+                filesForCommitManual.map(f => f.path)
+              );
+              if (commitResultManual.success) {
+                console.log(`    > Committed: ${commitResultManual.hash}`);
+              } else {
+                console.log(`    > Commit skipped: ${commitResultManual.error}`);
+              }
+            }
+
             console.log(`    Task ${t + 1} confirmed complete!\n`);
           } else {
             console.log('    > Issue flagged, reprocessing task with feedback...');