@litmers/cursorflow-orchestrator 0.1.40 → 0.2.2

package/src/core/runner/pipeline.ts

@@ -13,14 +13,30 @@ import {
   TaskExecutionResult, 
   LaneState
 } from '../../types';
-import { 
-  cursorAgentCreateChat 
-} from './agent';
+import { AgentSupervisor } from '../agent-supervisor';
 import { 
   runTask, 
-  waitForTaskDependencies, 
-  mergeDependencyBranches 
+  waitForTaskDependencies
 } from './task';
+import { GitPipelineCoordinator } from '../git-pipeline-coordinator';
+import {
+  readPendingIntervention,
+  clearPendingIntervention,
+  InterventionRequest,
+} from '../intervention';
+import {
+  getHookManager,
+  HookPoint,
+  createBeforeTaskContext,
+  createAfterTaskContext,
+  createOnErrorContext,
+  createOnLaneEndContext,
+  FlowAbortError,
+  FlowRetryError,
+  TaskDefinition,
+  TaskResult as HookTaskResult,
+  DependencyResult,
+} from '../../hooks';
 
 /**
  * Validate task configuration
@@ -37,6 +53,26 @@ function validateTaskConfig(config: RunnerConfig): void {
   }
 }
 
+/**
+ * Check for pending intervention and return intervention message if present
+ * This is called at the start of each task to inject intervention messages
+ */
+function checkAndConsumePendingIntervention(runDir: string): InterventionRequest | null {
+  const intervention = readPendingIntervention(runDir);
+  
+  if (intervention) {
+    logger.info(`📨 Pending intervention found (type: ${intervention.type})`);
+    logger.info(`   Message: "${intervention.message.substring(0, 80)}${intervention.message.length > 80 ? '...' : ''}"`);
+    
+    // Clear the intervention file so it's not picked up again
+    clearPendingIntervention(runDir);
+    
+    return intervention;
+  }
+  
+  return null;
+}
+
 /**
  * Run all tasks in sequence
  */
@@ -175,68 +211,13 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   logger.info(`Worktree: ${worktreeDir}`);
   logger.info(`Tasks: ${config.tasks.length}`);
   
-  // Check if worktree needs to be created or repaired
-  const worktreeNeedsCreation = !fs.existsSync(worktreeDir);
-  const worktreeIsInvalid = !worktreeNeedsCreation && !git.isValidWorktree(worktreeDir);
-  
-  if (worktreeIsInvalid) {
-    // Directory exists but is NOT a valid worktree - this can cause branch leakage!
-    // Clean it up and recreate
-    logger.warn(`⚠️ Directory exists but is not a valid worktree: ${worktreeDir}`);
-    logger.info(`   Cleaning up invalid directory and recreating worktree...`);
-    try {
-      git.cleanupInvalidWorktreeDir(worktreeDir);
-    } catch (e: any) {
-      logger.error(`Failed to cleanup invalid worktree directory: ${e.message}`);
-      throw new Error(`Cannot proceed: worktree directory is invalid and cleanup failed`);
-    }
-  }
-  
-  // Create worktree if it doesn't exist or was just cleaned up
-  if (worktreeNeedsCreation || worktreeIsInvalid) {
-    // Use a simple retry mechanism for Git worktree creation to handle potential race conditions
-    let retries = 3;
-    let lastError: Error | null = null;
-    
-    while (retries > 0) {
-      try {
-        // Ensure parent directory exists before calling git worktree
-        const worktreeParent = path.dirname(worktreeDir);
-        if (!fs.existsSync(worktreeParent)) {
-          fs.mkdirSync(worktreeParent, { recursive: true });
-        }
-
-        // Always use the current branch (already captured at start) as the base branch
-        await git.createWorktreeAsync(worktreeDir, pipelineBranch, { 
-          baseBranch: currentBranch,
-          cwd: repoRoot,
-        });
-        break; // Success
-      } catch (e: any) {
-        lastError = e;
-        retries--;
-        if (retries > 0) {
-          const delay = Math.floor(Math.random() * 1000) + 500;
-          logger.warn(`Worktree creation failed, retrying in ${delay}ms... (${retries} retries left)`);
-          await new Promise(resolve => setTimeout(resolve, delay));
-        }
-      }
-    }
-    
-    if (retries === 0 && lastError) {
-      throw new Error(`Failed to create Git worktree after retries: ${lastError.message}`);
-    }
-  } else {
-    // Worktree exists and is valid - reuse it
-    logger.info(`Reusing existing worktree: ${worktreeDir}`);
-    try {
-      git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
-    } catch (e) {
-      // If checkout fails in a valid worktree, log warning but continue
-      // The worktree might be on a different branch that will be handled later
-      logger.warn(`Failed to checkout branch ${pipelineBranch} in existing worktree: ${e}`);
-    }
-  }
+  const gitCoordinator = new GitPipelineCoordinator();
+  await gitCoordinator.ensureWorktree({
+    worktreeDir,
+    pipelineBranch,
+    repoRoot,
+    baseBranch: currentBranch,
+  });
   
   // Change current directory to worktree for all subsequent operations
   // This ensures that all spawned processes (like git or npm) inherit the correct CWD
