@litmers/cursorflow-orchestrator 0.1.9 → 0.1.12

package/src/cli/resume.ts

@@ -9,12 +9,31 @@ import * as logger from '../utils/logger';
 import { loadConfig, getLogsDir } from '../utils/config';
 import { loadState } from '../utils/state';
 import { LaneState } from '../utils/types';
+import { runDoctor } from '../utils/doctor';
 
 interface ResumeOptions {
   lane: string | null;
   runDir: string | null;
   clean: boolean;
   restart: boolean;
+  skipDoctor: boolean;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow resume <lane> [options]
+
+Resume an interrupted or failed lane.
+
+Options:
+  <lane>                 Lane name to resume
+  --run-dir <path>       Use a specific run directory (default: latest)
+  --clean                Clean up existing worktree before resuming
+  --restart              Restart from the first task (index 0)
+  --skip-doctor          Skip environment/branch checks (not recommended)
+  --help, -h             Show help
+  `);
 }
 
 function parseArgs(args: string[]): ResumeOptions {
@@ -25,6 +44,8 @@ function parseArgs(args: string[]): ResumeOptions {
     runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
     clean: args.includes('--clean'),
     restart: args.includes('--restart'),
+    skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
+    help: args.includes('--help') || args.includes('-h'),
   };
 }
 
@@ -45,6 +66,12 @@ function findLatestRunDir(logsDir: string): string | null {
 
 async function resume(args: string[]): Promise<void> {
   const options = parseArgs(args);
+  
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
   const config = loadConfig();
   const logsDir = getLogsDir(config);
   
@@ -77,6 +104,45 @@ async function resume(args: string[]): Promise<void> {
     throw new Error(`Original tasks file not found: ${state.tasksFile}. Resume impossible without task definition.`);
   }
   
+  // Run doctor check before resuming (check branches, etc.)
+  if (!options.skipDoctor) {
+    const tasksDir = path.dirname(state.tasksFile);
+    logger.info('Running pre-flight checks...');
+    
+    const report = runDoctor({
+      cwd: process.cwd(),
+      tasksDir,
+      includeCursorAgentChecks: false, // Skip agent checks for resume
+    });
+    
+    // Only show blocking errors for resume
+    const blockingIssues = report.issues.filter(i => 
+      i.severity === 'error' && 
+      (i.id.startsWith('branch.') || i.id.startsWith('git.'))
+    );
+    
+    if (blockingIssues.length > 0) {
+      logger.section('🛑 Pre-resume check found issues');
+      for (const issue of blockingIssues) {
+        logger.error(`${issue.title} (${issue.id})`, '❌');
+        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-resume checks failed. Use --skip-doctor to bypass (not recommended).');
+    }
+    
+    // Show warnings but don't block
+    const warnings = report.issues.filter(i => i.severity === 'warn' && i.id.startsWith('branch.'));
+    if (warnings.length > 0) {
+      logger.warn(`${warnings.length} warning(s) found. Run 'cursorflow doctor' for details.`);
+    }
+  }
+  
   logger.section(`🔁 Resuming Lane: ${options.lane}`);
   logger.info(`Run: ${path.basename(runDir)}`);
   logger.info(`Tasks: ${state.tasksFile}`);

package/src/cli/run.ts

@@ -7,31 +7,57 @@ 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 { runDoctor, getDoctorStatus } from '../utils/doctor';
 import { areCommandsInstalled, setupCommands } from './setup-commands';
 
 interface RunOptions {
   tasksDir?: string;
   dryRun: boolean;
   executor: string | null;
+  maxConcurrent: number | null;
   skipDoctor: boolean;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow run <tasks-dir> [options]
+
+Run task orchestration based on dependency graph.
+
+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)
+  --dry-run              Show execution plan without starting agents
+  --help, -h             Show help
+  `);
 }
 
 function parseArgs(args: string[]): RunOptions {
   const tasksDir = args.find(a => !a.startsWith('--'));
   const executorIdx = args.indexOf('--executor');
+  const maxConcurrentIdx = args.indexOf('--max-concurrent');
   
   return {
     tasksDir,
     dryRun: args.includes('--dry-run'),
     executor: executorIdx >= 0 ? args[executorIdx + 1] || null : null,
+    maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '0') || null : null,
     skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
+    help: args.includes('--help') || args.includes('-h'),
   };
 }
 
 async function run(args: string[]): Promise<void> {
   const options = parseArgs(args);
   
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
   // Auto-setup Cursor commands if missing or outdated
   if (!areCommandsInstalled()) {
     logger.info('Installing missing or outdated Cursor IDE commands...');
@@ -64,6 +90,14 @@ async function run(args: string[]): Promise<void> {
     throw new Error(`Tasks directory not found: ${tasksDir}`);
   }
 
+  // Check if doctor has been run at least once
+  const doctorStatus = getDoctorStatus(config.projectRoot);
+  if (!doctorStatus) {
+    logger.warn('It looks like you haven\'t run `cursorflow doctor` yet.');
+    logger.warn('Running doctor is highly recommended to catch environment issues early.');
+    console.log('   Run: cursorflow doctor\n');
+  }
+
   // Preflight checks (doctor)
   if (!options.skipDoctor) {
     const report = runDoctor({
@@ -99,7 +133,7 @@ async function run(args: string[]): Promise<void> {
       executor: options.executor || config.executor,
       pollInterval: config.pollInterval * 1000,
       runDir: path.join(logsDir, 'runs', `run-${Date.now()}`),
-      maxConcurrentLanes: config.maxConcurrentLanes,
+      maxConcurrentLanes: options.maxConcurrent || config.maxConcurrentLanes,
     });
   } catch (error: any) {
     // Re-throw to be handled by the main entry point

package/src/cli/signal.ts

@@ -14,6 +14,21 @@ interface SignalOptions {
   lane: string | null;
   message: string | null;
   runDir: string | null;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow signal <lane> "<message>" [options]
+
+Directly intervene in a running lane by sending a message to the agent.
+
+Options:
+  <lane>                 Lane name to signal
+  "<message>"            Message text to send
+  --run-dir <path>       Use a specific run directory (default: latest)
+  --help, -h             Show help
+  `);
 }
 
 function parseArgs(args: string[]): SignalOptions {
@@ -26,6 +41,7 @@ function parseArgs(args: string[]): SignalOptions {
     lane: nonOptions[0] || null,
     message: nonOptions.slice(1).join(' ') || null,
     runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
+    help: args.includes('--help') || args.includes('-h'),
   };
 }
 
@@ -43,6 +59,12 @@ function findLatestRunDir(logsDir: string): string | null {
 
 async function signal(args: string[]): Promise<void> {
   const options = parseArgs(args);
+  
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
   const config = loadConfig();
   const logsDir = getLogsDir(config);
   

package/src/utils/cursor-agent.ts

@@ -114,19 +114,35 @@ export function validateSetup(executor = 'cursor-agent'): { valid: boolean; erro
  * Get available models (if cursor-agent supports it)
  */
 export function getAvailableModels(): string[] {
+  // Known models in the current version of cursor-agent
+  const knownModels = [
+    'sonnet-4.5',
+    'sonnet-4.5-thinking',
+    'opus-4.5',
+    'opus-4.5-thinking',
+    'gpt-5.2',
+    'gpt-5.2-high',
+  ];
+
   try {
-    // This is a placeholder - actual implementation depends on cursor-agent API
-    // execSync('cursor-agent --model invalid "test"', {
-    //   encoding: 'utf8',
-    //   stdio: 'pipe',
-    // });
+    // Try to trigger a model list by using an invalid model with --print
+    // Some versions of cursor-agent output valid models when an invalid one is used.
+    const result = spawnSync('cursor-agent', ['--print', '--model', 'list-available-models', 'test'], {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 5000,
+    });
+    
+    const output = (result.stderr || result.stdout || '').toString();
+    const discoveredModels = parseModelsFromOutput(output);
     
-    return [];
+    if (discoveredModels.length > 0) {
+      return [...new Set([...knownModels, ...discoveredModels])];
+    }
+    
+    return knownModels;
   } catch (error: any) {
-    // Parse from error message
-    const output = (error.stderr || error.stdout || '').toString();
-    // Extract model names from output
-    return parseModelsFromOutput(output);
+    return knownModels;
   }
 }
 
@@ -175,6 +191,42 @@ export function testCursorAgent(): { success: boolean; output?: string; error?:
   }
 }
 
+/**
+ * Run interactive agent test to prime permissions (MCP, user approval, etc.)
+ */
+export function runInteractiveAgentTest(): boolean {
+  const { spawnSync } = require('child_process');
+  
+  console.log('\n' + '━'.repeat(60));
+  console.log('🤖 Interactive Agent Priming Test');
+  console.log('━'.repeat(60));
+  console.log('\nThis will start cursor-agent in interactive mode (NOT --print).');
+  console.log('Use this to approve MCP permissions or initial setup requests.\n');
+  console.log('MISSION: Just say hello and confirm MCP connectivity.');
+  console.log('ACTION: Once the agent responds and finishes, you can exit.');
+  console.log('\n' + '─'.repeat(60) + '\n');
+
+  try {
+    // Run WITHOUT --print to allow interactive user input and UI popups
+    const result = spawnSync('cursor-agent', ['Hello, verify MCP and system access.'], {
+      stdio: 'inherit', // Crucial for interactivity
+      env: process.env,
+    });
+
+    console.log('\n' + '─'.repeat(60));
+    if (result.status === 0) {
+      console.log('✅ Interactive test completed successfully!');
+      return true;
+    } else {
+      console.log('❌ Interactive test exited with code: ' + result.status);
+      return false;
+    }
+  } catch (error: any) {
+    console.log('❌ Failed to run interactive test: ' + error.message);
+    return false;
+  }
+}
+
 export interface AuthCheckResult {
   authenticated: boolean;
   message: string;