@litmers/cursorflow-orchestrator 0.1.8 → 0.1.12

package/src/cli/index.ts

@@ -7,58 +7,70 @@ import * as logger from '../utils/logger';
 // Command functions signature
 type CommandFn = (args: string[]) => Promise<void>;
 
-// Lazy load commands to speed up help/version output
+/**
+ * Command Registry
+ */
 const COMMANDS: Record<string, CommandFn> = {
   init: require('./init'),
+  prepare: require('./prepare'),
   run: require('./run'),
   monitor: require('./monitor'),
   clean: require('./clean'),
   resume: require('./resume'),
   doctor: require('./doctor'),
   signal: require('./signal'),
+  models: require('./models'),
+  setup: require('./setup-commands').main,
+  'setup-commands': require('./setup-commands').main,
 };
 
 function printHelp(): void {
   console.log(`
-CursorFlow - Git worktree-based parallel AI agent orchestration
+\x1b[1m\x1b[36mCursorFlow\x1b[0m - Git worktree-based parallel AI agent orchestration
 
-Usage: cursorflow <command> [options]
+\x1b[1mUSAGE\x1b[0m
+  $ \x1b[32mcursorflow\x1b[0m <command> [options]
 
-Commands:
-  init [options]              Initialize CursorFlow in project
-  run <tasks-dir> [options]   Run orchestration
-  monitor [run-dir] [options] Monitor lane execution
-  clean <type> [options]      Clean branches/worktrees/logs
-  resume <lane> [options]     Resume interrupted lane
-  doctor [options]            Check environment and preflight
-  signal <lane> <msg>         Directly intervene in a running lane
+\x1b[1mCOMMANDS\x1b[0m
+  \x1b[33minit\x1b[0m [options]              Initialize CursorFlow in project
+  \x1b[33mprepare\x1b[0m <feature> [opts]    Prepare task directory and JSON files
+  \x1b[33mrun\x1b[0m <tasks-dir> [options]   Run orchestration (DAG-based)
+  \x1b[33mmonitor\x1b[0m [run-dir] [options] \x1b[36mInteractive\x1b[0m lane dashboard
+  \x1b[33mclean\x1b[0m <type> [options]      Clean branches/worktrees/logs
+  \x1b[33mresume\x1b[0m <lane> [options]     Resume interrupted lane
+  \x1b[33mdoctor\x1b[0m [options]            Check environment and preflight
+  \x1b[33msignal\x1b[0m <lane> <msg>         Directly intervene in a running lane
+  \x1b[33mmodels\x1b[0m [options]            List available AI models
 
-Global Options:
+\x1b[1mGLOBAL OPTIONS\x1b[0m
   --config <path>             Config file path
   --help, -h                  Show help
   --version, -v               Show version
 
-Examples:
-  cursorflow init --example
-  cursorflow run _cursorflow/tasks/MyFeature/
-  cursorflow monitor --watch
-  cursorflow clean branches --all
-  cursorflow doctor
+\x1b[1mEXAMPLES\x1b[0m
+  $ \x1b[32mcursorflow init --example\x1b[0m
+  $ \x1b[32mcursorflow prepare NewFeature --lanes 3\x1b[0m
+  $ \x1b[32mcursorflow run _cursorflow/tasks/MyFeature/\x1b[0m
+  $ \x1b[32mcursorflow monitor latest\x1b[0m
+  $ \x1b[32mcursorflow models\x1b[0m
 
-Documentation:
+\x1b[1mDOCUMENTATION\x1b[0m
   https://github.com/eungjin-cigro/cursorflow#readme
   `);
 }
 
 function printVersion(): void {
   const pkg = require('../../package.json');
-  console.log(`CursorFlow v${pkg.version}`);
+  console.log(`\x1b[1m\x1b[36mCursorFlow\x1b[0m v${pkg.version}`);
 }
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
   
-  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  // Only show global help if no arguments provided or if first argument is help-related
+  const isGlobalHelp = args.length === 0 || args[0] === 'help' || (args.length === 1 && (args[0] === '--help' || args[0] === '-h'));
+  
+  if (isGlobalHelp) {
     printHelp();
     return;
   }

package/src/cli/init.ts

