@litmers/cursorflow-orchestrator 0.2.2 → 0.2.5

package/dist/utils/enhanced-logger.js

@@ -1,10 +1,6 @@
 "use strict";
 /**
- * Enhanced Logger - Simplified terminal output capture
- *
- * Features:
- * - Raw log: Original output as-is
- * - Readable log: Formatted with formatMessageForConsole style
+ * Enhanced Logger - Simplified JSONL terminal output capture
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -41,86 +37,31 @@ 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 log_formatter_1 = require("./log-formatter");
+const formatter_1 = require("../services/logging/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,
-    keepRawLogs: true,
-    keepAbsoluteRawLogs: false,
-    raw: false,
-    writeJsonLog: false, // Disabled by default now
+    writeJsonLog: true,
     timestampFormat: 'iso',
 };
 /**
- * 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
+ * Enhanced Log Manager - JSONL format only
  */
 class EnhancedLogManager {
     config;
     session;
     logDir;
-    rawLogPath;
-    readableLogPath;
-    rawLogFd = null;
-    readableLogFd = null;
-    rawLogSize = 0;
+    jsonlLogPath;
+    jsonlLogFd = null;
     onParsedMessage;
     constructor(logDir, session, config = {}, onParsedMessage) {
         this.config = { ...exports.DEFAULT_LOG_CONFIG, ...config };
@@ -130,10 +71,7 @@ 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.
-        // 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');
+        this.jsonlLogPath = (0, paths_1.getLaneLogPath)(logDir, 'jsonl');
         // Initialize log files
         this.initLogFiles();
     }
@@ -156,43 +94,34 @@ class EnhancedLogManager {
      * Initialize log files and write session headers
      */
     initLogFiles() {
-        // Check and rotate if necessary
-        if (this.config.keepRawLogs) {
-            this.rotateIfNeeded(this.rawLogPath);
-            this.rawLogFd = fs.openSync(this.rawLogPath, 'a');
+        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');
         }
-        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
+        this.writeSessionStart();
     }
     /**
-     * Write session header to logs
+     * Write session start to JSON log
      */
-    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);
+    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,
+                }
+            });
+        }
     }
     /**
      * Rotate log file if it exceeds max size
@@ -235,49 +164,35 @@ class EnhancedLogManager {
         fs.renameSync(logPath, rotatedPath);
     }
     /**
-     * Write to raw log with size tracking
+     * Write to JSONL log
      */
-    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)
+    writeToJsonLog(msg) {
+        if (this.jsonlLogFd === null)
             return;
         try {
-            fs.writeSync(this.readableLogFd, data);
+            // 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');
         }
         catch {
             // Ignore write errors
         }
     }
     /**
-     * Write a parsed message to the readable log using formatMessageForConsole style
+     * Write a parsed message to the JSON log and console
      */
     writeReadableMessage(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`);
+        // Write to JSON log
+        if (this.config.writeJsonLog) {
+            this.writeToJsonLog(msg);
+        }
         // Callback for console output
         if (this.onParsedMessage) {
             this.onParsedMessage(msg);
@@ -288,9 +203,6 @@ 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();
@@ -307,6 +219,11 @@ 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',
@@ -321,41 +238,29 @@ class EnhancedLogManager {
                     // Not valid JSON, fall through
                 }
             }
-            // Non-JSON line - write as-is with short timestamp and lane-task label
-            const cleanLine = stripAnsi(trimmed);
+            // Non-JSON line
+            const cleanLine = (0, formatter_1.stripAnsi)(trimmed);
             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();
-                // For file output, use clean line (no ANSI codes)
-                let fileFormattedLine;
-                if (hasTimestamp) {
-                    fileFormattedLine = cleanLine.includes(`[${label}]`)
-                        ? cleanLine
-                        : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
-                }
-                else {
-                    fileFormattedLine = `[${ts}] [${label}] ${cleanLine}`;
-                }
-                this.writeToReadableLog(`${fileFormattedLine}\n`);
-                // For console output, preserve ANSI colors from original line
+                // Detect if this looks like Git output
+                const isGit = this.isGitOutput(cleanLine);
+                const type = isGit ? 'git' : 'stdout';
+                // Output to console
                 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',
+                    this.onParsedMessage({
+                        type,
                         role: 'system',
-                        content: consoleFormattedLine,
+                        content: trimmed,
                         timestamp: Date.now(),
-                    };
-                    this.onParsedMessage(rawMsg);
+                    });
+                }
+                // Write to JSON log
+                if (this.config.writeJsonLog) {
+                    this.writeToJsonLog({
+                        type,
+                        role: 'system',
+                        content: cleanLine,
+                        timestamp: Date.now(),
+                    });
                 }
             }
         }
@@ -367,13 +272,32 @@ 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':
-                return {
-                    type: 'system',
-                    role: 'system',
-                    content: `Model: ${json.model || 'unknown'}, Mode: ${json.permissionMode || 'default'}`,
-                    timestamp,
-                };
+            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;
             case 'user':
                 if (json.message?.content) {
                     const textContent = json.message.content
@@ -464,45 +388,68 @@ 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 = stripAnsi(line).trim();
+            const cleanLine = (0, formatter_1.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 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}`;
+                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 }
+                    });
                 }
