@litmers/cursorflow-orchestrator 0.1.6 → 0.1.9

package/scripts/patches/test-cursor-agent.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+/**
+ * Direct cursor-agent spawn test script
+ * 
+ * This script tests cursor-agent directly to compare behavior with CursorFlow.
+ * It helps identify if the issue is in how CursorFlow spawns the agent.
+ * 
+ * Usage:
+ *   node scripts/patches/test-cursor-agent.js [--stdio-mode <mode>]
+ * 
+ * Modes:
+ *   - pipe: Full pipe mode (default, same as CursorFlow)
+ *   - inherit-stdin: Inherit stdin, pipe stdout/stderr
+ *   - inherit-all: Inherit all (like running directly in terminal)
+ */
+
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+
+// Parse args
+const args = process.argv.slice(2);
+const stdioModeIdx = args.indexOf('--stdio-mode');
+const stdioMode = stdioModeIdx >= 0 ? args[stdioModeIdx + 1] : 'pipe';
+
+console.log('='.repeat(60));
+console.log('cursor-agent Direct Spawn Test');
+console.log('='.repeat(60));
+console.log(`stdio mode: ${stdioMode}`);
+console.log('');
+
+// Step 1: Check cursor-agent is available
+console.log('1. Checking cursor-agent availability...');
+const whichResult = spawnSync('which', ['cursor-agent']);
+if (whichResult.status !== 0) {
+  console.error('   ❌ cursor-agent not found in PATH');
+  process.exit(1);
+}
+console.log(`   ✓ Found at: ${whichResult.stdout.toString().trim()}`);
+
+// Step 2: Create a chat session
+console.log('\n2. Creating chat session...');
+const createChatResult = spawnSync('cursor-agent', ['create-chat'], {
+  encoding: 'utf8',
+  stdio: 'pipe',
+  timeout: 30000,
+});
+
+if (createChatResult.status !== 0) {
+  console.error('   ❌ Failed to create chat:');
+  console.error(createChatResult.stderr || createChatResult.stdout);
+  process.exit(1);
+}
+
+const chatIdLines = createChatResult.stdout.trim().split('\n');
+const chatId = chatIdLines[chatIdLines.length - 1];
+console.log(`   ✓ Chat ID: ${chatId}`);
+
+// Step 3: Configure stdio based on mode
+let stdioConfig;
+switch (stdioMode) {
+  case 'inherit-stdin':
+    stdioConfig = ['inherit', 'pipe', 'pipe'];
+    break;
+  case 'inherit-all':
+    stdioConfig = 'inherit';
+    break;
+  case 'ignore-stdin':
+    stdioConfig = ['ignore', 'pipe', 'pipe'];
+    break;
+  case 'pipe':
+  default:
+    stdioConfig = ['pipe', 'pipe', 'pipe'];
+    break;
+}
+
+console.log(`\n3. Testing with stdio: ${JSON.stringify(stdioConfig)}`);
+
+// Step 4: Send a simple prompt
+const testPrompt = 'Just respond with: Hello World. Nothing else.';
+const workspace = process.cwd();
+
+const agentArgs = [
+  '--print',
+  '--output-format', 'json',
+  '--workspace', workspace,
+  '--model', 'gemini-3-flash',
+  '--resume', chatId,
+  testPrompt,
+];
+
+console.log(`   Workspace: ${workspace}`);
+console.log(`   Prompt: "${testPrompt}"`);
+console.log('');
+console.log('4. Spawning cursor-agent...');
+console.log(`   Command: cursor-agent ${agentArgs.join(' ').substring(0, 80)}...`);
+console.log('');
+
+const startTime = Date.now();
+
+const child = spawn('cursor-agent', agentArgs, {
+  stdio: stdioConfig,
+  env: {
+    ...process.env,
+    // Disable Python buffering if cursor-agent uses Python
+    PYTHONUNBUFFERED: '1',
+    // Disable Node.js experimental warnings
+    NODE_OPTIONS: '',
+  },
+});
+
+let fullStdout = '';
+let fullStderr = '';
+let gotData = false;
+
+// Track first byte time
+let firstByteTime = null;
+
+if (child.stdout) {
+  child.stdout.on('data', (data) => {
+    if (!firstByteTime) {
+      firstByteTime = Date.now();
+      console.log(`   [+${((firstByteTime - startTime) / 1000).toFixed(2)}s] First stdout byte received`);
+    }
+    gotData = true;
+    const str = data.toString();
+    fullStdout += str;
+    process.stdout.write(`   [stdout] ${str}`);
+  });
+}
+
+if (child.stderr) {
+  child.stderr.on('data', (data) => {
+    const str = data.toString();
+    fullStderr += str;
+    process.stderr.write(`   [stderr] ${str}`);
+  });
+}
+
+// Set timeout
+const timeout = setTimeout(() => {
+  console.log('\n   ⏰ TIMEOUT after 60 seconds');
+  console.log(`   Got any data: ${gotData}`);
+  console.log(`   Stdout length: ${fullStdout.length}`);
+  console.log(`   Stderr length: ${fullStderr.length}`);
+  child.kill('SIGTERM');
+}, 60000);
+
+child.on('close', (code) => {
+  clearTimeout(timeout);
+  const elapsed = (Date.now() - startTime) / 1000;
+  
+  console.log('\n' + '-'.repeat(60));
+  console.log('RESULT');
+  console.log('-'.repeat(60));
+  console.log(`Exit code: ${code}`);
+  console.log(`Duration: ${elapsed.toFixed(2)}s`);
+  console.log(`First byte: ${firstByteTime ? ((firstByteTime - startTime) / 1000).toFixed(2) + 's' : 'never'}`);
+  console.log(`Stdout bytes: ${fullStdout.length}`);
+  console.log(`Stderr bytes: ${fullStderr.length}`);
+  
+  if (fullStdout.length > 0) {
+    console.log('\nStdout content:');
+    console.log(fullStdout);
+  }
+  
+  if (fullStderr.length > 0) {
+    console.log('\nStderr content:');
+    console.log(fullStderr);
+  }
+  
+  // Try to parse JSON
+  const lines = fullStdout.split('\n').filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line.startsWith('{') && line.endsWith('}')) {
+      try {
+        const json = JSON.parse(line);
+        console.log('\nParsed JSON response:');
+        console.log(JSON.stringify(json, null, 2));
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  
+  console.log('\n' + '='.repeat(60));
+  if (code === 0 && fullStdout.includes('result')) {
+    console.log('✓ SUCCESS - cursor-agent responded correctly');
+  } else if (gotData) {
+    console.log('⚠ PARTIAL - Got data but may not have completed');
+  } else {
+    console.log('❌ FAILURE - No data received');
+  }
+  console.log('='.repeat(60));
+});
+
+child.on('error', (err) => {
+  clearTimeout(timeout);
+  console.error(`\n❌ Spawn error: ${err.message}`);
+  process.exit(1);
+});
+

package/src/cli/clean.ts

@@ -1,36 +1,156 @@
 /**
- * CursorFlow clean command (stub)
+ * CursorFlow clean command
+ * 
+ * Clean up worktrees, branches, and logs created by CursorFlow
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
 import * as logger from '../utils/logger';
+import * as git from '../utils/git';
+import { loadConfig, getLogsDir } from '../utils/config';
 
 interface CleanOptions {
   type?: string;
   pattern: string | null;
   dryRun: boolean;
   force: boolean;
+  all: boolean;
 }
 
 function parseArgs(args: string[]): CleanOptions {
   return {
-    type: args[0], // branches | worktrees | logs | all
+    type: args.find(a => ['branches', 'worktrees', 'logs', 'all'].includes(a)),
     pattern: null,
     dryRun: args.includes('--dry-run'),
     force: args.includes('--force'),
+    all: args.includes('--all'),
   };
 }
 
 async function clean(args: string[]): Promise<void> {
-  logger.section('🧹 Cleaning CursorFlow Resources');
-  
   const options = parseArgs(args);
+  const config = loadConfig();
+  const repoRoot = git.getRepoRoot();
+
+  logger.section('🧹 Cleaning CursorFlow Resources');
+
+  const type = options.type || 'all';
+
+  if (type === 'all') {
+    await cleanWorktrees(config, repoRoot, options);
+    await cleanBranches(config, repoRoot, options);
+    await cleanLogs(config, options);
+  } else if (type === 'worktrees') {
+    await cleanWorktrees(config, repoRoot, options);
+  } else if (type === 'branches') {
+    await cleanBranches(config, repoRoot, options);
+  } else if (type === 'logs') {
+    await cleanLogs(config, options);
+  }
+
+  logger.success('\n✨ Cleaning complete!');
+}
+
+async function cleanWorktrees(config: any, repoRoot: string, options: CleanOptions) {
+  logger.info('\nChecking worktrees...');
+  const worktrees = git.listWorktrees(repoRoot);
   
-  logger.info('This command will be fully implemented in the next phase');
-  logger.info(`Clean type: ${options.type}`);
-  logger.info(`Dry run: ${options.dryRun}`);
+  const worktreeRoot = path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees');
+  const toRemove = worktrees.filter(wt => {
+    // Skip main worktree
+    if (wt.path === repoRoot) return false;
+    
+    const isInsideRoot = wt.path.startsWith(worktreeRoot);
+    const hasPrefix = path.basename(wt.path).startsWith(config.worktreePrefix || 'cursorflow-');
+    
+    return isInsideRoot || hasPrefix;
+  });
+
+  if (toRemove.length === 0) {
+    logger.info('  No worktrees found to clean.');
+    return;
+  }
+
+  for (const wt of toRemove) {
+    if (options.dryRun) {
+      logger.info(`  [DRY RUN] Would remove worktree: ${wt.path} (${wt.branch || 'no branch'})`);
+    } else {
+      try {
+        logger.info(`  Removing worktree: ${wt.path}...`);
+        git.removeWorktree(wt.path, { cwd: repoRoot, force: options.force });
+        
+        // Git worktree remove might leave the directory if it has untracked files
+        if (fs.existsSync(wt.path)) {
+           if (options.force) {
+             fs.rmSync(wt.path, { recursive: true, force: true });
+             logger.info(`  (Forced removal of directory)`);
+           } else {
+             logger.warn(`  Directory still exists: ${wt.path} (contains untracked files). Use --force to delete anyway.`);
+           }
+        }
+      } catch (e: any) {
+        logger.error(`  Failed to remove worktree ${wt.path}: ${e.message}`);
+      }
+    }
+  }
+}
+
+async function cleanBranches(config: any, repoRoot: string, options: CleanOptions) {
+  logger.info('\nChecking branches...');
   
-  logger.warn('\n⚠️  Implementation pending');
-  logger.info('This will clean branches, worktrees, and logs');
+  // List all local branches
+  const result = git.runGitResult(['branch', '--list'], { cwd: repoRoot });
+  if (!result.success) return;
+
+  const branches = result.stdout
+    .split('\n')
+    .map(b => b.replace('*', '').trim())
+    .filter(b => b && b !== 'main' && b !== 'master');
+
+  const prefix = config.branchPrefix || 'feature/';
+  const toDelete = branches.filter(b => b.startsWith(prefix));
+
+  if (toDelete.length === 0) {
+    logger.info('  No branches found to clean.');
+    return;
+  }
+
+  for (const branch of toDelete) {
+    if (options.dryRun) {
+      logger.info(`  [DRY RUN] Would delete branch: ${branch}`);
+    } else {
+      try {
+        logger.info(`  Deleting branch: ${branch}...`);
+        git.deleteBranch(branch, { cwd: repoRoot, force: options.force || options.all });
+      } catch (e: any) {
+        logger.warn(`  Could not delete branch ${branch}: ${e.message}. Use --force if it's not merged.`);
+      }
+    }
+  }
+}
+
+async function cleanLogs(config: any, options: CleanOptions) {
+  const logsDir = getLogsDir(config);
+  logger.info(`\nChecking logs in ${logsDir}...`);
+
+  if (!fs.existsSync(logsDir)) {
+    logger.info('  Logs directory does not exist.');
+    return;
+  }
+
+  if (options.dryRun) {
+    logger.info(`  [DRY RUN] Would remove logs directory: ${logsDir}`);
+  } else {
+    try {
+      logger.info(`  Removing logs...`);
+      fs.rmSync(logsDir, { recursive: true, force: true });
+      fs.mkdirSync(logsDir, { recursive: true });
+      logger.info(`  Logs cleared.`);
+    } catch (e: any) {
+      logger.error(`  Failed to clean logs: ${e.message}`);
+    }
+  }
 }
 
 export = clean;

package/src/cli/index.ts

@@ -20,45 +20,45 @@ const COMMANDS: Record<string, CommandFn> = {
 
 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[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
 
-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 run _cursorflow/tasks/MyFeature/\x1b[0m
+  $ \x1b[32mcursorflow monitor latest\x1b[0m
+  $ \x1b[32mcursorflow signal lane-1 "Please use pnpm instead of npm"\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')) {
+  if (args.length === 0 || args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     printHelp();
     return;
   }