@litmers/cursorflow-orchestrator 0.1.20 → 0.1.28

package/src/cli/run.ts

@@ -10,6 +10,105 @@ import { getLogsDir, loadConfig } from '../utils/config';
 import { runDoctor, getDoctorStatus } from '../utils/doctor';
 import { areCommandsInstalled, setupCommands } from './setup-commands';
 import { safeJoin } from '../utils/path';
+import { loadState } from '../utils/state';
+import { LaneState } from '../types';
+
+interface IncompleteLaneInfo {
+  name: string;
+  status: string;
+  taskIndex: number;
+  totalTasks: number;
+  error?: string;
+}
+
+interface ExistingRunInfo {
+  runDir: string;
+  runId: string;
+  incompleteLanes: IncompleteLaneInfo[];
+  completedLanes: string[];
+  totalLanes: number;
+}
+
+/**
+ * Find existing run for a tasks directory
+ */
+function findExistingRunForTasks(logsDir: string, tasksDir: string): ExistingRunInfo | null {
+  const runsDir = safeJoin(logsDir, 'runs');
+  if (!fs.existsSync(runsDir)) return null;
+  
+  const runs = fs.readdirSync(runsDir)
+    .filter(d => d.startsWith('run-'))
+    .sort()
+    .reverse(); // Latest first
+  
+  for (const runId of runs) {
+    const runDir = safeJoin(runsDir, runId);
+    const lanesDir = safeJoin(runDir, 'lanes');
+    
+    if (!fs.existsSync(lanesDir)) continue;
+    
+    const laneDirs = fs.readdirSync(lanesDir)
+      .filter(f => fs.statSync(safeJoin(lanesDir, f)).isDirectory());
+    
+    if (laneDirs.length === 0) continue;
+    
+    // Check if any lane belongs to this tasks directory
+    let matchesTasksDir = false;
+    const incompleteLanes: IncompleteLaneInfo[] = [];
+    const completedLanes: string[] = [];
+    
+    for (const laneName of laneDirs) {
+      const statePath = safeJoin(lanesDir, laneName, 'state.json');
+      if (!fs.existsSync(statePath)) continue;
+      
+      const state = loadState<LaneState>(statePath);
+      if (!state) continue;
+      
+      // Check if this lane's tasks file is in the target tasks directory
+      if (state.tasksFile) {
+        const taskFileDir = path.dirname(state.tasksFile);
+        if (path.resolve(taskFileDir) === path.resolve(tasksDir)) {
+          matchesTasksDir = true;
+        }
+      }
+      
+      // Check completion status
+      if (state.status === 'completed') {
+        completedLanes.push(laneName);
+      } else {
+        // Check if process is alive (zombie detection)
+        let isZombie = false;
+        if (state.status === 'running' && state.pid) {
+          try {
+            process.kill(state.pid, 0);
+          } catch {
+            isZombie = true;
+          }
+        }
+        
+        incompleteLanes.push({
+          name: laneName,
+          status: isZombie ? 'zombie' : state.status,
+          taskIndex: state.currentTaskIndex,
+          totalTasks: state.totalTasks,
+          error: state.error || undefined,
+        });
+      }
+    }
+    
+    if (matchesTasksDir && incompleteLanes.length > 0) {
+      return {
+        runDir,
+        runId,
+        incompleteLanes,
+        completedLanes,
+        totalLanes: laneDirs.length,
+      };
+    }
+  }
+  
+  return null;
+}
 
 interface RunOptions {
   tasksDir?: string;
@@ -18,6 +117,7 @@ interface RunOptions {
   maxConcurrent: number | null;
   skipDoctor: boolean;
   noGit: boolean;
+  raw: boolean;
   help: boolean;
 }
 
@@ -27,12 +127,16 @@ Usage: cursorflow run <tasks-dir> [options]
 
 Run task orchestration based on dependency graph.
 
+If an existing run with incomplete lanes is found for the same tasks directory,
+it will automatically resume instead of starting a new run.
+
 Options:
   <tasks-dir>            Directory containing task JSON files
   --max-concurrent <num> Limit parallel agents (overrides config)
   --executor <type>      cursor-agent | cloud
   --skip-doctor          Skip environment checks (not recommended)
   --no-git               Disable Git operations (worktree, push, commit)
+  --raw                  Save raw logs (absolute raw, no processing)
   --dry-run              Show execution plan without starting agents
   --help, -h             Show help
 
@@ -54,6 +158,7 @@ function parseArgs(args: string[]): RunOptions {
     maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '0') || null : null,
     skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
     noGit: args.includes('--no-git'),
+    raw: args.includes('--raw'),
     help: args.includes('--help') || args.includes('-h'),
   };
 }