-                this.writeToReadableLog(`${formattedLine}\n`);
                 // Output to console
                 if (this.onParsedMessage) {
-                    const rawMsg = {
-                        type: 'raw',
+                    this.onParsedMessage({
+                        type,
                         role: 'system',
-                        content: formattedLine,
+                        content: line.trim(),
                         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
      */
@@ -526,21 +473,40 @@ class EnhancedLogManager {
      * Write a custom log entry
      */
     log(level, message, 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);
+        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
+            });
+        }
     }
     /**
      * Add a section marker
      */
     section(title) {
-        const divider = '═'.repeat(78);
-        const line = `\n${divider}\n  ${title}\n${divider}\n`;
-        this.writeToRawLog(line);
-        this.writeToReadableLog(line);
+        if (this.config.writeJsonLog) {
+            this.writeToJsonLog({
+                type: 'info',
+                role: 'system',
+                content: `--- ${title} ---`,
+                timestamp: Date.now(),
+                metadata: { isSection: true }
+            });
+        }
     }
     /**
      * Update task context
@@ -575,47 +541,39 @@ class EnhancedLogManager {
      */
     getLogPaths() {
         return {
-            clean: this.readableLogPath, // For backward compatibility
-            raw: this.rawLogPath,
-            readable: this.readableLogPath,
+            jsonl: this.jsonlLogPath,
+            clean: this.jsonlLogPath, // Backward compatibility
         };
     }
     /**
      * Create file descriptors for process stdio redirection
      */
     getFileDescriptors() {
-        const fd = this.rawLogFd;
+        const fd = this.jsonlLogFd;
         return { stdout: fd, stderr: fd };
     }
     /**
      * Close all log files
      */
     close() {
-        // 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 {
-                fs.writeSync(this.rawLogFd, endMarker);
-                fs.fsyncSync(this.rawLogFd);
-                fs.closeSync(this.rawLogFd);
-            }
-            catch { }
-            this.rawLogFd = null;
-        }
-        if (this.readableLogFd !== null) {
+        if (this.jsonlLogFd !== null) {
             try {
-                fs.writeSync(this.readableLogFd, endMarker);
-                fs.fsyncSync(this.readableLogFd);
-                fs.closeSync(this.readableLogFd);
+                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);
             }
             catch { }
-            this.readableLogFd = null;
+            this.jsonlLogFd = null;
         }
     }
     /**
@@ -623,39 +581,25 @@ class EnhancedLogManager {
      */
     getLastError() {
         try {
-            if (!fs.existsSync(this.readableLogPath))
+            if (!fs.existsSync(this.jsonlLogPath))
                 return null;
-            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');
+            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 { }
             }
-            return lines[lines.length - 1].trim();
+            return null;
         }
         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;
 /**
@@ -672,19 +616,45 @@ function createLogManager(laneRunDir, laneName, config, onParsedMessage, laneInd
     return new EnhancedLogManager(laneRunDir, session, config, onParsedMessage);
 }
 /**
- * Read and parse JSON log file (legacy compatibility - returns empty array)
+ * Read and parse JSON log file
  */
 function readJsonLog(logPath) {
-    return [];
+    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 [];
+    }
 }
 /**
- * Export logs (legacy compatibility)
+ * Export logs
  */
 function exportLogs(laneRunDir, format, outputPath) {
-    const logPath = (0, paths_1.getLaneLogPath)(laneRunDir, 'raw');
+    const logPath = (0, paths_1.getLaneLogPath)(laneRunDir, 'jsonl');
     let output = '';
     if (fs.existsSync(logPath)) {
-        output = fs.readFileSync(logPath, 'utf8');
+        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');
+        }
     }
     if (outputPath) {
         fs.writeFileSync(outputPath, output, 'utf8');