@litmers/cursorflow-orchestrator 0.2.5 → 0.2.7

package/dist/utils/enhanced-logger.js

@@ -1,6 +1,10 @@
 "use strict";
 /**
- * Enhanced Logger - Simplified JSONL terminal output capture
+ * Enhanced Logger - Simplified terminal output capture
+ *
+ * Features:
+ * - Raw log: Original output as-is
+ * - Readable log: Formatted with formatMessageForConsole style
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -37,31 +41,86 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CleanLogTransform = exports.StreamingMessageParser = exports.EnhancedLogManager = exports.DEFAULT_LOG_CONFIG = void 0;
+exports.stripAnsi = stripAnsi;
+exports.formatTimestamp = formatTimestamp;
 exports.createLogManager = createLogManager;
 exports.readJsonLog = readJsonLog;
 exports.exportLogs = exportLogs;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const formatter_1 = require("../services/logging/formatter");
+const log_formatter_1 = require("./log-formatter");
 const path_1 = require("./path");
 const paths_1 = require("../services/logging/paths");
 exports.DEFAULT_LOG_CONFIG = {
     enabled: true,
     stripAnsi: true,
+    addTimestamps: true,
     maxFileSize: 50 * 1024 * 1024, // 50MB
     maxFiles: 5,
-    writeJsonLog: true,
+    keepRawLogs: true,
+    keepAbsoluteRawLogs: false,
+    raw: false,
+    writeJsonLog: false, // Disabled by default now
     timestampFormat: 'iso',
 };
 /**
- * Enhanced Log Manager - JSONL format only
+ * ANSI escape sequence regex pattern
+ */
+const ANSI_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+const EXTENDED_ANSI_REGEX = /(?:\x1B[@-Z\\-_]|\x1B\[[0-?]*[ -/]*[@-~]|\x1B\][^\x07]*(?:\x07|\x1B\\)|\x1B[PX^_][^\x1B]*\x1B\\|\x1B.)/g;
+/**
+ * Strip ANSI escape sequences from text
+ */
+function stripAnsi(text) {
+    return text
+        .replace(EXTENDED_ANSI_REGEX, '')
+        .replace(ANSI_REGEX, '')
+        .replace(/\r[^\n]/g, '\n')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+}
+/**
+ * Format timestamp
+ */
+function formatTimestamp(format, startTime) {
+    const now = Date.now();
+    switch (format) {
+        case 'iso':
+            return new Date(now).toISOString();
+        case 'relative':
+            if (startTime) {
+                const elapsed = now - startTime;
+                const seconds = Math.floor(elapsed / 1000);
+                const minutes = Math.floor(seconds / 60);
+                const hours = Math.floor(minutes / 60);
+                if (hours > 0) {
+                    return `+${hours}h${minutes % 60}m${seconds % 60}s`;
+                }
+                else if (minutes > 0) {
+                    return `+${minutes}m${seconds % 60}s`;
+                }
+                else {
+                    return `+${seconds}s`;
+                }
+            }
+            return new Date(now).toISOString();
+        case 'short':
+            return new Date(now).toLocaleTimeString('en-US', { hour12: false });
+        default:
+            return new Date(now).toISOString();
+    }
+}
+/**
+ * Simplified Log Manager - Only raw and readable logs
  */
 class EnhancedLogManager {
     config;
     session;
     logDir;
-    jsonlLogPath;
-    jsonlLogFd = null;
+    rawLogPath;
+    readableLogPath;
+    rawLogFd = null;
+    readableLogFd = null;
+    rawLogSize = 0;
     onParsedMessage;
     constructor(logDir, session, config = {}, onParsedMessage) {
         this.config = { ...exports.DEFAULT_LOG_CONFIG, ...config };
@@ -71,7 +130,10 @@ class EnhancedLogManager {
         // Ensure log directory exists
         fs.mkdirSync(logDir, { recursive: true });
         // Subprocess (lane) logs live in the lane run directory to avoid nesting with main logs.
-        this.jsonlLogPath = (0, paths_1.getLaneLogPath)(logDir, 'jsonl');
+        // Main process logs are written separately to a run-level file (see utils/logger.ts).
+        // Set up log file paths (simplified)
+        this.rawLogPath = (0, paths_1.getLaneLogPath)(logDir, 'raw');
+        this.readableLogPath = (0, paths_1.getLaneLogPath)(logDir, 'readable');
         // Initialize log files
         this.initLogFiles();
     }
@@ -94,34 +156,43 @@ class EnhancedLogManager {
      * Initialize log files and write session headers
      */
     initLogFiles() {
-        if (this.config.writeJsonLog) {
-            // Ensure parent directory exists before opening file
-            const logDir = path.dirname(this.jsonlLogPath);
-            fs.mkdirSync(logDir, { recursive: true });
-            this.rotateIfNeeded(this.jsonlLogPath);
-            this.jsonlLogFd = fs.openSync(this.jsonlLogPath, 'a');
+        // Check and rotate if necessary
+        if (this.config.keepRawLogs) {
+            this.rotateIfNeeded(this.rawLogPath);
+            this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
         }
-        // Write session start to JSON log
-        this.writeSessionStart();
+        this.rotateIfNeeded(this.readableLogPath);
+        this.readableLogFd = fs.openSync(this.readableLogPath, 'a');
+        // Get initial file size for raw log if enabled
+        if (this.rawLogFd !== null) {
+            try {
+                this.rawLogSize = fs.statSync(this.rawLogPath).size;
+            }
+            catch {
+                this.rawLogSize = 0;
+            }
+        }
+        // Write session header
+        this.writeSessionHeader();
     }
     /**
-     * Write session start to JSON log
+     * Write session header to logs
      */
-    writeSessionStart() {
-        if (this.config.writeJsonLog) {
-            this.writeToJsonLog({
-                type: 'session',
-                role: 'system',
-                content: 'Session started',
-                timestamp: this.session.startTime,
-                metadata: {
-                    sessionId: this.session.id,
-                    laneName: this.session.laneName,
-                    taskName: this.session.taskName,
-                    model: this.session.model,
-                }
-            });
-        }
+    writeSessionHeader() {
+        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.writeToRawLog(header);
+        this.writeToReadableLog(header);
     }
     /**
      * Rotate log file if it exceeds max size
@@ -164,35 +235,49 @@ class EnhancedLogManager {
         fs.renameSync(logPath, rotatedPath);
     }
     /**
-     * Write to JSONL log
+     * Write to raw log with size tracking
      */
-    writeToJsonLog(msg) {
-        if (this.jsonlLogFd === null)
+    writeToRawLog(data) {
+        if (this.rawLogFd === null)
+            return;
+        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+        fs.writeSync(this.rawLogFd, buffer);
+        this.rawLogSize += buffer.length;
+        // Check if rotation needed
+        if (this.rawLogSize >= this.config.maxFileSize) {
+            fs.closeSync(this.rawLogFd);
+            this.rotateLog(this.rawLogPath);
+            this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
+            this.rawLogSize = 0;
+        }
+    }
+    /**
+     * Write to readable log
+     */
+    writeToReadableLog(data) {
+        if (this.readableLogFd === null)
             return;
         try {
-            // Add lane and task context to JSON log
-            const entry = {
-                ...msg,
-                lane: this.session.laneName,
-                task: this.session.taskName,
-                laneIndex: this.session.laneIndex,
-                taskIndex: this.session.taskIndex,
-                timestamp_iso: new Date(msg.timestamp).toISOString(),
-            };
-            fs.writeSync(this.jsonlLogFd, JSON.stringify(entry) + '\n');
+            fs.writeSync(this.readableLogFd, data);
         }
         catch {
             // Ignore write errors
         }
     }
     /**
-     * Write a parsed message to the JSON log and console
+     * Write a parsed message to the readable log using formatMessageForConsole style
      */
     writeReadableMessage(msg) {
-        // Write to JSON log
-        if (this.config.writeJsonLog) {
-            this.writeToJsonLog(msg);
-        }
+        // Use formatMessageForConsole for consistent formatting
+        // Use short lane-task label like [1-1-lanename10]
+        const formatted = (0, log_formatter_1.formatMessageForConsole)(msg, {
+            laneLabel: `[${this.getLaneTaskLabel()}]`,
+            includeTimestamp: false, // We'll add our own short timestamp
+        });
+        // Strip ANSI codes and add short timestamp for file output
+        const clean = stripAnsi(formatted);
+        const ts = this.getShortTime();
+        this.writeToReadableLog(`[${ts}] ${clean}\n`);
         // Callback for console output
         if (this.onParsedMessage) {
             this.onParsedMessage(msg);
@@ -203,6 +288,9 @@ class EnhancedLogManager {
      */
     writeStdout(data) {
         const text = data.toString();
+        // Write raw log (original data)
+        this.writeToRawLog(data);
+        // Parse JSON output and write to readable log
         const lines = text.split('\n');
         for (const line of lines) {
             const trimmed = line.trim();
@@ -219,11 +307,6 @@ class EnhancedLogManager {
                     }
                     // parseJsonToMessage returned null - create fallback message for known JSON
                     if (json.type) {
-                        // Skip noisy events that we don't want to show
-                        if (json.type === 'thinking' || json.type === 'call' ||
-                            (json.type === 'tool_call' && !json.tool_call)) {
-                            continue;
-                        }
                         const fallbackMsg = {
                             type: 'info',
                             role: 'system',
@@ -238,29 +321,41 @@ class EnhancedLogManager {
                     // Not valid JSON, fall through
                 }
             }
-            // Non-JSON line
-            const cleanLine = (0, formatter_1.stripAnsi)(trimmed);
+            // Non-JSON line - write as-is with short timestamp and lane-task label
+            const cleanLine = stripAnsi(trimmed);
             if (cleanLine && !this.isNoiseLog(cleanLine)) {
-                // Detect if this looks like Git output
-                const isGit = this.isGitOutput(cleanLine);
-                const type = isGit ? 'git' : 'stdout';
-                // Output to console
-                if (this.onParsedMessage) {
-                    this.onParsedMessage({
-                        type,
-                        role: 'system',
-                        content: trimmed,
-                        timestamp: Date.now(),
-                    });
+                const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
+                const label = this.getLaneTaskLabel();
+                const ts = this.getShortTime();
+                // For file output, use clean line (no ANSI codes)
+                let fileFormattedLine;
+                if (hasTimestamp) {
+                    fileFormattedLine = cleanLine.includes(`[${label}]`)
+                        ? cleanLine
+                        : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
                 }
-                // Write to JSON log
-                if (this.config.writeJsonLog) {
-                    this.writeToJsonLog({
-                        type,
+                else {
+                    fileFormattedLine = `[${ts}] [${label}] ${cleanLine}`;
+                }
+                this.writeToReadableLog(`${fileFormattedLine}\n`);
+                // For console output, preserve ANSI colors from original line
+                if (this.onParsedMessage) {
+                    let consoleFormattedLine;
+                    if (hasTimestamp) {
+                        consoleFormattedLine = trimmed.includes(`[${label}]`)
+                            ? trimmed
+                            : trimmed.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
+                    }
+                    else {
+                        consoleFormattedLine = `[${ts}] [${label}] ${trimmed}`;
+                    }
+                    const rawMsg = {
+                        type: 'raw',
                         role: 'system',
-                        content: cleanLine,
+                        content: consoleFormattedLine,
                         timestamp: Date.now(),
-                    });
+                    };
+                    this.onParsedMessage(rawMsg);
                 }
             }
         }
@@ -272,32 +367,13 @@ class EnhancedLogManager {
         const type = json.type;
         const timestamp = json.timestamp_ms || Date.now();
         switch (type) {
-            case 'info':
-            case 'warn':
-            case 'error':
-            case 'success':
-            case 'debug':
-            case 'progress':
             case 'system':
-            case 'git':
-                // Handle internal logger JSON or cursor-agent system events
-                if (json.content && typeof json.content === 'string') {
-                    return {
-                        type: type,
-                        role: 'system',
-                        content: json.content,
-                        timestamp,
-                    };
-                }
-                if (type === 'system') {
-                    return {
-                        type: 'system',
-                        role: 'system',
-                        content: `Model: ${json.model || 'unknown'}, Mode: ${json.permissionMode || 'default'}`,
-                        timestamp,
-                    };
-                }
-                return null;
+                return {
+                    type: 'system',
+                    role: 'system',
+                    content: `Model: ${json.model || 'unknown'}, Mode: ${json.permissionMode || 'default'}`,
+                    timestamp,
+                };
             case 'user':
                 if (json.message?.content) {
                     const textContent = json.message.content
@@ -388,68 +464,45 @@ class EnhancedLogManager {
      */
     writeStderr(data) {
         const text = data.toString();
+        // Write raw log
+        this.writeToRawLog(data);
+        // Write to readable log - treat stderr same as stdout
+        // Git and many tools use stderr for non-error output
         const lines = text.split('\n');
         for (const line of lines) {
-            const cleanLine = (0, formatter_1.stripAnsi)(line).trim();
+            const cleanLine = stripAnsi(line).trim();
             if (cleanLine && !this.isNoiseLog(cleanLine)) {
+                const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
+                const label = this.getLaneTaskLabel();
+                const ts = this.getShortTime();
+                // Determine if this is actually an error message
                 const isError = this.isErrorLine(cleanLine);
-                const isGit = this.isGitOutput(cleanLine);
-                const type = isError ? 'stderr' : (isGit ? 'git' : 'stderr');
-                // Write to JSON log
-                if (this.config.writeJsonLog) {
-                    this.writeToJsonLog({
-                        type,
-                        role: 'system',
-                        content: cleanLine,
-                        timestamp: Date.now(),
-                        metadata: { isError, isGit }
-                    });
+                const prefix = isError ? '❌ ERR' : '';
+                let formattedLine;
+                if (hasTimestamp) {
+                    formattedLine = cleanLine.includes(`[${label}]`)
+                        ? cleanLine
+                        : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]${prefix ? ' ' + prefix : ''}`);
+                }
+                else {
+                    formattedLine = prefix
+                        ? `[${ts}] [${label}] ${prefix} ${cleanLine}`
+                        : `[${ts}] [${label}] ${cleanLine}`;
                 }
+                this.writeToReadableLog(`${formattedLine}\n`);
                 // Output to console
                 if (this.onParsedMessage) {
-                    this.onParsedMessage({
-                        type,
+                    const rawMsg = {
+                        type: 'raw',
                         role: 'system',
-                        content: line.trim(),
+                        content: formattedLine,
                         timestamp: Date.now(),
-                    });
+                    };
+                    this.onParsedMessage(rawMsg);
                 }
             }
         }
     }
-    /**
-     * Check if a line is likely Git output
-     */
-    isGitOutput(text) {
-        const gitPatterns = [
-            /^Running: git /i,
-            /^git version /i,
-            /^On branch /i,
-            /^Your branch is /i,
-            /^Changes to be committed:/i,
-            /^Changes not staged for commit:/i,
-            /^Untracked files:/i,
-            /^\s*\((use "git |use --|use -)/i,
-            /^\s*modified:\s+/i,
-            /^\s*new file:\s+/i,
-            /^\s*deleted:\s+/i,
-            /^\s*renamed:\s+/i,
-            /^Switched to branch /i,
-            /^Switched to a new branch /i,
-            /^Merge made by the /i,
-            /^Everything up-to-date/i,
-            /^Already up to date/i,
-            /^branch '.*' set up to track remote branch '.*' from 'origin'/i,
-            /^Counting objects: /i,
-            /^Compressing objects: /i,
-            /^Writing objects: /i,
-            /^Total \d+ \(delta \d+\)/i,
-            /^remote: Resolving deltas:/i,
-            /^To .*\.git/i,
-            /^[a-f0-9]{7,40}\.\.[a-f0-9]{7,40}\s+.*->\s+.*/i,
-        ];
-        return gitPatterns.some(p => p.test(text));
-    }
     /**
      * Check if a line is actually an error message
      */
@@ -473,40 +526,21 @@ class EnhancedLogManager {
      * Write a custom log entry
      */
     log(level, message, metadata) {
-        const isGit = metadata?.context === 'git';
-        const type = isGit ? 'git' : level;
-        if (this.config.writeJsonLog) {
-            this.writeToJsonLog({
-                type,
-                role: 'system',
-                content: message,
-                timestamp: Date.now(),
-                metadata
-            });
-        }
-        if (this.onParsedMessage) {
-            this.onParsedMessage({
-                type,
-                role: 'system',
-                content: message,
-                timestamp: Date.now(),
-                metadata
-            });
-        }
+        const ts = this.getShortTime();
+        const label = this.getLaneTaskLabel();
+        const emoji = level === 'error' ? '❌' : level === 'info' ? 'ℹ️' : '🔍';
+        const line = `[${ts}] [${label}] ${emoji} ${level.toUpperCase()} ${message}\n`;
+        this.writeToRawLog(line);
+        this.writeToReadableLog(line);
     }
     /**
      * Add a section marker
      */
     section(title) {
-        if (this.config.writeJsonLog) {
-            this.writeToJsonLog({
-                type: 'info',
-                role: 'system',
-                content: `--- ${title} ---`,
-                timestamp: Date.now(),
-                metadata: { isSection: true }
-            });
-        }
+        const divider = '═'.repeat(78);
+        const line = `\n${divider}\n  ${title}\n${divider}\n`;
+        this.writeToRawLog(line);
+        this.writeToReadableLog(line);
     }
     /**
      * Update task context
@@ -541,39 +575,47 @@ class EnhancedLogManager {
      */
     getLogPaths() {
         return {
-            jsonl: this.jsonlLogPath,
-            clean: this.jsonlLogPath, // Backward compatibility
+            clean: this.readableLogPath, // For backward compatibility
+            raw: this.rawLogPath,
+            readable: this.readableLogPath,
         };
     }
     /**
      * Create file descriptors for process stdio redirection
      */
     getFileDescriptors() {
-        const fd = this.jsonlLogFd;
+        const fd = this.rawLogFd;
         return { stdout: fd, stderr: fd };
     }
     /**
      * Close all log files
      */
     close() {
-        if (this.jsonlLogFd !== null) {
+        // Write session end marker
+        const endMarker = `
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  Session Ended: ${new Date().toISOString().padEnd(60)}║
+║  Duration: ${this.formatDuration(Date.now() - this.session.startTime).padEnd(65)}║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+`;
+        if (this.rawLogFd !== null) {
             try {
-                if (this.config.writeJsonLog) {
-                    this.writeToJsonLog({
-                        type: 'session',
-                        role: 'system',
-                        content: 'Session ended',
-                        timestamp: Date.now(),
-                        metadata: {
-                            duration: Date.now() - this.session.startTime,
-                        }
-                    });
-                }
-                fs.fsyncSync(this.jsonlLogFd);
-                fs.closeSync(this.jsonlLogFd);
+                fs.writeSync(this.rawLogFd, endMarker);
+                fs.fsyncSync(this.rawLogFd);
+                fs.closeSync(this.rawLogFd);
             }
             catch { }
-            this.jsonlLogFd = null;
+            this.rawLogFd = null;
+        }
+        if (this.readableLogFd !== null) {
+            try {
+                fs.writeSync(this.readableLogFd, endMarker);
+                fs.fsyncSync(this.readableLogFd);
+                fs.closeSync(this.readableLogFd);
+            }
+            catch { }
+            this.readableLogFd = null;
         }
     }
     /**
@@ -581,25 +623,39 @@ class EnhancedLogManager {
      */
     getLastError() {
         try {
-            if (!fs.existsSync(this.jsonlLogPath))
+            if (!fs.existsSync(this.readableLogPath))
                 return null;
-            const content = fs.readFileSync(this.jsonlLogPath, 'utf8');
-            const lines = content.split('\n').filter(l => l.trim());
-            for (let i = lines.length - 1; i >= 0; i--) {
-                try {
-                    const entry = JSON.parse(lines[i]);
-                    if (entry.type === 'error' || entry.type === 'stderr' && entry.metadata?.isError) {
-                        return entry.content;
-                    }
-                }
-                catch { }
+            const content = fs.readFileSync(this.readableLogPath, 'utf8');
+            const lines = content.split('\n').filter(l => l.includes('❌') ||
+                l.includes('[ERROR]') ||
+                l.includes('error:') ||
+                l.includes('Fatal') ||
+                l.includes('fail'));
+            if (lines.length === 0) {
+                const allLines = content.split('\n').filter(l => l.trim());
+                return allLines.slice(-5).join('\n');
             }
-            return null;
+            return lines[lines.length - 1].trim();
         }
         catch {
             return null;
         }
     }
+    /**
+     * Format duration for display
+     */
+    formatDuration(ms) {
+        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`;
+        }
+        else if (minutes > 0) {
+            return `${minutes}m ${seconds}s`;
+        }
+        return `${seconds}s`;
+    }
 }
 exports.EnhancedLogManager = EnhancedLogManager;
 /**
@@ -616,45 +672,19 @@ function createLogManager(laneRunDir, laneName, config, onParsedMessage, laneInd
     return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
 }
 /**
- * Read and parse JSON log file
+ * Read and parse JSON log file (legacy compatibility - returns empty array)
  */
 function readJsonLog(logPath) {
-    try {
-        if (!fs.existsSync(logPath))
-            return [];
-        const content = fs.readFileSync(logPath, 'utf8');
-        return content.split('\n')
-            .filter(l => l.trim())
-            .map(l => {
-            try {
-                return JSON.parse(l);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter(Boolean);
-    }
-    catch {
-        return [];
-    }
+    return [];
 }
 /**
- * Export logs
+ * Export logs (legacy compatibility)
  */
 function exportLogs(laneRunDir, format, outputPath) {
-    const logPath = (0, paths_1.getLaneLogPath)(laneRunDir, 'jsonl');
+    const logPath = (0, paths_1.getLaneLogPath)(laneRunDir, 'raw');
     let output = '';
     if (fs.existsSync(logPath)) {
-        if (format === 'json') {
-            const logs = readJsonLog(logPath);
-            output = JSON.stringify(logs, null, 2);
-        }
-        else {
-            // Basic text conversion for other formats
-            const logs = readJsonLog(logPath);
-            output = logs.map(l => `[${l.timestamp_iso}] [${l.type}] ${l.content}`).join('\n');
-        }
+        output = fs.readFileSync(logPath, 'utf8');
     }
     if (outputPath) {
         fs.writeFileSync(outputPath, output, 'utf8');