@mndrk/agx 1.4.63 → 1.4.65

package/lib/executor.js

@@ -11,6 +11,17 @@ const path = require('path');
 const os = require('os');
 const { commandExists } = require('./proc/commandExists');
 const { interpolate, DEFAULT_STAGE_PROMPT, PROJECT_CONTEXT, EXECUTOR_PROMPT } = require('./prompts/templates');
+const { createCheckpoint, checkpointsPath } = require('./storage/checkpoints');
+const { captureGitState } = require('./storage/git');
+const { createCloudSyncer } = require('./cloud-sync');
+const { runVerifyGate } = require('./verify-gate');
+
+let json5;
+try {
+  json5 = require('json5');
+} catch {
+  json5 = null;
+}
 
 // Engine configurations
 const ENGINES = {
@@ -99,8 +110,143 @@ async function executeTask(options) {
     onLog,
     onProgress,
     onStream,
+    projectSlug,
+    taskSlug,
+    iteration = 1,
+    objective,
+    constraints,
+    dontRepeat,
+    verifyFailures,
+    plan: initialPlan,
+    criteria: initialCriteria,
+    repoPath,
   } = options;
 
+  const iterationValue = (() => {
+    const parsed = Number(iteration);
+    if (Number.isFinite(parsed) && parsed >= 1) {
+      return parsed;
+    }
+    return 1;
+  })();
+
+  const gitCwd = typeof repoPath === 'string' && repoPath ? repoPath : process.cwd();
+
+  const executionState = {
+    plan: initialPlan || null,
+    criteria: initialCriteria || null,
+  };
+  const cloudSyncer = (() => {
+    if (!projectSlug || !taskSlug || !options.cloudTaskId) return null;
+    try {
+      return createCloudSyncer({
+        taskRoot: path.dirname(checkpointsPath(projectSlug, taskSlug)),
+        cloudTaskId: options.cloudTaskId,
+        onLog,
+      });
+    } catch (err) {
+      onLog?.(`[cloud-sync] init failed: ${err?.message || err}`);
+      return null;
+    }
+  })();
+
+  const ensureDefaultPlan = () => {
+    if (!executionState.plan && iterationValue === 1) {
+      executionState.plan = createDefaultPlan();
+    }
+  };
+
+  const captureGitStateSafe = () => {
+    try {
+      return captureGitState(gitCwd);
+    } catch (err) {
+      onLog?.(`[checkpoint] unable to record git state: ${err?.message || err}`);
+      return null;
+    }
+  };
+
+  const persistCheckpoint = async (label) => {
+    if (!projectSlug || !taskSlug) return;
+    const trimmedLabel = (label || '').toString().trim();
+    if (!trimmedLabel) return;
+
+    ensureDefaultPlan();
+    const checkpointPayload = {
+      label: trimmedLabel,
+      iteration: iterationValue,
+      objective,
+      plan: executionState.plan,
+      criteria: executionState.criteria,
+      constraints,
+      dontRepeat,
+      verifyFailures,
+      git: captureGitStateSafe(),
+    };
+
+    try {
+      const checkpoint = await createCheckpoint(projectSlug, taskSlug, checkpointPayload);
+      if (cloudSyncer && checkpoint) {
+        try {
+          await cloudSyncer.sync(checkpoint);
+        } catch (err) {
+          onLog?.(`[cloud-sync] sync failed: ${err?.message || err}`);
+        }
+      }
+    } catch (err) {
+      onLog?.(`[checkpoint] failed to persist: ${err?.message || err}`);
+    }
+  };
+
+  const handleCheckpoint = (label) => {
+    void persistCheckpoint(label);
+  };
+
+  const handlePlanJson = (plan) => {
+    if (plan && typeof plan === 'object') {
+      executionState.plan = plan;
+    }
+  };
+
+  const handleCriteriaJson = (criteria) => {
+    if (criteria && typeof criteria === 'object') {
+      executionState.criteria = criteria;
+    }
+  };
+
+  const handleBlocked = async (blockedInfo) => {
+    // Persist rich blocked state with current checkpoint data
+    const richBlockedState = {
+      ...blockedInfo,
+      iteration: iterationValue,
+      objective,
+      plan: executionState.plan,
+      criteria: executionState.criteria,
+      constraints,
+      dontRepeat,
+      verifyFailures,
+      git: captureGitStateSafe(),
+    };
+    
+    // Save blocked state as a special checkpoint
+    try {
+      const checkpoint = await createCheckpoint(projectSlug, taskSlug, {
+        ...richBlockedState,
+        label: `blocked: ${blockedInfo.reason}`,
+        blockedAt: blockedInfo.timestamp,
+      });
+      onLog?.(`[blocked] State persisted for recovery`);
+      if (cloudSyncer && checkpoint) {
+        try {
+          await cloudSyncer.sync(checkpoint);
+        } catch (err) {
+          onLog?.(`[cloud-sync] sync failed: ${err?.message || err}`);
+        }
+      }
+    } catch (err) {
+      onLog?.(`[blocked] Failed to persist state: ${err?.message || err}`);
+    }
+  };
+
   const stageConfig = resolveStageConfig(options);
   const engineConfig = ENGINES[engine] || ENGINES.claude;
 
@@ -150,7 +296,17 @@ async function executeTask(options) {
       onStream?.(chunk);
       
       // Parse output markers
-      parseMarkers(chunk, { onLog, onProgress, taskId });
+      parseMarkers(chunk, {
+        onLog,
+        onProgress,
+        taskId,
+        projectSlug,
+        taskSlug,
+        onCheckpoint: handleCheckpoint,
+        onPlanJson: handlePlanJson,
+        onCriteriaJson: handleCriteriaJson,
+        onBlocked: handleBlocked,
+      });
       
       // Increment progress as we get output
       lastProgress = Math.min(90, lastProgress + 5);
@@ -181,24 +337,75 @@ async function executeTask(options) {
       timeout = null;
     };
 
+    // Auto-checkpoint every 5 minutes
+    const AUTO_CHECKPOINT_INTERVAL_MS = 5 * 60 * 1000;
+    let autoCheckpointTimer = null;
+    let autoCheckpointCount = 0;
+    
+    const startAutoCheckpoint = () => {
+      if (autoCheckpointTimer) return;
+      autoCheckpointTimer = setInterval(async () => {
+        autoCheckpointCount++;
+        onLog?.(`[checkpoint] auto-checkpoint #${autoCheckpointCount}`);
+        await persistCheckpoint(`auto-5min-${autoCheckpointCount}`);
+      }, AUTO_CHECKPOINT_INTERVAL_MS);
+      autoCheckpointTimer.unref?.();
+    };
+    
+    const stopAutoCheckpoint = () => {
+      if (autoCheckpointTimer) {
+        clearInterval(autoCheckpointTimer);
+        autoCheckpointTimer = null;
+      }
+    };
+    
+    // Start auto-checkpoint timer
+    startAutoCheckpoint();
+
     proc.on('error', (err) => {
+      stopAutoCheckpoint();
       clearStageTimeout();
       require('./telemetry').track('executor_spawn_error', { engine, error: err.message });
       settle(reject)(new Error(`Failed to spawn ${engine}: ${err.message}`));
     });
 
-    proc.on('close', (code) => {
+    proc.on('close', async (code) => {
+      stopAutoCheckpoint();
       clearStageTimeout();
       onProgress?.(100);
       
       if (code === 0 || code === null) {
-        onLog?.(`[${engine}] Stage completed successfully`);
+        onLog?.(`[${engine}] Stage process finished`);
+        
+        let gateResult = null;
+        try {
+          onLog?.(`[verify-gate] Running verification...`);
+          gateResult = await runVerifyGate({
+            criteria: executionState.criteria || [],
+            cwd: gitCwd,
+            verifyFailures: verifyFailures || 0,
+            onLog
+          });
+          
+          if (gateResult.forceAction) {
+            onLog?.(`[verify-gate] Force action triggered: ${gateResult.reason}`);
+            // We resolve as success but pass the gate result so the loop can handle the force action
+          } else if (gateResult.passed) {
+            onLog?.(`[verify-gate] Passed all checks`);
+          } else {
+            onLog?.(`[verify-gate] Checks failed or need LLM`);
+          }
+        } catch (err) {
+           onLog?.(`[verify-gate] execution error: ${err.message}`);
+        }
+
         require('./telemetry').track('executor_completed', { engine, stage, duration_ms: Date.now() - execStart });
         settle(resolve)({
           success: true,
           output,
           workDir,
           exitCode: code,
+          gateResult,
         });
       } else {
         onLog?.(`[${engine}] Stage failed with exit code ${code}`);
@@ -232,14 +439,95 @@ function buildPrompt(title, content, stage, stageConfig) {
   });
 }
 
+function createDefaultPlan() {
+  return {
+    steps: [
+      { desc: 'Analyze', status: 'done' },
+      { desc: 'Implement', status: 'in_progress' },
+      { desc: 'Verify', status: 'todo' },
+    ],
+    current: 1,
+  };
+}
+
+function tryParseJsonCandidate(candidate) {
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    if (json5) {
+      try {
+        return json5.parse(candidate);
+      } catch (json5Err) {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
+function extractJsonObjects(text, markerName) {
+  if (!text || !markerName) return [];
+  const lowerText = text.toLowerCase();
+  const marker = `[${markerName.toLowerCase()}:`;
+  const results = [];
+  let cursor = 0;
+  while (cursor < lowerText.length) {
+    const markerIndex = lowerText.indexOf(marker, cursor);
+    if (markerIndex === -1) break;
+    const braceStart = text.indexOf('{', markerIndex + marker.length);
+    if (braceStart === -1) {
+      cursor = markerIndex + marker.length;
+      continue;
+    }
+    let depth = 0;
+    let sliceEnd = -1;
+    for (let i = braceStart; i < text.length; i += 1) {
+      const ch = text[i];
+      if (ch === '{') {
+        depth += 1;
+      } else if (ch === '}') {
+        depth -= 1;
+        if (depth === 0) {
+          sliceEnd = i;
+          break;
+        }
+      }
+    }
+    if (sliceEnd === -1) {
+      cursor = markerIndex + marker.length;
+      continue;
+    }
+    const candidate = text.slice(braceStart, sliceEnd + 1);
+    const parsed = tryParseJsonCandidate(candidate);
+    if (parsed !== null) {
+      results.push(parsed);
+      cursor = sliceEnd + 1;
+    } else {
+      cursor = braceStart + 1;
+    }
+  }
+  return results;
+}
+
 /**
  * Parse output markers from agent output
  */
-function parseMarkers(text, { onLog, onProgress, taskId }) {
-  // [checkpoint: message]
-  const checkpointMatch = text.match(/\[checkpoint:\s*([^\]]+)\]/i);
-  if (checkpointMatch) {
-    onLog?.(`[checkpoint] ${checkpointMatch[1]}`);
+function parseMarkers(text, {
+  onLog,
+  onProgress,
+  taskId,
+  projectSlug,
+  taskSlug,
+  onCheckpoint,
+  onPlanJson,
+  onCriteriaJson,
+  onBlocked,
+}) {
+  // [checkpoint: message] - capture all occurrences in chunk
+  const checkpointMatches = [...text.matchAll(/\[checkpoint:\s*([^\]]+)\]/gi)];
+  for (const match of checkpointMatches) {
+    onLog?.(`[checkpoint] ${match[1]}`);
+    onCheckpoint?.(match[1]);
   }
 
   // [learn: insight]
@@ -257,13 +545,31 @@ function parseMarkers(text, { onLog, onProgress, taskId }) {
   // [blocked: reason]
   const blockedMatch = text.match(/\[blocked:\s*([^\]]+)\]/i);
   if (blockedMatch) {
-    onLog?.(`[blocked] ${blockedMatch[1]}`);
+    const reason = blockedMatch[1];
+    onLog?.(`[blocked] ${reason}`);
+    onBlocked?.({
+      reason,
+      timestamp: new Date().toISOString(),
+      taskId,
+      projectSlug,
+      taskSlug,
+    });
   }
 
   // [done]
   if (/\[done\]/i.test(text)) {
     onLog?.(`[done] Stage marked complete`);
   }
+
+  const planObjects = extractJsonObjects(text, 'plan_json');
+  for (const plan of planObjects) {
+    onPlanJson?.(plan);
+  }
+
+  const criteriaObjects = extractJsonObjects(text, 'criteria_json');
+  for (const criteria of criteriaObjects) {
+    onCriteriaJson?.(criteria);
+  }
 }
 
 /**