@@ -245,7 +226,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   
   // Create chat
   logger.info('Creating chat session...');
-  const chatId = cursorAgentCreateChat(worktreeDir);
+  const agentSupervisor = new AgentSupervisor();
+  const chatId = agentSupervisor.createChat(worktreeDir);
   
   // Initialize state if not loaded
   if (!state) {
@@ -281,6 +263,10 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   let previousTaskBranch: string | null = null;
   
   for (let i = startIndex; i < config.tasks.length; i++) {
+    // Check for pending intervention at the start of each task
+    // This handles both resume cases and mid-run interventions
+    const intervention = checkAndConsumePendingIntervention(runDir);
+    
     // Re-read tasks file to allow dynamic updates to future tasks
     try {
       const currentConfig = JSON.parse(fs.readFileSync(tasksFile, 'utf8')) as RunnerConfig;
@@ -308,7 +294,15 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       logger.warn(`⚠️ Could not reload tasks from ${tasksFile}. Using existing configuration. (${e instanceof Error ? e.message : String(e)})`);
     }
 
-    const task = config.tasks[i]!;
+    // Clone the task to avoid mutating the original config
+    let task = { ...config.tasks[i]! };
+    
+    // If there's a pending intervention, prepend it to the task prompt
+    if (intervention) {
+      const originalPrompt = task.prompt;
+      task.prompt = `${intervention.message}\n\n---\n\nContinue with the following task:\n${originalPrompt}`;
+      logger.info(`🔀 Intervention message injected into task prompt`);
+    }
     const taskBranch = `${pipelineBranch}--${String(i + 1).padStart(2, '0')}-${task.name}`;
 
     // Delete previous task branch if it exists (Task 1 deleted when Task 2 starts, etc.)
@@ -348,7 +342,7 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
           onTimeout: 'fail',
         });
         
-        await mergeDependencyBranches(task.dependsOn, runDir, worktreeDir, pipelineBranch);
+        await gitCoordinator.mergeDependencyBranches(task.dependsOn, runDir, worktreeDir, pipelineBranch);
         
         state.status = 'running';
         state.waitingFor = [];
@@ -371,8 +365,103 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       }
     }
     
