@litmers/cursorflow-orchestrator 0.2.2 → 0.2.5

package/src/cli/index.ts

@@ -19,8 +19,6 @@ const COMMANDS: Record<string, CommandFn> = {
   new: require('./new'),
   add: require('./add'),
   config: require('./config'),
-  // Legacy prepare command (deprecated)
-  prepare: require('./prepare'),
   run: require('./run'),
   monitor: require('./monitor'),
   clean: require('./clean'),
@@ -32,7 +30,6 @@ const COMMANDS: Record<string, CommandFn> = {
   tasks: require('./tasks'),
   stop: require('./stop'),
   setup: require('./setup-commands').main,
-  'setup-commands': require('./setup-commands').main,
 };
 
 function printHelp(): void {
@@ -65,9 +62,6 @@ function printHelp(): void {
   \x1b[33msignal\x1b[0m <lane> <msg>          Directly intervene in a running lane
   \x1b[33mmodels\x1b[0m [options]             List available AI models
 
-\x1b[1mLEGACY\x1b[0m
-  \x1b[33mprepare\x1b[0m <feature> [opts]     (deprecated) Use 'new' + 'add' instead
-
 \x1b[1mQUICK START\x1b[0m
   $ \x1b[32mcursorflow new MyFeature --lanes "backend,frontend"\x1b[0m
   $ \x1b[32mcursorflow add MyFeature backend --task "name=impl|model=sonnet-4.5|prompt=API 구현"\x1b[0m

package/src/cli/logs.ts

@@ -10,10 +10,9 @@ import { safeJoin } from '../utils/path';
 import { 
   readJsonLog, 
   exportLogs, 
-  stripAnsi,
   JsonLogEntry 
 } from '../utils/enhanced-logger';
-import { formatPotentialJsonMessage } from '../utils/log-formatter';
+import { formatMessageForConsole, formatPotentialJsonMessage, stripAnsi } from '../services/logging/formatter';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 import { startLogViewer } from '../ui/log-viewer';
 
@@ -152,32 +151,33 @@ function listLanes(runDir: string): string[] {
 }
 
 /**
- * Read and display text logs
+ * Read and display text logs (converted from JSONL)
  */
 function displayTextLogs(
   laneDir: string, 
   options: LogsOptions
 ): void {
-  let logFile: string;
-  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
-  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-
-  if (options.raw) {
-    logFile = rawLog;
-  } else {
-    // Default to readable log (clean option also uses readable now)
-    logFile = readableLog;
-  }
+  const logFile = safeJoin(laneDir, 'terminal.jsonl');
   
   if (!fs.existsSync(logFile)) {
     console.log('No log file found.');
     return;
   }
   
-  let content = fs.readFileSync(logFile, 'utf8');
-  let lines = content.split('\n');
+  const entries = readJsonLog(logFile);
+  let lines = entries.map(entry => {
+    const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
+    const level = entry.level || 'info';
+    const content = entry.content || entry.message || '';
+    
+    if (options.raw) {
+      // In "raw" mode for JSONL, we show a basic text representation
+      return `[${ts}] [${level.toUpperCase()}] ${content}`;
+    }
+    return `[${ts}] [${level.toUpperCase()}] ${stripAnsi(content)}`;
+  });
   
-  // Apply filter (case-insensitive string match to avoid ReDoS)
+  // Apply filter
   if (options.filter) {
     const filterLower = options.filter.toLowerCase();
     lines = lines.filter(line => line.toLowerCase().includes(filterLower));
@@ -188,11 +188,6 @@ function displayTextLogs(
     lines = lines.slice(-options.tail);
   }
   
-  // Clean ANSI if needed (for clean mode or default fallback)
-  if (!options.raw) {
-    lines = lines.map(line => stripAnsi(line));
-  }
-  
   console.log(lines.join('\n'));
 }
 
@@ -708,16 +703,7 @@ function escapeHtml(text: string): string {
  * Follow logs in real-time
  */
 function followLogs(laneDir: string, options: LogsOptions): void {
-  let logFile: string;
-  const readableLog = safeJoin(laneDir, 'terminal-readable.log');
-  const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-
-  if (options.raw) {
-    logFile = rawLog;
-  } else {
-    // Default to readable log
-    logFile = readableLog;
-  }
+  const logFile = safeJoin(laneDir, 'terminal.jsonl');
   
   if (!fs.existsSync(logFile)) {
     console.log('Waiting for log file...');
@@ -725,17 +711,14 @@ function followLogs(laneDir: string, options: LogsOptions): void {
   
   let lastSize = 0;
   try {
-    // Use statSync directly to avoid TOCTOU race condition
     lastSize = fs.statSync(logFile).size;
   } catch {
-    // File doesn't exist yet or other error - start from 0
     lastSize = 0;
   }
   
   console.log(`${logger.COLORS.cyan}Following ${logFile}... (Ctrl+C to stop)${logger.COLORS.reset}\n`);
   
   const checkInterval = setInterval(() => {
-    // Use fstat on open fd to avoid TOCTOU race condition
     let fd: number | null = null;
     try {
       fd = fs.openSync(logFile, 'r');
@@ -744,28 +727,37 @@ function followLogs(laneDir: string, options: LogsOptions): void {
         const buffer = Buffer.alloc(stats.size - lastSize);
         fs.readSync(fd, buffer, 0, buffer.length, lastSize);
         
-        let content = buffer.toString();
-        
-        // Apply filter (case-insensitive string match to avoid ReDoS)
-        if (options.filter) {
-          const filterLower = options.filter.toLowerCase();
-          const lines = content.split('\n');
-          content = lines.filter(line => line.toLowerCase().includes(filterLower)).join('\n');
-        }
-        
-        // Clean ANSI if needed (unless raw mode)
-        if (!options.raw) {
-          content = stripAnsi(content);
-        }
+        const content = buffer.toString();
+        const lines = content.split('\n').filter(l => l.trim());
         
-        if (content.trim()) {
-          process.stdout.write(content);
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
+            const level = entry.level || 'info';
+            const levelColor = getLevelColor(level);
+            const message = entry.content || entry.message || '';
+            
+            // Apply level filter
+            if (options.level && level !== options.level) continue;
+            
+            // Apply filter
+            if (options.filter) {
+              const filterLower = options.filter.toLowerCase();
+              if (!message.toLowerCase().includes(filterLower)) continue;
+            }
+            
+            const displayMsg = options.raw ? message : stripAnsi(message);
+            console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${levelColor}[${level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${displayMsg}`);
+          } catch {
+            // Skip invalid JSON
+          }
         }
         
         lastSize = stats.size;
       }
     } catch {
-      // Ignore errors (file might be rotating)
+      // Ignore errors
     } finally {
       if (fd !== null) {
         try { fs.closeSync(fd); } catch { /* ignore */ }
@@ -860,19 +852,13 @@ function displaySummary(runDir: string): void {
   
   for (const lane of lanes) {
     const laneDir = safeJoin(runDir, 'lanes', lane);
-    const rawLog = safeJoin(laneDir, 'terminal-raw.log');
-    const readableLog = safeJoin(laneDir, 'terminal-readable.log');
+    const jsonlLog = safeJoin(laneDir, 'terminal.jsonl');
     
     console.log(`  ${logger.COLORS.green}📁 ${lane}${logger.COLORS.reset}`);
     
-    if (fs.existsSync(readableLog)) {
-      const stats = fs.statSync(readableLog);
-      console.log(`     └─ terminal-readable.log ${formatSize(stats.size)} ${logger.COLORS.yellow}(default)${logger.COLORS.reset}`);
-    }
-    
-    if (fs.existsSync(rawLog)) {
-      const stats = fs.statSync(rawLog);
-      console.log(`     └─ terminal-raw.log      ${formatSize(stats.size)}`);
+    if (fs.existsSync(jsonlLog)) {
+      const stats = fs.statSync(jsonlLog);
+      console.log(`     └─ terminal.jsonl ${formatSize(stats.size)} ${logger.COLORS.yellow}(unified)${logger.COLORS.reset}`);
     }
     
     console.log('');

package/src/cli/monitor.ts

@@ -19,6 +19,7 @@ import { safeJoin } from '../utils/path';
 import { getLaneProcessStatus, getFlowSummary, LaneProcessStatus } from '../services/process';
 import { LogBufferService, BufferedLogEntry } from '../services/logging/buffer';
 import { formatReadableEntry, stripAnsi } from '../services/logging/formatter';
+import { createInterventionRequest, InterventionType, wrapUserIntervention } from '../core/intervention';
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 // UI Constants
@@ -671,6 +672,7 @@ class InteractiveMonitor {
   private getLaneActions(lane: LaneInfo): ActionItem[] {
     const status = this.getLaneStatus(lane.path, lane.name);
     const isRunning = status.status === 'running';
+    const isCompleted = status.status === 'completed' || status.status === 'success';
     
     return [
       {
@@ -689,6 +691,14 @@ class InteractiveMonitor {
         disabled: !isRunning,
         disabledReason: 'Lane not running',
       },
+      {
+        id: 'resume',
+        label: 'Resume Lane',
+        icon: '▶️',
+        action: () => this.resumeLane(lane),
+        disabled: isRunning || isCompleted,
+        disabledReason: isRunning ? 'Lane already running' : 'Lane already completed',
+      },
       {
         id: 'stop',
         label: 'Stop Lane',
@@ -715,6 +725,8 @@ class InteractiveMonitor {
   
   private getFlowActions(flow: FlowInfo): ActionItem[] {
     const isCurrent = flow.runDir === this.runDir;
+    const isAlive = flow.isAlive;
+    const isCompleted = flow.summary.completed === flow.summary.total && flow.summary.total > 0;
     
     return [
       {
@@ -725,6 +737,14 @@ class InteractiveMonitor {
         disabled: isCurrent,
         disabledReason: 'Already viewing this flow',
       },
+      {
+        id: 'resume',
+        label: 'Resume Flow',
+        icon: '▶️',
+        action: () => this.resumeFlow(flow),
+        disabled: isAlive || isCompleted,
+        disabledReason: isAlive ? 'Flow is already running' : 'Flow is already completed',
+      },
       {
         id: 'delete',
         label: 'Delete Flow',
@@ -805,9 +825,24 @@ class InteractiveMonitor {
     if (!lane || !message.trim()) return;
     
     try {
-      const interventionPath = safeJoin(lane.path, 'intervention.txt');
-      fs.writeFileSync(interventionPath, message, 'utf8');
+      // Create pending-intervention.json for the system
+      createInterventionRequest(lane.path, {
+        type: InterventionType.USER_MESSAGE,
+        message: wrapUserIntervention(message),
+        source: 'user',
+        priority: 10
+      });
       
+      // Kill the process if it's running - this triggers the restart in orchestrator
+      const status = this.laneProcessStatuses.get(lane.name);
+      if (status && status.pid && status.actualStatus === 'running') {
+        try {
+          process.kill(status.pid, 'SIGTERM');
+        } catch {
+          // Ignore kill errors
+        }
+      }
+
       const convoPath = safeJoin(lane.path, 'conversation.jsonl');
       const entry = {
         timestamp: new Date().toISOString(),
@@ -858,6 +893,45 @@ class InteractiveMonitor {
     this.render();
   }
   
+  private resumeFlow(flow: FlowInfo) {
+    this.runResumeCommand(['--all', '--run-dir', flow.runDir]);
+  }
+
+  private resumeLane(lane: LaneInfo) {
+    this.runResumeCommand([lane.name, '--run-dir', this.runDir]);
+  }
+
+  private runResumeCommand(args: string[]) {
+    try {
+      const { spawn } = require('child_process');
+      
+      // Determine the script to run
+      // In production, it's dist/cli/index.js. In dev, it's src/cli/index.ts.
+      let entryPoint = path.resolve(__dirname, 'index.js');
+      if (!fs.existsSync(entryPoint)) {
+        entryPoint = path.resolve(__dirname, 'index.ts');
+      }
+
+      const spawnArgs = [entryPoint, 'resume', ...args, '--skip-doctor'];
+      
+      // If it's a .ts file, we need ts-node or similar (assuming it's available)
+      const nodeArgs = entryPoint.endsWith('.ts') ? ['-r', 'ts-node/register'] : [];
+
+      const child = spawn(process.execPath, [...nodeArgs, ...spawnArgs], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env, NODE_OPTIONS: '' }
+      });
+      
+      child.unref();
+      
+      const target = args[0] === '--all' ? 'flow' : `lane ${args[0]}`;
+      this.showNotification(`Resume started for ${target}`, 'success');
+    } catch (error: any) {
+      this.showNotification(`Failed to spawn resume: ${error.message}`, 'error');
+    }
+  }
+  
   private switchToFlow(flow: FlowInfo) {
     this.runDir = flow.runDir;
     
@@ -1336,55 +1410,15 @@ class InteractiveMonitor {
   }
   
   private getTerminalLines(lanePath: string, maxLines: number): string[] {
-    const { dim, reset, cyan, green, yellow, red, gray } = UI.COLORS;
-    
-    // Choose log source based on format setting
-    if (this.state.readableFormat) {
-      // Try JSONL first for structured readable format
-      const jsonlPath = safeJoin(lanePath, 'terminal.jsonl');
-      if (fs.existsSync(jsonlPath)) {
-        return this.getJsonlLogLines(jsonlPath, maxLines);
-      }
-    }
+    const { dim, reset } = UI.COLORS;
     
-    // Fallback to raw terminal log
-    const logPath = safeJoin(lanePath, 'terminal-readable.log');
-    if (!fs.existsSync(logPath)) {
-      return [`${dim}(No output yet)${reset}`];
+    // Use terminal.jsonl as the only source for structured readable format
+    const jsonlPath = safeJoin(lanePath, 'terminal.jsonl');
+    if (fs.existsSync(jsonlPath)) {
+      return this.getJsonlLogLines(jsonlPath, maxLines);
     }
     
-    try {
-      const content = fs.readFileSync(logPath, 'utf8');
-      const allLines = content.split('\n');
-      const totalLines = allLines.length;
-      
-      // Calculate visible range (from end, accounting for scroll offset)
-      const end = Math.max(0, totalLines - this.state.terminalScrollOffset);
-      const start = Math.max(0, end - maxLines);
-      const visibleLines = allLines.slice(start, end);
-      
-      // Format lines with syntax highlighting
-      return visibleLines.map(line => {
-        if (line.includes('[HUMAN INTERVENTION]') || line.includes('Injecting intervention:')) {
-          return `${yellow}${line}${reset}`;
-        }
-        if (line.includes('=== Task:') || line.includes('Starting task:')) {
-          return `${green}${line}${reset}`;
-        }
-        if (line.includes('Executing cursor-agent') || line.includes('cursor-agent-v')) {
-          return `${cyan}${line}${reset}`;
-        }
-        if (line.toLowerCase().includes('error') || line.toLowerCase().includes('failed')) {
-          return `${red}${line}${reset}`;
-        }
-        if (line.toLowerCase().includes('success') || line.toLowerCase().includes('completed')) {
-          return `${green}${line}${reset}`;
-        }
-        return line;
-      });
-    } catch {
-      return [`${dim}(Error reading log)${reset}`];
-    }
+    return [`${dim}(No output yet)${reset}`];
   }
   
   /**

package/src/cli/resume.ts

@@ -17,7 +17,7 @@ import {
   createLogManager, 
   ParsedMessage
 } from '../utils/enhanced-logger';
-import { formatMessageForConsole } from '../utils/log-formatter';
+import { formatMessageForConsole } from '../services/logging/formatter';
 import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 
 interface ResumeOptions {

package/src/cli/signal.ts

@@ -19,6 +19,9 @@ import {
   executeUserIntervention,
   isProcessAlive,
   InterventionResult,
+  createInterventionRequest,
+  InterventionType,
+  wrapUserIntervention,
 } from '../core/intervention';
 
 interface SignalOptions {
@@ -26,7 +29,6 @@ interface SignalOptions {
   message: string | null;
   timeout: number | null;
   runDir: string | null;
-  force: boolean;  // 프로세스 종료 없이 대기 모드로 전송
   help: boolean;
 }
 
@@ -35,8 +37,12 @@ function printHelp(): void {
 Usage: cursorflow signal <lane> "<message>" [options]
        cursorflow signal <lane> --timeout <ms>
 
-Directly intervene in a running lane. The agent will be interrupted immediately
-and resume with your intervention message.
+Send an intervention message to a lane. For running lanes, the agent will be
+interrupted immediately and resume with your message. For pending/waiting/failed
+lanes, the message will be applied when the lane starts or resumes.
+
+Note: Completed lanes cannot receive signals.
+      To re-run a completed lane, start a new run with: cursorflow run
 
 Arguments:
   <lane>                 Lane name to signal
@@ -45,15 +51,12 @@ Arguments:
 Options:
   --timeout <ms>         Update execution timeout (in milliseconds)
   --run-dir <path>       Use a specific run directory (default: latest)
-  --force                Send signal without interrupting current process
-                         (message will be picked up on next task)
   --help, -h             Show help
 
 Examples:
   cursorflow signal lane-1 "Please focus on error handling first"
   cursorflow signal lane-2 "Skip the optional tasks and finish" 
   cursorflow signal lane-1 --timeout 600000   # Set 10 minute timeout
-  cursorflow signal lane-1 "Continue" --force # Don't interrupt, wait for next turn
   `);
 }
 
@@ -61,15 +64,24 @@ function parseArgs(args: string[]): SignalOptions {
   const runDirIdx = args.indexOf('--run-dir');
   const timeoutIdx = args.indexOf('--timeout');
   
+  // Collect indices of option values to exclude from nonOptions
+  const optionValueIndices = new Set<number>();
+  if (runDirIdx >= 0 && runDirIdx + 1 < args.length) {
+    optionValueIndices.add(runDirIdx + 1);
+  }
+  if (timeoutIdx >= 0 && timeoutIdx + 1 < args.length) {
+    optionValueIndices.add(timeoutIdx + 1);
+  }
+  
   // First non-option is lane, second (or rest joined) is message
-  const nonOptions = args.filter(a => !a.startsWith('--'));
+  // Exclude option flags and their values
+  const nonOptions = args.filter((a, i) => !a.startsWith('--') && !optionValueIndices.has(i));
   
   return {
     lane: nonOptions[0] || null,
     message: nonOptions.slice(1).join(' ') || null,
     timeout: timeoutIdx >= 0 ? parseInt(args[timeoutIdx + 1] || '0') || null : null,
     runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
-    force: args.includes('--force'),
     help: args.includes('--help') || args.includes('-h'),
   };
 }
@@ -108,18 +120,15 @@ function getLaneStatus(laneDir: string): { state: LaneState | null; isRunning: b
 }
 
 /**
- * 기존 방식으로 intervention.txt만 작성 (--force 옵션용)
+ * 개입 요청 파일 작성 (비실행 중인 lane용)
  */
-function sendLegacyIntervention(laneDir: string, message: string): void {
-  const interventionPath = safeJoin(laneDir, 'intervention.txt');
-  const convoPath = safeJoin(laneDir, 'conversation.jsonl');
-  
-  fs.writeFileSync(interventionPath, message);
-  
-  const entry = createConversationEntry('intervention', `[HUMAN INTERVENTION]: ${message}`, {
-    task: 'DIRECT_SIGNAL'
+function sendInterventionRequest(laneDir: string, message: string): void {
+  createInterventionRequest(laneDir, {
+    type: InterventionType.USER_MESSAGE,
+    message: wrapUserIntervention(message),
+    source: 'user',
+    priority: 10
   });
-  appendLog(convoPath, entry);
 }
 
 async function signal(args: string[]): Promise<void> {
@@ -167,30 +176,25 @@ async function signal(args: string[]): Promise<void> {
     logger.info(`📨 Sending intervention to lane: ${options.lane}`);
     logger.info(`   Message: "${options.message.substring(0, 50)}${options.message.length > 50 ? '...' : ''}"`);
     
+    // Completed 레인은 signal 거부 (브랜치 충돌 방지)
+    if (state?.status === 'completed') {
+      logger.error(`❌ Cannot signal a completed lane.`);
+      logger.info('   To re-run this lane, start a new run with: cursorflow run');
+      throw new Error('Lane is already completed');
+    }
+
     // Log to conversation for history
     const entry = createConversationEntry('intervention', `[HUMAN INTERVENTION]: ${options.message}`, {
       task: 'DIRECT_SIGNAL'
     });
     appendLog(convoPath, entry);
 
-    // --force: 기존 방식 (프로세스 중단 없이 파일만 작성)
-    if (options.force) {
-      sendLegacyIntervention(laneDir, options.message);
-      logger.success('✅ Signal queued (--force mode). Message will be applied on next task.');
-      return;
-    }
-
-    // Lane이 실행 중이 아닌 경우
+    // Lane이 실행 중이 아닌 경우 (pending/waiting/failed/paused)
     if (!isRunning) {
-      if (state?.status === 'completed') {
-        logger.warn(`⚠ Lane ${options.lane} is already completed.`);
-        return;
-      }
-      
-      // 실행 중이 아니면 다음 resume 시 적용되도록 파일만 작성
-      sendLegacyIntervention(laneDir, options.message);
+      // 실행 중이 아니면 다음 시작/resume 시 적용되도록 파일만 작성
+      sendInterventionRequest(laneDir, options.message);
       logger.info(`ℹ Lane ${options.lane} is not currently running (status: ${state?.status || 'unknown'}).`);
-      logger.success('✅ Signal queued. Message will be applied when lane resumes.');
+      logger.success('✅ Signal queued. Message will be applied when lane starts or resumes.');
       return;
     }