@mndrk/agx 1.4.64 → 1.4.65

package/lib/cli/runCli.js

@@ -704,7 +704,7 @@ async function checkOnboarding() {
   }
 
   async function runTaskInline(rawTaskId, options = {}) {
-    const { resetFirst = false, forceSwarm = false, fromStage = null } = options;
+    const { resetFirst = false, forceSwarm = false, fromStage = null, resumePrompt = '' } = options;
     const taskId = await resolveTaskId(rawTaskId);
 
     if (fromStage) {
@@ -736,7 +736,11 @@ async function checkOnboarding() {
       throw new Error(`Task not found: ${taskId}`);
     }
 
-    const effectiveTask = forceSwarm ? { ...task, swarm: true } : task;
+    const effectiveTask = forceSwarm ? { ...task, swarm: true } : { ...task };
+    const normalizedResumePrompt = typeof resumePrompt === 'string' ? resumePrompt.trim() : '';
+    if (normalizedResumePrompt) {
+      effectiveTask.prompt = normalizedResumePrompt;
+    }
     console.log(`${c.green}✓${c.reset} Running task inline`);
     console.log(`${c.dim}Task: ${taskId}${c.reset}`);
 
@@ -1801,6 +1805,213 @@ async function checkOnboarding() {
     process.exit(0);
   }
 
+  // agx resume [<project>:]<task> [--from <checkpoint-id>] [--git-restore] [--dry-run]
+  // Resume execution from last checkpoint (or specified checkpoint)
+  if (cmd === 'resume') {
+    const { getHead, readCheckpointsFile } = require('../storage/checkpoints');
+    const { restoreGitState } = require('../storage/git');
+    const { buildResumePrompt } = require('../prompts/resume');
+
+    let taskIdentifier = null;
+    let fromCheckpointId = null;
+    let gitRestore = false;
+    let dryRun = false;
+
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === '--from' || args[i] === '-f') {
+        fromCheckpointId = args[++i];
+      } else if (args[i] === '--git-restore' || args[i] === '--restore-git') {
+        gitRestore = true;
+      } else if (args[i] === '--dry-run' || args[i] === '-n') {
+        dryRun = true;
+      } else if (!args[i].startsWith('-')) {
+        taskIdentifier = args[i];
+      }
+    }
+
+    if (!taskIdentifier) {
+      console.log(`${c.yellow}Usage:${c.reset} agx resume [<project>:]<task>`);
+      console.log(`${c.dim}Options:${c.reset}`);
+      console.log(`  --from <id>      Resume from specific checkpoint (default: latest)`);
+      console.log(`  --git-restore    Restore git state from checkpoint`);
+      console.log(`  --dry-run        Show what would be resumed without executing`);
+      process.exit(1);
+    }
+
+    // Parse project:task or just task
+    let projectSlug = null;
+    let taskSlug = null;
+    if (taskIdentifier.includes(':')) {
+      [projectSlug, taskSlug] = taskIdentifier.split(':');
+    } else {
+      // Try to infer project from current directory or use default
+      taskSlug = taskIdentifier;
+      // Look for most recent project with this task
+      const projectsDir = path.join(os.homedir(), '.agx', 'projects');
+      if (fs.existsSync(projectsDir)) {
+        const projects = fs.readdirSync(projectsDir).filter(p => {
+          const taskDir = path.join(projectsDir, p, 'tasks', taskSlug);
+          return fs.existsSync(taskDir);
+        });
+        if (projects.length === 1) {
+          projectSlug = projects[0];
+        } else if (projects.length > 1) {
+          console.log(`${c.yellow}Multiple projects contain task '${taskSlug}':${c.reset}`);
+          projects.forEach(p => console.log(`  - ${p}:${taskSlug}`));
+          console.log(`${c.dim}Specify project: agx resume <project>:${taskSlug}${c.reset}`);
+          process.exit(1);
+        }
+      }
+    }
+
+    if (!projectSlug || !taskSlug) {
+      console.log(`${c.red}✗${c.reset} Could not resolve task '${taskIdentifier}'`);
+      console.log(`${c.dim}Use format: agx resume <project>:<task>${c.reset}`);
+      process.exit(1);
+    }
+
+    try {
+      // Load checkpoint
+      let checkpoint = null;
+      if (fromCheckpointId) {
+        const checkpointsData = await readCheckpointsFile(projectSlug, taskSlug);
+        checkpoint = checkpointsData.history.find(cp => cp.id === fromCheckpointId);
+        if (!checkpoint) {
+          console.log(`${c.red}✗${c.reset} Checkpoint '${fromCheckpointId}' not found`);
+          const available = checkpointsData.history.slice(0, 5).map(cp => cp.id).join(', ');
+          if (available) {
+            console.log(`${c.dim}Available: ${available}${c.reset}`);
+          }
+          process.exit(1);
+        }
+      } else {
+        checkpoint = await getHead(projectSlug, taskSlug);
+      }
+
+      if (!checkpoint) {
+        console.log(`${c.red}✗${c.reset} No checkpoints found for ${projectSlug}:${taskSlug}`);
+        console.log(`${c.dim}Task must have emitted [checkpoint: ...] markers to resume${c.reset}`);
+        process.exit(1);
+      }
+
+      // Display checkpoint info
+      console.log(`${c.bold}Resume from Checkpoint${c.reset}\n`);
+      console.log(`  ${c.dim}ID:${c.reset}      ${checkpoint.id}`);
+      console.log(`  ${c.dim}Created:${c.reset} ${checkpoint.createdAt || 'unknown'}`);
+      if (checkpoint.label) {
+        console.log(`  ${c.dim}Label:${c.reset}   ${checkpoint.label}`);
+      }
+      if (checkpoint.iteration !== undefined) {
+        console.log(`  ${c.dim}Iter:${c.reset}    ${checkpoint.iteration}`);
+      }
+
+      // Show git state if present
+      if (checkpoint.git) {
+        const { sha, branch, dirty, patchFile } = checkpoint.git;
+        console.log(`\n  ${c.dim}Git:${c.reset}     ${branch || 'detached'} @ ${(sha || '').slice(0, 7)}${dirty ? ' (dirty)' : ''}`);
+        if (patchFile) {
+          console.log(`  ${c.dim}Patch:${c.reset}   ${patchFile}`);
+        }
+      }
+
+      // Build resume prompt
+      const resumePrompt = buildResumePrompt(checkpoint);
+      console.log(`\n${c.bold}Resume Prompt${c.reset} (${resumePrompt.length} chars)\n`);
+      console.log(c.dim + '─'.repeat(60) + c.reset);
+      console.log(resumePrompt.slice(0, 1500) + (resumePrompt.length > 1500 ? '\n...(truncated)' : ''));
+      console.log(c.dim + '─'.repeat(60) + c.reset);
+
+      if (dryRun) {
+        console.log(`\n${c.yellow}Dry run - no execution${c.reset}`);
+        process.exit(0);
+      }
+
+      // Optionally restore git state
+      if (gitRestore && checkpoint.git) {
+        console.log(`\n${c.dim}Restoring git state...${c.reset}`);
+        try {
+          const cwd = process.cwd();
+          restoreGitState(checkpoint.git, cwd, { force: false });
+          console.log(`${c.green}✓${c.reset} Git state restored`);
+        } catch (err) {
+          console.log(`${c.yellow}⚠${c.reset} Git restore failed: ${err.message}`);
+          console.log(`${c.dim}Continuing without git restore. Use --force if working tree has changes.${c.reset}`);
+        }
+      }
+
+      // Continue execution with resume prompt
+      if (!dryRun) {
+        // Load task.json to get cloud task ID
+        const storage = require('../storage');
+        const taskJsonPath = path.join(storage.projectRoot(projectSlug), taskSlug, 'task.json');
+        let cloudTaskId = null;
+        
+        if (fs.existsSync(taskJsonPath)) {
+          try {
+            const taskData = JSON.parse(fs.readFileSync(taskJsonPath, 'utf8'));
+            cloudTaskId = taskData?.cloud?.task_id;
+          } catch {
+            // Ignore parse errors
+          }
+        }
+        
+        if (!cloudTaskId) {
+          console.log(`${c.yellow}⚠${c.reset} No cloud task ID found. Running locally.`);
+          // For now, just use the resume prompt with the default provider
+          const provider = 'claude';
+          console.log(`\n${c.dim}Executing with ${provider}...${c.reset}`);
+          
+          try {
+            const { executeTask } = require('../executor');
+            await executeTask({
+              taskId: `${projectSlug}:${taskSlug}`,
+              title: checkpoint.objective || 'Resume task',
+              content: resumePrompt,
+              stage: 'execute',
+              engine: provider,
+              projectSlug,
+              taskSlug,
+              iteration: (checkpoint.iteration || 0) + 1,
+              objective: checkpoint.objective,
+              constraints: checkpoint.constraints,
+              dontRepeat: checkpoint.dontRepeat,
+              verifyFailures: checkpoint.verifyFailures || 0,
+              plan: checkpoint.plan,
+              criteria: checkpoint.criteria,
+              onLog: (msg) => console.log(msg),
+              onProgress: () => {},
+            });
+            console.log(`${c.green}✓${c.reset} Resume execution completed`);
+          } catch (err) {
+            console.log(`${c.red}✗${c.reset} Execution failed: ${err.message}`);
+            process.exit(1);
+          }
+        } else {
+          // Use cloud task flow
+          console.log(`\n${c.dim}Resuming cloud task ${cloudTaskId.slice(0, 8)}...${c.reset}`);
+          try {
+            const exitCode = await runTaskInline(cloudTaskId, {
+              resumePrompt,
+              fromStage: 'execution',
+            });
+            process.exit(exitCode);
+          } catch (err) {
+            console.log(`${c.red}✗${c.reset} Resume failed: ${err.message}`);
+            process.exit(1);
+          }
+        }
+      }
+
+      process.exit(0);
+    } catch (err) {
+      console.log(`${c.red}✗${c.reset} Resume failed: ${err.message}`);
+      if (process.env.DEBUG) {
+        console.error(err);
+      }
+      process.exit(1);
+    }
+  }
+
   // agx retry <taskId> [--task <id>] [--swarm] [--async]
   if (cmd === 'retry' || (cmd === 'task' && args[1] === 'retry')) {
     const runArgs = cmd === 'task' ? args.slice(1) : args;

package/lib/cloud-sync.js

@@ -0,0 +1,267 @@
+/**
+ * Cloud Sync - Sync local checkpoints to agx cloud API.
+ *
+ * Local-first with cloud sync:
+ * - Checkpoints are always saved locally first
+ * - Cloud sync happens asynchronously (best-effort)
+ * - Failures don't block local operations
+ *
+ * Sync strategy:
+ * - On checkpoint create: queue for cloud sync
+ * - Background worker processes queue
+ * - Retry with exponential backoff
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SYNC_QUEUE_FILE = 'sync-queue.json';
+const MAX_RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 1000;
+
+/**
+ * Load cloud config from environment or config file.
+ * @returns {{ apiUrl: string, token: string, userId: string } | null}
+ */
+function loadCloudConfig() {
+  // Try environment first
+  if (process.env.AGX_CLOUD_URL) {
+    return {
+      apiUrl: process.env.AGX_CLOUD_URL,
+      token: process.env.AGX_CLOUD_TOKEN || '',
+      userId: process.env.AGX_CLOUD_USER_ID || '',
+    };
+  }
+  
+  // Try config file
+  try {
+    const configPath = path.join(process.env.HOME || '', '.agx', 'cloud-config.json');
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+  } catch {
+    // Ignore
+  }
+  
+  return null;
+}
+
+/**
+ * Sync a checkpoint to the cloud.
+ * @param {object} options
+ * @param {string} options.taskId - Cloud task ID
+ * @param {object} options.checkpoint - Checkpoint data
+ * @param {function} options.onLog - Logging callback
+ * @returns {Promise<{ success: boolean, error?: string }>}
+ */
+async function syncCheckpointToCloud({ taskId, checkpoint, onLog = () => {} }) {
+  const config = loadCloudConfig();
+  if (!config?.apiUrl) {
+    return { success: false, error: 'No cloud config' };
+  }
+  
+  if (!taskId) {
+    return { success: false, error: 'No task ID' };
+  }
+  
+  try {
+    const url = `${config.apiUrl}/api/tasks/${taskId}/checkpoints`;
+    
+    // Prepare checkpoint for cloud (remove large fields)
+    const cloudCheckpoint = {
+      id: checkpoint.id,
+      label: checkpoint.label,
+      createdAt: checkpoint.createdAt,
+      iteration: checkpoint.iteration,
+      objective: checkpoint.objective,
+      // Include plan summary, not full plan
+      planStepCount: checkpoint.plan?.steps?.length || 0,
+      currentStep: checkpoint.plan?.currentStep,
+      // Include criteria summary
+      criteriaCount: checkpoint.criteria?.length || 0,
+      criteriaPassed: checkpoint.criteria?.filter(c => c.passed)?.length || 0,
+      // Git info (no patch content)
+      gitSha: checkpoint.git?.sha,
+      gitBranch: checkpoint.git?.branch,
+      gitDirty: checkpoint.git?.dirty,
+      // Blocked info
+      blockedAt: checkpoint.blockedAt,
+      blockedReason: checkpoint.reason,
+    };
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(config.token ? { 'Authorization': `Bearer ${config.token}` } : {}),
+        ...(config.userId ? { 'x-user-id': config.userId } : {}),
+      },
+      body: JSON.stringify(cloudCheckpoint),
+    });
+    
+    if (!response.ok) {
+      const error = `HTTP ${response.status}`;
+      onLog(`[cloud-sync] Failed to sync checkpoint: ${error}`);
+      return { success: false, error };
+    }
+    
+    onLog(`[cloud-sync] Checkpoint ${checkpoint.id} synced`);
+    return { success: true };
+  } catch (err) {
+    const error = err?.message || String(err);
+    onLog(`[cloud-sync] Sync error: ${error}`);
+    return { success: false, error };
+  }
+}
+
+/**
+ * Queue a checkpoint for cloud sync.
+ * @param {string} taskRoot - Local task directory
+ * @param {object} checkpoint - Checkpoint data
+ * @param {string} cloudTaskId - Cloud task ID
+ */
+async function queueForSync(taskRoot, checkpoint, cloudTaskId) {
+  if (!taskRoot || !checkpoint || !cloudTaskId) return;
+  
+  try {
+    const queuePath = path.join(taskRoot, SYNC_QUEUE_FILE);
+    let queue = [];
+    
+    if (fs.existsSync(queuePath)) {
+      try {
+        queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+      } catch {
+        queue = [];
+      }
+    }
+    
+    queue.push({
+      checkpointId: checkpoint.id,
+      cloudTaskId,
+      checkpoint,
+      queuedAt: new Date().toISOString(),
+      attempts: 0,
+    });
+    
+    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2));
+  } catch {
+    // Ignore queue errors
+  }
+}
+
+/**
+ * Process the sync queue for a task.
+ * @param {string} taskRoot - Local task directory
+ * @param {function} onLog - Logging callback
+ * @returns {Promise<{ synced: number, failed: number }>}
+ */
+async function processSyncQueue(taskRoot, onLog = () => {}) {
+  const queuePath = path.join(taskRoot, SYNC_QUEUE_FILE);
+  if (!fs.existsSync(queuePath)) {
+    return { synced: 0, failed: 0 };
+  }
+  
+  let queue;
+  try {
+    queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+  } catch {
+    return { synced: 0, failed: 0 };
+  }
+  
+  if (!Array.isArray(queue) || queue.length === 0) {
+    return { synced: 0, failed: 0 };
+  }
+  
+  let synced = 0;
+  let failed = 0;
+  const remaining = [];
+  
+  for (const item of queue) {
+    const result = await syncCheckpointToCloud({
+      taskId: item.cloudTaskId,
+      checkpoint: item.checkpoint,
+      onLog,
+    });
+    
+    if (result.success) {
+      synced++;
+    } else {
+      item.attempts++;
+      item.lastError = result.error;
+      item.lastAttempt = new Date().toISOString();
+      
+      if (item.attempts < MAX_RETRY_ATTEMPTS) {
+        remaining.push(item);
+      } else {
+        failed++;
+        onLog(`[cloud-sync] Checkpoint ${item.checkpointId} failed after ${MAX_RETRY_ATTEMPTS} attempts`);
+      }
+    }
+  }
+  
+  // Update queue with remaining items
+  if (remaining.length > 0) {
+    fs.writeFileSync(queuePath, JSON.stringify(remaining, null, 2));
+  } else {
+    try {
+      fs.unlinkSync(queuePath);
+    } catch {
+      // Ignore
+    }
+  }
+  
+  return { synced, failed };
+}
+
+/**
+ * Create a cloud syncer that automatically syncs checkpoints.
+ * @param {object} options
+ * @param {string} options.taskRoot - Local task directory
+ * @param {string} options.cloudTaskId - Cloud task ID
+ * @param {function} options.onLog - Logging callback
+ * @returns {{ sync: function, processQueue: function }}
+ */
+function createCloudSyncer(options = {}) {
+  const { taskRoot, cloudTaskId, onLog = () => {} } = options;
+  
+  return {
+    /**
+     * Sync a checkpoint immediately (best-effort).
+     */
+    async sync(checkpoint) {
+      if (!cloudTaskId) {
+        // Queue for later if no cloud task ID yet
+        await queueForSync(taskRoot, checkpoint, cloudTaskId);
+        return { success: false, queued: true };
+      }
+      
+      const result = await syncCheckpointToCloud({
+        taskId: cloudTaskId,
+        checkpoint,
+        onLog,
+      });
+      
+      if (!result.success) {
+        // Queue for retry
+        await queueForSync(taskRoot, checkpoint, cloudTaskId);
+      }
+      
+      return result;
+    },
+    
+    /**
+     * Process queued checkpoints.
+     */
+    async processQueue() {
+      return processSyncQueue(taskRoot, onLog);
+    },
+  };
+}
+
+module.exports = {
+  loadCloudConfig,
+  syncCheckpointToCloud,
+  queueForSync,
+  processSyncQueue,
+  createCloudSyncer,
+};