@litmers/cursorflow-orchestrator 0.1.3 → 0.1.6

package/src/cli/{monitor.js → monitor.ts}

@@ -1,18 +1,24 @@
-#!/usr/bin/env node
 /**
  * CursorFlow monitor command
  */
 
-const fs = require('fs');
-const path = require('path');
-const logger = require('../utils/logger');
-const { loadState } = require('../utils/state');
-const { loadConfig } = require('../utils/config');
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { loadState } from '../utils/state';
+import { LaneState } from '../utils/types';
+import { loadConfig } from '../utils/config';
 
-function parseArgs(args) {
+interface MonitorOptions {
+  runDir?: string;
+  watch: boolean;
+  interval: number;
+}
+
+function parseArgs(args: string[]): MonitorOptions {
   const watch = args.includes('--watch');
   const intervalIdx = args.indexOf('--interval');
-  const interval = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1]) || 2 : 2;
+  const interval = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1] || '2') || 2 : 2;
   
   // Find run directory (first non-option argument)
   const runDir = args.find(arg => !arg.startsWith('--') && args.indexOf(arg) !== intervalIdx + 1);
@@ -27,7 +33,7 @@ function parseArgs(args) {
 /**
  * Find the latest run directory
  */
-function findLatestRunDir(logsDir) {
+function findLatestRunDir(logsDir: string): string | null {
   const runsDir = path.join(logsDir, 'runs');
   
   if (!fs.existsSync(runsDir)) {
@@ -43,13 +49,13 @@ function findLatestRunDir(logsDir) {
     }))
     .sort((a, b) => b.mtime - a.mtime);
   
-  return runs.length > 0 ? runs[0].path : null;
+  return runs.length > 0 ? runs[0]!.path : null;
 }
 
 /**
  * List all lanes in a run directory
  */
-function listLanes(runDir) {
+function listLanes(runDir: string): { name: string; path: string }[] {
   const lanesDir = path.join(runDir, 'lanes');
   
   if (!fs.existsSync(lanesDir)) {
@@ -70,9 +76,16 @@ function listLanes(runDir) {
 /**
  * Get lane status
  */
-function getLaneStatus(lanePath) {
+function getLaneStatus(lanePath: string): { 
+  status: string; 
+  currentTask: number | string; 
+  totalTasks: number | string; 
+  progress: string; 
+  pipelineBranch?: string; 
+  chatId?: string; 
+} {
   const statePath = path.join(lanePath, 'state.json');
-  const state = loadState(statePath);
+  const state = loadState<LaneState & { chatId?: string }>(statePath);
   
   if (!state) {
     return {
@@ -89,7 +102,7 @@ function getLaneStatus(lanePath) {
   
   return {
     status: state.status || 'unknown',
-    currentTask: state.currentTaskIndex + 1,
+    currentTask: (state.currentTaskIndex || 0) + 1,
     totalTasks: state.totalTasks || '?',
     progress: `${progress}%`,
     pipelineBranch: state.pipelineBranch || '-',
@@ -97,10 +110,25 @@ function getLaneStatus(lanePath) {
   };
 }
 
+/**
+ * Get status icon
+ */
+function getStatusIcon(status: string): string {
+  const icons: Record<string, string> = {
+    'running': '🔄',
+    'completed': '✅',
+    'failed': '❌',
+    'blocked_dependency': '🚫',
+    'no state': '⚪',
+  };
+  
+  return icons[status] || '❓';
+}
+
 /**
  * Display lane status table
  */
-function displayStatus(runDir, lanes) {
+function displayStatus(runDir: string, lanes: { name: string; path: string }[]): void {
   console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log(`📊 Run: ${path.basename(runDir)}`);
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
@@ -131,25 +159,10 @@ function displayStatus(runDir, lanes) {
   console.log();
 }
 
-/**
- * Get status icon
- */
-function getStatusIcon(status) {
-  const icons = {
-    'running': '🔄',
-    'completed': '✅',
-    'failed': '❌',
-    'blocked_dependency': '🚫',
-    'no state': '⚪',
-  };
-  
-  return icons[status] || '❓';
-}
-
 /**
  * Monitor lanes
  */
-async function monitor(args) {
+async function monitor(args: string[]): Promise<void> {
   logger.section('📡 Monitoring Lane Execution');
   
   const options = parseArgs(args);
@@ -159,20 +172,18 @@ async function monitor(args) {
   let runDir = options.runDir;
   
   if (!runDir || runDir === 'latest') {
-    runDir = findLatestRunDir(config.logsDir);
+    runDir = findLatestRunDir(config.logsDir) || undefined;
     
     if (!runDir) {
-      logger.error('No run directories found');
-      logger.info(`Runs directory: ${path.join(config.logsDir, 'runs')}`);
-      process.exit(1);
+      logger.error(`Runs directory: ${path.join(config.logsDir, 'runs')}`);
+      throw new Error('No run directories found');
     }
     
     logger.info(`Using latest run: ${path.basename(runDir)}`);
   }
   
   if (!fs.existsSync(runDir)) {
-    logger.error(`Run directory not found: ${runDir}`);
-    process.exit(1);
+    throw new Error(`Run directory not found: ${runDir}`);
   }
   
   // Watch mode
@@ -187,8 +198,8 @@ async function monitor(args) {
         process.stdout.write('\x1Bc');
       }
       
-      const lanes = listLanes(runDir);
-      displayStatus(runDir, lanes);
+      const lanes = listLanes(runDir!);
+      displayStatus(runDir!, lanes);
       
       iteration++;
     };
@@ -200,10 +211,12 @@ async function monitor(args) {
     const intervalId = setInterval(refresh, options.interval * 1000);
     
     // Handle Ctrl+C
-    process.on('SIGINT', () => {
-      clearInterval(intervalId);
-      console.log('\n👋 Monitoring stopped\n');
-      process.exit(0);
+    return new Promise((_, reject) => {
+      process.on('SIGINT', () => {
+        clearInterval(intervalId);
+        console.log('\n👋 Monitoring stopped\n');
+        process.exit(0);
+      });
     });
     
   } else {
@@ -213,4 +226,4 @@ async function monitor(args) {
   }
 }
 
-module.exports = monitor;
+export = monitor;

package/src/cli/resume.ts

@@ -0,0 +1,119 @@
+/**
+ * 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 | null;
+  runDir: string | null;
+  clean: boolean;
+  restart: boolean;
+}
+
+function parseArgs(args: string[]): ResumeOptions {
+  const runDirIdx = args.indexOf('--run-dir');
+  
+  return {
+    lane: args.find(a => !a.startsWith('--')) || null,
+    runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
+    clean: args.includes('--clean'),
+    restart: args.includes('--restart'),
+  };
+}
+
+/**
+ * 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...`);
+  
+  const child = spawn('node', runnerArgs, {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  
+  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

@@ -0,0 +1,109 @@
+/**
+ * CursorFlow run command
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as logger from '../utils/logger';
+import { orchestrate } from '../core/orchestrator';
+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 {
+  const tasksDir = args.find(a => !a.startsWith('--'));
+  const executorIdx = args.indexOf('--executor');
+  
+  return {
+    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');
+  }
+  
+  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(tasksDir, {
+      executor: options.executor || config.executor,
+      pollInterval: config.pollInterval * 1000,
+      runDir: path.join(logsDir, 'runs', `run-${Date.now()}`),
+    });
+  } catch (error: any) {
+    // Re-throw to be handled by the main entry point
+    throw new Error(`Orchestration failed: ${error.message}`);
+  }
+}
+
+export = run;

package/src/cli/{setup-commands.js → setup-commands.ts}

@@ -1,17 +1,22 @@
-#!/usr/bin/env node
 /**
  * Setup Cursor commands
  * 
  * Installs CursorFlow commands to .cursor/commands/cursorflow/
  */
 
-const fs = require('fs');
-const path = require('path');
-const logger = require('../utils/logger');
-const { findProjectRoot } = require('../utils/config');
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { findProjectRoot } from '../utils/config';
 
-function parseArgs(args) {
-  const options = {
+interface SetupOptions {
+  force?: boolean;
+  uninstall?: boolean;
+  silent?: boolean;
+}
+
+function parseArgs(args: string[]): SetupOptions {
+  const options: SetupOptions = {
     force: false,
     uninstall: false,
     silent: false,
@@ -39,7 +44,7 @@ function parseArgs(args) {
   return options;
 }
 
-function printHelp() {
+function printHelp(): void {
   console.log(`
 Usage: cursorflow-setup [options]
 
@@ -58,12 +63,12 @@ Examples:
   `);
 }
 
-function getCommandsSourceDir() {
+function getCommandsSourceDir(): string {
   // Commands are in the package directory
   return path.join(__dirname, '..', '..', 'commands');
 }
 
-function setupCommands(options = {}) {
+export function setupCommands(options: SetupOptions = {}): { installed: number; backed: number; skipped: number } {
   const projectRoot = findProjectRoot();
   const targetDir = path.join(projectRoot, '.cursor', 'commands', 'cursorflow');
   const sourceDir = getCommandsSourceDir();
@@ -139,7 +144,7 @@ function setupCommands(options = {}) {
   return { installed, backed, skipped };
 }
 
-function uninstallCommands(options = {}) {
+export function uninstallCommands(options: SetupOptions = {}): { removed: number } {
   const projectRoot = findProjectRoot();
   const targetDir = path.join(projectRoot, '.cursor', 'commands', 'cursorflow');
   
@@ -178,7 +183,26 @@ function uninstallCommands(options = {}) {
   return { removed };
 }
 
-async function main(args) {
+/**
+ * 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);
   
   try {
@@ -187,7 +211,7 @@ async function main(args) {
     } else {
       return setupCommands(options);
     }
-  } catch (error) {
+  } catch (error: any) {
     if (!options.silent) {
       logger.error(error.message);
     }
@@ -198,13 +222,9 @@ async function main(args) {
 if (require.main === module) {
   main(process.argv.slice(2)).catch(error => {
     console.error('❌ Error:', error.message);
-    if (process.env.DEBUG) {
+    if (process.env['DEBUG']) {
       console.error(error.stack);
     }
     process.exit(1);
   });
 }
-
-module.exports = setupCommands;
-module.exports.setupCommands = setupCommands;
-module.exports.uninstallCommands = uninstallCommands;

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;
+