@litmers/cursorflow-orchestrator 0.1.40 → 0.2.3

package/src/services/logging/file-writer.ts

@@ -1,526 +0,0 @@
-/**
- * Log File Writer - Write logs to files with rotation
- * 
- * Manages log file writing with support for multiple formats.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { Transform, TransformCallback } from 'stream';
-import { LogSession, JsonLogEntry, ParsedMessage } from '../../types/logging';
-import { EnhancedLogConfig } from '../../types/config';
-import { StreamingMessageParser } from './parser';
-import { stripAnsi, formatTimestampISO } from './formatter';
-
-export const DEFAULT_LOG_CONFIG: EnhancedLogConfig = {
-  enabled: true,
-  stripAnsi: true,
-  addTimestamps: true,
-  maxFileSize: 50 * 1024 * 1024,
-  maxFiles: 5,
-  keepRawLogs: true,
-  writeJsonLog: true,
-  timestampFormat: 'iso',
-};
-
-/**
- * Transform stream for clean log output
- */
-export class CleanLogTransform extends Transform {
-  private config: EnhancedLogConfig;
-  private session: LogSession;
-  private buffer = '';
-
-  constructor(config: EnhancedLogConfig, session: LogSession) {
-    super({ encoding: 'utf8' });
-    this.config = config;
-    this.session = session;
-  }
-
-  _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void {
-    let text = chunk.toString();
-    this.buffer += text;
-    const lines = this.buffer.split('\n');
-    this.buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      let processed = line;
-      if (this.config.stripAnsi) processed = stripAnsi(processed);
-      if (this.config.addTimestamps && processed.trim() && !this.hasTimestamp(processed)) {
-        const ts = formatTimestampISO(this.config.timestampFormat, this.session.startTime);
-        processed = `[${ts}] ${processed}`;
-      }
-      this.push(processed + '\n');
-    }
-    callback();
-  }
-
-  _flush(callback: TransformCallback): void {
-    if (this.buffer.trim()) {
-      let processed = this.buffer;
-      if (this.config.stripAnsi) processed = stripAnsi(processed);
-      if (this.config.addTimestamps && processed.trim() && !this.hasTimestamp(processed)) {
-        const ts = formatTimestampISO(this.config.timestampFormat, this.session.startTime);
-        processed = `[${ts}] ${processed}`;
-      }
-      this.push(processed + '\n');
-    }
-    callback();
-  }
-
-  private hasTimestamp(line: string): boolean {
-    return /^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(line.trim());
-  }
-}
-
-/**
- * Enhanced Log Manager - Handles all log file operations
- */
-export class EnhancedLogManager {
-  private config: EnhancedLogConfig;
-  private session: LogSession;
-  private logDir: string;
-
-  private cleanLogPath: string;
-  private rawLogPath: string;
-  private jsonLogPath: string;
-  private readableLogPath: string;
-
-  private cleanLogFd: number | null = null;
-  private rawLogFd: number | null = null;
-  private jsonLogFd: number | null = null;
-  private readableLogFd: number | null = null;
-
-  private cleanLogSize = 0;
-  private rawLogSize = 0;
-
-  private cleanTransform: CleanLogTransform | null = null;
-  private streamingParser: StreamingMessageParser | null = null;
-  private lineBuffer = '';
-  private onParsedMessage?: (msg: ParsedMessage) => void;
-
-  constructor(
-    logDir: string,
-    session: LogSession,
-    config: Partial<EnhancedLogConfig> = {},
-    onParsedMessage?: (msg: ParsedMessage) => void
-  ) {
-    this.config = { ...DEFAULT_LOG_CONFIG, ...config };
-    this.session = session;
-    this.logDir = logDir;
-    this.onParsedMessage = onParsedMessage;
-
-    fs.mkdirSync(logDir, { recursive: true });
-
-    this.cleanLogPath = path.join(logDir, 'terminal.log');
-    this.rawLogPath = path.join(logDir, 'terminal-raw.log');
-    this.jsonLogPath = path.join(logDir, 'terminal.jsonl');
-    this.readableLogPath = path.join(logDir, 'terminal-readable.log');
-
-    this.initLogFiles();
-  }
-
-  private initLogFiles(): void {
-    this.rotateIfNeeded(this.cleanLogPath);
-    if (this.config.keepRawLogs) this.rotateIfNeeded(this.rawLogPath);
-
-    this.cleanLogFd = fs.openSync(this.cleanLogPath, 'a');
-    if (this.config.keepRawLogs) this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
-    if (this.config.writeJsonLog) this.jsonLogFd = fs.openSync(this.jsonLogPath, 'a');
-    this.readableLogFd = fs.openSync(this.readableLogPath, 'a');
-
-    try {
-      this.cleanLogSize = fs.statSync(this.cleanLogPath).size;
-      if (this.config.keepRawLogs) this.rawLogSize = fs.statSync(this.rawLogPath).size;
-    } catch {
-      this.cleanLogSize = 0;
-      this.rawLogSize = 0;
-    }
-
-    this.writeSessionHeader();
-
-    this.cleanTransform = new CleanLogTransform(this.config, this.session);
-    this.cleanTransform.on('data', (data: string) => this.writeToCleanLog(data));
-
-    this.streamingParser = new StreamingMessageParser(msg => {
-      this.writeReadableMessage(msg);
-      if (this.onParsedMessage) this.onParsedMessage(msg);
-    });
-  }
-
-  private writeSessionHeader(): void {
-    const header = `
-╔══════════════════════════════════════════════════════════════════════════════╗
-║  CursorFlow Session Log                                                       ║
-╠══════════════════════════════════════════════════════════════════════════════╣
-║  Session ID:  ${this.session.id.padEnd(62)}║
-║  Lane:        ${this.session.laneName.padEnd(62)}║
-║  Task:        ${(this.session.taskName || '-').padEnd(62)}║
-║  Model:       ${(this.session.model || 'default').padEnd(62)}║
-║  Started:     ${new Date(this.session.startTime).toISOString().padEnd(62)}║
-╚══════════════════════════════════════════════════════════════════════════════╝
-
-`;
-    this.writeToCleanLog(header);
-    if (this.config.keepRawLogs && this.rawLogFd !== null) {
-      fs.writeSync(this.rawLogFd, header);
-    }
-
-    this.writeJsonEntry({
-      timestamp: new Date(this.session.startTime).toISOString(),
-      level: 'session',
-      source: 'system',
-      lane: this.session.laneName,
-      task: this.session.taskName,
-      message: 'Session started',
-      metadata: { sessionId: this.session.id, model: this.session.model, ...this.session.metadata },
-    });
-  }
-
-  private writeReadableMessage(msg: ParsedMessage): void {
-    if (this.readableLogFd === null) return;
-
-    const ts = new Date(msg.timestamp).toISOString();
-    let formatted: string;
-
-    switch (msg.type) {
-      case 'system':
-        formatted = `[${ts}] ⚙️ SYSTEM: ${msg.content}\n`;
-        break;
-
-      case 'user':
-      case 'assistant':
-      case 'result': {
-        const isUser = msg.type === 'user';
-        const isResult = msg.type === 'result';
-        const headerText = isUser ? '🧑 USER' : isResult ? '🤖 ASSISTANT (Final)' : '🤖 ASSISTANT';
-        const duration = msg.metadata?.duration_ms ? ` (${Math.round(msg.metadata.duration_ms / 1000)}s)` : '';
-        const label = `[ ${headerText}${duration} ] `;
-        const totalWidth = 80;
-        const topBorder = `┌─${label}${'─'.repeat(Math.max(0, totalWidth - label.length - 2))}`;
-        const bottomBorder = `└─${'─'.repeat(totalWidth - 2)}`;
-
-        formatted = `[${ts}] ${topBorder}\n`;
-        for (const line of msg.content.split('\n')) {
-          formatted += `[${ts}] │ ${line}\n`;
-        }
-        formatted += `[${ts}] ${bottomBorder}\n`;
-        break;
-      }
-
-      case 'tool':
-        formatted = `[${ts}] 🔧 TOOL: ${msg.content}\n`;
-        break;
-
-      case 'tool_result': {
-        const lines = msg.metadata?.lines ? ` (${msg.metadata.lines} lines)` : '';
-        formatted = `[${ts}] 📄 RESL: ${msg.metadata?.toolName || 'Tool'}${lines}\n`;
-        break;
-      }
-
-      case 'thinking': {
-        const thinkLabel = `[ 🤔 THINKING ] `;
-        const thinkWidth = 80;
-        const thinkTop = `┌─${thinkLabel}${'─'.repeat(Math.max(0, thinkWidth - thinkLabel.length - 2))}`;
-        const thinkBottom = `└─${'─'.repeat(thinkWidth - 2)}`;
-
-        formatted = `[${ts}] ${thinkTop}\n`;
-        for (const line of msg.content.trim().split('\n')) {
-          formatted += `[${ts}] │ ${line}\n`;
-        }
-        formatted += `[${ts}] ${thinkBottom}\n`;
-        break;
-      }
-
-      default:
-        formatted = `[${ts}] ${msg.content}\n`;
-    }
-
-    try {
-      fs.writeSync(this.readableLogFd, formatted);
-    } catch { /* Ignore write errors */ }
-  }
-
-  private rotateIfNeeded(logPath: string): void {
-    if (!fs.existsSync(logPath)) return;
-    try {
-      if (fs.statSync(logPath).size >= this.config.maxFileSize) {
-        this.rotateLog(logPath);
-      }
-    } catch { /* Ignore */ }
-  }
-
-  private rotateLog(logPath: string): void {
-    const dir = path.dirname(logPath);
-    const ext = path.extname(logPath);
-    const base = path.basename(logPath, ext);
-
-    for (let i = this.config.maxFiles - 1; i >= 1; i--) {
-      const oldPath = path.join(dir, `${base}.${i}${ext}`);
-      const newPath = path.join(dir, `${base}.${i + 1}${ext}`);
-      if (fs.existsSync(oldPath)) {
-        if (i === this.config.maxFiles - 1) {
-          fs.unlinkSync(oldPath);
-        } else {
-          fs.renameSync(oldPath, newPath);
-        }
-      }
-    }
-    fs.renameSync(logPath, path.join(dir, `${base}.1${ext}`));
-  }
-
-  private writeToCleanLog(data: string): void {
-    if (this.cleanLogFd === null) return;
-    const buffer = Buffer.from(data);
-    fs.writeSync(this.cleanLogFd, buffer);
-    this.cleanLogSize += buffer.length;
-
-    if (this.cleanLogSize >= this.config.maxFileSize) {
-      fs.closeSync(this.cleanLogFd);
-      this.rotateLog(this.cleanLogPath);
-      this.cleanLogFd = fs.openSync(this.cleanLogPath, 'a');
-      this.cleanLogSize = 0;
-    }
-  }
-
-  private writeToRawLog(data: string): void {
-    if (this.rawLogFd === null) return;
-    const buffer = Buffer.from(data);
-    fs.writeSync(this.rawLogFd, buffer);
-    this.rawLogSize += buffer.length;
-
-    if (this.rawLogSize >= this.config.maxFileSize) {
-      fs.closeSync(this.rawLogFd);
-      this.rotateLog(this.rawLogPath);
-      this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
-      this.rawLogSize = 0;
-    }
-  }
-
-  private writeJsonEntry(entry: JsonLogEntry): void {
-    if (this.jsonLogFd === null) return;
-    fs.writeSync(this.jsonLogFd, JSON.stringify(entry) + '\n');
-  }
-
-  writeStdout(data: Buffer | string): void {
-    const text = data.toString();
-    if (this.config.keepRawLogs) this.writeToRawLog(text);
-    if (this.cleanTransform) this.cleanTransform.write(data);
-
-    this.lineBuffer += text;
-    const lines = this.lineBuffer.split('\n');
-    this.lineBuffer = lines.pop() || '';
-
-    for (const line of lines) {
-      const cleanLine = stripAnsi(line).trim();
-      if (!cleanLine) continue;
-
-      if (cleanLine.startsWith('{')) {
-        if (this.streamingParser) this.streamingParser.parseLine(cleanLine);
-        if (this.config.writeJsonLog) {
-          try {
-            const json = JSON.parse(cleanLine);
-            this.writeJsonEntry({
-              timestamp: new Date().toISOString(),
-              level: 'stdout',
-              lane: this.session.laneName,
-              task: this.session.taskName,
-              message: cleanLine.substring(0, 2000),
-              metadata: json,
-            });
-            continue;
-          } catch { /* Not JSON */ }
-        }
-      }
-
-      if (this.config.writeJsonLog && !this.isNoise(cleanLine)) {
-        this.writeJsonEntry({
-          timestamp: new Date().toISOString(),
-          level: 'stdout',
-          lane: this.session.laneName,
-          task: this.session.taskName,
-          message: cleanLine.substring(0, 1000),
-        });
-      }
-    }
-  }
-
-  writeStderr(data: Buffer | string): void {
-    const text = data.toString();
-    if (this.config.keepRawLogs) this.writeToRawLog(text);
-    if (this.cleanTransform) this.cleanTransform.write(data);
-
-    if (this.readableLogFd !== null) {
-      for (const line of text.split('\n')) {
-        const cleanLine = stripAnsi(line).trim();
-        if (cleanLine && !this.isNoise(cleanLine)) {
-          try {
-            fs.writeSync(this.readableLogFd, `[${new Date().toISOString()}] ❌ STDERR: ${cleanLine}\n`);
-          } catch { /* Ignore */ }
-        }
-      }
-    }
-
-    if (this.config.writeJsonLog) {
-      const cleanText = stripAnsi(text).trim();
-      if (cleanText) {
-        this.writeJsonEntry({
-          timestamp: new Date().toISOString(),
-          level: 'stderr',
-          lane: this.session.laneName,
-          task: this.session.taskName,
-          message: cleanText.substring(0, 1000),
-        });
-      }
-    }
-  }
-
-  log(level: 'info' | 'error' | 'debug', message: string, metadata?: Record<string, any>): void {
-    const ts = formatTimestampISO(this.config.timestampFormat, this.session.startTime);
-    const line = `[${ts}] [${level.toUpperCase().padEnd(5)}] ${message}\n`;
-    this.writeToCleanLog(line);
-    if (this.config.keepRawLogs) this.writeToRawLog(line);
-
-    if (this.readableLogFd !== null) {
-      const icon = level === 'error' ? '❌ ERROR' : level === 'info' ? 'ℹ️ INFO' : '🔍 DEBUG';
-      try {
-        fs.writeSync(this.readableLogFd, `${new Date().toISOString()} ${icon}: ${message}\n`);
-      } catch { /* Ignore */ }
-    }
-
-    if (this.config.writeJsonLog) {
-      this.writeJsonEntry({
-        timestamp: new Date().toISOString(),
-        level,
-        lane: this.session.laneName,
-        task: this.session.taskName,
-        message,
-        metadata,
-      });
-    }
-  }
-
-  section(title: string): void {
-    const divider = '═'.repeat(78);
-    const line = `\n${divider}\n  ${title}\n${divider}\n`;
-    this.writeToCleanLog(line);
-    if (this.config.keepRawLogs) this.writeToRawLog(line);
-
-    if (this.readableLogFd !== null) {
-      const ts = new Date().toISOString();
-      try {
-        fs.writeSync(this.readableLogFd, `[${ts}] ━━━ ${title} ${'━'.repeat(60)}\n`);
-      } catch { /* Ignore */ }
-    }
-  }
-
-  setTask(taskName: string, model?: string): void {
-    this.session.taskName = taskName;
-    if (model) this.session.model = model;
-    this.section(`Task: ${taskName}${model ? ` (Model: ${model})` : ''}`);
-    
-    if (this.config.writeJsonLog) {
-      this.writeJsonEntry({
-        timestamp: new Date().toISOString(),
-        level: 'info',
-        source: 'system',
-        lane: this.session.laneName,
-        task: taskName,
-        message: `Task started: ${taskName}`,
-        metadata: { model },
-      });
-    }
-  }
-
-  private isNoise(text: string): boolean {
-    if (!text.trim()) return true;
-    const patterns = [/^[\s│├└─┌┐┘┴┬┤]+$/, /^[.\s]+$/, /^[=>\s-]+$/, /^\d+%$/, /^⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/];
-    return patterns.some(p => p.test(text));
-  }
-
-  getLogPaths(): { clean: string; raw?: string; json?: string; readable: string } {
-    return {
-      clean: this.cleanLogPath,
-      raw: this.config.keepRawLogs ? this.rawLogPath : undefined,
-      json: this.config.writeJsonLog ? this.jsonLogPath : undefined,
-      readable: this.readableLogPath,
-    };
-  }
-
-  getFileDescriptors(): { stdout: number; stderr: number } {
-    const fd = this.rawLogFd !== null ? this.rawLogFd : this.cleanLogFd!;
-    return { stdout: fd, stderr: fd };
-  }
-
-  close(): void {
-    if (this.cleanTransform) this.cleanTransform.end();
-
-    if (this.streamingParser) {
-      if (this.lineBuffer.trim()) this.streamingParser.parseLine(this.lineBuffer);
-      this.streamingParser.flush();
-    }
-
-    const endMarker = `
-╔══════════════════════════════════════════════════════════════════════════════╗
-║  Session Ended: ${new Date().toISOString().padEnd(60)}║
-║  Duration: ${this.formatDuration(Date.now() - this.session.startTime).padEnd(65)}║
-╚══════════════════════════════════════════════════════════════════════════════╝
-
-`;
-
-    if (this.cleanLogFd !== null) {
-      fs.writeSync(this.cleanLogFd, endMarker);
-      fs.closeSync(this.cleanLogFd);
-      this.cleanLogFd = null;
-    }
-
-    if (this.rawLogFd !== null) {
-      fs.writeSync(this.rawLogFd, endMarker);
-      fs.closeSync(this.rawLogFd);
-      this.rawLogFd = null;
-    }
-
-    if (this.jsonLogFd !== null) {
-      this.writeJsonEntry({
-        timestamp: new Date().toISOString(),
-        level: 'session',
-        source: 'system',
-        lane: this.session.laneName,
-        message: 'Session ended',
-        metadata: { sessionId: this.session.id, duration: Date.now() - this.session.startTime },
-      });
-      fs.closeSync(this.jsonLogFd);
-      this.jsonLogFd = null;
-    }
-
-    if (this.readableLogFd !== null) {
-      fs.writeSync(this.readableLogFd, endMarker);
-      fs.closeSync(this.readableLogFd);
-      this.readableLogFd = null;
-    }
-  }
-
-  private formatDuration(ms: number): string {
-    const seconds = Math.floor((ms / 1000) % 60);
-    const minutes = Math.floor((ms / (1000 * 60)) % 60);
-    const hours = Math.floor(ms / (1000 * 60 * 60));
-    if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
-    if (minutes > 0) return `${minutes}m ${seconds}s`;
-    return `${seconds}s`;
-  }
-}
-
-export function createLogManager(
-  laneRunDir: string,
-  laneName: string,
-  config?: Partial<EnhancedLogConfig>,
-  onParsedMessage?: (msg: ParsedMessage) => void
-): EnhancedLogManager {
-  const session: LogSession = {
-    id: `${laneName}-${Date.now().toString(36)}`,
-    laneName,
-    startTime: Date.now(),
-  };
-  return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
-}
-

package/src/types/review.ts

@@ -1,20 +0,0 @@
-/**
- * Review-related type definitions
- */
-
-export interface ReviewIssue {
-  severity: 'critical' | 'major' | 'minor';
-  description: string;
-  file?: string;
-  suggestion?: string;
-}
-
-export interface ReviewResult {
-  status: 'approved' | 'needs_changes';
-  buildSuccess: boolean;
-  issues: ReviewIssue[];
-  suggestions: string[];
-  summary: string;
-  raw: string;
-}
-