@hexidecibel/companion 0.0.1

package/dist/parser.js

@@ -0,0 +1,800 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCurrentActivityFast = detectCurrentActivityFast;
+exports.parseConversationFile = parseConversationFile;
+exports.extractHighlights = extractHighlights;
+exports.detectWaitingForInput = detectWaitingForInput;
+exports.detectIdle = detectIdle;
+exports.detectCurrentActivity = detectCurrentActivity;
+exports.getRecentActivity = getRecentActivity;
+exports.getSessionStatus = getSessionStatus;
+exports.getPendingApprovalTools = getPendingApprovalTools;
+exports.detectCompaction = detectCompaction;
+exports.extractUsageFromFile = extractUsageFromFile;
+exports.extractTasks = extractTasks;
+const fs = __importStar(require("fs"));
+const tool_config_1 = require("./tool-config");
+const MAX_MESSAGES = 100; // Limit to most recent messages
+// KNOWN_TOOLS alias for backward compatibility in this file
+const KNOWN_TOOLS = tool_config_1.KNOWN_TOOL_NAMES;
+// Rate-limit parser warnings: max one per key per 60s
+const _warnedRecently = new Map();
+function logParserWarning(type, details) {
+    const key = `${type}:${details.substring(0, 100)}`;
+    const now = Date.now();
+    const last = _warnedRecently.get(key);
+    if (last && now - last < 60000)
+        return;
+    _warnedRecently.set(key, now);
+    console.log(`[PARSER_WARN] ${type}: ${details}`);
+}
+/**
+ * Fast function to detect current activity by reading only the last few KB of a file.
+ * Much faster than parsing the entire conversation file.
+ * Tracks tool_result entries to avoid showing stale "pending" status for completed tools.
+ */
+function detectCurrentActivityFast(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const stats = fs.statSync(filePath);
+        const fileSize = stats.size;
+        // Read last 32KB - enough to get recent messages
+        const readSize = Math.min(32 * 1024, fileSize);
+        const buffer = Buffer.alloc(readSize);
+        const fd = fs.openSync(filePath, 'r');
+        fs.readSync(fd, buffer, 0, readSize, Math.max(0, fileSize - readSize));
+        fs.closeSync(fd);
+        const tail = buffer.toString('utf-8');
+        const lines = tail.split('\n').filter(line => line.trim());
+        // Collect tool_result IDs from recent lines so we know which tools completed
+        const completedToolIds = new Set();
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const entry = JSON.parse(lines[i]);
+                if (entry.message?.content && Array.isArray(entry.message.content)) {
+                    for (const block of entry.message.content) {
+                        if (block.type === 'tool_result' && block.tool_use_id) {
+                            completedToolIds.add(block.tool_use_id);
+                        }
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Walk backward to find the most recent meaningful entry
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const entry = JSON.parse(lines[i]);
+                if (entry.message?.role === 'user') {
+                    return 'Processing...';
+                }
+                if (entry.message?.role === 'assistant' && entry.message.content) {
+                    const entryContent = entry.message.content;
+                    if (Array.isArray(entryContent)) {
+                        // Find the last tool_use that hasn't been completed
+                        for (let j = entryContent.length - 1; j >= 0; j--) {
+                            const block = entryContent[j];
+                            if (block.type === 'tool_use' && block.name && block.id) {
+                                // Skip tools that already have results
+                                if (completedToolIds.has(block.id)) {
+                                    continue;
+                                }
+                                // Warn about unknown tools
+                                if (!(0, tool_config_1.isKnownTool)(block.name)) {
+                                    logParserWarning('unknown_tool', `Unrecognized tool: ${block.name}`);
+                                }
+                                // Check if this needs approval
+                                if (tool_config_1.APPROVAL_TOOLS.includes(block.name)) {
+                                    const input = block.input;
+                                    if (block.name === 'Bash' && input?.command) {
+                                        const cmd = input.command.substring(0, 40);
+                                        return `Approve? ${cmd}${input.command.length > 40 ? '...' : ''}`;
+                                    }
+                                    if ((block.name === 'Edit' || block.name === 'Write') && input?.file_path) {
+                                        const fileName = input.file_path.split('/').pop() || input.file_path;
+                                        return `Approve ${block.name.toLowerCase()}: ${fileName}?`;
+                                    }
+                                    return `Approve ${block.name}?`;
+                                }
+                                return (0, tool_config_1.getToolDescription)(block.name);
+                            }
+                        }
+                    }
+                    return undefined; // Assistant message, all tools completed
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+function parseConversationFile(filePath, limit = MAX_MESSAGES, preReadContent) {
+    const content = preReadContent ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+    if (!content) {
+        return [];
+    }
+    const lines = content.split('\n').filter(line => line.trim());
+    // First pass: collect all tool results, start times, and completion times
+    const toolResults = new Map();
+    const toolStartTimes = new Map();
+    const toolCompleteTimes = new Map();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            const timestamp = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+            if (entry.message?.content && Array.isArray(entry.message.content)) {
+                for (const block of entry.message.content) {
+                    // Track tool_use start times
+                    if (block.type === 'tool_use' && block.id) {
+                        toolStartTimes.set(block.id, timestamp);
+                    }
+                    // Track tool_result completion times and outputs
+                    if (block.type === 'tool_result' && block.tool_use_id) {
+                        toolCompleteTimes.set(block.tool_use_id, timestamp);
+                        // Extract output content - can be string or array of content blocks
+                        let output = '';
+                        if (typeof block.content === 'string') {
+                            output = block.content;
+                        }
+                        else if (Array.isArray(block.content)) {
+                            output = block.content
+                                .filter(c => c.type === 'text' && c.text)
+                                .map(c => c.text || '')
+                                .join('\n');
+                        }
+                        toolResults.set(block.tool_use_id, output);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    const completedToolIds = new Set(toolResults.keys());
+    const messages = [];
+    // Process from the end to get most recent messages first
+    for (let i = lines.length - 1; i >= 0 && messages.length < limit * 2; i--) {
+        try {
+            const entry = JSON.parse(lines[i]);
+            if (entry.type === 'user' || entry.type === 'assistant') {
+                const message = parseEntry(entry, toolResults, toolStartTimes, toolCompleteTimes);
+                if (message) {
+                    messages.unshift(message); // Add to beginning to maintain order
+                }
+            }
+            else if (entry.type && entry.type !== 'summary') {
+                logParserWarning('unknown_entry_type', `Unexpected JSONL entry type: ${entry.type}`);
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    // Return only the limit number of messages
+    return messages.slice(-limit);
+}
+function parseEntry(entry, toolResults, toolStartTimes, toolCompleteTimes) {
+    const message = entry.message;
+    if (!message)
+        return null;
+    let content = '';
+    const toolCalls = [];
+    let options;
+    let questions;
+    let isWaitingForChoice = false;
+    let multiSelect = false;
+    if (typeof message.content === 'string') {
+        content = message.content;
+    }
+    else if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+            if (block.type === 'text' && block.text) {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                if (!block.name) {
+                    logParserWarning('missing_tool_name', `tool_use block without name, id: ${block.id}`);
+                    continue;
+                }
+                if (!KNOWN_TOOLS.has(block.name)) {
+                    logParserWarning('unknown_tool', `Unrecognized tool in parseEntry: ${block.name}`);
+                }
+                const toolId = block.id || entry.uuid || '';
+                const output = toolResults.get(toolId);
+                const isPending = !output && output !== '';
+                const startedAt = toolStartTimes.get(toolId);
+                const completedAt = toolCompleteTimes.get(toolId);
+                toolCalls.push({
+                    id: toolId,
+                    name: block.name,
+                    input: block.input || {},
+                    output: output,
+                    status: isPending ? 'pending' : 'completed',
+                    startedAt,
+                    completedAt,
+                });
+                // Extract options from AskUserQuestion tool (only if still pending)
+                if (block.name === 'AskUserQuestion' && isPending) {
+                    const input = block.input;
+                    console.log(`Parser: Found AskUserQuestion tool, questions count: ${input.questions?.length || 0}`);
+                    if (input.questions && input.questions.length > 0) {
+                        // Extract all questions
+                        questions = input.questions.map(q => ({
+                            question: q.question,
+                            header: q.header,
+                            options: q.options.map(opt => ({
+                                label: opt.label,
+                                description: opt.description,
+                            })),
+                            multiSelect: q.multiSelect || false,
+                        }));
+                        // Set content to first question for backward compat / message bubble text
+                        const firstQuestion = input.questions[0];
+                        content = firstQuestion.question;
+                        // Set options from first question for backward compat (single-question case)
+                        options = firstQuestion.options.map(opt => ({
+                            label: opt.label,
+                            description: opt.description,
+                        }));
+                        isWaitingForChoice = true;
+                        multiSelect = firstQuestion.multiSelect || false;
+                        console.log(`Parser: Extracted ${questions.length} questions, first has ${options.length} options: "${content.substring(0, 50)}..." (multiSelect: ${multiSelect})`);
+                    }
+                }
+                else if (block.name === 'AskUserQuestion' && !isPending) {
+                    // Show the question content but no options (already answered)
+                    const input = block.input;
+                    if (input.questions && input.questions.length > 0) {
+                        content = input.questions[0].question;
+                    }
+                }
+                // Add Yes/No options for pending approval tools
+                // But NOT for Task tools - they run in background and stay "pending" for a long time
+                else if (isPending && tool_config_1.APPROVAL_TOOLS.includes(block.name) && block.name !== 'Task') {
+                    const input = block.input;
+                    let description = '';
+                    // Build a helpful description based on tool type
+                    if (block.name === 'Bash' && input.command) {
+                        description = `Run: ${input.command.substring(0, 100)}`;
+                    }
+                    else if ((block.name === 'Edit' || block.name === 'Write') && input.file_path) {
+                        description = `${block.name}: ${input.file_path}`;
+                    }
+                    else if (block.name === 'Task' && input.description) {
+                        description = `Task: ${input.description}`;
+                    }
+                    else {
+                        description = `Allow ${block.name}?`;
+                    }
+                    options = [
+                        { label: 'yes', description: `Approve: ${description}` },
+                        { label: 'no', description: 'Reject this action' },
+                    ];
+                    isWaitingForChoice = true;
+                    console.log(`Parser: Pending ${block.name} tool needs approval: "${description.substring(0, 50)}..."`);
+                }
+            }
+            else if (block.type === 'tool_result') {
+                // Skip tool results entirely - they're internal assistant responses
+                // We only want to show actual user-typed messages
+            }
+        }
+    }
+    const timestamp = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+    return {
+        id: entry.uuid || String(timestamp),
+        type: entry.type,
+        content,
+        timestamp,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        options,
+        questions,
+        isWaitingForChoice,
+        multiSelect: multiSelect || undefined,
+    };
+}
+function extractHighlights(messages) {
+    // Find the index of the last user message - anything before this has been "responded to"
+    let lastUserMessageIndex = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].type === 'user') {
+            lastUserMessageIndex = i;
+            break;
+        }
+    }
+    const rawHighlights = messages
+        .filter(msg => {
+        // Include user messages with content
+        if (msg.type === 'user' && msg.content && msg.content.trim())
+            return true;
+        // Include assistant messages with content OR toolCalls
+        if (msg.type === 'assistant') {
+            const hasContent = msg.content && msg.content.trim();
+            const hasToolCalls = msg.toolCalls && msg.toolCalls.length > 0;
+            return hasContent || hasToolCalls;
+        }
+        return false;
+    })
+        .map((msg, index, arr) => {
+        const isLastMessage = index === arr.length - 1;
+        const originalIndex = messages.indexOf(msg);
+        // Check if this message has pending approval tools
+        const hasPendingApprovalTools = msg.toolCalls?.some(tc => tc.status === 'pending' && tool_config_1.APPROVAL_TOOLS.includes(tc.name) && tc.name !== 'Task') ?? false;
+        // Check if all tools in this message are already completed/errored
+        const allToolsCompleted = (msg.toolCalls?.length ?? 0) > 0 && msg.toolCalls?.every(tc => tc.status === 'completed' || tc.status === 'error' || tc.output !== undefined);
+        // Check if user already responded after this message (tool is running, not waiting)
+        const userRespondedAfter = originalIndex < messages.length - 1 &&
+            messages.slice(originalIndex + 1).some(m => m.type === 'user');
+        // Show options if:
+        // 1. This message has options AND
+        // 2. Either it's the last message OR it has pending approval tools AND
+        // 3. Tools haven't all completed AND
+        // 4. User hasn't already responded (tool would be running, not waiting)
+        const showOptions = msg.options && msg.options.length > 0 &&
+            (isLastMessage || hasPendingApprovalTools) && !allToolsCompleted && !userRespondedAfter;
+        // If user responded after this message, pending tools are now running (not waiting for approval)
+        const toolCalls = userRespondedAfter && msg.toolCalls
+            ? msg.toolCalls.map(tc => tc.status === 'pending' ? { ...tc, status: 'running' } : tc)
+            : msg.toolCalls;
+        return {
+            id: msg.id,
+            type: msg.type,
+            content: msg.content,
+            timestamp: msg.timestamp,
+            options: showOptions ? msg.options : undefined,
+            questions: showOptions ? msg.questions : undefined,
+            isWaitingForChoice: showOptions ? msg.isWaitingForChoice : false,
+            multiSelect: showOptions ? msg.multiSelect : undefined,
+            toolCalls,
+        };
+    });
+    // Merge consecutive assistant messages that are tool-only (no text content)
+    // into a single message so the UI can collapse them together
+    const highlights = [];
+    for (const h of rawHighlights) {
+        const prev = highlights[highlights.length - 1];
+        const isToolOnly = h.type === 'assistant' && (!h.content || !h.content.trim()) && h.toolCalls && h.toolCalls.length > 0;
+        const prevIsToolOnly = prev && prev.type === 'assistant' && (!prev.content || !prev.content.trim()) && prev.toolCalls && prev.toolCalls.length > 0;
+        if (isToolOnly && prevIsToolOnly && !h.options && !prev.options) {
+            // Merge: append tool calls to previous message
+            prev.toolCalls = [...(prev.toolCalls || []), ...(h.toolCalls || [])];
+            prev.timestamp = h.timestamp; // Use latest timestamp
+        }
+        else {
+            highlights.push(h);
+        }
+    }
+    // Log if the last highlight has options
+    const lastHighlight = highlights[highlights.length - 1];
+    if (lastHighlight?.options && lastHighlight.options.length > 0) {
+        console.log(`Parser: Last message has ${lastHighlight.options.length} options`);
+    }
+    return highlights;
+}
+function detectWaitingForInput(messages) {
+    if (messages.length === 0)
+        return false;
+    const lastMessage = messages[messages.length - 1];
+    // If the last message is from the assistant
+    if (lastMessage.type === 'assistant') {
+        // Check for pending tool calls that need approval
+        if (lastMessage.toolCalls) {
+            const hasPendingApproval = lastMessage.toolCalls.some(tc => tc.status === 'pending' && tool_config_1.APPROVAL_TOOLS.includes(tc.name));
+            if (hasPendingApproval) {
+                return true;
+            }
+        }
+        // Check for text content that looks like a question or prompt
+        if (lastMessage.content.trim()) {
+            const questionPatterns = [
+                /\?$/,
+                /would you like/i,
+                /do you want/i,
+                /should I/i,
+                /let me know/i,
+                /please confirm/i,
+                /please provide/i,
+            ];
+            for (const pattern of questionPatterns) {
+                if (pattern.test(lastMessage.content)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+// Detect if the assistant has finished working and is idle (not actively expecting a response)
+function detectIdle(messages) {
+    if (messages.length === 0)
+        return false;
+    const lastMessage = messages[messages.length - 1];
+    // If the last message is from the assistant with all tools completed and no question
+    if (lastMessage.type === 'assistant') {
+        // Still has running/pending tools = not idle
+        if (lastMessage.toolCalls?.some(tc => tc.status === 'pending' || tc.status === 'running')) {
+            return false;
+        }
+        // All tools completed, no question pattern = idle (finished task)
+        if (!lastMessage.toolCalls || lastMessage.toolCalls.every(tc => tc.status === 'completed')) {
+            return !detectWaitingForInput(messages);
+        }
+    }
+    return false;
+}
+function detectCurrentActivity(messages) {
+    if (messages.length === 0)
+        return undefined;
+    const lastMessage = messages[messages.length - 1];
+    // If last message is from user, the assistant is processing
+    if (lastMessage.type === 'user') {
+        return 'Processing...';
+    }
+    // Check for tool calls in the last assistant message
+    if (lastMessage.type === 'assistant' && lastMessage.toolCalls && lastMessage.toolCalls.length > 0) {
+        const lastTool = lastMessage.toolCalls[lastMessage.toolCalls.length - 1];
+        // Check if this is a pending approval
+        if (lastTool.status === 'pending' && tool_config_1.APPROVAL_TOOLS.includes(lastTool.name)) {
+            const input = lastTool.input;
+            if (lastTool.name === 'Bash' && input.command) {
+                const cmd = input.command.substring(0, 40);
+                return `Approve? ${cmd}${input.command.length > 40 ? '...' : ''}`;
+            }
+            if ((lastTool.name === 'Edit' || lastTool.name === 'Write') && input.file_path) {
+                const filePath = input.file_path;
+                const fileName = filePath.split('/').pop() || filePath;
+                return `Approve ${lastTool.name.toLowerCase()}: ${fileName}?`;
+            }
+            return `Approve ${lastTool.name}?`;
+        }
+        const description = (0, tool_config_1.getToolDescription)(lastTool.name);
+        // Add file path info if available
+        if (lastTool.input) {
+            const input = lastTool.input;
+            if (input.file_path) {
+                const filePath = input.file_path;
+                const fileName = filePath.split('/').pop() || filePath;
+                return `${description}: ${fileName}`;
+            }
+            if (input.command) {
+                const cmd = input.command.substring(0, 30);
+                return `${description}: ${cmd}${input.command.length > 30 ? '...' : ''}`;
+            }
+        }
+        return description;
+    }
+    // Don't show "waiting for input" - there's already a separate indicator for that
+    return undefined;
+}
+function getRecentActivity(messages, limit = 5) {
+    const activities = [];
+    // Go through messages in reverse to get recent activity
+    for (let i = messages.length - 1; i >= 0 && activities.length < limit; i--) {
+        const msg = messages[i];
+        if (msg.type === 'assistant' && msg.toolCalls) {
+            for (const tool of msg.toolCalls) {
+                if (activities.length >= limit)
+                    break;
+                const input = tool.input;
+                let inputStr = '';
+                let outputStr = tool.output || '';
+                // Format input based on tool type
+                if (input.file_path) {
+                    inputStr = input.file_path;
+                }
+                else if (input.command) {
+                    inputStr = input.command;
+                }
+                else if (input.pattern) {
+                    inputStr = `Pattern: ${input.pattern}`;
+                }
+                else if (input.query) {
+                    inputStr = input.query;
+                }
+                activities.push({
+                    summary: `${tool.name}${inputStr ? `: ${inputStr.substring(0, 100)}` : ''}`,
+                    toolName: tool.name,
+                    input: inputStr,
+                    output: outputStr.substring(0, 2000), // Limit output size
+                    timestamp: msg.timestamp,
+                });
+            }
+        }
+    }
+    return activities.reverse(); // Return in chronological order
+}
+function getSessionStatus(conversationPath, isProcessRunning) {
+    const messages = parseConversationFile(conversationPath);
+    const lastMessage = messages[messages.length - 1];
+    return {
+        isRunning: isProcessRunning,
+        isWaitingForInput: isProcessRunning && detectWaitingForInput(messages),
+        lastActivity: lastMessage?.timestamp || 0,
+        conversationId: conversationPath,
+        currentActivity: isProcessRunning ? detectCurrentActivity(messages) : undefined,
+    };
+}
+/**
+ * Get list of pending tools that need approval from the last message
+ */
+function getPendingApprovalTools(messages) {
+    if (messages.length === 0)
+        return [];
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage.type !== 'assistant' || !lastMessage.toolCalls)
+        return [];
+    return lastMessage.toolCalls
+        .filter(tc => tc.status === 'pending')
+        .map(tc => tc.name);
+}
+/**
+ * Detect compaction events in a conversation file
+ * Returns the most recent compaction summary if found
+ */
+function detectCompaction(filePath, sessionId, sessionName, projectPath, lastCheckedLine = 0, preReadContent) {
+    const content = preReadContent ?? (fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '');
+    if (!content) {
+        return { event: null, lastLine: 0 };
+    }
+    const lines = content.split('\n').filter(line => line.trim());
+    let compactionEvent = null;
+    // Only check lines after lastCheckedLine to avoid re-detecting old compactions
+    for (let i = lastCheckedLine; i < lines.length; i++) {
+        try {
+            const entry = JSON.parse(lines[i]);
+            // Look for summary type entries (context compaction)
+            if (entry.type === 'summary' && entry.summary) {
+                const timestamp = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+                compactionEvent = {
+                    sessionId,
+                    sessionName,
+                    projectPath,
+                    summary: entry.summary,
+                    timestamp,
+                };
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return { event: compactionEvent, lastLine: lines.length };
+}
+/**
+ * Extract usage data from a conversation JSONL file
+ */
+function extractUsageFromFile(filePath, sessionName) {
+    const result = {
+        sessionId: filePath,
+        sessionName,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheCreationTokens: 0,
+        totalCacheReadTokens: 0,
+        messageCount: 0,
+        currentContextTokens: 0,
+    };
+    if (!fs.existsSync(filePath)) {
+        return result;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const seenMessageIds = new Set();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            // Only count assistant messages with usage data
+            if (entry.type === 'assistant' && entry.message?.usage) {
+                const msgId = entry.message?.id;
+                // Skip duplicate message IDs (same message can appear multiple times as it streams)
+                if (msgId && seenMessageIds.has(msgId)) {
+                    continue;
+                }
+                if (msgId) {
+                    seenMessageIds.add(msgId);
+                }
+                const usage = entry.message.usage;
+                // Only add non-zero usage (final message has the totals)
+                if (usage.input_tokens && usage.input_tokens > 0) {
+                    result.totalInputTokens += usage.input_tokens;
+                    result.messageCount++;
+                }
+                if (usage.output_tokens && usage.output_tokens > 0) {
+                    result.totalOutputTokens += usage.output_tokens;
+                }
+                if (usage.cache_creation_input_tokens && usage.cache_creation_input_tokens > 0) {
+                    result.totalCacheCreationTokens += usage.cache_creation_input_tokens;
+                }
+                if (usage.cache_read_input_tokens && usage.cache_read_input_tokens > 0) {
+                    result.totalCacheReadTokens += usage.cache_read_input_tokens;
+                }
+                // Track current context size from the most recent message
+                if (usage.input_tokens) {
+                    result.currentContextTokens = usage.input_tokens;
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return result;
+}
+/**
+ * Extract tasks from JSONL content (from TaskCreate/TaskUpdate tool calls)
+ */
+function extractTasks(content) {
+    const lines = content.split('\n').filter(line => line.trim());
+    // Track tasks by temporary ID (toolu_xxx) until we get real ID from result
+    const pendingTasks = new Map();
+    // Map toolu_xxx to real task ID
+    const toolIdToTaskId = new Map();
+    // Final tasks by real ID
+    const tasks = new Map();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.message?.content && Array.isArray(entry.message.content)) {
+                const timestamp = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+                for (const block of entry.message.content) {
+                    // Handle TaskCreate
+                    if (block.type === 'tool_use' && block.name === 'TaskCreate') {
+                        const input = block.input;
+                        const toolId = block.id;
+                        pendingTasks.set(toolId, {
+                            task: {
+                                subject: input.subject,
+                                description: input.description,
+                                activeForm: input.activeForm,
+                                status: 'pending',
+                                blockedBy: [],
+                                blocks: [],
+                                createdAt: timestamp,
+                                updatedAt: timestamp,
+                            },
+                            timestamp,
+                        });
+                    }
+                    // Handle TaskUpdate
+                    if (block.type === 'tool_use' && block.name === 'TaskUpdate') {
+                        const input = block.input;
+                        const taskId = input.taskId;
+                        // Find existing task
+                        const existingTask = tasks.get(taskId);
+                        if (existingTask) {
+                            // Handle deletion
+                            if (input.status === 'deleted') {
+                                tasks.delete(taskId);
+                                continue;
+                            }
+                            // Apply updates
+                            if (input.status) {
+                                existingTask.status = input.status;
+                            }
+                            if (input.subject) {
+                                existingTask.subject = input.subject;
+                            }
+                            if (input.description) {
+                                existingTask.description = input.description;
+                            }
+                            if (input.activeForm) {
+                                existingTask.activeForm = input.activeForm;
+                            }
+                            else if (input.status === 'completed') {
+                                // Clear activeForm when completed
+                                existingTask.activeForm = undefined;
+                            }
+                            if (input.owner) {
+                                existingTask.owner = input.owner;
+                            }
+                            if (input.addBlockedBy) {
+                                existingTask.blockedBy = [
+                                    ...(existingTask.blockedBy || []),
+                                    ...input.addBlockedBy,
+                                ];
+                            }
+                            if (input.addBlocks) {
+                                existingTask.blocks = [
+                                    ...(existingTask.blocks || []),
+                                    ...input.addBlocks,
+                                ];
+                            }
+                            existingTask.updatedAt = timestamp;
+                        }
+                    }
+                    // Handle tool_result to get real task IDs
+                    if (block.type === 'tool_result' && block.tool_use_id) {
+                        const toolId = block.tool_use_id;
+                        const pending = pendingTasks.get(toolId);
+                        if (pending) {
+                            // Extract task ID from result content
+                            let resultContent = '';
+                            if (typeof block.content === 'string') {
+                                resultContent = block.content;
+                            }
+                            else if (Array.isArray(block.content)) {
+                                resultContent = block.content
+                                    .filter((c) => c.type === 'text' && c.text)
+                                    .map((c) => c.text || '')
+                                    .join('\n');
+                            }
+                            // Try to extract task ID from "Task created with ID: X"
+                            const idMatch = resultContent.match(/(?:Task created with ID:|id[:\s]+)(\d+)/i);
+                            if (idMatch) {
+                                const realId = idMatch[1];
+                                toolIdToTaskId.set(toolId, realId);
+                                // Create the task with real ID
+                                tasks.set(realId, {
+                                    id: realId,
+                                    subject: pending.task.subject || '',
+                                    description: pending.task.description || '',
+                                    status: pending.task.status || 'pending',
+                                    activeForm: pending.task.activeForm,
+                                    owner: pending.task.owner,
+                                    blockedBy: pending.task.blockedBy,
+                                    blocks: pending.task.blocks,
+                                    createdAt: pending.task.createdAt || timestamp,
+                                    updatedAt: pending.task.updatedAt || timestamp,
+                                });
+                            }
+                            pendingTasks.delete(toolId);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    // Return tasks sorted by ID (numeric order)
+    return Array.from(tasks.values()).sort((a, b) => {
+        const aNum = parseInt(a.id, 10);
+        const bNum = parseInt(b.id, 10);
+        return aNum - bNum;
+    });
+}
+//# sourceMappingURL=parser.js.map