@litmers/cursorflow-orchestrator 0.2.5 → 0.2.7

package/src/core/orchestrator.ts

@@ -26,10 +26,11 @@ import {
   EnhancedLogManager, 
   createLogManager, 
   DEFAULT_LOG_CONFIG,
-  ParsedMessage
+  ParsedMessage,
+  stripAnsi
 } from '../utils/enhanced-logger';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
-import { formatMessageForConsole, stripAnsi } from '../services/logging/formatter';
+import { formatMessageForConsole } from '../utils/log-formatter';
 import { FailureType, analyzeFailure as analyzeFailureFromPolicy } from './failure-policy';
 import { 
   savePOF,
@@ -292,7 +293,6 @@ export function spawnLane({
   // Build environment for child process
   const childEnv = {
     ...process.env,
-    CURSORFLOW_LANE: 'true',
   };
   
   if (logConfig.enabled) {
@@ -392,7 +392,7 @@ export function spawnLane({
     return { child, logPath, logManager, info };
   } else {
     // Fallback to simple file logging
-    logPath = getLaneLogPath(laneRunDir, 'jsonl');
+    logPath = getLaneLogPath(laneRunDir, 'raw');
     const logFd = fs.openSync(logPath, 'a');
     
     child = spawn('node', args, {
@@ -519,12 +519,12 @@ async function resolveAllDependencies(
   const worktreeDir = state?.worktreeDir || safeJoin(runRoot, 'resolution-worktree');
 
   if (!fs.existsSync(worktreeDir)) {
-    logger.info(`🏗️ Creating resolution worktree at ${worktreeDir}`, { context: 'git' });
+    logger.info(`🏗️ Creating resolution worktree at ${worktreeDir}`);
     git.createWorktree(worktreeDir, pipelineBranch, { baseBranch: git.getCurrentBranch() });
   }
 
   // 3. Resolve on pipeline branch
-  logger.info(`🔄 Resolving dependencies on branch ${pipelineBranch}`, { context: 'git' });
+  logger.info(`🔄 Resolving dependencies on branch ${pipelineBranch}`);
   git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
   
   for (const cmd of uniqueCommands) {
@@ -566,7 +566,7 @@ async function resolveAllDependencies(
     if (task) {
       const lanePipelineBranch = `${pipelineBranch}/${lane.name}`;
       const taskBranch = `${lanePipelineBranch}--${String(currentIdx + 1).padStart(2, '0')}-${task.name}`;
-      logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`, { context: 'git' });
+      logger.info(`Syncing lane ${lane.name} branch ${taskBranch}`);
       
       try {
         // If task branch doesn't exist yet, it will be created from pipelineBranch when the lane starts
@@ -591,6 +591,188 @@ async function resolveAllDependencies(
   git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
 }
 
+/**
+ * Finalize flow: merge all lane branches into integrated branch and cleanup
+ */
+export async function finalizeFlow(params: {
+  tasksDir: string;
+  runId: string;
+  runRoot: string;
+  laneRunDirs: Record<string, string>;
+  laneWorktreeDirs: Record<string, string>;
+  pipelineBranch: string;
+  repoRoot: string;
+  noCleanup?: boolean;
+}): Promise<void> {
+  const { tasksDir, runId, runRoot, laneRunDirs, laneWorktreeDirs, pipelineBranch, repoRoot, noCleanup } = params;
+  
+  // 1. Load FlowMeta
+  const metaPath = safeJoin(tasksDir, 'flow.meta.json');
+  let meta: any = null;
+  let flowName = path.basename(tasksDir).replace(/^\d+_/, '');
+  let baseBranch = 'main';
+  
+  if (fs.existsSync(metaPath)) {
+    try {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+      flowName = meta.name || flowName;
+      baseBranch = meta.baseBranch || 'main';
+      
+      // Update status to integrating
+      meta.status = 'integrating';
+      fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+    } catch (e) {
+      logger.warn(`Failed to read flow.meta.json: ${e}`);
+    }
+  }
+  
+  logger.section(`🏁 Finalizing Flow: ${flowName}`);
+  
+  // 2. Collect lane branches
+  const laneBranches: string[] = [];
+  for (const [laneName, laneDir] of Object.entries(laneRunDirs)) {
+    const statePath = safeJoin(laneDir, 'state.json');
+    if (fs.existsSync(statePath)) {
+      try {
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        if (state.pipelineBranch) {
+          laneBranches.push(state.pipelineBranch);
+        }
+      } catch (e) {
+        logger.warn(`Failed to read lane state for ${laneName}: ${e}`);
+      }
+    }
+  }
+  
+  if (laneBranches.length === 0) {
+    logger.warn('No lane branches found to integrate');
+    return;
+  }
+  
+  // 3. Create integrated branch
+  const targetBranch = `feature/${flowName}-integrated`;
+  logger.info(`Target Branch: ${targetBranch}`);
+  logger.info(`Base Branch: ${baseBranch}`);
+  logger.info(`Lanes to merge: ${laneBranches.length}`);
+  
+  // Ensure we are on a clean state
+  if (git.hasUncommittedChanges(repoRoot)) {
+    logger.warn('Main repository has uncommitted changes. Stashing...');
+    git.stash('auto-stash before flow completion', { cwd: repoRoot });
+  }
+  
+  // Checkout base branch and create target branch
+  logger.info(`Creating target branch '${targetBranch}' from '${baseBranch}'...`);
+  git.runGit(['checkout', baseBranch], { cwd: repoRoot });
+  git.runGit(['checkout', '-B', targetBranch], { cwd: repoRoot });
+  
+  // 4. Merge each lane branch
+  for (const branch of laneBranches) {
+    logger.info(`Merging ${branch}...`);
+    
+    // Determine what ref to use for merge
+    let branchRef: string;
+    
+    if (git.branchExists(branch, { cwd: repoRoot })) {
+      // Local branch exists, use it directly
+      branchRef = branch;
+    } else {
+      // Local branch doesn't exist - fetch from remote with proper refspec
+      // Note: `git fetch origin <branch>` only updates FETCH_HEAD, not origin/<branch>
+      // We must use refspec to update the remote tracking ref
+      try {
+        git.runGit(['fetch', 'origin', `${branch}:refs/remotes/origin/${branch}`], { cwd: repoRoot });
+        branchRef = `origin/${branch}`;
+      } catch (e) {
+        // Fallback: try fetching and use FETCH_HEAD directly
+        logger.warn(`Failed to fetch with refspec, trying FETCH_HEAD: ${e}`);
+        try {
+          git.runGit(['fetch', 'origin', branch], { cwd: repoRoot });
+          branchRef = 'FETCH_HEAD';
+        } catch (e2) {
+          logger.warn(`Failed to fetch ${branch}: ${e2}`);
+          throw new Error(`Cannot fetch branch ${branch} from remote`);
+        }
+      }
+    }
+    
+    const mergeResult = git.safeMerge(branchRef, {
+      cwd: repoRoot,
+      noFf: true,
+      message: `chore: merge lane ${branch} into flow integration`,
+      abortOnConflict: true,
+    });
+    
+    if (!mergeResult.success) {
+      if (mergeResult.conflict) {
+        logger.error(`❌ Merge conflict with '${branch}': ${mergeResult.conflictingFiles.join(', ')}`);
+        
+        // Update meta with error
+        if (meta) {
+          meta.status = 'failed';
+          meta.error = `Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`;
+          fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+        }
+        
+        throw new Error(`Merge conflict during integration: ${mergeResult.conflictingFiles.join(', ')}`);
+      }
+      throw new Error(`Merge failed for ${branch}: ${mergeResult.error}`);
+    }
+    logger.success(`✓ Merged ${branch}`);
+  }
+  
+  // 5. Push final branch
+  logger.info(`Pushing '${targetBranch}' to remote...`);
+  git.push(targetBranch, { cwd: repoRoot, setUpstream: true });
+  logger.success(`✓ Pushed ${targetBranch}`);
+  
+  // 6. Cleanup (if not disabled)
+  if (!noCleanup) {
+    logger.info('🧹 Cleaning up temporary resources...');
+    
+    // Delete local and remote lane branches
+    for (const branch of laneBranches) {
+      try {
+        git.deleteBranch(branch, { cwd: repoRoot, force: true });
+        try {
+          git.deleteBranch(branch, { cwd: repoRoot, remote: true });
+        } catch {
+          // Remote branch might not exist or no permission
+        }
+      } catch (e) {
+        logger.warn(`Failed to delete branch ${branch}: ${e}`);
+      }
+    }
+    
+    // Remove worktrees
+    for (const wtPath of Object.values(laneWorktreeDirs)) {
+      if (fs.existsSync(wtPath)) {
+        try {
+          git.removeWorktree(wtPath, { cwd: repoRoot, force: true });
+          if (fs.existsSync(wtPath)) {
+            fs.rmSync(wtPath, { recursive: true, force: true });
+          }
+        } catch (e) {
+          logger.warn(`Failed to remove worktree ${wtPath}: ${e}`);
+        }
+      }
+    }
+  }
+  
+  // 7. Update FlowMeta with completion info
+  if (meta) {
+    meta.status = 'completed';
+    meta.integratedBranch = targetBranch;
+    meta.integratedAt = new Date().toISOString();
+    delete meta.error;
+    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  }
+  
+  logger.section(`🎉 Flow Completed!`);
+  logger.info(`Integrated branch: ${targetBranch}`);
+  logger.success(`All ${laneBranches.length} lanes merged successfully.`);
+}
+
 /**
  * Run orchestration with dependency management
  */
@@ -606,6 +788,10 @@ export async function orchestrate(tasksDir: string, options: {
   skipPreflight?: boolean;
   stallConfig?: Partial<StallDetectionConfig>;
   browser?: boolean;
+  /** Auto-complete flow when all lanes succeed (merge branches, cleanup) */
+  autoComplete?: boolean;
+  /** Skip cleanup even if autoComplete is true */
+  noCleanup?: boolean;
 } = {}): Promise<{ lanes: LaneInfo[]; exitCodes: Record<string, number>; runRoot: string }> {
   const lanes = listLaneFiles(tasksDir);
   
@@ -1119,6 +1305,27 @@ export async function orchestrate(tasksDir: string, options: {
   }
   
   logger.success('All lanes completed successfully!');
+  
+  // Auto-complete flow: merge all lane branches and cleanup
+  const autoComplete = options.autoComplete !== false && !options.noGit;
+  if (autoComplete && completedLanes.size === lanes.length) {
+    try {
+      await finalizeFlow({
+        tasksDir,
+        runId,
+        runRoot,
+        laneRunDirs,
+        laneWorktreeDirs,
+        pipelineBranch,
+        repoRoot,
+        noCleanup: options.noCleanup,
+      });
+    } catch (error: any) {
+      logger.error(`Flow auto-completion failed: ${error.message}`);
+      logger.info('You can manually complete the flow with: cursorflow complete');
+    }
+  }
+  
   events.emit('orchestration.completed', {
     runId,
     laneCount: lanes.length,

package/src/core/runner/pipeline.ts

@@ -156,7 +156,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   // ALWAYS use current branch as base - ignore config.baseBranch
   // This ensures dependency structure is maintained in the worktree
   const currentBranch = git.getCurrentBranch(repoRoot);
-  logger.info(`📍 Base branch: ${currentBranch} (current branch)`, { context: 'git' });
+  logger.info(`📍 Base branch: ${currentBranch} (current branch)`);
   
   // Load existing state if resuming
   const statePath = safeJoin(runDir, 'state.json');
@@ -207,8 +207,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     logger.section(`🔁 Resuming Pipeline from task ${startIndex + 1}`);
   }
   
-  logger.info(`Pipeline Branch: ${pipelineBranch}`, { context: 'git' });
-  logger.info(`Worktree: ${worktreeDir}`, { context: 'git' });
+  logger.info(`Pipeline Branch: ${pipelineBranch}`);
+  logger.info(`Worktree: ${worktreeDir}`);
   logger.info(`Tasks: ${config.tasks.length}`);
   
   const gitCoordinator = new GitPipelineCoordinator();

package/src/hooks/data-accessor.ts

@@ -333,9 +333,9 @@ export class HookDataAccessorImpl implements HookDataAccessor {
       }
       
       try {
-        // Try multiple possible log file locations, preferring terminal.jsonl
+        // Try multiple possible log file locations
         const possiblePaths = [
-          safeJoin(this.options.runDir, 'terminal.jsonl'),
+          safeJoin(this.options.runDir, 'terminal-raw.log'),
           safeJoin(this.options.runDir, 'terminal.log'),
           safeJoin(this.options.runDir, 'agent-output.log'),
         ];

package/src/services/logging/buffer.ts

@@ -109,16 +109,14 @@ export class LogBufferService extends EventEmitter {
     const newEntries: BufferedLogEntryType[] = [];
 
     for (const laneName of this.lanes) {
-      const jsonlPath = path.join(lanesDir, laneName, 'terminal.jsonl');
+      const readablePath = path.join(lanesDir, laneName, 'terminal-readable.log');
 
       let fd: number | null = null;
       try {
-        if (!fs.existsSync(jsonlPath)) continue;
-
         // Read file content atomically to avoid TOCTOU race condition
-        const lastPos = this.filePositions.get(jsonlPath) || 0;
-        fd = fs.openSync(jsonlPath, 'r');
-        const stat = fs.fstatSync(fd); 
+        const lastPos = this.filePositions.get(readablePath) || 0;
+        fd = fs.openSync(readablePath, 'r');
+        const stat = fs.fstatSync(fd); // Use fstat on open fd to avoid race
         
         if (stat.size > lastPos) {
           const buffer = Buffer.alloc(stat.size - lastPos);
@@ -128,16 +126,11 @@ export class LogBufferService extends EventEmitter {
           const lines = newContent.split('\n').filter(line => line.trim());
 
           for (const line of lines) {
-            try {
-              const entry = JSON.parse(line);
-              const processed = this.processJsonEntry(entry, laneName);
-              if (processed) newEntries.push(processed);
-            } catch {
-              // Skip invalid JSON
-            }
+            const processed = this.processReadableLine(line, laneName);
+            if (processed) newEntries.push(processed);
           }
 
-          this.filePositions.set(jsonlPath, stat.size);
+          this.filePositions.set(readablePath, stat.size);
         }
       } catch { /* File in use, skip */ }
       finally {
@@ -161,11 +154,11 @@ export class LogBufferService extends EventEmitter {
     }
   }
 
-  private processJsonEntry(entry: any, laneName: string): BufferedLogEntryType | null {
-    const timestamp = new Date(entry.timestamp || Date.now());
-    const level = entry.level || 'info';
-    const type = entry.type || 'stdout';
-    const message = entry.content || entry.message || '';
+  private processReadableLine(line: string, laneName: string): BufferedLogEntryType | null {
+    const cleaned = stripAnsi(line).trim();
+    if (!cleaned) return null;
+
+    const { timestamp, message, level, type } = this.parseReadableMessage(cleaned);
     const importance = this.inferImportance(type, level);
 
     return {
@@ -177,10 +170,65 @@ export class LogBufferService extends EventEmitter {
       message: this.truncateMessage(message),
       importance,
       laneColor: this.laneColorMap.get(laneName) || COLORS.white,
-      raw: entry,
+      raw: {
+        timestamp: timestamp.toISOString(),
+        level: level as JsonLogEntry['level'],
+        lane: laneName,
+        message,
+      },
     };
   }
 
+  private parseReadableMessage(line: string): {
+    timestamp: Date;
+    message: string;
+    level: string;
+    type: MessageType | string;
+  } {
+    let remaining = line;
+    let timestamp = new Date();
+
+    const isoMatch = remaining.match(/^\[(\d{4}-\d{2}-\d{2}T[^\]]+)\]\s*/);
+    if (isoMatch) {
+      timestamp = new Date(isoMatch[1]!);
+      remaining = remaining.slice(isoMatch[0].length);
+    } else {
+      const timeMatch = remaining.match(/^\[(\d{2}:\d{2}:\d{2})\]\s*/);
+      if (timeMatch) {
+        const [hours, minutes, seconds] = timeMatch[1]!.split(':').map(Number);
+        const now = new Date();
+        now.setHours(hours || 0, minutes || 0, seconds || 0, 0);
+        timestamp = now;
+        remaining = remaining.slice(timeMatch[0].length);
+      }
+    }
+
+    const labelMatch = remaining.match(/^\[[^\]]+\]\s*/);
+    if (labelMatch) {
+      remaining = remaining.slice(labelMatch[0].length);
+    }
+
+    const upper = remaining.toUpperCase();
+    let level = 'info';
+    let type: MessageType | string = 'stdout';
+
+    if (remaining.includes('❌') || upper.includes('ERR') || upper.includes('ERROR')) {
+      level = 'error';
+      type = 'error';
+    } else if (remaining.includes('⚠️') || upper.includes('WARN')) {
+      level = 'warn';
+      type = 'warn';
+    } else if (remaining.includes('🔍') || upper.includes('DEBUG')) {
+      level = 'debug';
+      type = 'debug';
+    } else if (remaining.includes('ℹ️') || upper.includes('INFO')) {
+      level = 'info';
+      type = 'info';
+    }
+
+    return { timestamp, message: remaining, level, type };
+  }
+
   private inferImportance(type: string, level: string): LogImportance {
     if (level === 'error' || type === 'error' || type === 'result') return LogImportance.HIGH;
     if (type === 'tool' || type === 'tool_result') return LogImportance.MEDIUM;