+    // =========================================================================
+    // Hook System: Prepare context options
+    // =========================================================================
+    const hookManager = getHookManager();
+    const taskStartTime = Date.now();
+    
+    // Build completed tasks list for hooks
+    const completedTasksForHooks: HookTaskResult[] = (state.completedTasks || []).map((name, idx) => ({
+      name,
+      status: 'success' as const,
+      duration: 0, // Not tracked historically
+    }));
+    
+    // Convert config.tasks to TaskDefinition format
+    const tasksAsDefinitions: TaskDefinition[] = config.tasks.map(t => ({
+      name: t.name,
+      prompt: t.prompt,
+      model: t.model,
+      timeout: t.timeout,
+      dependsOn: t.dependsOn,
+    }));
+    
+    const hookContextOptions = {
+      laneName,
+      runId: path.basename(path.dirname(runDir)),
+      taskIndex: i,
+      totalTasks: config.tasks.length,
+      task: {
+        name: task.name,
+        prompt: task.prompt,
+        model: task.model || config.model || 'sonnet-4.5',
+        dependsOn: task.dependsOn,
+      },
+      worktreeDir,
+      runDir,
+      taskBranch,
+      pipelineBranch,
+      tasksFile,
+      chatId,
+      tasks: tasksAsDefinitions,
+      completedTasks: completedTasksForHooks,
+      dependencyResults: [] as DependencyResult[], // TODO: populate from actual deps
+      taskStartTime,
+      laneStartTime: state.startTime || Date.now(),
+      agentSupervisor,
+    };
+    
+    // =========================================================================
+    // Hook: beforeTask
+    // =========================================================================
+    let currentTask = task;
+    
+    if (hookManager.hasHooks(HookPoint.BEFORE_TASK)) {
+      try {
+        const { context, flowController } = createBeforeTaskContext(hookContextOptions);
+        await hookManager.executeBeforeTask(context);
+        
+        // Check if prompt was modified
+        const modifiedPrompt = flowController.getModifiedPrompt();
+        if (modifiedPrompt) {
+          currentTask = { ...task, prompt: modifiedPrompt };
+          logger.info(`🔧 [Hook] Task prompt modified by beforeTask hook`);
+        }
+        
+        // Re-read tasks in case hooks modified them
+        hookContextOptions.tasks = config.tasks.map(t => ({
+          name: t.name,
+          prompt: t.prompt,
+          model: t.model,
+          timeout: t.timeout,
+          dependsOn: t.dependsOn,
+        }));
+      } catch (hookError: any) {
+        if (hookError instanceof FlowAbortError) {
+          state.status = 'failed';
+          state.error = hookError.message;
+          saveState(statePath, state);
+          logger.error(`[Hook] Flow aborted: ${hookError.message}`);
+          process.exit(1);
+        }
+        if (hookError instanceof FlowRetryError) {
+          // Retry with modified prompt if provided
+          if (hookError.modifiedPrompt) {
+            currentTask = { ...task, prompt: hookError.modifiedPrompt };
+          }
+          logger.info(`[Hook] Retry requested, continuing with ${hookError.modifiedPrompt ? 'modified' : 'original'} prompt`);
+        } else {
+          logger.warn(`[Hook] beforeTask hook error: ${hookError.message}`);
+        }
+      }
+    }
+    
+    // =========================================================================
+    // Execute Task
+    // =========================================================================
     const result = await runTask({
-      task,
+      task: currentTask,
       config,
       index: i,
       worktreeDir,
@@ -380,6 +469,8 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       taskBranch,
       chatId,
       runDir,
+      agentSupervisor,
+      laneName,
     });
     
     results.push(result);
@@ -392,8 +483,74 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     }
     saveState(statePath, state);
     
