@litmers/cursorflow-orchestrator 0.1.20 → 0.1.26

package/src/services/logging/buffer.ts

@@ -0,0 +1,326 @@
+/**
+ * Log Buffer Service - In-memory log buffer for TUI
+ * 
+ * Provides real-time log streaming and filtering for the interactive monitor.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventEmitter } from 'events';
+import { LogImportance, JsonLogEntry, BufferedLogEntry as BufferedLogEntryType, MessageType } from '../../types/logging';
+import { COLORS } from './console';
+
+// Re-export types for convenience
+export type { BufferedLogEntry } from '../../types/logging';
+
+export interface LogBufferOptions {
+  maxEntries?: number;
+  pollInterval?: number;
+}
+
+export interface LogFilter {
+  lane?: string;
+  importance?: LogImportance;
+  search?: string;
+  type?: string;
+}
+
+export interface LogBufferState {
+  totalEntries: number;
+  filteredCount: number;
+  newCount: number;
+  isStreaming: boolean;
+  lanes: string[];
+}
+
+const LANE_COLORS = [
+  COLORS.cyan,
+  COLORS.magenta,
+  COLORS.yellow,
+  COLORS.green,
+  COLORS.blue,
+  COLORS.red,
+];
+
+export class LogBufferService extends EventEmitter {
+  private runDir: string;
+  private options: Required<LogBufferOptions>;
+  private entries: BufferedLogEntryType[] = [];
+  private entryIdCounter = 0;
+  private isStreaming = false;
+  private pollTimer: NodeJS.Timeout | null = null;
+  private filePositions = new Map<string, number>();
+  private lanes: string[] = [];
+  private laneColorMap = new Map<string, string>();
+  private newEntriesCount = 0;
+  private lastAcknowledgedId = 0;
+
+  constructor(runDir: string, options: LogBufferOptions = {}) {
+    super();
+    this.runDir = runDir;
+    this.options = {
+      maxEntries: options.maxEntries ?? 10000,
+      pollInterval: options.pollInterval ?? 100,
+    };
+  }
+
+  startStreaming(): void {
+    if (this.isStreaming) return;
+    this.isStreaming = true;
+    this.discoverLanes();
+    this.pollLogs();
+    this.pollTimer = setInterval(() => this.pollLogs(), this.options.pollInterval);
+    this.emit('started');
+  }
+
+  stopStreaming(): void {
+    if (!this.isStreaming) return;
+    this.isStreaming = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.emit('stopped');
+  }
+
+  private discoverLanes(): void {
+    const lanesDir = path.join(this.runDir, 'lanes');
+    if (!fs.existsSync(lanesDir)) return;
+
+    const dirs = fs.readdirSync(lanesDir).filter(name => {
+      const dirPath = path.join(lanesDir, name);
+      return fs.statSync(dirPath).isDirectory();
+    });
+
+    this.lanes = dirs.sort();
+    this.lanes.forEach((lane, index) => {
+      this.laneColorMap.set(lane, LANE_COLORS[index % LANE_COLORS.length]);
+    });
+  }
+
+  private pollLogs(): void {
+    const lanesDir = path.join(this.runDir, 'lanes');
+    if (!fs.existsSync(lanesDir)) return;
+
+    // Re-discover lanes to pick up new ones
+    this.discoverLanes();
+
+    const newEntries: BufferedLogEntryType[] = [];
+
+    for (const laneName of this.lanes) {
+      const jsonlPath = path.join(lanesDir, laneName, 'terminal.jsonl');
+
+      let fd: number | null = null;
+      try {
+        // Read file content atomically to avoid TOCTOU race condition
+        const lastPos = this.filePositions.get(jsonlPath) || 0;
+        fd = fs.openSync(jsonlPath, 'r');
+        const stat = fs.fstatSync(fd); // Use fstat on open fd to avoid race
+        
+        if (stat.size > lastPos) {
+          const buffer = Buffer.alloc(stat.size - lastPos);
+          fs.readSync(fd, buffer, 0, buffer.length, lastPos);
+          
+          const newContent = buffer.toString('utf-8');
+          const lines = newContent.split('\n').filter(line => line.trim());
+
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line) as JsonLogEntry;
+              const processed = this.processEntry(entry, laneName);
+              if (processed) newEntries.push(processed);
+            } catch { /* Skip invalid JSON */ }
+          }
+
+          this.filePositions.set(jsonlPath, stat.size);
+        }
+      } catch { /* File in use, skip */ }
+      finally {
+        if (fd !== null) {
+          try { fs.closeSync(fd); } catch { /* ignore */ }
+        }
+      }
+    }
+
+    if (newEntries.length > 0) {
+      newEntries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+      this.entries.push(...newEntries);
+      this.newEntriesCount += newEntries.length;
+
+      if (this.entries.length > this.options.maxEntries) {
+        const excess = this.entries.length - this.options.maxEntries;
+        this.entries.splice(0, excess);
+      }
+
+      this.emit('update', newEntries);
+    }
+  }
+
+  private processEntry(entry: JsonLogEntry, laneName: string): BufferedLogEntryType | null {
+    const timestamp = new Date(entry.timestamp || Date.now());
+    const type = (entry.type || 'unknown') as MessageType;
+    const level = entry.level || this.inferLevel(type);
+    const message = entry.content || entry.message || JSON.stringify(entry);
+    const importance = this.inferImportance(type, level);
+
+    return {
+      id: ++this.entryIdCounter,
+      timestamp,
+      laneName,
+      level,
+      type,
+      message: this.truncateMessage(message),
+      importance,
+      laneColor: this.laneColorMap.get(laneName) || COLORS.white,
+      raw: entry,
+    };
+  }
+
+  private inferLevel(type: string): string {
+    switch (type.toLowerCase()) {
+      case 'error':
+      case 'stderr':
+        return 'error';
+      case 'warning':
+        return 'warn';
+      case 'debug':
+      case 'thinking':
+        return 'debug';
+      default:
+        return 'info';
+    }
+  }
+
+  private inferImportance(type: string, level: string): LogImportance {
+    if (level === 'error' || type === 'error' || type === 'result') return LogImportance.HIGH;
+    if (type === 'tool' || type === 'tool_result') return LogImportance.MEDIUM;
+    if (type === 'thinking' || level === 'debug') return LogImportance.DEBUG;
+    if (type === 'assistant' || type === 'user') return LogImportance.MEDIUM;
+    return LogImportance.INFO;
+  }
+
+  private truncateMessage(message: string, maxLength = 500): string {
+    if (message.length <= maxLength) return message;
+    return message.substring(0, maxLength) + '...';
+  }
+
+  getEntries(options: {
+    offset?: number;
+    limit?: number;
+    filter?: LogFilter;
+    fromEnd?: boolean;
+  } = {}): BufferedLogEntryType[] {
+    const { offset = 0, limit = 100, filter, fromEnd = true } = options;
+    let filtered = this.applyFilter(this.entries, filter);
+
+    if (fromEnd) {
+      const start = Math.max(0, filtered.length - offset - limit);
+      const end = Math.max(0, filtered.length - offset);
+      return filtered.slice(start, end);
+    }
+    return filtered.slice(offset, offset + limit);
+  }
+
+  private applyFilter(entries: BufferedLogEntryType[], filter?: LogFilter): BufferedLogEntryType[] {
+    if (!filter) return entries;
+
+    return entries.filter(entry => {
+      if (filter.lane && entry.laneName !== filter.lane) return false;
+
+      if (filter.importance) {
+        const order = [LogImportance.DEBUG, LogImportance.INFO, LogImportance.LOW, 
+                       LogImportance.MEDIUM, LogImportance.HIGH, LogImportance.CRITICAL];
+        if (order.indexOf(entry.importance) < order.indexOf(filter.importance)) return false;
+      }
+
+      if (filter.type && entry.type !== filter.type) return false;
+
+      if (filter.search) {
+        const searchLower = filter.search.toLowerCase();
+        if (!entry.message.toLowerCase().includes(searchLower) &&
+            !entry.type.toLowerCase().includes(searchLower)) return false;
+      }
+
+      return true;
+    });
+  }
+
+  getTotalCount(filter?: LogFilter): number {
+    if (!filter) return this.entries.length;
+    return this.applyFilter(this.entries, filter).length;
+  }
+
+  getNewEntriesCount(): number {
+    return this.newEntriesCount;
+  }
+
+  acknowledgeNewEntries(): void {
+    this.newEntriesCount = 0;
+    this.lastAcknowledgedId = this.entryIdCounter;
+  }
+
+  getLanes(): string[] {
+    return [...this.lanes];
+  }
+
+  getState(): LogBufferState {
+    return {
+      totalEntries: this.entries.length,
+      filteredCount: this.entries.length,
+      newCount: this.newEntriesCount,
+      isStreaming: this.isStreaming,
+      lanes: this.getLanes(),
+    };
+  }
+
+  getLaneColor(laneName: string): string {
+    return this.laneColorMap.get(laneName) || COLORS.white;
+  }
+
+  clear(): void {
+    this.entries = [];
+    this.entryIdCounter = 0;
+    this.newEntriesCount = 0;
+    this.lastAcknowledgedId = 0;
+    this.filePositions.clear();
+  }
+
+  formatEntry(entry: BufferedLogEntryType, options: { showLane?: boolean; showTimestamp?: boolean } = {}): string {
+    const { showLane = true, showTimestamp = true } = options;
+    const parts: string[] = [];
+
+    if (showTimestamp) {
+      const ts = entry.timestamp.toLocaleTimeString('en-US', { hour12: false });
+      parts.push(`${COLORS.gray}[${ts}]${COLORS.reset}`);
+    }
+
+    if (showLane) {
+      parts.push(`${entry.laneColor}[${entry.laneName.padEnd(12)}]${COLORS.reset}`);
+    }
+
+    parts.push(this.getTypeIndicator(entry.type));
+    parts.push(entry.message);
+
+    return parts.join(' ');
+  }
+
+  private getTypeIndicator(type: string): string {
+    const indicators: Record<string, string> = {
+      user: `${COLORS.cyan}[USER  ]${COLORS.reset}`,
+      assistant: `${COLORS.green}[ASST  ]${COLORS.reset}`,
+      tool: `${COLORS.yellow}[TOOL  ]${COLORS.reset}`,
+      tool_result: `${COLORS.gray}[RESULT]${COLORS.reset}`,
+      error: `${COLORS.red}[ERROR ]${COLORS.reset}`,
+      stderr: `${COLORS.red}[ERROR ]${COLORS.reset}`,
+      thinking: `${COLORS.gray}[THINK ]${COLORS.reset}`,
+      result: `${COLORS.green}[DONE  ]${COLORS.reset}`,
+      stdout: `${COLORS.white}[STDOUT]${COLORS.reset}`,
+    };
+    return indicators[type.toLowerCase()] || `${COLORS.gray}[${type.toUpperCase().padEnd(6)}]${COLORS.reset}`;
+  }
+}
+
+export function createLogBuffer(runDir: string, options?: LogBufferOptions): LogBufferService {
+  return new LogBufferService(runDir, options);
+}
+