@@ -98,6 +203,49 @@ async function run(args: string[]): Promise<void> {
     throw new Error(`Tasks directory not found: ${tasksDir}`);
   }
 
+  // Check for existing incomplete run and auto-resume
+  const existingRun = findExistingRunForTasks(logsDir, tasksDir);
+  if (existingRun && existingRun.incompleteLanes.length > 0) {
+    logger.section('📋 Existing Run Detected');
+    logger.info(`Run: ${existingRun.runId}`);
+    logger.info(`Completed: ${existingRun.completedLanes.length}/${existingRun.totalLanes} lanes`);
+    
+    console.log('');
+    logger.info('Incomplete lanes:');
+    for (const lane of existingRun.incompleteLanes) {
+      const statusEmoji = lane.status === 'failed' ? '❌' : 
+                          lane.status === 'zombie' ? '🧟' :
+                          lane.status === 'running' ? '🔄' : '⏸';
+      logger.info(`  ${statusEmoji} ${lane.name}: ${lane.status} (${lane.taskIndex}/${lane.totalTasks})`);
+      if (lane.error) {
+        logger.warn(`     └─ ${lane.error.substring(0, 60)}${lane.error.length > 60 ? '...' : ''}`);
+      }
+    }
+    
+    console.log('');
+    logger.info('🔄 Auto-resuming from existing run...');
+    console.log('');
+    
+    // Call the resume command with --all flag
+    const resumeCmd = require('./resume');
+    const resumeArgs = [
+      '--all',
+      '--run-dir', existingRun.runDir,
+    ];
+    
+    if (options.skipDoctor) resumeArgs.push('--skip-doctor');
+    if (options.noGit) resumeArgs.push('--no-git');
+    if (options.executor) {
+      resumeArgs.push('--executor', options.executor);
+    }
+    if (options.maxConcurrent) {
+      resumeArgs.push('--max-concurrent', String(options.maxConcurrent));
+    }
+    
+    await resumeCmd(resumeArgs);
+    return;
+  }
+
   // Check if doctor has been run at least once
   const doctorStatus = getDoctorStatus(config.projectRoot);
   if (!doctorStatus) {
@@ -120,9 +268,9 @@ async function run(args: string[]): Promise<void> {
       for (const issue of report.issues) {
         const header = `${issue.title} (${issue.id})`;
         if (issue.severity === 'error') {
-          logger.error(header, '❌');
+          logger.error(header, { emoji: '❌' });
         } else {
-          logger.warn(header, '⚠️');
+          logger.warn(header, { emoji: '⚠️' });
         }
         console.log(`   ${issue.message}`);
         if (issue.details) console.log(`   Details: ${issue.details}`);
@@ -143,7 +291,10 @@ async function run(args: string[]): Promise<void> {
       runDir: path.join(logsDir, 'runs', `run-${Date.now()}`),
       maxConcurrentLanes: options.maxConcurrent || config.maxConcurrentLanes,
       webhooks: config.webhooks || [],
-      enhancedLogging: config.enhancedLogging,
+      enhancedLogging: {
+        ...config.enhancedLogging,
+        ...(options.raw ? { raw: true } : {}),
+      },
       noGit: options.noGit,
     });
   } catch (error: any) {

package/src/cli/runs.ts

@@ -0,0 +1,212 @@
+/**
+ * CursorFlow runs command - List and view run details
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { loadConfig, getLogsDir } from '../utils/config';
+import { RunService } from '../utils/run-service';
+import { RunStatus, RunInfo } from '../utils/types';
+import { safeJoin } from '../utils/path';
+
+interface RunsOptions {
+  status?: RunStatus;
+  json: boolean;
+  help: boolean;
+  runId?: string;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow runs [run-id] [options]
+
+List all runs or view details of a specific run.
+
+Options:
+  [run-id]               View details of a specific run
+  --running              Filter to show only running runs
+  --status <status>      Filter by status: running, completed, failed, partial, pending
+  --json                 Output in JSON format
+  --help, -h             Show help
+
+Examples:
+  cursorflow runs              # List all runs
+  cursorflow runs --running    # List only running runs
+  cursorflow runs run-123      # View details of run-123
+  `);
+}
+
+function parseArgs(args: string[]): RunsOptions {
+  const statusIdx = args.indexOf('--status');
+  const running = args.includes('--running');
+  
+  // Find run ID (first non-option argument)
+  const runId = args.find((arg, i) => {
+    if (arg.startsWith('--') || arg.startsWith('-')) return false;
+    // Skip values for options
+    const prevArg = args[i - 1];
+    if (prevArg && ['--status'].includes(prevArg)) {
+      return false;
+    }
+    return true;
+  });
+
+  return {
+    runId,
+    status: running ? 'running' : (statusIdx >= 0 ? args[statusIdx + 1] as RunStatus : undefined),
+    json: args.includes('--json'),
+    help: args.includes('--help') || args.includes('-h'),
+  };
+}
+
+/**
+ * Format duration in a human-readable way
+ */
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+
+/**
+ * Get status color and emoji
+ */
+function getStatusDisplay(status: RunStatus): string {
+  switch (status) {
+    case 'running':
+      return `${logger.COLORS.blue}🔄 running${logger.COLORS.reset}`;
+    case 'completed':
+      return `${logger.COLORS.green}✅ done   ${logger.COLORS.reset}`;
+    case 'failed':
+      return `${logger.COLORS.red}❌ failed ${logger.COLORS.reset}`;
+    case 'partial':
+      return `${logger.COLORS.yellow}⚠️ partial${logger.COLORS.reset}`;
+    case 'pending':
+      return `${logger.COLORS.gray}⏳ pending${logger.COLORS.reset}`;
+    default:
+      return status;
+  }
+}
+
+/**
+ * Display list of runs
+ */
+function displayRunList(runs: RunInfo[]): void {
+  if (runs.length === 0) {
+    console.log('No runs found.');
+    return;
+  }
+
+  console.log(`    Run ID              Task            Status     Lanes     Duration`);
+  console.log(`${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+
+  for (const run of runs) {
+    const isRunning = run.status === 'running';
+    const prefix = isRunning ? `${logger.COLORS.blue}  ▶${logger.COLORS.reset}` : '   ';
+    
+    const id = run.id.padEnd(20);
+    const task = (run.taskName || 'unnamed').substring(0, 15).padEnd(15);
+    const status = getStatusDisplay(run.status);
+    
+    const completedLanes = run.lanes.filter(l => l.status === 'completed').length;
+    const totalLanes = run.lanes.length;
+    const lanes = `${completedLanes}/${totalLanes}`.padEnd(10);
+    
+    const duration = formatDuration(run.duration);
+    
+    console.log(`${prefix} ${id} ${task} ${status} ${lanes} ${duration}`);
+  }
+}
+
+/**
+ * Display detailed information for a single run
+ */
+function displayRunDetail(run: RunInfo): void {
+  logger.section(`Run Details: ${run.id}`);
+  
+  console.log(`${logger.COLORS.bold}Task:${logger.COLORS.reset}      ${run.taskName}`);
+  console.log(`${logger.COLORS.bold}Status:${logger.COLORS.reset}    ${getStatusDisplay(run.status)}`);
+  console.log(`${logger.COLORS.bold}Start Time:${logger.COLORS.reset} ${new Date(run.startTime).toLocaleString()}`);
+  console.log(`${logger.COLORS.bold}Duration:${logger.COLORS.reset}   ${formatDuration(run.duration)}`);
+  console.log(`${logger.COLORS.bold}Path:${logger.COLORS.reset}       ${run.path}`);
+  
+  console.log(`\n${logger.COLORS.bold}Lanes:${logger.COLORS.reset}`);
+  for (const lane of run.lanes) {
+    const statusColor = lane.status === 'completed' ? logger.COLORS.green : 
+                       lane.status === 'failed' ? logger.COLORS.red : 
+                       lane.status === 'running' ? logger.COLORS.blue : logger.COLORS.reset;
+    
+    console.log(`  - ${lane.name.padEnd(20)} [${statusColor}${lane.status.toUpperCase()}${logger.COLORS.reset}] Task ${lane.currentTask}/${lane.totalTasks} (PID: ${lane.pid || 'N/A'})`);
+  }
+  
+  if (run.branches.length > 0) {
+    console.log(`\n${logger.COLORS.bold}Branches:${logger.COLORS.reset}`);
+    for (const branch of run.branches) {
+      console.log(`  - ${branch}`);
+    }
+  }
+  
+  if (run.worktrees.length > 0) {
+    console.log(`\n${logger.COLORS.bold}Worktrees:${logger.COLORS.reset}`);
+    for (const wt of run.worktrees) {
+      console.log(`  - ${wt}`);
+    }
+  }
+  
+  console.log(`\nView logs: ${logger.COLORS.cyan}cursorflow logs ${run.id} --all${logger.COLORS.reset}`);
+}
+
+async function runs(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+  
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  
+  const config = loadConfig();
+  const logsDir = getLogsDir(config);
+  const runsDir = safeJoin(logsDir, 'runs');
+  
+  if (!fs.existsSync(runsDir)) {
+    if (options.json) {
+      console.log('[]');
+    } else {
+      console.log('No runs found. (Runs directory does not exist)');
+    }
+    return;
+  }
+  
+  const runService = new RunService(runsDir);
+  
+  if (options.runId) {
+    const run = runService.getRunInfo(options.runId);
+    if (!run) {
+      throw new Error(`Run not found: ${options.runId}`);
+    }
+    
+    if (options.json) {
+      console.log(JSON.stringify(run, null, 2));
+    } else {
+      displayRunDetail(run);
+    }
+    return;
+  }
+  
+  const runsList = runService.listRuns({ status: options.status });
+  
+  if (options.json) {
+    console.log(JSON.stringify(runsList, null, 2));
+  } else {
+    displayRunList(runsList);
+  }
+}
+
+export = runs;

package/src/cli/signal.ts

@@ -112,7 +112,7 @@ async function signal(args: string[]): Promise<void> {
     fs.writeFileSync(interventionPath, options.message);
     
     // 2. Also append to conversation log for visibility and history
-    const entry = createConversationEntry('system', `[COMMANDER INTERVENTION]\n${options.message}`, {
+    const entry = createConversationEntry('intervention', `[HUMAN INTERVENTION]: ${options.message}`, {
       task: 'DIRECT_SIGNAL'
     });
     appendLog(convoPath, entry);

package/src/cli/stop.ts

@@ -0,0 +1,209 @@
+/**
+ * CursorFlow stop command - Stop running workflows or specific lanes
+ */
+
+import * as readline from 'readline';
+import * as logger from '../utils/logger';
+import { loadConfig, getLogsDir } from '../utils/config';
+import { RunService } from '../utils/run-service';
+import { ProcessManager } from '../utils/process-manager';
+import { safeJoin } from '../utils/path';
+
+interface StopOptions {
+  runId?: string;
+  lane?: string;
+  force: boolean;
+  yes: boolean;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow stop [run-id] [options]
+
+Stop running workflows or specific lanes.
+
+Options:
+  [run-id]               Stop a specific run
+  --lane <name>          Stop only a specific lane
+  --force                Use SIGKILL instead of SIGTERM
+  --yes, -y              Skip confirmation prompt
+  --help, -h             Show help
+
+Examples:
+  cursorflow stop              # Stop all running workflows
+  cursorflow stop run-123      # Stop run-123
+  cursorflow stop --lane api   # Stop only the 'api' lane in the latest run
+  cursorflow stop --force      # Force stop all workflows
+  `);
+}
+
+function parseArgs(args: string[]): StopOptions {
+  const laneIdx = args.indexOf('--lane');
+  
+  // Find run ID (first non-option argument)
+  const runId = args.find((arg, i) => {
+    if (arg.startsWith('--') || arg.startsWith('-')) return false;
+    // Skip values for options
+    const prevArg = args[i - 1];
+    if (prevArg && ['--lane'].includes(prevArg)) {
+      return false;
+    }
+    return true;
+  });
+
+  return {
+    runId,
+    lane: laneIdx >= 0 ? args[laneIdx + 1] : undefined,
+    force: args.includes('--force'),
+    yes: args.includes('--yes') || args.includes('-y'),
+    help: args.includes('--help') || args.includes('-h'),
+  };
+}
+
+/**
+ * Prompt user for confirmation
+ */
+async function confirm(message: string): Promise<boolean> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N]: `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+async function stop(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+  
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  
+  const config = loadConfig();
+  const logsDir = getLogsDir(config);
+  const runsDir = safeJoin(logsDir, 'runs');
+  const runService = new RunService(runsDir);
+  
+  const signal = options.force ? 'SIGKILL' : 'SIGTERM';
+  
+  // Case 1: Stop specific lane in specific run (or latest if runId not provided)
+  if (options.lane) {
+    let runId = options.runId;
+    if (!runId) {
+      const activeRuns = runService.getActiveRuns();
+      if (activeRuns.length === 0) {
+        logger.info('No active runs found.');
+        return;
+      }
+      runId = activeRuns[0]!.id;
+    }
+    
+    const run = runService.getRunInfo(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+    
+    const lane = run.lanes.find(l => l.name === options.lane);
+    if (!lane) {
+      throw new Error(`Lane '${options.lane}' not found in run '${runId}'`);
+    }
+    
+    if (!lane.pid) {
+      logger.info(`Lane '${options.lane}' is not currently running (no PID).`);
+      return;
+    }
+    
+    if (!options.yes) {
+      const ok = await confirm(`⚠️  Stop lane '${options.lane}' in run '${runId}'?`);
+      if (!ok) return;
+    }
+    
+    logger.info(`🛑 Stopping lane '${options.lane}' (PID ${lane.pid})...`);
+    if (ProcessManager.killProcess(lane.pid, signal)) {
+      logger.success(`✓ lane '${options.lane}' stopped.`);
+    } else {
+      logger.error(`Failed to stop lane '${options.lane}'.`);
+    }
+    return;
+  }
+  
+  // Case 2: Stop specific run
+  if (options.runId) {
+    const run = runService.getRunInfo(options.runId);
+    if (!run) {
+      throw new Error(`Run not found: ${options.runId}`);
+    }
+    
+    if (run.status !== 'running') {
+      logger.info(`Run '${options.runId}' is not currently running (Status: ${run.status}).`);
+      return;
+    }
+    
+    if (!options.yes) {
+      const ok = await confirm(`⚠️  Stop run '${options.runId}' (${run.taskName})?`);
+      if (!ok) return;
+    }
+    
+    logger.info(`🛑 Stopping run '${options.runId}'...`);
+    let stoppedCount = 0;
+    for (const lane of run.lanes) {
+      if (lane.pid && ProcessManager.killProcess(lane.pid, signal)) {
+        logger.info(`  ✓ lane '${lane.name}' (PID ${lane.pid}) stopped`);
+        stoppedCount++;
+      }
+    }
+    
+    if (stoppedCount > 0) {
+      logger.success(`✅ Run '${options.runId}' stopped.`);
+    } else {
+      logger.info('No active lanes were stopped.');
+    }
+    return;
+  }
+  
+  // Case 3: Stop all running workflows
+  const activeRuns = runService.getActiveRuns();
+  if (activeRuns.length === 0) {
+    logger.info('No active runs found.');
+    return;
+  }
+  
+  if (!options.yes) {
+    console.log('\n⚠️  Stop all running workflows?\n');
+    console.log('Currently running:');
+    for (const run of activeRuns) {
+      const activeLanes = run.lanes.filter(l => l.pid).length;
+      console.log(`  - ${run.id} (${run.taskName}): ${activeLanes} lanes active`);
+    }
+    console.log('');
+    
+    const ok = await confirm('Continue?');
+    if (!ok) return;
+  }
+  
+  logger.info('🛑 Stopping all workflows...');
+  let totalStopped = 0;
+  for (const run of activeRuns) {
+    for (const lane of run.lanes) {
+      if (lane.pid && ProcessManager.killProcess(lane.pid, signal)) {
+        logger.info(`  ✓ lane '${lane.name}' (PID ${lane.pid}) stopped`);
+        totalStopped++;
+      }
+    }
+  }
+  
+  if (totalStopped > 0) {
+    logger.success(`\n✅ All workflows stopped (${totalStopped} lanes).`);
+  } else {
+    logger.info('\nNo active lanes were stopped.');
+  }
+}
+
+export = stop;