@litmers/cursorflow-orchestrator 0.1.13 → 0.1.15

package/dist/cli/logs.js

@@ -0,0 +1,759 @@
+"use strict";
+/**
+ * CursorFlow logs command - View and export logs
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger = __importStar(require("../utils/logger"));
+const config_1 = require("../utils/config");
+const enhanced_logger_1 = require("../utils/enhanced-logger");
+function printHelp() {
+    console.log(`
+Usage: cursorflow logs [run-dir] [options]
+
+View and export lane logs.
+
+Options:
+  [run-dir]              Run directory (default: latest)
+  --lane <name>          Filter to specific lane
+  --all, -a              View all lanes merged (sorted by timestamp)
+  --format <fmt>         Output format: text, json, markdown, html (default: text)
+  --output <path>        Write output to file instead of stdout
+  --tail <n>             Show last n lines/entries (default: all)
+  --follow, -f           Follow log output in real-time
+  --filter <pattern>     Filter entries by regex pattern
+  --level <level>        Filter by log level: stdout, stderr, info, error, debug
+  --readable, -r         Show readable log (parsed AI output) (default)
+  --clean                Show clean terminal logs without ANSI codes
+  --raw                  Show raw terminal logs with ANSI codes
+  --help, -h             Show help
+
+Examples:
+  cursorflow logs                              # View latest run logs summary
+  cursorflow logs --lane api-setup             # View readable parsed log (default)
+  cursorflow logs --lane api-setup --clean     # View clean terminal logs
+  cursorflow logs --all                        # View all lanes merged by time
+  cursorflow logs --all --follow               # Follow all lanes in real-time
+  cursorflow logs --all --format json          # Export all lanes as JSON
+  cursorflow logs --all --filter "error"       # Filter all lanes for errors
+  cursorflow logs --format json --output out.json  # Export as JSON
+  `);
+}
+function parseArgs(args) {
+    const laneIdx = args.indexOf('--lane');
+    const formatIdx = args.indexOf('--format');
+    const outputIdx = args.indexOf('--output');
+    const tailIdx = args.indexOf('--tail');
+    const filterIdx = args.indexOf('--filter');
+    const levelIdx = args.indexOf('--level');
+    // Find run directory (first non-option argument)
+    const runDir = args.find((arg, i) => {
+        if (arg.startsWith('--') || arg.startsWith('-'))
+            return false;
+        // Skip values for options
+        const prevArg = args[i - 1];
+        if (prevArg && ['--lane', '--format', '--output', '--tail', '--filter', '--level'].includes(prevArg)) {
+            return false;
+        }
+        return true;
+    });
+    const raw = args.includes('--raw');
+    const clean = args.includes('--clean');
+    const readable = args.includes('--readable') || args.includes('-r');
+    return {
+        runDir,
+        lane: laneIdx >= 0 ? args[laneIdx + 1] : undefined,
+        all: args.includes('--all') || args.includes('-a'),
+        format: (formatIdx >= 0 ? args[formatIdx + 1] : 'text'),
+        output: outputIdx >= 0 ? args[outputIdx + 1] : undefined,
+        tail: tailIdx >= 0 ? parseInt(args[tailIdx + 1] || '50') : undefined,
+        follow: args.includes('--follow') || args.includes('-f'),
+        filter: filterIdx >= 0 ? args[filterIdx + 1] : undefined,
+        level: levelIdx >= 0 ? args[levelIdx + 1] : undefined,
+        raw,
+        clean,
+        // Default to readable if no other format is specified
+        readable: readable || (!raw && !clean),
+        help: args.includes('--help') || args.includes('-h'),
+    };
+}
+/**
+ * Find the latest run directory
+ */
+function findLatestRunDir(logsDir) {
+    const runsDir = path.join(logsDir, 'runs');
+    if (!fs.existsSync(runsDir))
+        return null;
+    const runs = fs.readdirSync(runsDir)
+        .filter(d => d.startsWith('run-'))
+        .map(d => ({
+        name: d,
+        path: path.join(runsDir, d),
+        mtime: fs.statSync(path.join(runsDir, d)).mtime.getTime()
+    }))
+        .sort((a, b) => b.mtime - a.mtime);
+    return runs.length > 0 ? runs[0].path : null;
+}
+/**
+ * List lanes in a run directory
+ */
+function listLanes(runDir) {
+    const lanesDir = path.join(runDir, 'lanes');
+    if (!fs.existsSync(lanesDir))
+        return [];
+    return fs.readdirSync(lanesDir)
+        .filter(d => fs.statSync(path.join(lanesDir, d)).isDirectory());
+}
+/**
+ * Read and display text logs
+ */
+function displayTextLogs(laneDir, options) {
+    let logFile;
+    const readableLog = path.join(laneDir, 'terminal-readable.log');
+    const rawLog = path.join(laneDir, 'terminal-raw.log');
+    const cleanLog = path.join(laneDir, 'terminal.log');
+    if (options.raw) {
+        logFile = rawLog;
+    }
+    else if (options.clean) {
+        logFile = cleanLog;
+    }
+    else if (options.readable && fs.existsSync(readableLog)) {
+        logFile = readableLog;
+    }
+    else {
+        // Default or fallback to clean log
+        logFile = cleanLog;
+    }
+    if (!fs.existsSync(logFile)) {
+        console.log('No log file found.');
+        return;
+    }
+    let content = fs.readFileSync(logFile, 'utf8');
+    let lines = content.split('\n');
+    // Apply filter
+    if (options.filter) {
+        const regex = new RegExp(options.filter, 'i');
+        lines = lines.filter(line => regex.test(line));
+    }
+    // Apply tail
+    if (options.tail && lines.length > options.tail) {
+        lines = lines.slice(-options.tail);
+    }
+    // Clean ANSI if needed (for clean mode or default fallback)
+    if (!options.raw) {
+        lines = lines.map(line => (0, enhanced_logger_1.stripAnsi)(line));
+    }
+    console.log(lines.join('\n'));
+}
+/**
+ * Read and display JSON logs
+ */
+function displayJsonLogs(laneDir, options) {
+    const logFile = path.join(laneDir, 'terminal.jsonl');
+    if (!fs.existsSync(logFile)) {
+        console.log('No JSON log file found.');
+        return;
+    }
+    let entries = (0, enhanced_logger_1.readJsonLog)(logFile);
+    // Apply level filter
+    if (options.level) {
+        entries = entries.filter(e => e.level === options.level);
+    }
+    // Apply regex filter
+    if (options.filter) {
+        const regex = new RegExp(options.filter, 'i');
+        entries = entries.filter(e => regex.test(e.message) || regex.test(e.task || ''));
+    }
+    // Apply tail
+    if (options.tail && entries.length > options.tail) {
+        entries = entries.slice(-options.tail);
+    }
+    if (options.format === 'json') {
+        console.log(JSON.stringify(entries, null, 2));
+    }
+    else {
+        // Display as formatted text
+        for (const entry of entries) {
+            const levelColor = getLevelColor(entry.level);
+            const ts = new Date(entry.timestamp).toLocaleTimeString();
+            console.log(`${levelColor}[${ts}] [${entry.level.toUpperCase().padEnd(6)}]${logger.COLORS.reset} ${entry.message}`);
+        }
+    }
+}
+/**
+ * Get color for log level
+ */
+function getLevelColor(level) {
+    switch (level) {
+        case 'error':
+            return logger.COLORS.red;
+        case 'stderr':
+            return logger.COLORS.yellow;
+        case 'info':
+        case 'session':
+            return logger.COLORS.cyan;
+        case 'debug':
+            return logger.COLORS.gray;
+        default:
+            return logger.COLORS.reset;
+    }
+}
+/**
+ * Lane color palette for distinguishing lanes in merged view
+ */
+const LANE_COLORS = [
+    '\x1b[38;5;39m', // Blue
+    '\x1b[38;5;208m', // Orange
+    '\x1b[38;5;156m', // Light Green
+    '\x1b[38;5;213m', // Pink
+    '\x1b[38;5;87m', // Cyan
+    '\x1b[38;5;228m', // Yellow
+    '\x1b[38;5;183m', // Light Purple
+    '\x1b[38;5;121m', // Sea Green
+];
+/**
+ * Get consistent color for a lane name
+ */
+function getLaneColor(laneName, laneIndex) {
+    return LANE_COLORS[laneIndex % LANE_COLORS.length];
+}
+/**
+ * Read and merge all lane logs
+ */
+function readAllLaneLogs(runDir) {
+    const lanes = listLanes(runDir);
+    const allEntries = [];
+    lanes.forEach((laneName, index) => {
+        const laneDir = path.join(runDir, 'lanes', laneName);
+        const jsonLogPath = path.join(laneDir, 'terminal.jsonl');
+        if (fs.existsSync(jsonLogPath)) {
+            const entries = (0, enhanced_logger_1.readJsonLog)(jsonLogPath);
+            const laneColor = getLaneColor(laneName, index);
+            for (const entry of entries) {
+                allEntries.push({
+                    ...entry,
+                    laneName,
+                    laneColor,
+                });
+            }
+        }
+    });
+    // Sort by timestamp
+    allEntries.sort((a, b) => {
+        const timeA = new Date(a.timestamp).getTime();
+        const timeB = new Date(b.timestamp).getTime();
+        return timeA - timeB;
+    });
+    return allEntries;
+}
+/**
+ * Display merged logs from all lanes
+ */
+function displayMergedLogs(runDir, options) {
+    let entries = readAllLaneLogs(runDir);
+    if (entries.length === 0) {
+        console.log('No log entries found in any lane.');
+        return;
+    }
+    // Apply level filter
+    if (options.level) {
+        entries = entries.filter(e => e.level === options.level);
+    }
+    // Apply regex filter
+    if (options.filter) {
+        const regex = new RegExp(options.filter, 'i');
+        entries = entries.filter(e => regex.test(e.message) ||
+            regex.test(e.task || '') ||
+            regex.test(e.laneName));
+    }
+    // Apply tail
+    if (options.tail && entries.length > options.tail) {
+        entries = entries.slice(-options.tail);
+    }
+    // Get unique lanes for legend
+    const lanes = [...new Set(entries.map(e => e.laneName))];
+    // Print header
+    console.log(`\n${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}  🔀 Merged Logs - ${path.basename(runDir)} (${entries.length} entries from ${lanes.length} lanes)${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+    // Print lane legend
+    console.log('\n  Lanes: ' + lanes.map((lane, i) => {
+        const color = getLaneColor(lane, lanes.indexOf(lane));
+        return `${color}■${logger.COLORS.reset} ${lane}`;
+    }).join('  '));
+    console.log('');
+    // Format output based on format option
+    if (options.format === 'json') {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    // Display entries
+    for (const entry of entries) {
+        const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
+        const levelColor = getLevelColor(entry.level);
+        const laneColor = entry.laneColor;
+        const lanePad = entry.laneName.substring(0, 12).padEnd(12);
+        const levelPad = entry.level.toUpperCase().padEnd(6);
+        // Skip session entries for cleaner output unless they're important
+        if (entry.level === 'session' && entry.message === 'Session started') {
+            console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Started ──${logger.COLORS.reset}`);
+            continue;
+        }
+        if (entry.level === 'session' && entry.message === 'Session ended') {
+            console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Ended ──${logger.COLORS.reset}`);
+            continue;
+        }
+        console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${entry.message}`);
+    }
+    console.log(`\n${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+}
+/**
+ * Follow all lanes in real-time
+ */
+function followAllLogs(runDir, options) {
+    const lanes = listLanes(runDir);
+    if (lanes.length === 0) {
+        console.log('No lanes found.');
+        return;
+    }
+    // Track last read position for each lane
+    const lastPositions = {};
+    const laneColors = {};
+    lanes.forEach((lane, index) => {
+        lastPositions[lane] = 0;
+        laneColors[lane] = getLaneColor(lane, index);
+    });
+    // Print header
+    console.log(`\n${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}  🔴 Following All Lanes - ${path.basename(runDir)} (Ctrl+C to stop)${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+    console.log('\n  Lanes: ' + lanes.map((lane, i) => {
+        return `${laneColors[lane]}■${logger.COLORS.reset} ${lane}`;
+    }).join('  '));
+    console.log('');
+    const checkInterval = setInterval(() => {
+        const newEntries = [];
+        for (const lane of lanes) {
+            const laneDir = path.join(runDir, 'lanes', lane);
+            const jsonLogPath = path.join(laneDir, 'terminal.jsonl');
+            if (!fs.existsSync(jsonLogPath))
+                continue;
+            try {
+                const stats = fs.statSync(jsonLogPath);
+                if (stats.size > lastPositions[lane]) {
+                    const fd = fs.openSync(jsonLogPath, 'r');
+                    const buffer = Buffer.alloc(stats.size - lastPositions[lane]);
+                    fs.readSync(fd, buffer, 0, buffer.length, lastPositions[lane]);
+                    fs.closeSync(fd);
+                    const content = buffer.toString();
+                    const lines = content.split('\n').filter(l => l.trim());
+                    for (const line of lines) {
+                        try {
+                            const entry = JSON.parse(line);
+                            newEntries.push({
+                                ...entry,
+                                laneName: lane,
+                                laneColor: laneColors[lane],
+                            });
+                        }
+                        catch {
+                            // Skip invalid lines
+                        }
+                    }
+                    lastPositions[lane] = stats.size;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        // Sort new entries by timestamp
+        newEntries.sort((a, b) => {
+            const timeA = new Date(a.timestamp).getTime();
+            const timeB = new Date(b.timestamp).getTime();
+            return timeA - timeB;
+        });
+        // Apply filters and display
+        for (let entry of newEntries) {
+            // Apply level filter
+            if (options.level && entry.level !== options.level)
+                continue;
+            // Apply regex filter
+            if (options.filter) {
+                const regex = new RegExp(options.filter, 'i');
+                if (!regex.test(entry.message) && !regex.test(entry.task || '') && !regex.test(entry.laneName)) {
+                    continue;
+                }
+            }
+            const ts = new Date(entry.timestamp).toLocaleTimeString('en-US', { hour12: false });
+            const levelColor = getLevelColor(entry.level);
+            const lanePad = entry.laneName.substring(0, 12).padEnd(12);
+            const levelPad = entry.level.toUpperCase().padEnd(6);
+            // Skip verbose session entries
+            if (entry.level === 'session') {
+                if (entry.message === 'Session started') {
+                    console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Started ──${logger.COLORS.reset}`);
+                }
+                else if (entry.message === 'Session ended') {
+                    console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${logger.COLORS.cyan}── Session Ended ──${logger.COLORS.reset}`);
+                }
+                continue;
+            }
+            console.log(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${entry.laneColor}[${lanePad}]${logger.COLORS.reset} ${levelColor}[${levelPad}]${logger.COLORS.reset} ${entry.message}`);
+        }
+    }, 100);
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+        clearInterval(checkInterval);
+        console.log('\n\nStopped following logs.');
+        process.exit(0);
+    });
+}
+/**
+ * Export merged logs to various formats
+ */
+function exportMergedLogs(runDir, format, outputPath) {
+    let entries = readAllLaneLogs(runDir);
+    let output = '';
+    switch (format) {
+        case 'json':
+            output = JSON.stringify(entries, null, 2);
+            break;
+        case 'markdown':
+            output = exportMergedToMarkdown(entries, runDir);
+            break;
+        case 'html':
+            output = exportMergedToHtml(entries, runDir);
+            break;
+        default:
+            // Text format
+            for (const entry of entries) {
+                const ts = new Date(entry.timestamp).toISOString();
+                output += `[${ts}] [${entry.laneName}] [${entry.level.toUpperCase()}] ${entry.message}\n`;
+            }
+    }
+    if (outputPath) {
+        fs.writeFileSync(outputPath, output, 'utf8');
+    }
+    return output;
+}
+/**
+ * Export merged logs to Markdown
+ */
+function exportMergedToMarkdown(entries, runDir) {
+    const lanes = [...new Set(entries.map(e => e.laneName))];
+    let md = `# CursorFlow Merged Logs\n\n`;
+    md += `**Run:** ${path.basename(runDir)}\n`;
+    md += `**Lanes:** ${lanes.join(', ')}\n`;
+    md += `**Entries:** ${entries.length}\n\n`;
+    md += `## Timeline\n\n`;
+    md += '| Time | Lane | Level | Message |\n';
+    md += '|------|------|-------|--------|\n';
+    for (const entry of entries) {
+        const ts = new Date(entry.timestamp).toLocaleTimeString();
+        const message = entry.message.replace(/\|/g, '\\|').substring(0, 80);
+        md += `| ${ts} | ${entry.laneName} | ${entry.level} | ${message} |\n`;
+    }
+    return md;
+}
+/**
+ * Export merged logs to HTML
+ */
+function exportMergedToHtml(entries, runDir) {
+    const lanes = [...new Set(entries.map(e => e.laneName))];
+    let html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>CursorFlow Merged Logs - ${path.basename(runDir)}</title>
+  <style>
+    body { font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace; margin: 20px; background: #1e1e1e; color: #d4d4d4; }
+    h1, h2 { color: #569cd6; }
+    .legend { margin: 10px 0; padding: 10px; background: #252526; border-radius: 4px; }
+    .legend-item { display: inline-block; margin-right: 15px; }
+    .legend-color { display: inline-block; width: 12px; height: 12px; margin-right: 5px; border-radius: 2px; }
+    .entry { padding: 4px 8px; margin: 2px 0; border-radius: 4px; display: flex; }
+    .entry .time { color: #808080; width: 80px; flex-shrink: 0; }
+    .entry .lane { width: 120px; flex-shrink: 0; font-weight: bold; }
+    .entry .level { width: 70px; flex-shrink: 0; }
+    .entry .message { flex: 1; white-space: pre-wrap; }
+    .entry.stdout { background: #252526; }
+    .entry.stderr { background: #3c1f1f; }
+    .entry.stderr .level { color: #f48771; }
+    .entry.info { background: #1e3a5f; }
+    .entry.error { background: #5f1e1e; }
+    .entry.session { background: #1e4620; color: #6a9955; }
+  </style>
+</head>
+<body>
+  <h1>🔀 CursorFlow Merged Logs</h1>
+  <p><strong>Run:</strong> ${path.basename(runDir)} | <strong>Entries:</strong> ${entries.length}</p>
+  
+  <div class="legend">
+    <strong>Lanes:</strong> `;
+    const colors = ['#5dade2', '#f39c12', '#58d68d', '#af7ac5', '#48c9b0', '#f7dc6f', '#bb8fce', '#76d7c4'];
+    lanes.forEach((lane, i) => {
+        const color = colors[i % colors.length];
+        html += `<span class="legend-item"><span class="legend-color" style="background: ${color}"></span>${lane}</span>`;
+    });
+    html += `</div>\n`;
+    for (const entry of entries) {
+        const ts = new Date(entry.timestamp).toLocaleTimeString();
+        const laneIndex = lanes.indexOf(entry.laneName);
+        const color = colors[laneIndex % colors.length];
+        html += `  <div class="entry ${entry.level}">
+    <span class="time">${ts}</span>
+    <span class="lane" style="color: ${color}">${entry.laneName}</span>
+    <span class="level">[${entry.level.toUpperCase()}]</span>
+    <span class="message">${escapeHtml(entry.message)}</span>
+  </div>\n`;
+    }
+    html += '</body></html>';
+    return html;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+/**
+ * Follow logs in real-time
+ */
+function followLogs(laneDir, options) {
+    let logFile;
+    const readableLog = path.join(laneDir, 'terminal-readable.log');
+    const rawLog = path.join(laneDir, 'terminal-raw.log');
+    const cleanLog = path.join(laneDir, 'terminal.log');
+    if (options.raw) {
+        logFile = rawLog;
+    }
+    else if (options.clean) {
+        logFile = cleanLog;
+    }
+    else if (options.readable && fs.existsSync(readableLog)) {
+        logFile = readableLog;
+    }
+    else {
+        // Default or fallback to clean log
+        logFile = cleanLog;
+    }
+    if (!fs.existsSync(logFile)) {
+        console.log('Waiting for log file...');
+    }
+    let lastSize = 0;
+    try {
+        lastSize = fs.existsSync(logFile) ? fs.statSync(logFile).size : 0;
+    }
+    catch {
+        // Ignore
+    }
+    console.log(`${logger.COLORS.cyan}Following ${logFile}... (Ctrl+C to stop)${logger.COLORS.reset}\n`);
+    const checkInterval = setInterval(() => {
+        try {
+            if (!fs.existsSync(logFile))
+                return;
+            const stats = fs.statSync(logFile);
+            if (stats.size > lastSize) {
+                const fd = fs.openSync(logFile, 'r');
+                const buffer = Buffer.alloc(stats.size - lastSize);
+                fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+                fs.closeSync(fd);
+                let content = buffer.toString();
+                // Apply filter
+                if (options.filter) {
+                    const regex = new RegExp(options.filter, 'i');
+                    const lines = content.split('\n');
+                    content = lines.filter(line => regex.test(line)).join('\n');
+                }
+                // Clean ANSI if needed (unless raw mode)
+                if (!options.raw) {
+                    content = (0, enhanced_logger_1.stripAnsi)(content);
+                }
+                if (content.trim()) {
+                    process.stdout.write(content);
+                }
+                lastSize = stats.size;
+            }
+        }
+        catch (e) {
+            // Ignore errors (file might be rotating)
+        }
+    }, 100);
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+        clearInterval(checkInterval);
+        console.log('\n\nStopped following logs.');
+        process.exit(0);
+    });
+}
+/**
+ * Display logs summary for all lanes
+ */
+function displaySummary(runDir) {
+    const lanes = listLanes(runDir);
+    console.log(`\n${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}  📋 Logs Summary - ${path.basename(runDir)}${logger.COLORS.reset}`);
+    console.log(`${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}\n`);
+    if (lanes.length === 0) {
+        console.log('  No lanes found.');
+        return;
+    }
+    for (const lane of lanes) {
+        const laneDir = path.join(runDir, 'lanes', lane);
+        const cleanLog = path.join(laneDir, 'terminal.log');
+        const rawLog = path.join(laneDir, 'terminal-raw.log');
+        const jsonLog = path.join(laneDir, 'terminal.jsonl');
+        const readableLog = path.join(laneDir, 'terminal-readable.log');
+        console.log(`  ${logger.COLORS.green}📁 ${lane}${logger.COLORS.reset}`);
+        if (fs.existsSync(cleanLog)) {
+            const stats = fs.statSync(cleanLog);
+            console.log(`     └─ terminal.log          ${formatSize(stats.size)}`);
+        }
+        if (fs.existsSync(rawLog)) {
+            const stats = fs.statSync(rawLog);
+            console.log(`     └─ terminal-raw.log      ${formatSize(stats.size)}`);
+        }
+        if (fs.existsSync(readableLog)) {
+            const stats = fs.statSync(readableLog);
+            console.log(`     └─ terminal-readable.log ${formatSize(stats.size)} ${logger.COLORS.yellow}(parsed AI output)${logger.COLORS.reset}`);
+        }
+        if (fs.existsSync(jsonLog)) {
+            const stats = fs.statSync(jsonLog);
+            const entries = (0, enhanced_logger_1.readJsonLog)(jsonLog);
+            const errors = entries.filter(e => e.level === 'error' || e.level === 'stderr').length;
+            console.log(`     └─ terminal.jsonl        ${formatSize(stats.size)} (${entries.length} entries, ${errors} errors)`);
+        }
+        console.log('');
+    }
+}
+/**
+ * Format file size
+ */
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Main logs command
+ */
+async function logs(args) {
+    const options = parseArgs(args);
+    if (options.help) {
+        printHelp();
+        return;
+    }
+    const config = (0, config_1.loadConfig)();
+    // Find run directory
+    let runDir = options.runDir;
+    if (!runDir || runDir === 'latest') {
+        runDir = findLatestRunDir(config.logsDir) || undefined;
+        if (!runDir) {
+            throw new Error('No run directories found');
+        }
+    }
+    if (!fs.existsSync(runDir)) {
+        throw new Error(`Run directory not found: ${runDir}`);
+    }
+    // Handle --all option (view all lanes merged)
+    if (options.all) {
+        // Handle follow mode for all lanes
+        if (options.follow) {
+            followAllLogs(runDir, options);
+            return;
+        }
+        // Handle export for all lanes
+        if (options.output) {
+            exportMergedLogs(runDir, options.format, options.output);
+            console.log(`Exported merged logs to: ${options.output}`);
+            return;
+        }
+        // Display merged logs
+        if (options.format === 'json') {
+            const entries = readAllLaneLogs(runDir);
+            console.log(JSON.stringify(entries, null, 2));
+        }
+        else if (options.format === 'markdown' || options.format === 'html') {
+            const content = exportMergedLogs(runDir, options.format);
+            console.log(content);
+        }
+        else {
+            displayMergedLogs(runDir, options);
+        }
+        return;
+    }
+    // If no lane specified, show summary
+    if (!options.lane) {
+        displaySummary(runDir);
+        console.log(`${logger.COLORS.gray}Use --lane <name> to view logs (default: readable), --clean for terminal logs, or --all to view all lanes merged${logger.COLORS.reset}`);
+        return;
+    }
+    // Find lane directory
+    const laneDir = path.join(runDir, 'lanes', options.lane);
+    if (!fs.existsSync(laneDir)) {
+        const lanes = listLanes(runDir);
+        throw new Error(`Lane not found: ${options.lane}\nAvailable lanes: ${lanes.join(', ')}`);
+    }
+    // Handle follow mode
+    if (options.follow) {
+        followLogs(laneDir, options);
+        return;
+    }
+    // Handle export
+    if (options.output) {
+        const content = (0, enhanced_logger_1.exportLogs)(laneDir, options.format, options.output);
+        console.log(`Exported logs to: ${options.output}`);
+        return;
+    }
+    // Display logs
+    if (options.format === 'json' || options.level) {
+        displayJsonLogs(laneDir, options);
+    }
+    else if (options.format === 'markdown' || options.format === 'html') {
+        const content = (0, enhanced_logger_1.exportLogs)(laneDir, options.format);
+        console.log(content);
+    }
+    else {
+        displayTextLogs(laneDir, options);
+    }
+}
+module.exports = logs;
+//# sourceMappingURL=logs.js.map