@litmers/cursorflow-orchestrator 0.1.2 → 0.1.5

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

@@ -1,11 +1,17 @@
-#!/usr/bin/env node
 /**
  * CursorFlow clean command (stub)
  */
 
-const logger = require('../utils/logger');
+import * as logger from '../utils/logger';
 
-function parseArgs(args) {
+interface CleanOptions {
+  type?: string;
+  pattern: string | null;
+  dryRun: boolean;
+  force: boolean;
+}
+
+function parseArgs(args: string[]): CleanOptions {
   return {
     type: args[0], // branches | worktrees | logs | all
     pattern: null,
@@ -14,7 +20,7 @@ function parseArgs(args) {
   };
 }
 
-async function clean(args) {
+async function clean(args: string[]): Promise<void> {
   logger.section('🧹 Cleaning CursorFlow Resources');
   
   const options = parseArgs(args);
@@ -27,4 +33,4 @@ async function clean(args) {
   logger.info('This will clean branches, worktrees, and logs');
 }
 
-module.exports = clean;
+export = clean;

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

@@ -1,11 +1,14 @@
-#!/usr/bin/env node
 /**
  * CursorFlow CLI - Main entry point
  */
 
-const logger = require('../utils/logger');
+import * as logger from '../utils/logger';
 
-const COMMANDS = {
+// Command functions signature
+type CommandFn = (args: string[]) => Promise<void>;
+
+// Lazy load commands to speed up help/version output
+const COMMANDS: Record<string, CommandFn> = {
   init: require('./init'),
   run: require('./run'),
   monitor: require('./monitor'),
@@ -13,7 +16,7 @@ const COMMANDS = {
   resume: require('./resume'),
 };
 
-function printHelp() {
+function printHelp(): void {
   console.log(`
 CursorFlow - Git worktree-based parallel AI agent orchestration
 
@@ -42,38 +45,40 @@ Documentation:
   `);
 }
 
-function printVersion() {
+function printVersion(): void {
   const pkg = require('../../package.json');
   console.log(`CursorFlow v${pkg.version}`);
 }
 
-async function main() {
+async function main(): Promise<void> {
   const args = process.argv.slice(2);
   
   if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
     printHelp();
-    process.exit(0);
+    return;
   }
   
   if (args.includes('--version') || args.includes('-v')) {
     printVersion();
-    process.exit(0);
+    return;
   }
   
-  const command = args[0];
+  const commandName = args[0]!;
   const commandArgs = args.slice(1);
   
-  if (!COMMANDS[command]) {
-    logger.error(`Unknown command: ${command}`);
+  const command = COMMANDS[commandName];
+  
+  if (!command) {
+    logger.error(`Unknown command: ${commandName}`);
     console.log('\nRun "cursorflow --help" for usage information.');
     process.exit(1);
   }
   
   try {
-    await COMMANDS[command](commandArgs);
-  } catch (error) {
+    await command(commandArgs);
+  } catch (error: any) {
     logger.error(error.message);
-    if (process.env.DEBUG) {
+    if (process.env['DEBUG']) {
       console.error(error.stack);
     }
     process.exit(1);
@@ -83,11 +88,12 @@ async function main() {
 if (require.main === module) {
   main().catch(error => {
     logger.error(`Fatal error: ${error.message}`);
-    if (process.env.DEBUG) {
+    if (process.env['DEBUG']) {
       console.error(error.stack);
     }
     process.exit(1);
   });
 }
 
-module.exports = main;
+export default main;
+export { main };

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

@@ -1,18 +1,25 @@
-#!/usr/bin/env node
 /**
  * CursorFlow init command
  * 
  * Initialize CursorFlow in a project
  */
 
-const fs = require('fs');
-const path = require('path');
-const logger = require('../utils/logger');
-const { findProjectRoot, createDefaultConfig } = require('../utils/config');
-const { setupCommands } = require('./setup-commands');
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { findProjectRoot, createDefaultConfig, CursorFlowConfig } from '../utils/config';
+import { setupCommands } from './setup-commands';
 
-function parseArgs(args) {
-  const options = {
+interface InitOptions {
+  example: boolean;
+  withCommands: boolean;
+  configOnly: boolean;
+  force: boolean;
+  gitignore: boolean;
+}
+
+function parseArgs(args: string[]): InitOptions {
+  const options: InitOptions = {
     example: false,
     withCommands: true,
     configOnly: false,
@@ -53,7 +60,7 @@ function parseArgs(args) {
   return options;
 }
 
-function printHelp() {
+function printHelp(): void {
   console.log(`
 Usage: cursorflow init [options]
 
@@ -76,7 +83,7 @@ Examples:
   `);
 }
 
-function createDirectories(projectRoot, config) {
+function createDirectories(projectRoot: string, config: CursorFlowConfig): void {
   const tasksDir = path.join(projectRoot, config.tasksDir);
   const logsDir = path.join(projectRoot, config.logsDir);
   
@@ -95,7 +102,7 @@ function createDirectories(projectRoot, config) {
   }
 }
 
-function createExampleTasks(projectRoot, config) {
+function createExampleTasks(projectRoot: string, config: CursorFlowConfig): void {
   const exampleDir = path.join(projectRoot, config.tasksDir, 'example');
   
   if (!fs.existsSync(exampleDir)) {
@@ -164,7 +171,7 @@ cursorflow run ${config.tasksDir}/example/
 /**
  * Add _cursorflow to .gitignore
  */
-function updateGitignore(projectRoot) {
+function updateGitignore(projectRoot: string): void {
   const gitignorePath = path.join(projectRoot, '.gitignore');
   const entry = '_cursorflow/';
   
@@ -209,7 +216,7 @@ function updateGitignore(projectRoot) {
   logger.success('Added _cursorflow/ to .gitignore');
 }
 
-async function init(args) {
+async function init(args: string[]): Promise<void> {
   logger.section('🚀 Initializing CursorFlow');
   
   const options = parseArgs(args);
@@ -228,7 +235,7 @@ async function init(args) {
     try {
       createDefaultConfig(projectRoot, options.force);
       logger.success(`Created config file: cursorflow.config.js`);
-    } catch (error) {
+    } catch (error: any) {
       if (error.message.includes('already exists') && !options.force) {
         logger.warn(error.message);
       } else {
@@ -237,7 +244,8 @@ async function init(args) {
     }
   }
   
-  const config = require(configPath);
+  // We need to require the config file after it might have been created
+  const config: CursorFlowConfig = require(configPath);
   
   if (options.configOnly) {
     logger.section('✅ Configuration initialized');
@@ -256,7 +264,7 @@ async function init(args) {
     logger.info('\n📝 Updating .gitignore...');
     try {
       updateGitignore(projectRoot);
-    } catch (error) {
+    } catch (error: any) {
       logger.warn(`Failed to update .gitignore: ${error.message}`);
       logger.info('You can manually add "_cursorflow/" to your .gitignore');
     }
@@ -267,7 +275,7 @@ async function init(args) {
     logger.info('\n📋 Installing Cursor commands...');
     try {
       await setupCommands({ force: options.force, silent: false });
-    } catch (error) {
+    } catch (error: any) {
       logger.warn(`Failed to install Cursor commands: ${error.message}`);
       logger.info('You can install them later with: npx cursorflow-setup');
     }
@@ -297,4 +305,4 @@ async function init(args) {
   console.log('');
 }
 
-module.exports = init;
+export = init;

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.js → resume.ts}

@@ -1,11 +1,17 @@
-#!/usr/bin/env node
 /**
  * CursorFlow resume command (stub)
  */
 
-const logger = require('../utils/logger');
+import * as logger from '../utils/logger';
 
-function parseArgs(args) {
+interface ResumeOptions {
+  lane?: string;
+  runDir: string | null;
+  clean: boolean;
+  restart: boolean;
+}
+
+function parseArgs(args: string[]): ResumeOptions {
   return {
     lane: args[0],
     runDir: null,
@@ -14,7 +20,7 @@ function parseArgs(args) {
   };
 }
 
-async function resume(args) {
+async function resume(args: string[]): Promise<void> {
   logger.section('🔁 Resuming Lane');
   
   const options = parseArgs(args);
@@ -28,4 +34,4 @@ async function resume(args) {
   logger.info('This will resume interrupted lanes');
 }
 
-module.exports = resume;
+export = resume;

package/src/cli/run.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 { loadConfig } from '../utils/config';
+
+interface RunOptions {
+  tasksDir?: string;
+  dryRun: boolean;
+  executor: string | null;
+}
+
+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,
+  };
+}
+
+async function run(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+  
+  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();
+  
+  try {
+    await orchestrate(options.tasksDir, {
+      executor: options.executor || config.executor,
+      pollInterval: config.pollInterval * 1000,
+      runDir: path.join(config.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,7 @@ function uninstallCommands(options = {}) {
   return { removed };
 }
 
-async function main(args) {
+async function main(args: string[]): Promise<any> {
   const options = parseArgs(args);
   
   try {
@@ -187,7 +192,7 @@ async function main(args) {
     } else {
       return setupCommands(options);
     }
-  } catch (error) {
+  } catch (error: any) {
     if (!options.silent) {
       logger.error(error.message);
     }
@@ -198,13 +203,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;