@litmers/cursorflow-orchestrator 0.1.39 → 0.2.2

package/src/utils/flow.ts

@@ -1,6 +1,89 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { safeJoin } from './path';
+import { FlowInfo, FlowStatus } from '../types/flow';
+import { CursorFlowConfig } from './config';
+import { TaskService } from './task-service';
+
+/**
+ * List all flows in a directory
+ */
+export function listFlows(flowsDir: string): FlowInfo[] {
+  if (!fs.existsSync(flowsDir)) {
+    return [];
+  }
+
+  const dirs = fs.readdirSync(flowsDir)
+    .filter(name => {
+      const dirPath = safeJoin(flowsDir, name);
+      try {
+        return fs.statSync(dirPath).isDirectory() && !name.startsWith('.');
+      } catch {
+        return false;
+      }
+    })
+    .sort((a, b) => b.localeCompare(a)); // Most recent first
+
+  return dirs.map(name => {
+    const flowPath = safeJoin(flowsDir, name);
+    const metaPath = safeJoin(flowPath, 'flow.meta.json');
+    
+    let meta: any = null;
+    try {
+      if (fs.existsSync(metaPath)) {
+        meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+      }
+    } catch {}
+
+    // Parse flow name from directory (e.g., "001_TestFeature" -> "TestFeature")
+    const match = name.match(/^(\d+)_(.+)$/);
+    const id = match ? match[1] : name;
+    const flowName = match ? match[2] : name;
+
+    // Get lane files
+    const laneFiles = fs.readdirSync(flowPath)
+      .filter(f => f.endsWith('.json') && f !== 'flow.meta.json')
+      .map(f => {
+        const laneMatch = f.match(/^\d+-([^.]+)\.json$/);
+        return laneMatch ? laneMatch[1] : f.replace('.json', '');
+      });
+
+    return {
+      id,
+      name: flowName,
+      path: flowPath,
+      timestamp: meta?.createdAt ? new Date(meta.createdAt) : new Date(fs.statSync(flowPath).mtime),
+      lanes: laneFiles,
+      status: (meta?.status as FlowStatus) || 'pending',
+      meta: meta || undefined,
+    };
+  });
+}
+
+/**
+ * Find the most recently created flow or legacy task directory
+ */
+export function findLatestFlowOrTask(config: CursorFlowConfig): string | null {
+  const flowsDir = safeJoin(config.projectRoot, config.flowsDir);
+  const tasksDir = safeJoin(config.projectRoot, config.tasksDir);
+  
+  const flows = listFlows(flowsDir);
+  
+  const taskService = new TaskService(tasksDir);
+  const tasks = taskService.listTaskDirs();
+  
+  const latestFlow = flows.length > 0 ? flows[0] : null;
+  const latestTask = tasks.length > 0 ? tasks[0] : null;
+  
+  if (!latestFlow && !latestTask) return null;
+  if (!latestFlow) return latestTask!.path;
+  if (!latestTask) return latestFlow!.path;
+  
+  // Compare by timestamp to find the truly latest
+  return latestFlow.timestamp.getTime() >= latestTask.timestamp.getTime() 
+    ? latestFlow.path 
+    : latestTask.path;
+}
 
 /**
  * Find flow directory by name in the flows directory.
@@ -40,3 +123,4 @@ export function findFlowDir(flowsDir: string, flowName: string): string | null {
 }
 
 
+

package/src/utils/git.ts

@@ -265,7 +265,7 @@ export function isGitRepo(cwd?: string): boolean {
 }
 
 /**
- * Check if worktree exists
+ * Check if worktree exists in Git's worktree list
  */
 export function worktreeExists(worktreePath: string, cwd?: string): boolean {
   const result = runGitResult(['worktree', 'list'], { cwd });
@@ -274,6 +274,64 @@ export function worktreeExists(worktreePath: string, cwd?: string): boolean {
   return result.stdout.includes(worktreePath);
 }
 
+/**
+ * Check if a directory is a valid Git worktree (not just a regular directory)
+ * This prevents accidental checkout in the main repository when the worktree
+ * directory exists but is not properly registered as a worktree.
+ */
+export function isValidWorktree(dirPath: string): boolean {
+  // 1. Directory must exist
+  if (!fs.existsSync(dirPath)) {
+    return false;
+  }
+  
+  // 2. Check if Git recognizes this as a worktree by checking .git file
+  // In a worktree, .git is a file (not a directory) pointing to the main repo's .git/worktrees/
+  const dotGitPath = path.join(dirPath, '.git');
+  if (!fs.existsSync(dotGitPath)) {
+    return false;
+  }
+  
+  try {
+    const stat = fs.statSync(dotGitPath);
+    
+    // In worktrees, .git is a FILE containing "gitdir: /path/to/.git/worktrees/..."
+    // In the main repo, .git is a DIRECTORY
+    if (stat.isDirectory()) {
+      // This is the main repository, not a worktree
+      return false;
+    }
+    
+    // Read the .git file to verify it points to a valid worktree
+    const content = fs.readFileSync(dotGitPath, 'utf8').trim();
+    if (!content.startsWith('gitdir:')) {
+      return false;
+    }
+    
+    // Verify the gitdir path exists
+    const gitdirPath = content.replace('gitdir:', '').trim();
+    return fs.existsSync(gitdirPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove a directory that was supposed to be a worktree but isn't valid
+ * Used to clean up orphaned/corrupted worktree directories before recreation
+ */
+export function cleanupInvalidWorktreeDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) return;
+  
+  // Only remove if it's NOT a valid worktree (safety check)
+  if (isValidWorktree(dirPath)) {
+    throw new Error(`Cannot cleanup: ${dirPath} is a valid worktree`);
+  }
+  
+  // Remove the directory recursively
+  fs.rmSync(dirPath, { recursive: true, force: true });
+}
+
 /**
  * Create worktree
  */

package/src/utils/log-constants.ts

@@ -15,6 +15,8 @@ export const COLORS = {
   white: '\x1b[37m',
 };
 
+export const MAIN_LOG_FILENAME = 'main-raw.log';
+
 export enum LogLevel {
   error = 0,
   warn = 1,
@@ -23,4 +25,3 @@ export enum LogLevel {
   progress = 2,
   debug = 3,
 }
-

package/src/utils/log-formatter.ts

@@ -1,13 +1,14 @@
 /**
  * Utility for formatting log messages for console display
  * 
- * Format: [HH:MM:SS] [lane-task] ICON TYPE content
+ * Format: [HH:MM:SS] [MAIN] or [SUB:<id>] ICON TYPE content
+ * (labels are padded to keep alignment consistent)
  * 
  * Rules:
  * - Box format only for: user, assistant, system, result
  * - Compact format for: tool, tool_result, thinking (gray/dim)
  * - Tool names simplified: ShellToolCall → Shell
- * - Lane labels max 16 chars: [01-types-tests]
+ * - Lane labels fixed 20 chars: [1-1-backend       ]
  */
 
 import { COLORS } from './log-constants';
@@ -44,17 +45,12 @@ export function formatMessageForConsole(
   const ts = includeTimestamp ? new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false }) : '';
   const tsPrefix = ts ? `${COLORS.gray}[${ts}]${COLORS.reset} ` : '';
   
-  // Handle context (e.g. from logger.info) - max 18 chars inside brackets
-  // Format: [1-1-lanename1234] padded to fixed width 20 (including brackets)
-  let effectiveLaneLabel = laneLabel || (context ? `[${context.substring(0, 18).padEnd(18)}]` : '');
+  // Handle context (e.g. from logger.info) - keep labels compact
+  // Format: [1-1-refactor] without fixed width padding
+  let effectiveLaneLabel = laneLabel || (context ? `[${context.substring(0, 12)}]` : '');
   
-  // Smart truncation: ensure it always ends with ]
-  if (effectiveLaneLabel.length > 20) {
-    effectiveLaneLabel = effectiveLaneLabel.substring(0, 19) + ']';
-  }
-  
-  // Fixed width 20 chars for consistent alignment
-  const labelPrefix = effectiveLaneLabel ? `${COLORS.magenta}${effectiveLaneLabel.padEnd(20)}${COLORS.reset} ` : '';
+  // Compact label with color
+  const labelPrefix = effectiveLaneLabel ? `${COLORS.magenta}${effectiveLaneLabel}${COLORS.reset} ` : '';
   
   let typePrefix = '';
   let content = msg.content;
@@ -156,6 +152,9 @@ export function formatMessageForConsole(
     case 'error':
       typePrefix = `${COLORS.red}❌ ERR${COLORS.reset}`;
       break;
+    case 'raw':
+      // Raw type means the content is already fully formatted - return as-is
+      return content;
   }
   
   if (!typePrefix) return `${tsPrefix}${labelPrefix}${content}`;

package/src/utils/logger.ts

@@ -3,14 +3,47 @@
  * 
  * 통일된 로그 형식: [HH:MM:SS] emoji TYPE message
  * 컨텍스트 포함 시: [HH:MM:SS] [context] emoji TYPE message
+ * 
+ * Main process logs are optionally mirrored to a dedicated file to keep
+ * orchestration logs separate from lane/subprocess logs.
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
 import { COLORS, LogLevel } from './log-constants';
 import { formatMessageForConsole } from './log-formatter';
 
 export { COLORS, LogLevel };
 
 let currentLogLevel: number = LogLevel.info;
+let defaultContext: string | null = null;
+let logFileStream: fs.WriteStream | null = null;
+
+/**
+ * Set default context label for logs (e.g., MAIN).
+ */
+export function setDefaultContext(context?: string | null): void {
+  defaultContext = context ?? null;
+}
+
+/**
+ * Mirror main process logs to a file (raw console output with ANSI codes).
+ */
+export function setLogFile(logPath?: string | null): void {
+  if (logFileStream) {
+    try {
+      logFileStream.end();
+    } catch {
+      // Ignore stream close errors
+    }
+    logFileStream = null;
+  }
+
+  if (!logPath) return;
+
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  logFileStream = fs.createWriteStream(logPath, { flags: 'a' });
+}
 
 /**
  * Set log level
@@ -66,11 +99,14 @@ function logInternal(
     timestamp: Date.now(),
   }, {
     includeTimestamp: !options.noTimestamp,
-    context: options.context,
+    context: options.context ?? defaultContext ?? undefined,
     compact: !options.box
   });
 
   console.log(formatted);
+  if (logFileStream) {
+    logFileStream.write(`${formatted}\n`);
+  }
 }
 
 // ============================================================================
@@ -144,10 +180,14 @@ export function withContext(context: string) {
  */
 export function section(message: string): void {
   console.log('');
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  const divider = `${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`;
+  console.log(divider);
   console.log(`${COLORS.cyan}  ${message}${COLORS.reset}`);
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(divider);
   console.log('');
+  if (logFileStream) {
+    logFileStream.write(`\n${divider}\n${COLORS.cyan}  ${message}${COLORS.reset}\n${divider}\n\n`);
+  }
 }
 
 /**
@@ -155,6 +195,9 @@ export function section(message: string): void {
  */
 export function raw(message: string): void {
   process.stdout.write(message);
+  if (logFileStream) {
+    logFileStream.write(message);
+  }
 }
 
 /**
@@ -162,6 +205,9 @@ export function raw(message: string): void {
  */
 export function log(message: string): void {
   console.log(message);
+  if (logFileStream) {
+    logFileStream.write(`${message}\n`);
+  }
 }
 
 // ============================================================================

package/src/utils/repro-thinking-logs.ts

@@ -11,7 +11,6 @@ async function testThinkingLogs() {
 
   console.log('--- Initializing Log Manager ---');
   const manager = createLogManager(testDir, 'test-lane-thinking', {
-    writeJsonLog: true,
     keepRawLogs: true
   });
 
@@ -35,20 +34,6 @@ async function testThinkingLogs() {
   console.log('\n--- Verifying terminal-readable.log ---');
   const readableLog = fs.readFileSync(path.join(testDir, 'terminal-readable.log'), 'utf8');
   console.log(readableLog);
-
-  console.log('\n--- Verifying terminal.jsonl (last 3 entries) ---');
-  const jsonlLog = fs.readFileSync(path.join(testDir, 'terminal.jsonl'), 'utf8');
-  const lines = jsonlLog.trim().split('\n');
-  for (const line of lines.slice(-3)) {
-    const parsed = JSON.parse(line);
-    console.log(JSON.stringify({
-      level: parsed.level,
-      message: parsed.message.substring(0, 50) + '...',
-      hasMetadata: !!parsed.metadata,
-      metadataType: parsed.metadata?.type
-    }, null, 2));
-  }
 }
 
 testThinkingLogs().catch(console.error);
-

package/src/utils/run-service.ts

@@ -183,7 +183,7 @@ export class RunService {
     const statuses = lanes.map(l => l.status);
     
     // If any lane is running, the run is running
-    if (statuses.some(s => s === 'running' || s === 'reviewing')) {
+    if (statuses.some(s => s === 'running')) {
       return 'running';
     }
     

package/dist/services/logging/file-writer.d.ts

@@ -1,71 +0,0 @@
-/**
- * Log File Writer - Write logs to files with rotation
- *
- * Manages log file writing with support for multiple formats.
- */
-import { Transform, TransformCallback } from 'stream';
-import { LogSession, ParsedMessage } from '../../types/logging';
-import { EnhancedLogConfig } from '../../types/config';
-export declare const DEFAULT_LOG_CONFIG: EnhancedLogConfig;
-/**
- * Transform stream for clean log output
- */
-export declare class CleanLogTransform extends Transform {
-    private config;
-    private session;
-    private buffer;
-    constructor(config: EnhancedLogConfig, session: LogSession);
-    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: TransformCallback): void;
-    private hasTimestamp;
-}
-/**
- * Enhanced Log Manager - Handles all log file operations
- */
-export declare class EnhancedLogManager {
-    private config;
-    private session;
-    private logDir;
-    private cleanLogPath;
-    private rawLogPath;
-    private jsonLogPath;
-    private readableLogPath;
-    private cleanLogFd;
-    private rawLogFd;
-    private jsonLogFd;
-    private readableLogFd;
-    private cleanLogSize;
-    private rawLogSize;
-    private cleanTransform;
-    private streamingParser;
-    private lineBuffer;
-    private onParsedMessage?;
-    constructor(logDir: string, session: LogSession, config?: Partial<EnhancedLogConfig>, onParsedMessage?: (msg: ParsedMessage) => void);
-    private initLogFiles;
-    private writeSessionHeader;
-    private writeReadableMessage;
-    private rotateIfNeeded;
-    private rotateLog;
-    private writeToCleanLog;
-    private writeToRawLog;
-    private writeJsonEntry;
-    writeStdout(data: Buffer | string): void;
-    writeStderr(data: Buffer | string): void;
-    log(level: 'info' | 'error' | 'debug', message: string, metadata?: Record<string, any>): void;
-    section(title: string): void;
-    setTask(taskName: string, model?: string): void;
-    private isNoise;
-    getLogPaths(): {
-        clean: string;
-        raw?: string;
-        json?: string;
-        readable: string;
-    };
-    getFileDescriptors(): {
-        stdout: number;
-        stderr: number;
-    };
-    close(): void;
-    private formatDuration;
-}
-export declare function createLogManager(laneRunDir: string, laneName: string, config?: Partial<EnhancedLogConfig>, onParsedMessage?: (msg: ParsedMessage) => void): EnhancedLogManager;