package/src/services/logging/console.ts

@@ -0,0 +1,193 @@
+/**
+ * Console Logging Utilities
+ * 
+ * Provides formatted console output with colors, timestamps, and context support.
+ */
+
+export enum LogLevel {
+  error = 0,
+  warn = 1,
+  info = 2,
+  debug = 3,
+}
+
+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',
+  white: '\x1b[37m',
+} as const;
+
+let currentLogLevel: number = LogLevel.info;
+
+/**
+ * Set log level
+ */
+export function setLogLevel(level: string | number): void {
+  if (typeof level === 'string') {
+    currentLogLevel = (LogLevel as any)[level] ?? LogLevel.info;
+  } else {
+    currentLogLevel = level;
+  }
+}
+
+/**
+ * Get current log level
+ */
+export function getLogLevel(): number {
+  return currentLogLevel;
+}
+
+/**
+ * Format timestamp as [HH:MM:SS] in local time
+ */
+export function formatTimestamp(date: Date = new Date()): string {
+  return date.toLocaleTimeString('en-US', { hour12: false });
+}
+
+/**
+ * Log options interface for contextual logging
+ */
+export interface LogOptions {
+  context?: string;
+  emoji?: string;
+  noTimestamp?: boolean;
+  color?: string;
+}
+
+/**
+ * Internal log function with color support
+ */
+function logWithColor(
+  color: string,
+  level: keyof typeof LogLevel,
+  message: string,
+  options: LogOptions = {}
+): void {
+  if (LogLevel[level] > currentLogLevel) return;
+
+  const { context, emoji = '', noTimestamp = false } = options;
+  const timestamp = noTimestamp ? '' : `${COLORS.gray}[${formatTimestamp()}]${COLORS.reset}`;
+  const contextPart = context ? ` ${COLORS.magenta}[${context}]${COLORS.reset}` : '';
+  const emojiPart = emoji ? `${emoji} ` : '';
+  const levelPart = `${color}${level.toUpperCase().padEnd(5)}${COLORS.reset}`;
+
+  const lines = String(message).split('\n');
+  const prefix = `${timestamp}${contextPart} ${emojiPart}${levelPart}`;
+
+  for (const line of lines) {
+    console.log(`${prefix} ${line}`);
+  }
+}
+
+function normalizeOptions(options: LogOptions | string | undefined, defaultEmoji: string): LogOptions {
+  if (typeof options === 'string') {
+    return { emoji: options };
+  }
+  return { emoji: defaultEmoji, ...options };
+}
+
+// Primary logging functions
+export function error(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.red, 'error', message, normalizeOptions(options, '❌'));
+}
+
+export function warn(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.yellow, 'warn', message, normalizeOptions(options, '⚠️'));
+}
+
+export function info(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.cyan, 'info', message, normalizeOptions(options, 'ℹ️'));
+}
+
+export function success(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.green, 'info', message, normalizeOptions(options, '✅'));
+}
+
+export function debug(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.gray, 'debug', message, normalizeOptions(options, '🔍'));
+}
+
+export function progress(message: string, options?: LogOptions | string): void {
+  logWithColor(COLORS.blue, 'info', message, normalizeOptions(options, '🔄'));
+}
+
+/**
+ * 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 }),
+  };
+}
+
+/**
+ * Lane-specific output
+ */
+export function laneOutput(laneName: string, message: string, isError = false): void {
+  const timestamp = `${COLORS.gray}[${formatTimestamp()}]${COLORS.reset}`;
+  const laneLabel = `${COLORS.magenta}${laneName.padEnd(10)}${COLORS.reset}`;
+  const output = isError ? `${COLORS.red}${message}${COLORS.reset}` : message;
+  
+  if (isError) {
+    process.stderr.write(`${timestamp} ${laneLabel} ${output}\n`);
+  } else {
+    process.stdout.write(`${timestamp} ${laneLabel} ${output}\n`);
+  }
+}
+
+/**
+ * Section header
+ */
+export function section(message: string): void {
+  console.log('');
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(`${COLORS.cyan}  ${message}${COLORS.reset}`);
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log('');
+}
+
+/**
+ * Simple log without formatting
+ */
+export function log(message: string | any): void {
+  console.log(message);
+}
+
+/**
+ * Raw output (no formatting)
+ */
+export function raw(message: string): void {
+  process.stdout.write(message);
+}
+
+/**
+ * Status indicators
+ */
+export const STATUS = {
+  running: `${COLORS.blue}🔄${COLORS.reset}`,
+  done: `${COLORS.green}✅${COLORS.reset}`,
+  failed: `${COLORS.red}❌${COLORS.reset}`,
+  warning: `${COLORS.yellow}⚠️${COLORS.reset}`,
+  pending: `${COLORS.gray}⏳${COLORS.reset}`,
+  paused: `${COLORS.yellow}⏸️${COLORS.reset}`,
+  waiting: `${COLORS.gray}⏳${COLORS.reset}`,
+} as const;
+