@litmers/cursorflow-orchestrator 0.1.5 → 0.1.8

package/src/core/runner.ts

@@ -6,7 +6,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { execSync, spawnSync } from 'child_process';
+import { execSync, spawn, spawnSync } from 'child_process';
 
 import * as git from '../utils/git';
 import * as logger from '../utils/logger';
@@ -107,12 +107,16 @@ function parseJsonFromStdout(stdout: string): any {
   return null;
 }
 
-export function cursorAgentSend({ workspaceDir, chatId, prompt, model }: { 
+/**
+ * Execute cursor-agent command with streaming and better error handling
+ */
+export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, signalDir }: { 
   workspaceDir: string; 
   chatId: string; 
   prompt: string; 
   model?: string; 
-}): AgentSendResult {
+  signalDir?: string;
+}): Promise<AgentSendResult> {
   const args = [
     '--print',
     '--output-format', 'json',
@@ -124,74 +128,100 @@ export function cursorAgentSend({ workspaceDir, chatId, prompt, model }: {
   
   logger.info('Executing cursor-agent...');
   
-  const res = spawnSync('cursor-agent', args, {
-    encoding: 'utf8',
-    stdio: 'pipe',
-    timeout: 300000, // 5 minute timeout for LLM response
-  });
-  
-  // Check for timeout
-  if (res.error) {
-    if ((res.error as any).code === 'ETIMEDOUT') {
-      return {
+  return new Promise((resolve) => {
+    const child = spawn('cursor-agent', args, {
+      stdio: ['pipe', 'pipe', 'pipe'], // Enable stdin piping
+      env: process.env,
+    });
+
+    let fullStdout = '';
+    let fullStderr = '';
+
+    // Watch for "intervention.txt" signal file if any
+    const interventionPath = signalDir ? path.join(signalDir, 'intervention.txt') : null;
+    let interventionWatcher: fs.FSWatcher | null = null;
+
+    if (interventionPath && fs.existsSync(path.dirname(interventionPath))) {
+      interventionWatcher = fs.watch(path.dirname(interventionPath), (event, filename) => {
+        if (filename === 'intervention.txt' && fs.existsSync(interventionPath)) {
+          try {
+            const message = fs.readFileSync(interventionPath, 'utf8').trim();
+            if (message) {
+              logger.info(`Injecting intervention: ${message}`);
+              child.stdin.write(message + '\n');
+              fs.unlinkSync(interventionPath); // Clear it
+            }
+          } catch (e) {
+            logger.warn('Failed to read intervention file');
+          }
+        }
+      });
+    }
+
+    child.stdout.on('data', (data) => {
+      const str = data.toString();
+      fullStdout += str;
+      // Also pipe to our own stdout so it goes to terminal.log
+      process.stdout.write(data);
+    });
+
+    child.stderr.on('data', (data) => {
+      fullStderr += data.toString();
+      // Pipe to our own stderr so it goes to terminal.log
+      process.stderr.write(data);
+    });
+
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve({
         ok: false,
         exitCode: -1,
         error: 'cursor-agent timed out after 5 minutes. The LLM request may be taking too long or there may be network issues.',
-      };
-    }
-    
-    return {
-      ok: false,
-      exitCode: -1,
-      error: `cursor-agent error: ${res.error.message}`,
-    };
-  }
-  
-  const json = parseJsonFromStdout(res.stdout);
-  
-  if (res.status !== 0 || !json || json.type !== 'result') {
-    let errorMsg = res.stderr?.trim() || res.stdout?.trim() || `exit=${res.status}`;
-    
-    // Check for authentication errors
-    if (errorMsg.includes('not authenticated') || 
-        errorMsg.includes('login') || 
-        errorMsg.includes('auth')) {
-      errorMsg = 'Authentication error. Please:\n' +
-        '  1. Open Cursor IDE\n' +
-        '  2. Sign in to your account\n' +
-        '  3. Verify AI features are working\n' +
-        '  4. Try again\n\n' +
-        `Details: ${errorMsg}`;
-    }
-    
-    // Check for rate limit errors
-    if (errorMsg.includes('rate limit') || errorMsg.includes('quota')) {
-      errorMsg = 'API rate limit or quota exceeded. Please:\n' +
-        '  1. Check your Cursor subscription\n' +
-        '  2. Wait a few minutes and try again\n\n' +
-        `Details: ${errorMsg}`;
-    }
-    
-    // Check for model errors
-    if (errorMsg.includes('model')) {
-      errorMsg = `Model error (requested: ${model || 'default'}). ` +
-        'Please check if the model is available in your Cursor subscription.\n\n' +
-        `Details: ${errorMsg}`;
-    }
-    
-    return {
-      ok: false,
-      exitCode: res.status ?? -1,
-      error: errorMsg,
-    };
-  }
-  
-  return {
-    ok: !json.is_error,
-    exitCode: res.status ?? 0,
-    sessionId: json.session_id || chatId,
-    resultText: json.result || '',
-  };
+      });
+    }, 300000);
+
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      if (interventionWatcher) interventionWatcher.close();
+      
+      const json = parseJsonFromStdout(fullStdout);
+      
+      if (code !== 0 || !json || json.type !== 'result') {
+        let errorMsg = fullStderr.trim() || fullStdout.trim() || `exit=${code}`;
+        
+        // Check for common errors
+        if (errorMsg.includes('not authenticated') || errorMsg.includes('login') || errorMsg.includes('auth')) {
+          errorMsg = 'Authentication error. Please sign in to Cursor IDE.';
+        } else if (errorMsg.includes('rate limit') || errorMsg.includes('quota')) {
+          errorMsg = 'API rate limit or quota exceeded.';
+        } else if (errorMsg.includes('model')) {
+          errorMsg = `Model error (requested: ${model || 'default'}). Check your subscription.`;
+        }
+        
+        resolve({
+          ok: false,
+          exitCode: code ?? -1,
+          error: errorMsg,
+        });
+      } else {
+        resolve({
+          ok: !json.is_error,
+          exitCode: code ?? 0,
+          sessionId: json.session_id || chatId,
+          resultText: json.result || '',
+        });
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timeout);
+      resolve({
+        ok: false,
+        exitCode: -1,
+        error: `Failed to start cursor-agent: ${err.message}`,
+      });
+    });
+  });
 }
 
 /**
@@ -326,11 +356,12 @@ export async function runTask({
   }));
   
   logger.info('Sending prompt to agent...');
-  const r1 = cursorAgentSend({
+  const r1 = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId,
     prompt: prompt1,
     model,
+    signalDir: runDir
   });
   
   appendLog(convoPath, createConversationEntry('assistant', r1.resultText || r1.error || 'No response', {
@@ -371,7 +402,9 @@ export async function runTask({
 /**
  * Run all tasks in sequence
  */