@@ -291,15 +291,17 @@ async function init(args: string[]): Promise<void> {
   logger.section('✅ CursorFlow initialized successfully!');
   
   console.log('\n📚 Next steps:\n');
-  console.log('  1. Review cursorflow.config.js');
-  console.log('  2. Type "/" in Cursor IDE to see available commands');
+  console.log('  1. Review \x1b[32mcursorflow.config.js\x1b[0m');
+  console.log('  2. Type \x1b[33m"/"\x1b[0m in Cursor IDE to see available commands');
   
   if (options.example) {
-    console.log(`  3. Run: cursorflow run ${config.tasksDir}/example/`);
+    console.log(`  3. Run: \x1b[32mcursorflow run ${config.tasksDir}/example/\x1b[0m`);
   } else {
-    console.log('  3. Create tasks with: cursorflow prepare MyFeature');
+    console.log('  3. Create your first task: \x1b[32mcursorflow prepare MyFeature\x1b[0m');
   }
   
+  console.log('\n💡 Tip: Use \x1b[33mcursorflow models\x1b[0m to see available AI models.');
+  
   console.log('\n📖 Documentation:');
   console.log('  https://github.com/eungjin-cigro/cursorflow#readme');
   console.log('');

package/src/cli/models.ts

@@ -0,0 +1,83 @@
+/**
+ * CursorFlow models command
+ * 
+ * List available models
+ */
+
+import * as logger from '../utils/logger';
+import { getAvailableModels } from '../utils/cursor-agent';
+
+/**
+ * Model details metadata
+ */
+const MODEL_METADATA: Record<string, { name: string; provider: string; description: string }> = {
+  'sonnet-4.5': { name: 'Claude 3.7 Sonnet', provider: 'Anthropic', description: 'General implementation, fast work (Most versatile)' },
+  'sonnet-4.5-thinking': { name: 'Claude 3.7 Sonnet (Thinking)', provider: 'Anthropic', description: 'Code review, deeper reasoning (Thinking model)' },
+  'opus-4.5': { name: 'Claude 4.0 Opus', provider: 'Anthropic', description: 'Complex tasks, high quality (Advanced)' },
+  'opus-4.5-thinking': { name: 'Claude 4.0 Opus (Thinking)', provider: 'Anthropic', description: 'Architecture design (Premium)' },
+  'gpt-5.2': { name: 'GPT-5.2', provider: 'OpenAI', description: 'General tasks' },
+  'gpt-5.2-high': { name: 'GPT-5.2 High Reasoning', provider: 'OpenAI', description: 'Advanced reasoning (High performance)' },
+  'gemini-3-flash': { name: 'Gemini 3 Flash', provider: 'Google', description: 'General tasks' },
+  'gemini-3-pro': { name: 'Gemini 3 Pro', provider: 'Google', description: 'Advanced reasoning (High performance)' }
+};
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow models [options]
+
+List available AI models for use in tasks.
+
+Options:
+  --list, -l         List models in a table (default)
+  --json             Output as JSON
+  --help, -h         Show help
+
+Examples:
+  cursorflow models
+  cursorflow models --json
+  `);
+}
+
+async function models(args: string[]): Promise<void> {
+  const isJson = args.includes('--json');
+  const isHelp = args.includes('--help') || args.includes('-h');
+
+  if (isHelp) {
+    printHelp();
+    return;
+  }
+
+  // Fetch available models from cursor-agent
+  const availableModelIds = getAvailableModels();
+  
+  const modelsData = availableModelIds.map(id => {
+    const meta = MODEL_METADATA[id] || { 
+      name: id, 
+      provider: 'Unknown', 
+      description: 'Discovered via cursor-agent' 
+    };
+    return { id, ...meta };
+  });
+
+  if (isJson) {
+    console.log(JSON.stringify(modelsData, null, 2));
+    return;
+  }
+
+  logger.section('🤖 Available AI Models (from cursor-agent)');
+  
+  const maxIdLen = Math.max(...modelsData.map(m => m.id.length), 10);
+  const maxNameLen = Math.max(...modelsData.map(m => m.name.length), 15);
+  const maxProviderLen = Math.max(...modelsData.map(m => m.provider.length), 10);
+
+  console.log(`  ${'ID'.padEnd(maxIdLen)}  ${'Name'.padEnd(maxNameLen)}  ${'Provider'.padEnd(maxProviderLen)}  Description`);
+  console.log(`  ${'─'.repeat(maxIdLen)}  ${'─'.repeat(maxNameLen)}  ${'─'.repeat(maxProviderLen)}  ${'─'.repeat(30)}`);
+
+  for (const m of modelsData) {
+    console.log(`  ${m.id.padEnd(maxIdLen)}  ${m.name.padEnd(maxNameLen)}  ${m.provider.padEnd(maxProviderLen)}  ${m.description}`);
+  }
+
+  console.log('\n💡 Tip: Use these IDs in your task JSON files under the "model" field.\n');
+}
+
+export = models;

package/src/cli/monitor.ts

@@ -19,6 +19,20 @@ interface LaneWithDeps {
 interface MonitorOptions {
   runDir?: string;
   interval: number;
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: cursorflow monitor [run-dir] [options]
+
+Interactive lane dashboard to track progress and dependencies.
+
+Options:
+  [run-dir]              Run directory to monitor (default: latest)
+  --interval <seconds>   Refresh interval (default: 2)
+  --help, -h             Show help
+  `);
 }
 
 enum View {
@@ -44,6 +58,7 @@ class InteractiveMonitor {
   private terminalScrollOffset: number = 0;
   private lastTerminalTotalLines: number = 0;
   private interventionInput: string = '';
+  private notification: { message: string; type: 'info' | 'error' | 'success'; time: number } | null = null;
 
   constructor(runDir: string, interval: number) {
     this.runDir = runDir;
@@ -155,6 +170,9 @@ class InteractiveMonitor {
         this.terminalScrollOffset = 0;
         this.render();
         break;
+      case 'k':
+        this.killLane();
+        break;
       case 'i':
         const lane = this.lanes.find(l => l.name === this.selectedLaneName);
         if (lane) {
@@ -304,10 +322,43 @@ class InteractiveMonitor {
     this.render();
   }
 
+  private killLane() {
+    if (!this.selectedLaneName) return;
+    const lane = this.lanes.find(l => l.name === this.selectedLaneName);
+    if (!lane) return;
+
+    const status = this.getLaneStatus(lane.path, lane.name);
+    if (status.pid && status.status === 'running') {
+      try {
+        process.kill(status.pid, 'SIGTERM');
+        this.showNotification(`Sent SIGTERM to PID ${status.pid}`, 'success');
+      } catch (e) {
+        this.showNotification(`Failed to kill PID ${status.pid}`, 'error');
+      }
+    } else {
+      this.showNotification(`No running process found for ${this.selectedLaneName}`, 'info');
+    }
+  }
+
+  private showNotification(message: string, type: 'info' | 'error' | 'success') {
+    this.notification = { message, type, time: Date.now() };
+    this.render();
+  }
+
   private render() {
     // Clear screen
     process.stdout.write('\x1Bc');
     
+    // Clear old notifications
+    if (this.notification && Date.now() - this.notification.time > 3000) {
+      this.notification = null;
+    }
+
+    if (this.notification) {
+      const color = this.notification.type === 'error' ? '\x1b[31m' : this.notification.type === 'success' ? '\x1b[32m' : '\x1b[36m';
+      console.log(`${color}🔔 ${this.notification.message}\x1b[0m\n`);
+    }
+    
     switch (this.view) {
       case View.LIST:
         this.renderList();
@@ -413,6 +464,7 @@ class InteractiveMonitor {
     console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
 
     process.stdout.write(`  Status:    ${this.getStatusIcon(status.status)} ${status.status}\n`);
+    process.stdout.write(`  PID:       ${status.pid || '-'}\n`);
     process.stdout.write(`  Progress:  ${status.progress} (${status.currentTask}/${status.totalTasks} tasks)\n`);
     process.stdout.write(`  Time:      ${this.formatDuration(status.duration)}\n`);
     process.stdout.write(`  Branch:    ${status.pipelineBranch}\n`);
@@ -429,7 +481,7 @@ class InteractiveMonitor {
 
     console.log('\n💬 Conversation History (Select to see full details):');
     console.log('─'.repeat(80));
-    process.stdout.write('  [↑/↓] Browse | [→/Enter] Full Msg | [I] Intervene | [T] Live Terminal | [Esc/←] Back\n\n');
+    process.stdout.write('  [↑/↓] Browse | [→/Enter] Full Msg | [I] Intervene | [K] Kill | [T] Live Terminal | [Esc/←] Back\n\n');
 
     if (this.currentLogs.length === 0) {
       console.log('  (No messages yet)');
@@ -670,6 +722,7 @@ class InteractiveMonitor {
       dependsOn,
       duration,
       error: state.error,
+      pid: state.pid
     };
   }
 
@@ -715,6 +768,12 @@ function findLatestRunDir(logsDir: string): string | null {
  * Monitor lanes
  */
 async function monitor(args: string[]): Promise<void> {
+  const help = args.includes('--help') || args.includes('-h');
+  if (help) {
+    printHelp();
+    return;
+  }
+
   const watchIdx = args.indexOf('--watch');
   const intervalIdx = args.indexOf('--interval');
   const interval = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1] || '2') || 2 : 2;