@litmers/cursorflow-orchestrator 0.1.40 → 0.2.2

package/src/core/runner/task.ts

@@ -1,17 +1,12 @@
-import * as fs from 'fs';
 import * as path from 'path';
 import * as git from '../../utils/git';
 import * as logger from '../../utils/logger';
 import { events } from '../../utils/events';
 import { safeJoin } from '../../utils/path';
 import { appendLog, createConversationEntry } from '../../utils/state';
-import { Task, RunnerConfig, TaskExecutionResult, LaneState } from '../../types';
-import { loadState } from '../../utils/state';
+import { Task, RunnerConfig, TaskExecutionResult } from '../../types';
 import { waitForTaskDependencies as waitForDeps, DependencyWaitOptions } from '../../utils/dependency';
-import { 
-  cursorAgentSend, 
-  extractDependencyRequest 
-} from './agent';
+import { extractDependencyRequest } from './agent';
 import { 
   wrapPrompt, 
   applyDependencyFilePermissions 
@@ -23,6 +18,7 @@ import {
   clearDependencyRequestFile,
   DependencyResult
 } from './utils';
+import { AgentSupervisor } from '../agent-supervisor';
 
 /**
  * Wait for task-level dependencies to be completed by other lanes
@@ -56,78 +52,6 @@ export async function waitForTaskDependencies(
   }
 }
 
-/**
- * Merge branches from dependency lanes with safe merge and conflict pre-check
- */
-export async function mergeDependencyBranches(deps: string[], runDir: string, worktreeDir: string, pipelineBranch: string): Promise<void> {
-  if (!deps || deps.length === 0) return;
-
-  const lanesRoot = path.dirname(runDir);
-  const lanesToMerge = new Set(deps.map(d => d.split(':')[0]!));
-
-  // Ensure we are on the pipeline branch before merging dependencies
-  logger.info(`🔄 Syncing with ${pipelineBranch} before merging dependencies`);
-  git.runGit(['checkout', pipelineBranch], { cwd: worktreeDir });
-
-  for (const laneName of lanesToMerge) {
-    const depStatePath = safeJoin(lanesRoot, laneName, 'state.json');
-    if (!fs.existsSync(depStatePath)) continue;
-
-    try {
-      const state = loadState<LaneState>(depStatePath);
-      if (!state?.pipelineBranch) continue;
-      
-      logger.info(`Merging branch from ${laneName}: ${state.pipelineBranch}`);
-      
-      // Ensure we have the latest from remote
-      git.runGit(['fetch', 'origin', state.pipelineBranch], { cwd: worktreeDir, silent: true });
-      
-      // Use the remote ref for merging (origin/<branch>) since dependency branches
-      // are pushed to remote by other lanes and may not exist as local branches
-      const remoteBranchRef = `origin/${state.pipelineBranch}`;
-      
-      // Pre-check for conflicts before attempting merge
-      const conflictCheck = git.checkMergeConflict(remoteBranchRef, { cwd: worktreeDir });
-      
-      if (conflictCheck.willConflict) {
-        logger.warn(`⚠️ Pre-check: Merge conflict detected with ${laneName}`);
-        logger.warn(`   Conflicting files: ${conflictCheck.conflictingFiles.join(', ')}`);
-        
-        // Emit event for potential auto-recovery or notification
-        events.emit('merge.conflict_detected', {
-          laneName,
-          targetBranch: state.pipelineBranch,
-          conflictingFiles: conflictCheck.conflictingFiles,
-          preCheck: true,
-        });
-        
-        throw new Error(`Pre-merge conflict check failed: ${conflictCheck.conflictingFiles.join(', ')}. Consider rebasing or resolving conflicts manually.`);
-      }
-      
-      // Use safe merge with conflict detection - merge from remote ref
-      const mergeResult = git.safeMerge(remoteBranchRef, {
-        cwd: worktreeDir,
-        noFf: true,
-        message: `chore: merge task dependency from ${laneName}`,
-        abortOnConflict: true,
-      });
-      
-      if (!mergeResult.success) {
-        if (mergeResult.conflict) {
-          logger.error(`Merge conflict with ${laneName}: ${mergeResult.conflictingFiles.join(', ')}`);
-          throw new Error(`Merge conflict: ${mergeResult.conflictingFiles.join(', ')}`);
-        }
-        throw new Error(mergeResult.error || 'Merge failed');
-      }
-      
-      logger.success(`✓ Merged ${laneName}`);
-    } catch (e) {
-      logger.error(`Failed to merge branch from ${laneName}: ${e}`);
-      throw e;
-    }
-  }
-}
-
 /**
  * Run a single task
  */
@@ -141,6 +65,8 @@ export async function runTask({
   chatId,
   runDir,
   runRoot,
+  agentSupervisor,
+  laneName,
 }: {
   task: Task;
   config: RunnerConfig;
@@ -151,6 +77,8 @@ export async function runTask({
   chatId: string;
   runDir: string;
   runRoot?: string;
+  agentSupervisor: AgentSupervisor;
+  laneName: string;
 }): Promise<TaskExecutionResult> {
   // Calculate runRoot if not provided (runDir is lanes/{laneName}/, runRoot is parent of lanes/)
   const calculatedRunRoot = runRoot || path.dirname(path.dirname(runDir));
@@ -216,32 +144,20 @@ export async function runTask({
   }));
   
   logger.info('Sending prompt to agent...');
-  const startTime = Date.now();
-  events.emit('agent.prompt_sent', {
-    taskName: task.name,
-    model,
-    promptLength: wrappedPrompt.length,
-  });
-
-  const r1 = await cursorAgentSend({
+  const r1 = await agentSupervisor.sendTaskPrompt({
     workspaceDir: worktreeDir,
     chatId,
     prompt: wrappedPrompt,
     model,
+    laneName,
     signalDir: runDir,
     timeout,
     enableIntervention: config.enableIntervention,
     outputFormat: config.agentOutputFormat,
     taskName: task.name,
-  });
-  
-  const duration = Date.now() - startTime;
-  events.emit('agent.response_received', {
-    taskName: task.name,
-    ok: r1.ok,
-    duration,
-    responseLength: r1.resultText?.length || 0,
-    error: r1.error,
+    browser: task.browser || config.browser,
+    autoApproveCommands: config.autoApproveCommands,
+    autoApproveMcps: config.autoApproveMcps,
   });
 
   appendLog(convoPath, createConversationEntry('assistant', r1.resultText || r1.error || 'No response', {
@@ -308,4 +224,3 @@ export async function runTask({
     status: 'FINISHED',
   };
 }
-

package/src/core/runner.ts

@@ -36,6 +36,8 @@ if (require.main === module) {
   const startIdxIdx = args.indexOf('--start-index');
   const pipelineBranchIdx = args.indexOf('--pipeline-branch');
   const worktreeDirIdx = args.indexOf('--worktree-dir');
+  const browser = args.includes('--browser');
+  const skipPreflight = args.includes('--skip-preflight');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
   const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
@@ -75,6 +77,9 @@ if (require.main === module) {
     if (forcedWorktreeDir) {
       config.worktreeDir = forcedWorktreeDir;
     }
+    if (browser) {
+      config.browser = true;
+    }
   } catch (error: any) {
     console.error(`Failed to load tasks file: ${error.message}`);
     process.exit(1);
@@ -87,11 +92,12 @@ if (require.main === module) {
   };
   
   // Add agent output format default
-  config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'json';
+  config.agentOutputFormat = config.agentOutputFormat || globalConfig?.agentOutputFormat || 'stream-json';
   
   // Merge intervention and logging settings
   config.enableIntervention = config.enableIntervention ?? globalConfig?.enableIntervention ?? true;
   config.verboseGit = config.verboseGit ?? globalConfig?.verboseGit ?? false;
+  config.browser = config.browser ?? globalConfig?.browser ?? false;
   
   // Handle process interruption to ensure cleanup
   const handleSignal = (signal: string) => {
@@ -105,7 +111,7 @@ if (require.main === module) {
   process.on('SIGTERM', () => handleSignal('SIGTERM'));
 
   // Run tasks
-  runTasks(tasksFile, config, runDir, { startIndex })
+  runTasks(tasksFile, config, runDir, { startIndex, skipPreflight })
     .then(() => {
       process.exit(0);
     })

package/src/core/stall-detection.ts

@@ -18,6 +18,14 @@ import { ChildProcess } from 'child_process';
 import * as logger from '../utils/logger';
 import { events } from '../utils/events';
 import { safeJoin } from '../utils/path';
+import {
+  createInterventionRequest,
+  InterventionType,
+  createContinueMessage,
+  createStrongerPromptMessage,
+  createRestartMessage,
+  killAndWait,
+} from './intervention';
 
 // ============================================================================
 // 설정 (Configuration)
@@ -732,8 +740,10 @@ export class StallDetectionService {
    * Stall 체크 및 복구 액션 실행
    * 
    * @returns 실행된 분석 결과 (orchestrator에서 추가 처리 필요시 사용)
+   * 
+   * 새로운 방식에서는 복구 액션이 프로세스 중단을 포함하므로 async
    */
-  checkAndRecover(laneName: string): StallAnalysis {
+  async checkAndRecover(laneName: string): Promise<StallAnalysis> {
     const state = this.laneStates.get(laneName);
     if (!state) {
       return {
@@ -760,18 +770,18 @@ export class StallDetectionService {
     // 실패 이력 기록
     this.recordFailure(state, analysis);
     
-    // 액션 실행
+    // 액션 실행 (프로세스 중단 포함 - await 필요)
     switch (analysis.action) {
       case RecoveryAction.SEND_CONTINUE:
-        this.sendContinueSignal(state);
+        await this.sendContinueSignal(state);
         break;
         
       case RecoveryAction.SEND_STRONGER_PROMPT:
-        this.sendStrongerPrompt(state);
+        await this.sendStrongerPrompt(state);
         break;
         
       case RecoveryAction.REQUEST_RESTART:
-        this.requestRestart(state);
+        await this.requestRestart(state);
         break;
         
       case RecoveryAction.RUN_DOCTOR:
@@ -787,9 +797,14 @@ export class StallDetectionService {
   }
   
   /**
-   * Continue 신호 발송
+   * Continue 신호 발송 - 프로세스 중단 및 개입 메시지와 함께 resume
+   * 
+   * 새로운 방식:
+   * 1. pending-intervention.json 생성
+   * 2. 현재 프로세스 SIGTERM으로 종료
+   * 3. Orchestrator가 감지하여 개입 메시지와 함께 resume
    */
-  private sendContinueSignal(state: LaneStallState): void {
+  private async sendContinueSignal(state: LaneStallState): Promise<void> {
     // Intervention이 비활성화된 경우 신호를 보내지 않고 phase만 업데이트
     if (state.interventionEnabled === false) {
       logger.warn(`[${state.laneName}] Continue signal skipped (intervention disabled). Stall will escalate on next check.`);
@@ -803,16 +818,26 @@ export class StallDetectionService {
       return;
     }
     
-    const interventionPath = safeJoin(state.laneRunDir, 'intervention.txt');
-    
     try {
-      fs.writeFileSync(interventionPath, 'continue');
+      // 1. 개입 요청 생성
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.CONTINUE_SIGNAL,
+        message: createContinueMessage(),
+        source: 'stall-detector',
+        priority: 5,
+      });
+      
+      // 2. 프로세스 종료 (있는 경우)
+      if (state.childProcess?.pid && !state.childProcess.killed) {
+        logger.info(`[${state.laneName}] Interrupting process ${state.childProcess.pid} for continue signal`);
+        await killAndWait(state.childProcess.pid);
+      }
       
       state.phase = StallPhase.CONTINUE_SENT;
       state.lastPhaseChangeTime = Date.now();
       state.continueSignalCount++;
       
-      logger.info(`[${state.laneName}] Sent continue signal (#${state.continueSignalCount})`);
+      logger.info(`[${state.laneName}] Continue signal queued (#${state.continueSignalCount}) - agent will resume with intervention`);
       
       events.emit('recovery.continue_signal', {
         laneName: state.laneName,
@@ -825,9 +850,9 @@ export class StallDetectionService {
   }
   
   /**
-   * Stronger prompt 발송
+   * Stronger prompt 발송 - 프로세스 중단 및 강력한 개입 메시지와 함께 resume
    */
-  private sendStrongerPrompt(state: LaneStallState): void {
+  private async sendStrongerPrompt(state: LaneStallState): Promise<void> {
     // Intervention이 비활성화된 경우 신호를 보내지 않고 phase만 업데이트
     if (state.interventionEnabled === false) {
       logger.warn(`[${state.laneName}] Stronger prompt skipped (intervention disabled). Will escalate to restart.`);
@@ -841,20 +866,25 @@ export class StallDetectionService {
       return;
     }
     
-    const interventionPath = safeJoin(state.laneRunDir, 'intervention.txt');
-    const prompt = `[SYSTEM INTERVENTION] You seem to be stuck or waiting. 
-Please continue with your current task immediately. 
-If you're waiting for something, explain what you need and proceed with what you can do now.
-If you've completed the task, please summarize your work and finish.
-If you encountered a git error, resolve it and continue.`;
-    
     try {
-      fs.writeFileSync(interventionPath, prompt);
+      // 1. 개입 요청 생성
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.STRONGER_PROMPT,
+        message: createStrongerPromptMessage(),
+        source: 'stall-detector',
+        priority: 7,
+      });
+      
+      // 2. 프로세스 종료 (있는 경우)
+      if (state.childProcess?.pid && !state.childProcess.killed) {
+        logger.warn(`[${state.laneName}] Interrupting process ${state.childProcess.pid} for stronger prompt`);
+        await killAndWait(state.childProcess.pid);
+      }
       
       state.phase = StallPhase.STRONGER_PROMPT_SENT;
       state.lastPhaseChangeTime = Date.now();
       
-      logger.warn(`[${state.laneName}] Sent stronger prompt after continue signal failed`);
+      logger.warn(`[${state.laneName}] Stronger prompt queued - agent will resume with intervention`);
       
       events.emit('recovery.stronger_prompt', {
         laneName: state.laneName,
@@ -865,16 +895,31 @@ If you encountered a git error, resolve it and continue.`;
   }
   
   /**
-   * 재시작 요청 (프로세스 종료)
+   * 재시작 요청 - 프로세스 종료 및 재시작 메시지와 함께 resume
    */
-  private requestRestart(state: LaneStallState): void {
+  private async requestRestart(state: LaneStallState): Promise<void> {
     state.restartCount++;
     state.phase = StallPhase.RESTART_REQUESTED;
     state.lastPhaseChangeTime = Date.now();
     
-    // 프로세스 종료
-    if (state.childProcess && !state.childProcess.killed) {
+    // 1. 개입 요청 생성 (재시작 메시지)
+    if (state.laneRunDir) {
+      createInterventionRequest(state.laneRunDir, {
+        type: InterventionType.SYSTEM_RESTART,
+        message: createRestartMessage('Agent became unresponsive after multiple intervention attempts'),
+        source: 'stall-detector',
+        priority: 9,
+        metadata: {
+          restartCount: state.restartCount,
+          maxRestarts: this.config.maxRestarts,
+        },
+      });
+    }
+    
+    // 2. 프로세스 종료 (SIGKILL 사용 - 강제 종료)
+    if (state.childProcess?.pid && !state.childProcess.killed) {
       try {
+        // SIGKILL로 즉시 종료 (SIGTERM이 안 먹힐 수 있으므로)
         state.childProcess.kill('SIGKILL');
         logger.info(`[StallService] [${state.laneName}] Killed process ${state.childProcess.pid}`);
       } catch (error: any) {
@@ -882,7 +927,7 @@ If you encountered a git error, resolve it and continue.`;
       }
     }
     
-    logger.warn(`[${state.laneName}] Killing and restarting lane (restart #${state.restartCount})`);
+    logger.warn(`[${state.laneName}] Restart requested (restart #${state.restartCount}/${this.config.maxRestarts})`);
     
     events.emit('recovery.restart', {
       laneName: state.laneName,

package/src/hooks/contexts/index.ts

@@ -0,0 +1,256 @@
+/**
+ * CursorFlow Hook System - Context Builders
+ * 
+ * 각 Hook Point에 대한 컨텍스트를 생성하는 빌더 함수들입니다.
+ */
+
+import {
+  HookContext,
+  BeforeTaskContext,
+  AfterTaskContext,
+  OnErrorContext,
+  OnStallContext,
+  OnLaneEndContext,
+  TaskDefinition,
+  TaskResult,
+  DependencyResult,
+  FlowController,
+  HookDataAccessor,
+} from '../types';
+import { createDataAccessor, DataAccessorOptions } from '../data-accessor';
+import { createFlowController, FlowControllerOptions, FlowControllerImpl } from '../flow-controller';
+
+// ============================================================================
+// Base Context Builder Options
+// ============================================================================
+
+export interface BaseContextOptions {
+  /** Lane 이름 */
+  laneName: string;
+  /** Run ID */
+  runId: string;
+  /** 현재 태스크 인덱스 */
+  taskIndex: number;
+  /** 전체 태스크 수 */
+  totalTasks: number;
+  /** 현재 태스크 */
+  task: {
+    name: string;
+    prompt: string;
+    model: string;
+    dependsOn?: string[];
+  };
+  /** Worktree 디렉토리 */
+  worktreeDir: string;
+  /** Run 디렉토리 */
+  runDir: string;
+  /** 태스크 브랜치 */
+  taskBranch: string;
+  /** 파이프라인 브랜치 */
+  pipelineBranch: string;
+  /** 태스크 파일 경로 */
+  tasksFile: string;
+  /** Chat ID */
+  chatId: string;
+  /** 태스크 목록 (수정 가능 참조) */
+  tasks: TaskDefinition[];
+  /** 완료된 태스크 목록 */
+  completedTasks: TaskResult[];
+  /** 의존성 결과 */
+  dependencyResults: DependencyResult[];
+  /** 태스크 시작 시간 */
+  taskStartTime: number;
+  /** Lane 시작 시간 */
+  laneStartTime: number;
+  /** AgentSupervisor 인스턴스 */
+  agentSupervisor?: any;
+  /** Run Root */
+  runRoot?: string;
+}
+
+// ============================================================================
+// Context Builders
+// ============================================================================
+
+/**
+ * 기본 컨텍스트 생성
+ */
+function createBaseContext(options: BaseContextOptions): {
+  context: Omit<HookContext, 'flow' | 'getData'>;
+  flowController: FlowControllerImpl;
+  dataAccessor: HookDataAccessor;
+} {
+  // FlowController 생성
+  const flowControllerOptions: FlowControllerOptions = {
+    laneName: options.laneName,
+    runDir: options.runDir,
+    worktreeDir: options.worktreeDir,
+    currentTaskIndex: options.taskIndex,
+    tasks: options.tasks,
+    tasksFile: options.tasksFile,
+    chatId: options.chatId,
+    agentSupervisor: options.agentSupervisor,
+  };
+  
+  const flowController = createFlowController(flowControllerOptions);
+  
+  // DataAccessor 생성
+  const dataAccessorOptions: DataAccessorOptions = {
+    worktreeDir: options.worktreeDir,
+    runDir: options.runDir,
+    taskBranch: options.taskBranch,
+    pipelineBranch: options.pipelineBranch,
+    laneName: options.laneName,
+    taskName: options.task.name,
+    completedTasks: options.completedTasks,
+    pendingTasks: options.tasks.slice(options.taskIndex + 1),
+    dependencyResults: options.dependencyResults,
+    taskStartTime: options.taskStartTime,
+    laneStartTime: options.laneStartTime,
+    runRoot: options.runRoot,
+  };
+  
+  const dataAccessor = createDataAccessor(dataAccessorOptions);
+  
+  // 기본 컨텍스트
+  const context = {
+    laneName: options.laneName,
+    runId: options.runId,
+    taskIndex: options.taskIndex,
+    totalTasks: options.totalTasks,
+    task: options.task,
+  };
+  
+  return { context, flowController, dataAccessor };
+}
+
+/**
+ * beforeTask 컨텍스트 생성
+ */
+export function createBeforeTaskContext(options: BaseContextOptions): {
+  context: BeforeTaskContext;
+  flowController: FlowControllerImpl;
+} {
+  const { context, flowController, dataAccessor } = createBaseContext(options);
+  
+  return {
+    context: {
+      ...context,
+      flow: flowController,
+      getData: dataAccessor,
+    },
+    flowController,
+  };
+}
+
+/**
+ * afterTask 컨텍스트 생성
+ */
+export function createAfterTaskContext(
+  options: BaseContextOptions,
+  result: {
+    status: 'success' | 'error' | 'blocked';
+    exitCode?: number;
+    error?: string;
+  }
+): {
+  context: AfterTaskContext;
+  flowController: FlowControllerImpl;
+} {
+  const { context, flowController, dataAccessor } = createBaseContext(options);
+  
+  return {
+    context: {
+      ...context,
+      flow: flowController,
+      getData: dataAccessor,
+      result,
+    },
+    flowController,
+  };
+}
+
+/**
+ * onError 컨텍스트 생성
+ */
+export function createOnErrorContext(
+  options: BaseContextOptions,
+  error: {
+    type: 'agent_error' | 'git_error' | 'timeout' | 'unknown';
+    message: string;
+    stack?: string;
+    retryable: boolean;
+  }
+): {
+  context: OnErrorContext;
+  flowController: FlowControllerImpl;
+} {
+  const { context, flowController, dataAccessor } = createBaseContext(options);
+  
+  return {
+    context: {
+      ...context,
+      flow: flowController,
+      getData: dataAccessor,
+      error,
+    },
+    flowController,
+  };
+}
+
+/**
+ * onStall 컨텍스트 생성
+ */
+export function createOnStallContext(
+  options: BaseContextOptions,
+  stall: {
+    idleTimeMs: number;
+    lastActivity: string;
+    bytesReceived: number;
+    phase: 'initial' | 'warning' | 'critical';
+  }
+): {
+  context: OnStallContext;
+  flowController: FlowControllerImpl;
+} {
+  const { context, flowController, dataAccessor } = createBaseContext(options);
+  
+  return {
+    context: {
+      ...context,
+      flow: flowController,
+      getData: dataAccessor,
+      stall,
+    },
+    flowController,
+  };
+}
+
+/**
+ * onLaneEnd 컨텍스트 생성
+ */
+export function createOnLaneEndContext(
+  options: BaseContextOptions,
+  summary: {
+    status: 'completed' | 'failed' | 'aborted';
+    completedTasks: number;
+    failedTasks: number;
+    totalDuration: number;
+  }
+): {
+  context: OnLaneEndContext;
+  flowController: FlowControllerImpl;
+} {
+  const { context, flowController, dataAccessor } = createBaseContext(options);
+  
+  return {
+    context: {
+      ...context,
+      flow: flowController,
+      getData: dataAccessor,
+      summary,
+    },
+    flowController,
+  };
+}
+