@litmers/cursorflow-orchestrator 0.1.14 → 0.1.18

package/src/cli/prepare.ts

@@ -97,12 +97,16 @@ Prepare task files for a new feature - Terminal-first workflow.
     --prompt <text>           Task prompt (uses preset or single task)
     --criteria <list>         Comma-separated acceptance criteria
     --model <model>           Model to use (default: sonnet-4.5)
-    --task <spec>             Full task spec: "name|model|prompt|criteria" (repeatable)
+    --task <spec>             Full task spec: "name|model|prompt|criteria|dependsOn|timeout" (repeatable)
 
   Dependencies:
     --sequential              Chain lanes: 1 → 2 → 3
     --deps <spec>             Custom dependencies: "2:1;3:1,2"
     --depends-on <lanes>      Dependencies for --add-lane: "01-lane-1,02-lane-2"
+    Task-level deps:          In --task, add "lane:task" at the end.
+                              Example: "test|sonnet-4.5|Run tests|All pass|01-lane-1:setup"
+    Task-level timeout:       In --task, add milliseconds at the end.
+                              Example: "heavy|sonnet-4.5|Big task|Done||1200000"
 
   Incremental (add to existing):
     --add-lane <dir>          Add a new lane to existing task directory
@@ -203,23 +207,31 @@ function parseArgs(args: string[]): PrepareOptions {
 }
 
 function parseTaskSpec(spec: string): Task {
-  // Format: "name|model|prompt|criteria1,criteria2"
+  // Format: "name|model|prompt|criteria1,criteria2|lane:task1,lane:task2|timeoutMs"
   const parts = spec.split('|');
   
   if (parts.length < 3) {
-    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria1,criteria2]"`);
+    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria[|dependsOn[|timeout]]]"`);
   }
   
-  const [name, model, prompt, criteriaStr] = parts;
+  const [name, model, prompt, criteriaStr, depsStr, timeoutStr] = parts;
   const acceptanceCriteria = criteriaStr 
     ? criteriaStr.split(',').map(c => c.trim()).filter(c => c)
     : undefined;
   
+  const dependsOn = depsStr
+    ? depsStr.split(',').map(d => d.trim()).filter(d => d)
+    : undefined;
+
+  const timeout = timeoutStr ? parseInt(timeoutStr) : undefined;
+  
   return {
     name: name.trim(),
     model: model.trim() || 'sonnet-4.5',
     prompt: prompt.trim(),
     ...(acceptanceCriteria && acceptanceCriteria.length > 0 ? { acceptanceCriteria } : {}),
+    ...(dependsOn && dependsOn.length > 0 ? { dependsOn } : {}),
+    ...(timeout ? { timeout } : {}),
   };
 }
 
@@ -612,10 +624,6 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
   const fileName = `${laneNumber.toString().padStart(2, '0')}-${laneName}.json`;
   const filePath = path.join(taskDir, fileName);
   
-  if (fs.existsSync(filePath) && !options.force) {
-    throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
-  }
-  
   const hasDependencies = options.dependsOnLanes.length > 0;
   
   // Build tasks from options (auto-detects merge preset if has dependencies)
@@ -628,7 +636,16 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
     ...(hasDependencies ? { dependsOn: options.dependsOnLanes } : {}),
   };
   
-  fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', 'utf8');
+  // Use atomic write with wx flag to avoid TOCTOU race condition (unless force is set)
+  try {
+    const writeFlag = options.force ? 'w' : 'wx';
+    fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', { encoding: 'utf8', flag: writeFlag });
+  } catch (err: any) {
+    if (err.code === 'EEXIST') {
+      throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
+    }
+    throw err;
+  }
   
   const taskSummary = tasks.map(t => t.name).join(' → ');
   const depsInfo = hasDependencies ? ` (depends: ${options.dependsOnLanes.join(', ')})` : '';