+    // =========================================================================
+    // Hook: afterTask
+    // =========================================================================
+    if (hookManager.hasHooks(HookPoint.AFTER_TASK)) {
+      try {
+        // Update completed tasks for the context
+        hookContextOptions.completedTasks = (state.completedTasks || []).map((name) => ({
+          name,
+          status: 'success' as const,
+          duration: Date.now() - taskStartTime,
+        }));
+        
+        const afterTaskResult = {
+          status: (result.status === 'FINISHED' ? 'success' : 
+                   result.status === 'BLOCKED_DEPENDENCY' ? 'blocked' : 'error') as 'success' | 'error' | 'blocked',
+          exitCode: result.status === 'FINISHED' ? 0 : 1,
+          error: result.error,
+        };
+        
+        const { context } = createAfterTaskContext(hookContextOptions, afterTaskResult);
+        await hookManager.executeAfterTask(context);
+        
+        // Re-read tasks in case hooks modified them (injected new tasks)
+        try {
+          const updatedConfig = JSON.parse(fs.readFileSync(tasksFile, 'utf8')) as RunnerConfig;
+          if (updatedConfig.tasks && updatedConfig.tasks.length !== config.tasks.length) {
+            config.tasks = updatedConfig.tasks;
+            state.totalTasks = config.tasks.length;
+            saveState(statePath, state);
+            logger.info(`📋 [Hook] Task list updated by afterTask hook. New total: ${state.totalTasks}`);
+          }
+        } catch {
+          // Ignore file read errors
+        }
+      } catch (hookError: any) {
+        if (hookError instanceof FlowAbortError) {
+          state.status = 'failed';
+          state.error = hookError.message;
+          saveState(statePath, state);
+          logger.error(`[Hook] Flow aborted: ${hookError.message}`);
+          process.exit(1);
+        }
+        if (hookError instanceof FlowRetryError) {
+          // Decrement index to retry this task
+          i--;
+          logger.info(`[Hook] Retry requested for task "${task.name}"`);
+          continue;
+        }
+        logger.warn(`[Hook] afterTask hook error: ${hookError.message}`);
+      }
+    }
+    
     // Handle blocked or error
     if (result.status === 'BLOCKED_DEPENDENCY') {
+      // Execute onError hook for blocked state
+      if (hookManager.hasHooks(HookPoint.ON_ERROR)) {
+        try {
+          const { context } = createOnErrorContext(hookContextOptions, {
+            type: 'unknown',
+            message: 'Task blocked on dependency change',
+            retryable: false,
+          });
+          await hookManager.executeOnError(context);
+        } catch {
+          // Continue with normal error handling
+        }
+      }
+      
       state.status = 'failed';
       state.dependencyRequest = result.dependencyRequest || null;
       saveState(statePath, state);
@@ -410,6 +567,24 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     }
     
     if (result.status !== 'FINISHED') {
+      // Execute onError hook
+      if (hookManager.hasHooks(HookPoint.ON_ERROR)) {
+        try {
+          const { context } = createOnErrorContext(hookContextOptions, {
+            type: 'agent_error',
+            message: result.error || 'Unknown error',
+            retryable: true,
+          });
+          await hookManager.executeOnError(context);
+        } catch (hookError: any) {
+          if (hookError instanceof FlowRetryError) {
+            i--;
+            logger.info(`[Hook] Retry requested after error`);
+            continue;
+          }
+        }
+      }
+      
       state.status = 'failed';
       state.error = result.error || 'Unknown error';
       saveState(statePath, state);
@@ -418,52 +593,18 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     }
     
     // Merge into pipeline