-export async function runTasks(config: RunnerConfig, runDir: string): Promise<TaskExecutionResult[]> {
+export async function runTasks(tasksFile: string, config: RunnerConfig, runDir: string, options: { startIndex?: number } = {}): Promise<TaskExecutionResult[]> {
+  const startIndex = options.startIndex || 0;
+  
   // Ensure cursor-agent is installed
   ensureCursorAgent();
   
@@ -400,44 +433,113 @@ export async function runTasks(config: RunnerConfig, runDir: string): Promise<Ta
   logger.success('✓ Cursor authentication OK');
   
   const repoRoot = git.getRepoRoot();
-  const pipelineBranch = config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}`;
-  const worktreeDir = path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch);
   
-  logger.section('🚀 Starting Pipeline');
+  // Load existing state if resuming
+  const statePath = path.join(runDir, 'state.json');
+  let state: LaneState | null = null;
+  
+  if (startIndex > 0 && fs.existsSync(statePath)) {
+    state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  }
+  
+  const pipelineBranch = state?.pipelineBranch || config.pipelineBranch || `${config.branchPrefix || 'cursorflow/'}${Date.now().toString(36)}`;
+  const worktreeDir = state?.worktreeDir || path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees', pipelineBranch);
+  
+  if (startIndex === 0) {
+    logger.section('🚀 Starting Pipeline');
+  } else {
+    logger.section(`🔁 Resuming Pipeline from task ${startIndex + 1}`);
+  }
+  
   logger.info(`Pipeline Branch: ${pipelineBranch}`);
   logger.info(`Worktree: ${worktreeDir}`);
   logger.info(`Tasks: ${config.tasks.length}`);
   
-  // Create worktree
-  git.createWorktree(worktreeDir, pipelineBranch, {
-    baseBranch: config.baseBranch || 'main',
-    cwd: repoRoot,
-  });
+  // Create worktree only if starting fresh
+  if (startIndex === 0 || !fs.existsSync(worktreeDir)) {
+    git.createWorktree(worktreeDir, pipelineBranch, { 
+      baseBranch: config.baseBranch || 'main',
+      cwd: repoRoot,
+    });
+  }
   
   // Create chat
   logger.info('Creating chat session...');
   const chatId = cursorAgentCreateChat();
   
-  // Save initial state
-  const state: LaneState = {
-    status: 'running',
-    pipelineBranch,
-    worktreeDir,
-    totalTasks: config.tasks.length,
-    currentTaskIndex: 0,
-    label: pipelineBranch,
-    startTime: Date.now(),
-    endTime: null,
-    error: null,
-    dependencyRequest: null,
-  };
+  // Initialize state if not loaded
+  if (!state) {
+    state = {
+      status: 'running',
+      pipelineBranch,
+      worktreeDir,
+      totalTasks: config.tasks.length,
+      currentTaskIndex: 0,
+      label: pipelineBranch,
+      startTime: Date.now(),
+      endTime: null,
+      error: null,
+      dependencyRequest: null,
+      tasksFile, // Store tasks file for resume
+      dependsOn: config.dependsOn || [],
+    };
+  } else {
+    state.status = 'running';
+    state.error = null;
+    state.dependencyRequest = null;
+    state.dependsOn = config.dependsOn || [];
+  }
+  
+  saveState(statePath, state);
   
-  saveState(path.join(runDir, 'state.json'), state);
+  // Merge dependencies if any
+  if (startIndex === 0 && config.dependsOn && config.dependsOn.length > 0) {
+    logger.section('🔗 Merging Dependencies');
+    
+    // The runDir for the lane is passed in. Dependencies are in ../<depName> relative to this runDir
+    const lanesRoot = path.dirname(runDir);
+    
+    for (const depName of config.dependsOn) {
+      const depRunDir = path.join(lanesRoot, depName);
+      const depStatePath = path.join(depRunDir, 'state.json');
+      
+      if (!fs.existsSync(depStatePath)) {
+        logger.warn(`Dependency state not found for ${depName} at ${depStatePath}`);
+        continue;
+      }
+      
+      try {
+        const depState = JSON.parse(fs.readFileSync(depStatePath, 'utf8')) as LaneState;
+        if (depState.status !== 'completed') {
+          logger.warn(`Dependency ${depName} is in status ${depState.status}, merge might be incomplete`);
+        }
+        
+        if (depState.pipelineBranch) {
+          logger.info(`Merging dependency branch: ${depState.pipelineBranch} (${depName})`);
+          
+          // Fetch first to ensure we have the branch
+          git.runGit(['fetch', 'origin', depState.pipelineBranch], { cwd: worktreeDir, silent: true });
+          
+          // Merge
+          git.merge(depState.pipelineBranch, { 
+            cwd: worktreeDir, 
+            noFf: true, 
+            message: `chore: merge dependency ${depName} (${depState.pipelineBranch})` 
+          });
+        }
+      } catch (e) {
+        logger.error(`Failed to merge dependency ${depName}: ${e}`);
+      }
+    }
+    
+    // Push the merged state
+    git.push(pipelineBranch, { cwd: worktreeDir });
+  }
   
   // Run tasks
   const results: TaskExecutionResult[] = [];
   
-  for (let i = 0; i < config.tasks.length; i++) {
+  for (let i = startIndex; i < config.tasks.length; i++) {
     const task = config.tasks[i]!;
     const taskBranch = `${pipelineBranch}--${String(i + 1).padStart(2, '0')}-${task.name}`;
     
@@ -456,13 +558,13 @@ export async function runTasks(config: RunnerConfig, runDir: string): Promise<Ta
     
     // Update state
     state.currentTaskIndex = i + 1;
-    saveState(path.join(runDir, 'state.json'), state);
+    saveState(statePath, state);
     
     // Handle blocked or error
     if (result.status === 'BLOCKED_DEPENDENCY') {
-      state.status = 'failed'; // Or blocked if we had a blocked status in LaneState
+      state.status = 'failed';
       state.dependencyRequest = result.dependencyRequest || null;
-      saveState(path.join(runDir, 'state.json'), state);
+      saveState(statePath, state);
       logger.warn('Task blocked on dependency change');
       process.exit(2);
     }
@@ -470,7 +572,7 @@ export async function runTasks(config: RunnerConfig, runDir: string): Promise<Ta
     if (result.status !== 'FINISHED') {
       state.status = 'failed';
       state.error = result.error || 'Unknown error';
-      saveState(path.join(runDir, 'state.json'), state);
+      saveState(statePath, state);
       logger.error(`Task failed: ${result.error}`);
       process.exit(1);
     }
@@ -484,7 +586,7 @@ export async function runTasks(config: RunnerConfig, runDir: string): Promise<Ta
   // Complete
   state.status = 'completed';
   state.endTime = Date.now();
-  saveState(path.join(runDir, 'state.json'), state);
+  saveState(statePath, state);
   
   logger.success('All tasks completed!');
   return results;
@@ -503,9 +605,11 @@ if (require.main === module) {
   
   const tasksFile = args[0]!;
   const runDirIdx = args.indexOf('--run-dir');
+  const startIdxIdx = args.indexOf('--start-index');
   // const executorIdx = args.indexOf('--executor');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
+  const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
   // const executor = executorIdx >= 0 ? args[executorIdx + 1] : 'cursor-agent';
   
   if (!fs.existsSync(tasksFile)) {
@@ -529,7 +633,7 @@ if (require.main === module) {
   };
   
   // Run tasks
-  runTasks(config, runDir)
+  runTasks(tasksFile, config, runDir, { startIndex })
     .then(() => {
       process.exit(0);
     })