@@ -645,16 +662,20 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
 async function addTaskToLane(options: PrepareOptions): Promise<void> {
   const laneFile = path.resolve(process.cwd(), options.addTask!);
   
-  if (!fs.existsSync(laneFile)) {
-    throw new Error(`Lane file not found: ${laneFile}`);
-  }
-  
   if (options.taskSpecs.length === 0) {
     throw new Error('No task specified. Use --task "name|model|prompt|criteria" to define a task.');
   }
   
-  // Read existing config
-  const existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  // Read existing config - let the error propagate if file doesn't exist (avoids TOCTOU)
+  let existingConfig: any;
+  try {
+    existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Lane file not found: ${laneFile}`);
+    }
+    throw err;
+  }
   
   if (!existingConfig.tasks || !Array.isArray(existingConfig.tasks)) {
     existingConfig.tasks = [];

package/src/cli/resume.ts

@@ -7,7 +7,7 @@ import * as fs from 'fs';
 import { spawn, ChildProcess } from 'child_process';
 import * as logger from '../utils/logger';
 import { loadConfig, getLogsDir } from '../utils/config';
-import { loadState, listLanesInRun } from '../utils/state';
+import { loadState } from '../utils/state';
 import { LaneState } from '../utils/types';
 import { runDoctor } from '../utils/doctor';
 

package/src/cli/run.ts

@@ -16,6 +16,7 @@ interface RunOptions {
   executor: string | null;
   maxConcurrent: number | null;
   skipDoctor: boolean;
+  noGit: boolean;
   help: boolean;
 }
 
@@ -30,8 +31,13 @@ Options:
   --max-concurrent <num> Limit parallel agents (overrides config)
   --executor <type>      cursor-agent | cloud
   --skip-doctor          Skip environment checks (not recommended)
+  --no-git               Disable Git operations (worktree, push, commit)
   --dry-run              Show execution plan without starting agents
   --help, -h             Show help
+
+Examples:
+  cursorflow run _cursorflow/tasks
+  cursorflow run _cursorflow/tasks --no-git --skip-doctor
   `);
 }
 
@@ -46,6 +52,7 @@ function parseArgs(args: string[]): RunOptions {
     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'),
+    noGit: args.includes('--no-git'),
     help: args.includes('--help') || args.includes('-h'),
   };
 }