-    logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
-    
-    // Ensure we are on the pipeline branch before merging the task branch
-    logger.info(`🔄 Switching to pipeline branch ${pipelineBranch} to integrate changes`);
-    git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
-    
-    // Pre-check for conflicts (should be rare since task branch was created from pipeline)
-    const conflictCheck = git.checkMergeConflict(taskBranch, { cwd: worktreeDir });
-    if (conflictCheck.willConflict) {
-      logger.warn(`⚠️ Unexpected conflict detected when merging ${taskBranch}`);
-      logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
-      logger.warn(`   This may indicate concurrent modifications to ${pipelineBranch}`);
-      
-      events.emit('merge.conflict_detected', {
+    try {
+      gitCoordinator.mergeTaskIntoPipeline({
         taskName: task.name,
         taskBranch,
         pipelineBranch,
-        conflictingFiles: conflictCheck.conflictingFiles,
-        preCheck: true,
+        worktreeDir,
       });
-    }
-    
-    // Use safeMerge instead of plain merge for better error handling
-    logger.info(`🔀 Merging task ${task.name} (${taskBranch}) into ${pipelineBranch}`);
-    const mergeResult = git.safeMerge(taskBranch, { 
-      cwd: worktreeDir, 
-      noFf: true,
-      message: `chore: merge task ${task.name} into pipeline`,
-      abortOnConflict: true,
-    });
-    
-    if (!mergeResult.success) {
-      if (mergeResult.conflict) {
-        logger.error(`❌ Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
-        state.status = 'failed';
-        state.error = `Merge conflict when integrating task ${task.name}: ${mergeResult.conflictingFiles.join(', ')}`;
-        saveState(statePath, state);
-        process.exit(1);
-      }
-      throw new Error(mergeResult.error || 'Merge failed');
-    }
-    
-    // Log changed files
-    const stats = git.getLastOperationStats(worktreeDir);
-    if (stats) {
-      logger.info('Changed files:\n' + stats);
+    } catch (e: any) {
+      state.status = 'failed';
+      state.error = e.message;
+      saveState(statePath, state);
+      process.exit(1);
     }
 
     git.push(pipelineBranch, { cwd: worktreeDir });
@@ -487,30 +628,11 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
   }
 
   // 2. Create flow branch from pipelineBranch and cleanup
-  if (flowBranch !== pipelineBranch) {
-    logger.info(`🌿 Creating final flow branch: ${flowBranch}`);
-    try {
-      // Create/Overwrite flow branch from pipeline branch
-      git.runGit(['checkout', '-B', flowBranch, pipelineBranch], { cwd: worktreeDir });
-      git.push(flowBranch, { cwd: worktreeDir, setUpstream: true });
-      
-      // 3. Delete temporary pipeline branch (LOCAL ONLY)
-      // Keep remote branch for dependency lanes that may need to merge it!
-      logger.info(`🗑️ Deleting local pipeline branch: ${pipelineBranch}`);
-      // Must be on another branch to delete pipelineBranch
-      git.runGit(['checkout', flowBranch], { cwd: worktreeDir });
-      git.deleteBranch(pipelineBranch, { cwd: worktreeDir, force: true });
-      
-      // NOTE: We intentionally keep the remote pipeline branch alive
-      // because other lanes with dependsOn may need to merge it.
-      // The pipeline branch on remote serves as the "official" completion branch
-      // that dependency-tracking code in task.ts uses (via state.pipelineBranch).
-      
-      logger.success(`✓ Flow branch '${flowBranch}' created. Remote pipeline branch preserved for dependencies.`);
-    } catch (e) {
-      logger.error(`❌ Failed during final consolidation: ${e}`);
-    }
-  }
+  gitCoordinator.finalizeFlowBranch({
+    flowBranch,
+    pipelineBranch,
+    worktreeDir,
+  });
 
   // Complete
   state.status = 'completed';
@@ -528,7 +650,65 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     // Ignore
   }
   
+  // =========================================================================
+  // Hook: onLaneEnd
+  // =========================================================================
+  const hookManager = getHookManager();
+  if (hookManager.hasHooks(HookPoint.ON_LANE_END)) {
+    try {
+      const totalDuration = (state.endTime || Date.now()) - (state.startTime || Date.now());
+      const failedCount = results.filter(r => r.status !== 'FINISHED').length;
+      
+      const laneEndContextOptions = {
+        laneName,
+        runId: path.basename(path.dirname(runDir)),
+        taskIndex: config.tasks.length - 1,
+        totalTasks: config.tasks.length,
+        task: {
+          name: config.tasks[config.tasks.length - 1]?.name || 'unknown',
+          prompt: '',
+          model: config.model || 'sonnet-4.5',
+        },
+        worktreeDir,
+        runDir,
+        taskBranch: pipelineBranch,
+        pipelineBranch,
+        tasksFile,
+        chatId,
+        tasks: config.tasks.map(t => ({
+          name: t.name,
+          prompt: t.prompt,
+          model: t.model,
+          timeout: t.timeout,
+          dependsOn: t.dependsOn,
+        })),
+        completedTasks: (state.completedTasks || []).map(name => ({
+          name,
+          status: 'success' as const,
+          duration: 0,
+        })),
+        dependencyResults: [] as DependencyResult[],
+        taskStartTime: state.startTime || Date.now(),
+        laneStartTime: state.startTime || Date.now(),
+        agentSupervisor,
+      };
+      
+      const { context } = createOnLaneEndContext(laneEndContextOptions, {
+        status: 'completed',
+        completedTasks: results.length - failedCount,
+        failedTasks: failedCount,
+        totalDuration,
+      });
+      
+      // Execute async (don't block lane completion)
+      hookManager.executeOnLaneEnd(context).catch(err => {
+        logger.warn(`[Hook] onLaneEnd error: ${err.message}`);
+      });
+    } catch (hookError: any) {
+      logger.warn(`[Hook] onLaneEnd setup error: ${hookError.message}`);
+    }
+  }
+  
   logger.success('All tasks completed!');
   return results;
 }
-