@litmers/cursorflow-orchestrator 0.1.5 → 0.1.8

package/src/cli/resume.ts

@@ -1,37 +1,119 @@
 /**
- * CursorFlow resume command (stub)
+ * CursorFlow resume command
  */
 
+import * as path from 'path';
+import * as fs from 'fs';
+import { spawn } from 'child_process';
 import * as logger from '../utils/logger';
+import { loadConfig, getLogsDir } from '../utils/config';
+import { loadState } from '../utils/state';
+import { LaneState } from '../utils/types';
 
 interface ResumeOptions {
-  lane?: string;
+  lane: string | null;
   runDir: string | null;
   clean: boolean;
   restart: boolean;
 }
 
 function parseArgs(args: string[]): ResumeOptions {
+  const runDirIdx = args.indexOf('--run-dir');
+  
   return {
-    lane: args[0],
-    runDir: null,
+    lane: args.find(a => !a.startsWith('--')) || null,
+    runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
     clean: args.includes('--clean'),
     restart: args.includes('--restart'),
   };
 }
 
-async function resume(args: string[]): Promise<void> {
-  logger.section('🔁 Resuming Lane');
+/**
+ * Find the latest run directory
+ */
+function findLatestRunDir(logsDir: string): string | null {
+  const runsDir = path.join(logsDir, 'runs');
+  if (!fs.existsSync(runsDir)) return null;
   
+  const runs = fs.readdirSync(runsDir)
+    .filter(d => d.startsWith('run-'))
+    .sort()
+    .reverse();
+    
+  return runs.length > 0 ? path.join(runsDir, runs[0]!) : null;
+}
+
+async function resume(args: string[]): Promise<void> {
   const options = parseArgs(args);
+  const config = loadConfig();
+  const logsDir = getLogsDir(config);
+  
+  if (!options.lane) {
+    throw new Error('Lane name required (e.g., cursorflow resume lane-1)');
+  }
+  
+  let runDir = options.runDir;
+  if (!runDir) {
+    runDir = findLatestRunDir(logsDir);
+  }
+  
+  if (!runDir || !fs.existsSync(runDir)) {
+    throw new Error(`Run directory not found: ${runDir || 'latest'}`);
+  }
+  
+  const laneDir = path.join(runDir, 'lanes', options.lane);
+  const statePath = path.join(laneDir, 'state.json');
+  
+  if (!fs.existsSync(statePath)) {
+    throw new Error(`Lane state not found at ${statePath}. Is the lane name correct?`);
+  }
+  
+  const state = loadState<LaneState>(statePath);
+  if (!state) {
+    throw new Error(`Failed to load state from ${statePath}`);
+  }
+  
+  if (!state.tasksFile || !fs.existsSync(state.tasksFile)) {
+    throw new Error(`Original tasks file not found: ${state.tasksFile}. Resume impossible without task definition.`);
+  }
+  
+  logger.section(`🔁 Resuming Lane: ${options.lane}`);
+  logger.info(`Run: ${path.basename(runDir)}`);
+  logger.info(`Tasks: ${state.tasksFile}`);
+  logger.info(`Starting from task index: ${options.restart ? 0 : state.currentTaskIndex}`);
+  
+  const runnerPath = require.resolve('../core/runner');
+  const runnerArgs = [
+    runnerPath,
+    state.tasksFile,
+    '--run-dir', laneDir,
+    '--start-index', options.restart ? '0' : String(state.currentTaskIndex),
+  ];
+  
+  logger.info(`Spawning runner process...`);
   
-  logger.info('This command will be fully implemented in the next phase');
-  logger.info(`Lane: ${options.lane}`);
-  logger.info(`Clean: ${options.clean}`);
-  logger.info(`Restart: ${options.restart}`);
+  const child = spawn('node', runnerArgs, {
+    stdio: 'inherit',
+    env: process.env,
+  });
   
-  logger.warn('\n⚠️  Implementation pending');
-  logger.info('This will resume interrupted lanes');
+  return new Promise((resolve, reject) => {
+    child.on('exit', (code) => {
+      if (code === 0) {
+        logger.success(`Lane ${options.lane} completed successfully`);
+        resolve();
+      } else if (code === 2) {
+        logger.warn(`Lane ${options.lane} blocked on dependency change`);
+        resolve();
+      } else {
+        reject(new Error(`Lane ${options.lane} failed with exit code ${code}`));
+      }
+    });
+    
+    child.on('error', (error) => {
+      reject(new Error(`Failed to start runner: ${error.message}`));
+    });
+  });
 }
 
 export = resume;

package/src/cli/run.ts

@@ -6,12 +6,15 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as logger from '../utils/logger';
 import { orchestrate } from '../core/orchestrator';
-import { loadConfig } from '../utils/config';
+import { getLogsDir, loadConfig } from '../utils/config';
+import { runDoctor } from '../utils/doctor';
+import { areCommandsInstalled, setupCommands } from './setup-commands';
 
 interface RunOptions {
   tasksDir?: string;
   dryRun: boolean;
   executor: string | null;
+  skipDoctor: boolean;
 }
 
 function parseArgs(args: string[]): RunOptions {
@@ -22,28 +25,81 @@ function parseArgs(args: string[]): RunOptions {
     tasksDir,
     dryRun: args.includes('--dry-run'),
     executor: executorIdx >= 0 ? args[executorIdx + 1] || null : null,
+    skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
   };
 }
 
 async function run(args: string[]): Promise<void> {
   const options = parseArgs(args);
   
+  // Auto-setup Cursor commands if missing or outdated
+  if (!areCommandsInstalled()) {
+    logger.info('Installing missing or outdated Cursor IDE commands...');
+    try {
+      setupCommands({ silent: true });
+    } catch (e) {
+      // Non-blocking
+    }
+  }
+
   if (!options.tasksDir) {
     console.log('\nUsage: cursorflow run <tasks-dir> [options]');
     throw new Error('Tasks directory required');
   }
   
-  if (!fs.existsSync(options.tasksDir)) {
-    throw new Error(`Tasks directory not found: ${options.tasksDir}`);
-  }
-  
   const config = loadConfig();
+  const logsDir = getLogsDir(config);
+
+  // Resolve tasks dir:
+  // - Prefer the exact path if it exists relative to cwd
+  // - Otherwise, fall back to projectRoot-relative path for better ergonomics
+  const tasksDir =
+    path.isAbsolute(options.tasksDir)
+      ? options.tasksDir
+      : (fs.existsSync(options.tasksDir)
+        ? path.resolve(process.cwd(), options.tasksDir)
+        : path.join(config.projectRoot, options.tasksDir));
+
+  if (!fs.existsSync(tasksDir)) {
+    throw new Error(`Tasks directory not found: ${tasksDir}`);
+  }
+
+  // Preflight checks (doctor)
+  if (!options.skipDoctor) {
+    const report = runDoctor({
+      cwd: process.cwd(),
+      tasksDir,
+      executor: options.executor || config.executor,
+      includeCursorAgentChecks: true,
+    });
+
+    if (!report.ok) {
+      logger.section('🛑 Pre-flight check failed');
+      for (const issue of report.issues) {
+        const header = `${issue.title} (${issue.id})`;
+        if (issue.severity === 'error') {
+          logger.error(header, '❌');
+        } else {
+          logger.warn(header, '⚠️');
+        }
+        console.log(`   ${issue.message}`);
+        if (issue.details) console.log(`   Details: ${issue.details}`);
+        if (issue.fixes?.length) {
+          console.log('   Fix:');
+          for (const fix of issue.fixes) console.log(`     - ${fix}`);
+        }
+        console.log('');
+      }
+      throw new Error('Pre-flight checks failed. Run `cursorflow doctor` for details.');
+    }
+  }
   
   try {
-    await orchestrate(options.tasksDir, {
+    await orchestrate(tasksDir, {
       executor: options.executor || config.executor,
       pollInterval: config.pollInterval * 1000,
-      runDir: path.join(config.logsDir, 'runs', `run-${Date.now()}`),
+      runDir: path.join(logsDir, 'runs', `run-${Date.now()}`),
+      maxConcurrentLanes: config.maxConcurrentLanes,
     });
   } catch (error: any) {
     // Re-throw to be handled by the main entry point

package/src/cli/setup-commands.ts

@@ -183,6 +183,25 @@ export function uninstallCommands(options: SetupOptions = {}): { removed: number
   return { removed };
 }
 
+/**
+ * Check if commands are already installed
+ */
+export function areCommandsInstalled(): boolean {
+  const projectRoot = findProjectRoot();
+  const targetDir = path.join(projectRoot, '.cursor', 'commands', 'cursorflow');
+  const sourceDir = getCommandsSourceDir();
+  
+  if (!fs.existsSync(targetDir) || !fs.existsSync(sourceDir)) {
+    return false;
+  }
+  
+  const sourceFiles = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+  const targetFiles = fs.readdirSync(targetDir).filter(f => f.endsWith('.md'));
+  
+  // Basic check: do we have all the files from source in target?
+  return sourceFiles.every(f => targetFiles.includes(f));
+}
+
 async function main(args: string[]): Promise<any> {
   const options = parseArgs(args);
   

package/src/cli/signal.ts

@@ -0,0 +1,89 @@
+/**
+ * CursorFlow signal command
+ * 
+ * Send a direct message to a running lane
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as logger from '../utils/logger';
+import { loadConfig, getLogsDir } from '../utils/config';
+import { appendLog, createConversationEntry } from '../utils/state';
+
+interface SignalOptions {
+  lane: string | null;
+  message: string | null;
+  runDir: string | null;
+}
+
+function parseArgs(args: string[]): SignalOptions {
+  const runDirIdx = args.indexOf('--run-dir');
+  
+  // First non-option is lane, second (or rest joined) is message
+  const nonOptions = args.filter(a => !a.startsWith('--'));
+  
+  return {
+    lane: nonOptions[0] || null,
+    message: nonOptions.slice(1).join(' ') || null,
+    runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
+  };
+}
+
+function findLatestRunDir(logsDir: string): string | null {
+  const runsDir = path.join(logsDir, 'runs');
+  if (!fs.existsSync(runsDir)) return null;
+  
+  const runs = fs.readdirSync(runsDir)
+    .filter(d => d.startsWith('run-'))
+    .sort()
+    .reverse();
+    
+  return runs.length > 0 ? path.join(runsDir, runs[0]!) : null;
+}
+
+async function signal(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+  const config = loadConfig();
+  const logsDir = getLogsDir(config);
+  
+  if (!options.lane) {
+    throw new Error('Lane name required: cursorflow signal <lane> "<message>"');
+  }
+  
+  if (!options.message) {
+    throw new Error('Message required: cursorflow signal <lane> "<message>"');
+  }
+  
+  let runDir = options.runDir;
+  if (!runDir) {
+    runDir = findLatestRunDir(logsDir);
+  }
+  
+  if (!runDir || !fs.existsSync(runDir)) {
+    throw new Error(`Run directory not found: ${runDir || 'latest'}`);
+  }
+  
+  const convoPath = path.join(runDir, 'lanes', options.lane, 'conversation.jsonl');
+  
+  if (!fs.existsSync(convoPath)) {
+    throw new Error(`Conversation log not found at ${convoPath}. Is the lane running?`);
+  }
+  
+  logger.info(`Sending signal to lane: ${options.lane}`);
+  logger.info(`Message: "${options.message}"`);
+  
+  // Append as a "commander" role message
+  // Note: We cast to 'system' or similar if 'commander' isn't in the enum, 
+  // but let's use 'reviewer' or 'system' which agents usually respect, 
+  // or update the type definition.
+  const entry = createConversationEntry('system', `[COMMANDER INTERVENTION]\n${options.message}`, {
+    task: 'DIRECT_SIGNAL'
+  });
+  
+  appendLog(convoPath, entry);
+  
+  logger.success('Signal sent successfully. The agent will see this message in its next turn or via file monitoring.');
+}
+
+export = signal;
+

package/src/core/orchestrator.ts

@@ -10,11 +10,12 @@ import { spawn, ChildProcess } from 'child_process';
 
 import * as logger from '../utils/logger';
 import { loadState } from '../utils/state';
-import { LaneState } from '../utils/types';
+import { LaneState, RunnerConfig } from '../utils/types';
 
 export interface LaneInfo {
   name: string;
   path: string;
+  dependsOn: string[];
 }
 
 export interface SpawnLaneResult {
@@ -76,7 +77,7 @@ export function waitChild(proc: ChildProcess): Promise<number> {
 }
 
 /**
- * List lane task files in directory
+ * List lane task files in directory and load their configs for dependencies
  */
 export function listLaneFiles(tasksDir: string): LaneInfo[] {
   if (!fs.existsSync(tasksDir)) {
@@ -87,10 +88,24 @@ export function listLaneFiles(tasksDir: string): LaneInfo[] {
   return files
     .filter(f => f.endsWith('.json'))
     .sort()
-    .map(f => ({
-      name: path.basename(f, '.json'),
-      path: path.join(tasksDir, f),
-    }));
+    .map(f => {
+      const filePath = path.join(tasksDir, f);
+      const name = path.basename(f, '.json');
+      let dependsOn: string[] = [];
+      
+      try {
+        const config = JSON.parse(fs.readFileSync(filePath, 'utf8')) as RunnerConfig;
+        dependsOn = config.dependsOn || [];
+      } catch (e) {
+        logger.warn(`Failed to parse config for lane ${name}: ${e}`);
+      }
+      
+      return {
+        name,
+        path: filePath,
+        dependsOn,
+      };
+    });
 }
 
 /**
@@ -105,7 +120,8 @@ export function printLaneStatus(lanes: LaneInfo[], laneRunDirs: Record<string, s
     const state = loadState<LaneState>(statePath);
     
     if (!state) {
-      return { lane: lane.name, status: '(no state)', task: '-' };
+      const isWaiting = lane.dependsOn.length > 0;
+      return { lane: lane.name, status: isWaiting ? 'waiting' : 'pending', task: '-' };
     }
     
     const idx = (state.currentTaskIndex || 0) + 1;
@@ -123,12 +139,13 @@ export function printLaneStatus(lanes: LaneInfo[], laneRunDirs: Record<string, s
 }
 
 /**
- * Run orchestration
+ * Run orchestration with dependency management
  */
 export async function orchestrate(tasksDir: string, options: { 
   runDir?: string; 
   executor?: string; 
   pollInterval?: number; 
+  maxConcurrentLanes?: number;
 } = {}): Promise<{ lanes: LaneInfo[]; exitCodes: Record<string, number>; runRoot: string }> {
   const lanes = listLaneFiles(tasksDir);
   
@@ -142,6 +159,7 @@ export async function orchestrate(tasksDir: string, options: {
   const laneRunDirs: Record<string, string> = {};
   for (const lane of lanes) {
     laneRunDirs[lane.name] = path.join(runRoot, 'lanes', lane.name);
+    fs.mkdirSync(laneRunDirs[lane.name], { recursive: true });
   }
   
   logger.section('🧭 Starting Orchestration');
@@ -149,31 +167,88 @@ export async function orchestrate(tasksDir: string, options: {
   logger.info(`Run directory: ${runRoot}`);
   logger.info(`Lanes: ${lanes.length}`);
   
-  // Spawn all lanes
-  const running: { lane: string; child: ChildProcess; logPath: string }[] = [];
-  
-  for (const lane of lanes) {
-    const { child, logPath } = spawnLane({
-      laneName: lane.name,
-      tasksFile: lane.path,
-      laneRunDir: laneRunDirs[lane.name]!,
-      executor: options.executor || 'cursor-agent',
-    });
-    
-    running.push({ lane: lane.name, child, logPath });
-    logger.info(`Lane started: ${lane.name}`);
-  }
+  const maxConcurrent = options.maxConcurrentLanes || 10;
+  const running: Map<string, { child: ChildProcess; logPath: string }> = new Map();
+  const exitCodes: Record<string, number> = {};
+  const completedLanes = new Set<string>();
+  const failedLanes = new Set<string>();
   
   // Monitor lanes
   const monitorInterval = setInterval(() => {
     printLaneStatus(lanes, laneRunDirs);
   }, options.pollInterval || 60000);
   
-  // Wait for all lanes
-  const exitCodes: Record<string, number> = {};
-  
-  for (const r of running) {
-    exitCodes[r.lane] = await waitChild(r.child);
+  while (completedLanes.size + failedLanes.size < lanes.length) {
+    // 1. Identify lanes ready to start
+    const readyToStart = lanes.filter(lane => {
+      // Not already running or completed
+      if (running.has(lane.name) || completedLanes.has(lane.name) || failedLanes.has(lane.name)) {
+        return false;
+      }
+      
+      // Check dependencies
+      for (const dep of lane.dependsOn) {
+        if (failedLanes.has(dep)) {
+          // If a dependency failed, this lane fails too
+          logger.error(`Lane ${lane.name} failed because dependency ${dep} failed`);
+          failedLanes.add(lane.name);
+          exitCodes[lane.name] = 1;
+          return false;
+        }
+        if (!completedLanes.has(dep)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    
+    // 2. Spawn ready lanes up to maxConcurrent
+    for (const lane of readyToStart) {
+      if (running.size >= maxConcurrent) break;
+      
+      logger.info(`Lane started: ${lane.name}`);
+      const spawnResult = spawnLane({
+        laneName: lane.name,
+        tasksFile: lane.path,
+        laneRunDir: laneRunDirs[lane.name]!,
+        executor: options.executor || 'cursor-agent',
+      });
+      
+      running.set(lane.name, spawnResult);
+    }
+    
+    // 3. Wait for any running lane to finish
+    if (running.size > 0) {
+      // We need to wait for at least one to finish
+      const promises = Array.from(running.entries()).map(async ([name, { child }]) => {
+        const code = await waitChild(child);
+        return { name, code };
+      });
+      
+      const finished = await Promise.race(promises);
+      
+      running.delete(finished.name);
+      exitCodes[finished.name] = finished.code;
+      
+      if (finished.code === 0 || finished.code === 2) {
+        completedLanes.add(finished.name);
+      } else {
+        failedLanes.add(finished.name);
+      }
+      
+      printLaneStatus(lanes, laneRunDirs);
+    } else {
+      // Nothing running and nothing ready (but not all finished)
+      // This could happen if there's a circular dependency or some logic error
+      if (readyToStart.length === 0 && completedLanes.size + failedLanes.size < lanes.length) {
+        const remaining = lanes.filter(l => !completedLanes.has(l.name) && !failedLanes.has(l.name));
+        logger.error(`Deadlock detected! Remaining lanes cannot start: ${remaining.map(l => l.name).join(', ')}`);
+        for (const l of remaining) {
+          failedLanes.add(l.name);
+          exitCodes[l.name] = 1;
+        }
+      }
+    }
   }
   
   clearInterval(monitorInterval);