@@ -136,6 +143,7 @@ async function run(args: string[]): Promise<void> {
       maxConcurrentLanes: options.maxConcurrent || config.maxConcurrentLanes,
       webhooks: config.webhooks || [],
       enhancedLogging: config.enhancedLogging,
+      noGit: options.noGit,
     });
   } catch (error: any) {
     // Re-throw to be handled by the main entry point

package/src/core/orchestrator.ts

@@ -13,9 +13,16 @@ import { loadState } from '../utils/state';
 import { LaneState, RunnerConfig, WebhookConfig, DependencyRequestPlan, EnhancedLogConfig } from '../utils/types';
 import { events } from '../utils/events';
 import { registerWebhooks } from '../utils/webhook';
+import { loadConfig, getLogsDir } from '../utils/config';
 import * as git from '../utils/git';
 import { execSync } from 'child_process';
-import { EnhancedLogManager, createLogManager, DEFAULT_LOG_CONFIG } from '../utils/enhanced-logger';
+import { 
+  EnhancedLogManager, 
+  createLogManager, 
+  DEFAULT_LOG_CONFIG,
+  ParsedMessage,
+  stripAnsi
+} from '../utils/enhanced-logger';
 
 export interface LaneInfo {
   name: string;
@@ -41,6 +48,7 @@ export function spawnLane({
   startIndex = 0, 
   pipelineBranch,
   enhancedLogConfig,
+  noGit = false,
 }: { 
   laneName: string; 
   tasksFile: string; 
@@ -49,6 +57,7 @@ export function spawnLane({
   startIndex?: number;
   pipelineBranch?: string;
   enhancedLogConfig?: Partial<EnhancedLogConfig>;
+  noGit?: boolean;
 }): SpawnLaneResult {
   fs.mkdirSync(laneRunDir, { recursive: true});
   
@@ -67,6 +76,10 @@ export function spawnLane({
     args.push('--pipeline-branch', pipelineBranch);
   }
   
+  if (noGit) {
+    args.push('--no-git');
+  }
+  
   // Create enhanced log manager if enabled
   const logConfig = { ...DEFAULT_LOG_CONFIG, ...enhancedLogConfig };
   let logManager: EnhancedLogManager | undefined;
@@ -79,7 +92,90 @@ export function spawnLane({
   };
   
   if (logConfig.enabled) {
-    logManager = createLogManager(laneRunDir, laneName, logConfig);
+    // Create callback for clean console output
+    const onParsedMessage = (msg: ParsedMessage) => {
+      // Print a clean, colored version of the message to the console
+      const ts = new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false });
+      const laneLabel = `[${laneName}]`.padEnd(12);
+      
+      let prefix = '';
+      let content = msg.content;
+      
+      switch (msg.type) {
+        case 'user':
+          prefix = `${logger.COLORS.cyan}🧑 USER${logger.COLORS.reset}`;
+          // No truncation for user prompt to ensure full command visibility
+          content = content.replace(/\n/g, ' ');
+          break;
+        case 'assistant':
+          prefix = `${logger.COLORS.green}🤖 ASST${logger.COLORS.reset}`;
+          break;
+        case 'tool':
+          prefix = `${logger.COLORS.yellow}🔧 TOOL${logger.COLORS.reset}`;
+          // Simplify tool call: [Tool: read_file] {"target_file":"..."} -> read_file(target_file: ...)
+          const toolMatch = content.match(/\[Tool: ([^\]]+)\] (.*)/);
+          if (toolMatch) {
+            const [, name, args] = toolMatch;
+            try {
+              const parsedArgs = JSON.parse(args!);
+              let argStr = '';
+              
+              if (name === 'read_file' && parsedArgs.target_file) {
+                argStr = parsedArgs.target_file;
+              } else if (name === 'run_terminal_cmd' && parsedArgs.command) {
+                argStr = parsedArgs.command;
+              } else if (name === 'write' && parsedArgs.file_path) {
+                argStr = parsedArgs.file_path;
+              } else if (name === 'search_replace' && parsedArgs.file_path) {
+                argStr = parsedArgs.file_path;
+              } else {
+                // Generic summary for other tools
+                const keys = Object.keys(parsedArgs);
+                if (keys.length > 0) {
+                  argStr = String(parsedArgs[keys[0]]).substring(0, 50);
+                }
+              }
+              content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}(${argStr})`;
+            } catch {
+              content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}: ${args}`;
+            }
+          }
+          break;
+        case 'tool_result':
+          prefix = `${logger.COLORS.gray}📄 RESL${logger.COLORS.reset}`;
+          // Simplify tool result: [Tool Result: read_file] ... -> read_file OK
+          const resMatch = content.match(/\[Tool Result: ([^\]]+)\]/);
+          content = resMatch ? `${resMatch[1]} OK` : 'result';
+          break;
+        case 'result':
+          prefix = `${logger.COLORS.green}✅ DONE${logger.COLORS.reset}`;
+          break;
+        case 'system':
+          prefix = `${logger.COLORS.gray}⚙️  SYS${logger.COLORS.reset}`;
+          break;
+        case 'thinking':
+          prefix = `${logger.COLORS.gray}🤔 THNK${logger.COLORS.reset}`;
+          break;
+      }
+      
+      if (prefix) {
+        const lines = content.split('\n');
+        const tsPrefix = `${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneLabel}${logger.COLORS.reset}`;
+        
+        if (msg.type === 'user' || msg.type === 'assistant' || msg.type === 'result' || msg.type === 'thinking') {
+          const header = `${prefix} ┌${'─'.repeat(60)}`;
+          process.stdout.write(`${tsPrefix} ${header}\n`);
+          for (const line of lines) {
+            process.stdout.write(`${tsPrefix} ${' '.repeat(stripAnsi(prefix).length)} │ ${line}\n`);
+          }
+          process.stdout.write(`${tsPrefix} ${' '.repeat(stripAnsi(prefix).length)} └${'─'.repeat(60)}\n`);
+        } else {
+          process.stdout.write(`${tsPrefix} ${prefix} ${content}\n`);
+        }
+      }
+    };
+
+    logManager = createLogManager(laneRunDir, laneName, logConfig, onParsedMessage);
     logPath = logManager.getLogPaths().clean;
     
     // Spawn with pipe for enhanced logging
@@ -89,20 +185,54 @@ export function spawnLane({
       detached: false,
     });
     
+    // Buffer for non-JSON lines
+    let lineBuffer = '';
+
     // Pipe stdout and stderr through enhanced logger
     if (child.stdout) {
       child.stdout.on('data', (data: Buffer) => {
         logManager!.writeStdout(data);
-        // Also write to process stdout for real-time visibility
-        process.stdout.write(data);
+        
+        // Filter out JSON lines from console output to keep it clean
+        const str = data.toString();
+        lineBuffer += str;
+        const lines = lineBuffer.split('\n');
+        lineBuffer = lines.pop() || '';
+        
+        for (const line of lines) {
+          const trimmed = line.trim();
+          // Only print if NOT a noisy line
+          if (trimmed && 
+              !trimmed.startsWith('{') && 
+              !trimmed.startsWith('[') && 
+              !trimmed.includes('{"type"')) {
+            process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneName.padEnd(10)}${logger.COLORS.reset} ${line}\n`);
+          }
+        }
       });
     }
     
     if (child.stderr) {
       child.stderr.on('data', (data: Buffer) => {
         logManager!.writeStderr(data);
-        // Also write to process stderr for real-time visibility
-        process.stderr.write(data);
+        const str = data.toString();
+        const lines = str.split('\n');
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed) {
+            // Check if it's a real error or just git/status output on stderr
+            const isStatus = trimmed.startsWith('Preparing worktree') || 
+                             trimmed.startsWith('Switched to a new branch') ||
+                             trimmed.startsWith('HEAD is now at') ||
+                             trimmed.includes('actual output');
+            
+            if (isStatus) {
+              process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneName.padEnd(10)}${logger.COLORS.reset} ${trimmed}\n`);
+            } else {
+              process.stderr.write(`${logger.COLORS.red}[${laneName}] ERROR: ${trimmed}${logger.COLORS.reset}\n`);
+            }
+          }
+        }
       });
     }
     
