@litmers/cursorflow-orchestrator 0.1.20 → 0.1.26

package/src/utils/logger.ts

@@ -1,25 +1,14 @@
 /**
  * Logging utilities for CursorFlow
+ * 
+ * 통일된 로그 형식: [HH:MM:SS] emoji TYPE message
+ * 컨텍스트 포함 시: [HH:MM:SS] [context] emoji TYPE message
  */
 
-export enum LogLevel {
-  error = 0,
-  warn = 1,
-  info = 2,
-  debug = 3,
-}
+import { COLORS, LogLevel } from './log-constants';
+import { formatMessageForConsole } from './log-formatter';
 
-export const COLORS = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  magenta: '\x1b[35m',
-  gray: '\x1b[90m',
-  bold: '\x1b[1m',
-};
+export { COLORS, LogLevel };
 
 let currentLogLevel: number = LogLevel.info;
 
@@ -35,67 +24,119 @@ export function setLogLevel(level: string | number): void {
 }
 
 /**
- * Format message with timestamp
+ * Get current log level
+ */
+export function getLogLevel(): number {
+  return currentLogLevel;
+}
+
+/**
+ * Log options interface for contextual logging
  */
-function formatMessage(level: string, message: string, emoji = ''): string {
-  const timestamp = new Date().toISOString();
-  const prefix = emoji ? `${emoji} ` : '';
-  const lines = String(message).split('\n');
-  return lines.map(line => `[${timestamp}] [${level.toUpperCase()}] ${prefix}${line}`).join('\n');
+export interface LogOptions {
+  /** Context label (e.g., lane name) */
+  context?: string;
+  /** Custom emoji override */
+  emoji?: string;
+  /** Skip timestamp */
+  noTimestamp?: boolean;
+  /** Custom color */
+  color?: string;
+  /** Use box format */
+  box?: boolean;
 }
 
 /**
- * Log with color
+ * Internal log function that uses formatMessageForConsole
  */
-function logWithColor(color: string, level: keyof typeof LogLevel, message: string, emoji = ''): void {
-  if (LogLevel[level] > currentLogLevel) {
+function logInternal(
+  type: string,
+  message: string,
+  options: LogOptions = {}
+): void {
+  const level = (LogLevel as any)[type] ?? LogLevel.info;
+  if (level > currentLogLevel) {
     return;
   }
-  
-  const formatted = formatMessage(level, message, emoji);
-  console.log(`${color}${formatted}${COLORS.reset}`);
+
+  const formatted = formatMessageForConsole({
+    type: type as any,
+    role: 'system',
+    content: message,
+    timestamp: Date.now(),
+  }, {
+    includeTimestamp: !options.noTimestamp,
+    context: options.context,
+    compact: !options.box
+  });
+
+  console.log(formatted);
 }
 
+// ============================================================================
+// Primary Logging Functions
+// ============================================================================
+
 /**
  * Error log
  */
-export function error(message: string, emoji = '❌'): void {
-  logWithColor(COLORS.red, 'error', message, emoji);
+export function error(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('error', message, opts);
 }
 
 /**
  * Warning log
  */
-export function warn(message: string, emoji = '⚠️'): void {
-  logWithColor(COLORS.yellow, 'warn', message, emoji);
+export function warn(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('warn', message, opts);
 }
 
 /**
  * Info log
  */
-export function info(message: string, emoji = 'ℹ️'): void {
-  logWithColor(COLORS.cyan, 'info', message, emoji);
+export function info(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('info', message, opts);
 }
 
 /**
  * Success log
  */
-export function success(message: string, emoji = '✅'): void {
-  logWithColor(COLORS.green, 'info', message, emoji);
+export function success(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('success', message, opts);
 }
 
 /**
  * Debug log
  */
-export function debug(message: string, emoji = '🔍'): void {
-  logWithColor(COLORS.gray, 'debug', message, emoji);
+export function debug(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('debug', message, opts);
 }
 
 /**
  * Progress log
  */
-export function progress(message: string, emoji = '🔄'): void {
-  logWithColor(COLORS.blue, 'info', message, emoji);
+export function progress(message: string, options: LogOptions | string = {}): void {
+  const opts = typeof options === 'string' ? { emoji: options } : options;
+  logInternal('progress', message, opts);
+}
+
+/**
+ * Create a context-bound logger
+ */
+export function withContext(context: string) {
+  return {
+    error: (message: string, options?: Omit<LogOptions, 'context'>) => error(message, { ...options, context }),
+    warn: (message: string, options?: Omit<LogOptions, 'context'>) => warn(message, { ...options, context }),
+    info: (message: string, options?: Omit<LogOptions, 'context'>) => info(message, { ...options, context }),
+    success: (message: string, options?: Omit<LogOptions, 'context'>) => success(message, { ...options, context }),
+    debug: (message: string, options?: Omit<LogOptions, 'context'>) => debug(message, { ...options, context }),
+    progress: (message: string, options?: Omit<LogOptions, 'context'>) => progress(message, { ...options, context }),
+  };
 }
 
 /**
@@ -110,26 +151,29 @@ export function section(message: string): void {
 }
 
 /**
- * Simple log without formatting
+ * Raw output (direct to stdout)
  */
-export function log(message: string | any): void {
-  console.log(message);
+export function raw(message: string): void {
+  process.stdout.write(message);
 }
 
 /**
- * Log JSON data (pretty print in debug mode)
+ * Simple log without formatting
  */
-export function json(data: any): void {
-  if (currentLogLevel >= LogLevel.debug) {
-    console.log(JSON.stringify(data, null, 2));
-  }
+export function log(message: string): void {
+  console.log(message);
 }
 
+// ============================================================================
+// Spinner
+// ============================================================================
+
 export interface Spinner {
   start(): void;
   stop(finalMessage?: string | null): void;
   succeed(message: string): void;
   fail(message: string): void;
+  update(message: string): void;
 }
 
 /**
@@ -139,13 +183,14 @@ export function createSpinner(message: string): Spinner {
   const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
   let i = 0;
   let interval: NodeJS.Timeout | null = null;
+  let currentMessage = message;
   
   const spinner: Spinner = {
     start() {
-      process.stdout.write(`${message} ${frames[0]}`);
+      process.stdout.write(`${currentMessage} ${frames[0]}`);
       interval = setInterval(() => {
         i = (i + 1) % frames.length;
-        process.stdout.write(`\r${message} ${frames[i]}`);
+        process.stdout.write(`\r${currentMessage} ${frames[i]}`);
       }, 80);
     },
     
@@ -167,6 +212,10 @@ export function createSpinner(message: string): Spinner {
     fail(message: string) {
       this.stop(`${COLORS.red}✗${COLORS.reset} ${message}`);
     },
+    
+    update(message: string) {
+      currentMessage = message;
+    },
   };
 
   return spinner;

package/src/utils/process-manager.ts

@@ -0,0 +1,100 @@
+import { spawnSync } from 'child_process';
+import * as os from 'os';
+
+export class ProcessManager {
+  /**
+   * Check if a process is running by its PID
+   */
+  static isProcessRunning(pid: number): boolean {
+    try {
+      // Signal 0 checks for process existence without killing it
+      process.kill(pid, 0);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Kill a process by its PID
+   * @param pid Process ID
+   * @param signal Signal to send (default: SIGTERM)
+   */
+  static killProcess(pid: number, signal: string = 'SIGTERM'): boolean {
+    try {
+      if (os.platform() === 'win32') {
+        // Windows doesn't support signals in the same way, use taskkill
+        const result = spawnSync('taskkill', ['/F', '/PID', String(pid)]);
+        return result.status === 0;
+      } else {
+        process.kill(pid, signal as NodeJS.Signals);
+        return true;
+      }
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Kill a process and all its child processes
+   * Cross-platform implementation
+   */
+  static killProcessTree(pid: number): boolean {
+    try {
+      if (os.platform() === 'win32') {
+        // Windows: /T flag kills child processes too
+        const result = spawnSync('taskkill', ['/F', '/T', '/PID', String(pid)]);
+        return result.status === 0;
+      } else {
+        // Linux/macOS: Find and kill children recursively or use pkill
+        // A simple approach is to use pgrep to find children
+        const result = spawnSync('pgrep', ['-P', String(pid)], { encoding: 'utf8' });
+        if (result.status === 0 && result.stdout) {
+          const children = result.stdout.split('\n').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
+          for (const child of children) {
+            this.killProcessTree(child);
+          }
+        }
+        
+        // Kill the process itself
+        return this.killProcess(pid);
+      }
+    } catch (e) {
+      // Fallback to simple kill
+      return this.killProcess(pid);
+    }
+  }
+
+  /**
+   * Find cursorflow related processes using pgrep (Linux/macOS only)
+   */
+  static findCursorFlowProcesses(): number[] {
+    if (os.platform() === 'win32') {
+      // Basic Windows implementation using tasklist if needed, 
+      // but for now focusing on core requirements
+      return [];
+    }
+
+    try {
+      // Find processes with 'cursorflow' in their command line, 
+      // avoiding unrelated matches by looking for specific execution patterns
+      const result = spawnSync('pgrep', ['-f', 'cursorflow.*(index|runner|orchestrator)'], { encoding: 'utf8' });
+      if (result.status !== 0) {
+        // Fallback to simpler pattern
+        const fallback = spawnSync('pgrep', ['-f', 'cursorflow'], { encoding: 'utf8' });
+        if (fallback.status !== 0) return [];
+        return fallback.stdout
+          .split('\n')
+          .map(s => parseInt(s.trim()))
+          .filter(n => !isNaN(n) && n !== process.pid);
+      }
+      
+      return result.stdout
+        .split('\n')
+        .map(s => parseInt(s.trim()))
+        .filter(n => !isNaN(n) && n !== process.pid);
+    } catch (e) {
+      return [];
+    }
+  }
+}