@@ -284,7 +414,8 @@ async function resolveAllDependencies(
     const task = taskConfig.tasks[currentIdx];
     
     if (task) {
-      const taskBranch = `${pipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
+      const lanePipelineBranch = `${pipelineBranch}/${lane.name}`;
+      const taskBranch = `${lanePipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
       logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`);
       
       try {
@@ -321,6 +452,7 @@ export async function orchestrate(tasksDir: string, options: {
   webhooks?: WebhookConfig[];
   autoResolveDependencies?: boolean;
   enhancedLogging?: Partial<EnhancedLogConfig>;
+  noGit?: boolean;
 } = {}): Promise<{ lanes: LaneInfo[]; exitCodes: Record<string, number>; runRoot: string }> {
   const lanes = listLaneFiles(tasksDir);
   
@@ -328,11 +460,18 @@ export async function orchestrate(tasksDir: string, options: {
     throw new Error(`No lane task files found in ${tasksDir}`);
   }
   
+  const config = loadConfig();
+  const logsDir = getLogsDir(config);
   const runId = `run-${Date.now()}`;
-  const runRoot = options.runDir || `_cursorflow/logs/runs/${runId}`;
+  // Use absolute path for runRoot to avoid issues with subfolders
+  const runRoot = options.runDir 
+    ? (path.isAbsolute(options.runDir) ? options.runDir : path.resolve(process.cwd(), options.runDir))
+    : path.join(logsDir, 'runs', runId);
+  
   fs.mkdirSync(runRoot, { recursive: true });
 
-  const pipelineBranch = `cursorflow/run-${Date.now().toString(36)}`;
+  const randomSuffix = Math.random().toString(36).substring(2, 7);
+  const pipelineBranch = `cursorflow/run-${Date.now().toString(36)}-${randomSuffix}`;
 
   // Initialize event system
   events.setRunId(runId);
@@ -370,7 +509,27 @@ export async function orchestrate(tasksDir: string, options: {
   logger.info(`Run directory: ${runRoot}`);
   logger.info(`Lanes: ${lanes.length}`);
 
-  const autoResolve = options.autoResolveDependencies !== false;
+  // Display dependency graph
+  logger.info('\n📊 Dependency Graph:');
+  for (const lane of lanes) {
+    const deps = lane.dependsOn.length > 0 ? ` [depends on: ${lane.dependsOn.join(', ')}]` : '';
+    console.log(`  ${logger.COLORS.cyan}${lane.name}${logger.COLORS.reset}${deps}`);
+    
+    // Simple tree-like visualization for deep dependencies
+    if (lane.dependsOn.length > 0) {
+      for (const dep of lane.dependsOn) {
+        console.log(`    └─ ${dep}`);
+      }
+    }
+  }
+  console.log('');
+
+  // Disable auto-resolve when noGit mode is enabled
+  const autoResolve = !options.noGit && options.autoResolveDependencies !== false;
+  
+  if (options.noGit) {
+    logger.info('🚫 Git operations disabled (--no-git mode)');
+  }
   
   // Monitor lanes
   const monitorInterval = setInterval(() => {
@@ -415,8 +574,9 @@ export async function orchestrate(tasksDir: string, options: {
         laneRunDir: laneRunDirs[lane.name]!,
         executor: options.executor || 'cursor-agent',
         startIndex: lane.startIndex,
-        pipelineBranch,
+        pipelineBranch: `${pipelineBranch}/${lane.name}`,
         enhancedLogConfig: options.enhancedLogging,
+        noGit: options.noGit,
       });
       
       running.set(lane.name, spawnResult);

package/src/core/reviewer.ts

@@ -144,18 +144,25 @@ export function buildFeedbackPrompt(review: ReviewResult): string {
 /**
  * Review task
  */
-export async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgentSend, cursorAgentCreateChat }: { 
+export async function reviewTask({ taskResult, worktreeDir, runDir, config, model, cursorAgentSend, cursorAgentCreateChat }: { 
   taskResult: TaskResult; 
   worktreeDir: string; 
   runDir: string; 
   config: RunnerConfig; 
-  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult; 
+  model?: string;
+  cursorAgentSend: (options: { 
+    workspaceDir: string; 
+    chatId: string; 
+    prompt: string; 
+    model?: string;
+    outputFormat?: 'stream-json' | 'json' | 'plain';
+  }) => Promise<AgentSendResult>; 
   cursorAgentCreateChat: () => string; 
 }): Promise<ReviewResult> {
   const reviewPrompt = buildReviewPrompt({
     taskName: taskResult.taskName,
     taskBranch: taskResult.taskBranch,
-    acceptanceCriteria: config.acceptanceCriteria || [],
+    acceptanceCriteria: taskResult.acceptanceCriteria || config.acceptanceCriteria || [],
   });
   
   logger.info(`Reviewing: ${taskResult.taskName}`);
@@ -166,11 +173,14 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   });
 
   const reviewChatId = cursorAgentCreateChat();
-  const reviewResult = cursorAgentSend({
+  const reviewModel = model || config.reviewModel || config.model || 'sonnet-4.5';
+  
+  const reviewResult = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId: reviewChatId,
     prompt: reviewPrompt,
-    model: config.reviewModel || 'sonnet-4.5-thinking',
+    model: reviewModel,
+    outputFormat: config.agentOutputFormat,
   });
   
   const review = parseReviewResult(reviewResult.resultText || '');
@@ -179,7 +189,7 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
   const convoPath = path.join(runDir, 'conversation.jsonl');
   appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText || 'No result', {
     task: taskResult.taskName,
-    model: config.reviewModel,
+    model: reviewModel,
   }));
   
   logger.info(`Review result: ${review.status} (${review.issues?.length || 0} issues)`);
@@ -197,14 +207,21 @@ export async function reviewTask({ taskResult, worktreeDir, runDir, config, curs
 /**
  * Review loop with feedback
  */
-export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, cursorAgentSend, cursorAgentCreateChat }: {
+export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, model, cursorAgentSend, cursorAgentCreateChat }: {
   taskResult: TaskResult;
   worktreeDir: string;
   runDir: string;
   config: RunnerConfig;
   workChatId: string;
-  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult;
-  cursorAgentCreateChat: () => string;
+  model?: string;
+  cursorAgentSend: (options: { 
+    workspaceDir: string; 
+    chatId: string; 
+    prompt: string; 
+    model?: string;
+    outputFormat?: 'stream-json' | 'json' | 'plain';
+  }) => Promise<AgentSendResult>; 
+  cursorAgentCreateChat: () => string; 
 }): Promise<{ approved: boolean; review: ReviewResult; iterations: number; error?: string }> {
   const maxIterations = config.maxReviewIterations || 3;
   let iteration = 0;
@@ -216,10 +233,11 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
       worktreeDir,
       runDir,
       config,
+      model,
       cursorAgentSend,
       cursorAgentCreateChat,
     });
-    
+
     if (currentReview.status === 'approved') {
       logger.success(`Review passed: ${taskResult.taskName} (iteration ${iteration + 1})`);
       events.emit('review.approved', {
@@ -245,11 +263,12 @@ export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, w
     logger.info(`Sending feedback (iteration ${iteration}/${maxIterations})`);
     const feedbackPrompt = buildFeedbackPrompt(currentReview);
     
-    const fixResult = cursorAgentSend({
+    const fixResult = await cursorAgentSend({
       workspaceDir: worktreeDir,
       chatId: workChatId,
       prompt: feedbackPrompt,
       model: config.model,
+      outputFormat: config.agentOutputFormat,
     });
     
     if (!fixResult.ok) {