arbiter-ai 1.0.0

package/dist/context-analyzer.js

@@ -0,0 +1,603 @@
+/**
+ * Context Analyzer - Systematic SDK Context Usage Analysis
+ *
+ * This tool helps analyze how context window usage is tracked in the Claude Agent SDK.
+ * It captures all usage data in a structured format for analysis.
+ *
+ * Usage:
+ *   npm run analyze:context -- [options]
+ *
+ * Options:
+ *   --subagents     Allow subagent usage (default: no subagents)
+ *   --prompts N     Number of test prompts to send (default: 3)
+ *   --output FILE   Output prefix for CSV/JSON files (default: context-analysis)
+ */
+import * as fs from 'node:fs';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+/** Type guard for assistant messages with usage data */
+function isAssistantMessage(msg) {
+    return (typeof msg === 'object' &&
+        msg !== null &&
+        'type' in msg &&
+        msg.type === 'assistant');
+}
+// ============================================================================
+// Constants
+// ============================================================================
+const MAX_CONTEXT_TOKENS = 200_000;
+const TEST_PROMPTS_NO_SUBAGENT = [
+    'What is 2 + 2? Reply with just the number.',
+    'What is the capital of France? Reply with just the city name.',
+    'What color is the sky? Reply with just one word.',
+    'Name three programming languages.',
+    'What is the largest planet in our solar system?',
+    'Explain what a variable is in programming in 2-3 sentences.',
+    'What is the difference between a list and a dictionary in Python?',
+    'Name the four cardinal directions.',
+    'What does API stand for?',
+    'Explain what recursion is in one paragraph.',
+    'What is the time complexity of binary search?',
+    'Name three popular JavaScript frameworks.',
+];
+const TEST_PROMPTS_WITH_SUBAGENT = [
+    'Read the package.json file and tell me what dependencies this project has.',
+    'Look at the src/router.ts file and summarize what it does in 2-3 sentences.',
+    'Find all TypeScript files in the src directory and list them.',
+    'Read the CLAUDE.md file and tell me what this project is about.',
+    'Look at src/state.ts and explain the AppState interface.',
+    "Search for any files that mention 'context' in their name.",
+    'Read src/arbiter.ts and tell me what MCP tools are defined there.',
+    'Find all files in .claude/knowledge directory.',
+    'Look at the tsconfig.json and tell me the TypeScript target version.',
+    "Search for 'spawn_orchestrator' in the codebase and tell me where it's used.",
+    'Read src/orchestrator.ts and summarize its purpose.',
+    'Find any test files in the project and list them.',
+];
+// ============================================================================
+// Parsing Utilities
+// ============================================================================
+/**
+ * Parse token count from string like "18.4k" or "3.1k" or "8" or "181.6k"
+ */
+function parseTokenCount(str) {
+    if (!str)
+        return 0;
+    const cleaned = str.replace(/,/g, '').trim();
+    if (cleaned.endsWith('k')) {
+        return Math.round(parseFloat(cleaned.slice(0, -1)) * 1000);
+    }
+    return parseInt(cleaned, 10) || 0;
+}
+/**
+ * Parse /context command output to extract token counts
+ * Handles the markdown table format:
+ *   **Tokens:** 18.4k / 200.0k (9%)
+ *   | System prompt | 3.1k | 1.6% |
+ *   | Messages | 8 | 0.0% |
+ */
+function parseContextOutput(output) {
+    const result = {
+        raw_output: output,
+        total_tokens: 0,
+        total_percent: 0,
+        messages_tokens: 0,
+        system_tokens: 0,
+    };
+    // Match total: **Tokens:** 18.4k / 200.0k (9%)
+    const totalMatch = output.match(/\*\*Tokens:\*\*\s*([0-9,.]+k?)\s*\/\s*200\.?0?k\s*\((\d+)%\)/i);
+    if (totalMatch) {
+        result.total_tokens = parseTokenCount(totalMatch[1]);
+        result.total_percent = parseFloat(totalMatch[2]);
+    }
+    // Parse markdown table rows: | Category | Tokens | Percentage |
+    const tableRowRegex = /\|\s*([^|]+)\s*\|\s*([0-9,.]+k?)\s*\|\s*([0-9.]+)%\s*\|/g;
+    let match = null;
+    let systemTotal = 0;
+    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex exec loop
+    while ((match = tableRowRegex.exec(output)) !== null) {
+        const category = match[1].trim().toLowerCase();
+        const tokens = parseTokenCount(match[2]);
+        if (category === 'messages') {
+            result.messages_tokens = tokens;
+        }
+        else if (category === 'system prompt' ||
+            category === 'system tools' ||
+            category === 'mcp tools' ||
+            category === 'memory' ||
+            category === 'custom agents' ||
+            category === 'memory files') {
+            systemTotal += tokens;
+        }
+    }
+    if (systemTotal > 0) {
+        result.system_tokens = systemTotal;
+    }
+    else if (result.total_tokens && result.messages_tokens) {
+        // Infer system tokens (subtract messages and free space)
+        result.system_tokens = result.total_tokens - result.messages_tokens;
+    }
+    return result;
+}
+/**
+ * Extract text preview from SDK message
+ */
+function getTextPreview(message, maxLen = 100) {
+    try {
+        if (message.type === 'assistant') {
+            const content = message.message?.content;
+            if (typeof content === 'string') {
+                return content.slice(0, maxLen).replace(/\n/g, ' ');
+            }
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'text' && block.text) {
+                        return block.text.slice(0, maxLen).replace(/\n/g, ' ');
+                    }
+                }
+            }
+        }
+        if (message.type === 'user') {
+            const content = message.message?.content;
+            if (typeof content === 'string') {
+                return content.slice(0, maxLen).replace(/\n/g, ' ');
+            }
+        }
+        if (message.type === 'result') {
+            const subtype = message.subtype;
+            return `[result: ${subtype}]`;
+        }
+        if (message.type === 'system') {
+            const subtype = message.subtype;
+            return `[system: ${subtype}]`;
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return `[${message.type}]`;
+}
+// ============================================================================
+// Core Analyzer
+// ============================================================================
+class ContextAnalyzer {
+    cwd;
+    useSubagents;
+    seenMsgIds = new Set();
+    maxCacheRead = 0;
+    sumCacheCreate = 0;
+    sumInput = 0;
+    sumOutput = 0;
+    // Combined metric tracking: cache_read + cache_create
+    firstCombinedRC = 0; // First message's (cache_read + cache_create)
+    maxCombinedRC = 0; // Max(cache_read + cache_create) seen
+    messages = [];
+    seq = 0;
+    startTime;
+    sessionId = null;
+    constructor(cwd, useSubagents) {
+        this.cwd = cwd;
+        this.useSubagents = useSubagents;
+        this.startTime = Date.now();
+    }
+    /**
+     * Run /context command and parse the output
+     * Uses the current session if available for accurate measurement
+     */
+    async runContextCommand(label) {
+        console.log(`\n[${label}] Running /context command...${this.sessionId ? ` (session: ${this.sessionId.slice(0, 8)}...)` : ' (new session)'}`);
+        const options = {
+            cwd: this.cwd,
+            permissionMode: 'bypassPermissions',
+        };
+        // Resume existing session if we have one
+        if (this.sessionId) {
+            options.resume = this.sessionId;
+        }
+        const q = query({
+            prompt: '/context',
+            options,
+        });
+        let rawOutput = '';
+        for await (const msg of q) {
+            // Capture session ID from system init
+            if (msg.type === 'system') {
+                const sysMsg = msg;
+                if (sysMsg.subtype === 'init' && sysMsg.session_id) {
+                    this.sessionId = sysMsg.session_id;
+                }
+            }
+            // /context output comes through in various ways
+            if (msg.type === 'user') {
+                const content = msg.message?.content;
+                if (typeof content === 'string') {
+                    rawOutput += `${content}\n`;
+                }
+            }
+            if (msg.type === 'result') {
+                const resultContent = msg.result;
+                if (typeof resultContent === 'string') {
+                    rawOutput += `${resultContent}\n`;
+                }
+            }
+            // Also check for assistant messages that might contain the output
+            if (msg.type === 'assistant') {
+                const content = msg.message?.content;
+                if (typeof content === 'string' && content.includes('tokens')) {
+                    rawOutput += `${content}\n`;
+                }
+                else if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text' && block.text?.includes('tokens')) {
+                            rawOutput += `${block.text}\n`;
+                        }
+                    }
+                }
+            }
+        }
+        const parsed = parseContextOutput(rawOutput);
+        const snapshot = {
+            timestamp: new Date().toISOString(),
+            elapsed_ms: Date.now() - this.startTime,
+            label,
+            total_tokens: parsed.total_tokens || 0,
+            total_percent: parsed.total_percent || 0,
+            messages_tokens: parsed.messages_tokens || 0,
+            system_tokens: parsed.system_tokens || 0,
+            raw_output: rawOutput.trim(),
+        };
+        console.log(`[${label}] Total: ${snapshot.total_tokens} tokens (${snapshot.total_percent}%)`);
+        console.log(`[${label}] Messages: ${snapshot.messages_tokens}, System: ${snapshot.system_tokens}`);
+        return snapshot;
+    }
+    /**
+     * Process a single SDK message and record usage data
+     */
+    processMessage(msg) {
+        // Only process assistant messages for usage data
+        if (msg.type !== 'assistant') {
+            return null;
+        }
+        const assistantMsg = msg;
+        const usage = assistantMsg.message?.usage;
+        const msgId = assistantMsg.message?.id;
+        const uuid = assistantMsg.uuid;
+        if (!usage || !msgId) {
+            return null;
+        }
+        // Dedupe by message.id (NOT uuid)
+        if (this.seenMsgIds.has(msgId)) {
+            return null;
+        }
+        this.seenMsgIds.add(msgId);
+        // Extract raw values
+        const cacheRead = usage.cache_read_input_tokens || 0;
+        const cacheCreate = usage.cache_creation_input_tokens || 0;
+        const input = usage.input_tokens || 0;
+        const output = usage.output_tokens || 0;
+        // Combined metric: cache_read + cache_create
+        const combinedRC = cacheRead + cacheCreate;
+        // Update running totals
+        this.maxCacheRead = Math.max(this.maxCacheRead, cacheRead);
+        this.sumCacheCreate += cacheCreate;
+        this.sumInput += input;
+        this.sumOutput += output;
+        // Track combined metric
+        if (this.firstCombinedRC === 0) {
+            this.firstCombinedRC = combinedRC; // First message's combined value
+        }
+        this.maxCombinedRC = Math.max(this.maxCombinedRC, combinedRC);
+        // Calculate formulas
+        const formulaMaxOnly = this.maxCacheRead;
+        const formulaMaxPlusSums = this.maxCacheRead + this.sumInput + this.sumOutput;
+        const formulaCreatePlusSums = this.sumCacheCreate + this.sumInput + this.sumOutput;
+        const formulaCombinedGrowth = this.maxCombinedRC - this.firstCombinedRC; // NEW
+        const row = {
+            seq: ++this.seq,
+            timestamp: new Date().toISOString(),
+            elapsed_ms: Date.now() - this.startTime,
+            message_id: msgId,
+            uuid,
+            type: msg.type,
+            cache_read: cacheRead,
+            cache_create: cacheCreate,
+            input,
+            output,
+            running_max_cache_read: this.maxCacheRead,
+            running_sum_cache_create: this.sumCacheCreate,
+            running_sum_input: this.sumInput,
+            running_sum_output: this.sumOutput,
+            // Combined metric tracking
+            combined_rc: combinedRC,
+            running_max_combined_rc: this.maxCombinedRC,
+            first_combined_rc: this.firstCombinedRC,
+            formula_max_only: formulaMaxOnly,
+            formula_max_plus_sums: formulaMaxPlusSums,
+            formula_create_plus_sums: formulaCreatePlusSums,
+            formula_combined_growth: formulaCombinedGrowth,
+            pct_max_only: (formulaMaxOnly / MAX_CONTEXT_TOKENS) * 100,
+            pct_max_plus_sums: (formulaMaxPlusSums / MAX_CONTEXT_TOKENS) * 100,
+            pct_create_plus_sums: (formulaCreatePlusSums / MAX_CONTEXT_TOKENS) * 100,
+            pct_combined_growth: (formulaCombinedGrowth / MAX_CONTEXT_TOKENS) * 100,
+            unique_api_calls: this.seenMsgIds.size,
+            text_preview: getTextPreview(msg),
+        };
+        this.messages.push(row);
+        // Log progress
+        console.log(`  [${row.seq}] ${msgId.slice(0, 12)}... r=${cacheRead}, c=${cacheCreate}, r+c=${combinedRC}`);
+        console.log(`       max(r+c)=${this.maxCombinedRC}, growth=${formulaCombinedGrowth}`);
+        return row;
+    }
+    /**
+     * Send a prompt and collect all messages
+     * Uses session resumption to maintain the same session
+     */
+    async sendPrompt(prompt, promptNum) {
+        console.log(`\n[Prompt ${promptNum}] Sending: "${prompt}"${this.sessionId ? ` (session: ${this.sessionId.slice(0, 8)}...)` : ''}`);
+        const options = {
+            cwd: this.cwd,
+            permissionMode: 'bypassPermissions',
+        };
+        // Resume existing session if we have one
+        if (this.sessionId) {
+            options.resume = this.sessionId;
+        }
+        // Add system prompt for first message
+        if (!this.sessionId) {
+            if (!this.useSubagents) {
+                options.systemPrompt =
+                    'You are a helpful assistant. Do NOT use any tools or spawn any subagents. Answer directly and concisely.';
+            }
+            else {
+                options.systemPrompt =
+                    'You are a helpful assistant. Use tools as needed to complete tasks. Do NOT use non-blocking subagents - only use blocking tool calls. Be concise in your responses.';
+            }
+        }
+        const q = query({
+            prompt,
+            options,
+        });
+        for await (const msg of q) {
+            // Capture session ID from system init
+            if (msg.type === 'system') {
+                const sysMsg = msg;
+                if (sysMsg.subtype === 'init' && sysMsg.session_id) {
+                    this.sessionId = sysMsg.session_id;
+                }
+            }
+            // Process for usage data
+            if (isAssistantMessage(msg)) {
+                this.processMessage(msg);
+            }
+        }
+    }
+    /**
+     * Run the full analysis
+     */
+    async run(prompts) {
+        console.log('='.repeat(60));
+        console.log('CONTEXT ANALYZER - SDK Usage Analysis');
+        console.log('='.repeat(60));
+        console.log(`CWD: ${this.cwd}`);
+        console.log(`Subagents: ${this.useSubagents ? 'ENABLED' : 'DISABLED'}`);
+        console.log(`Prompts: ${prompts.length}`);
+        console.log('='.repeat(60));
+        const startedAt = new Date().toISOString();
+        // Step 1: Get baseline context
+        const baseline = await this.runContextCommand('BASELINE');
+        // Step 2: Send test prompts
+        for (let i = 0; i < prompts.length; i++) {
+            await this.sendPrompt(prompts[i], i + 1);
+        }
+        // Step 3: Get final context
+        const final = await this.runContextCommand('FINAL');
+        const endedAt = new Date().toISOString();
+        // Build result
+        const result = {
+            session_id: this.sessionId || 'unknown',
+            started_at: startedAt,
+            ended_at: endedAt,
+            duration_ms: Date.now() - this.startTime,
+            cwd: this.cwd,
+            used_subagents: this.useSubagents,
+            baseline,
+            final,
+            messages: this.messages,
+            summary: {
+                total_messages: this.messages.length,
+                unique_api_calls: this.seenMsgIds.size,
+                final_max_cache_read: this.maxCacheRead,
+                final_sum_cache_create: this.sumCacheCreate,
+                final_sum_input: this.sumInput,
+                final_sum_output: this.sumOutput,
+                // Combined metric tracking
+                first_combined_rc: this.firstCombinedRC,
+                final_max_combined_rc: this.maxCombinedRC,
+                // Calculated formulas
+                calculated_max_only: this.maxCacheRead,
+                calculated_max_plus_sums: this.maxCacheRead + this.sumInput + this.sumOutput,
+                calculated_create_plus_sums: this.sumCacheCreate + this.sumInput + this.sumOutput,
+                calculated_combined_growth: this.maxCombinedRC - this.firstCombinedRC,
+                actual_total: final.total_tokens,
+                actual_messages: final.messages_tokens,
+            },
+        };
+        return result;
+    }
+    /**
+     * Get current running totals (for access during analysis)
+     */
+    getRunningTotals() {
+        return {
+            maxCacheRead: this.maxCacheRead,
+            sumCacheCreate: this.sumCacheCreate,
+            sumInput: this.sumInput,
+            sumOutput: this.sumOutput,
+            firstCombinedRC: this.firstCombinedRC,
+            maxCombinedRC: this.maxCombinedRC,
+            combinedGrowth: this.maxCombinedRC - this.firstCombinedRC,
+            uniqueApiCalls: this.seenMsgIds.size,
+        };
+    }
+}
+// ============================================================================
+// Output Formatters
+// ============================================================================
+function toCSV(messages) {
+    const headers = [
+        'seq',
+        'timestamp',
+        'elapsed_ms',
+        'message_id',
+        'uuid',
+        'type',
+        'cache_read',
+        'cache_create',
+        'input',
+        'output',
+        'combined_rc',
+        'running_max_combined_rc',
+        'first_combined_rc',
+        'running_max_cache_read',
+        'running_sum_cache_create',
+        'running_sum_input',
+        'running_sum_output',
+        'formula_max_only',
+        'formula_max_plus_sums',
+        'formula_create_plus_sums',
+        'formula_combined_growth',
+        'pct_max_only',
+        'pct_max_plus_sums',
+        'pct_create_plus_sums',
+        'pct_combined_growth',
+        'unique_api_calls',
+        'text_preview',
+    ];
+    const rows = messages.map((m) => [
+        m.seq,
+        m.timestamp,
+        m.elapsed_ms,
+        m.message_id,
+        m.uuid,
+        m.type,
+        m.cache_read,
+        m.cache_create,
+        m.input,
+        m.output,
+        m.combined_rc,
+        m.running_max_combined_rc,
+        m.first_combined_rc,
+        m.running_max_cache_read,
+        m.running_sum_cache_create,
+        m.running_sum_input,
+        m.running_sum_output,
+        m.formula_max_only,
+        m.formula_max_plus_sums,
+        m.formula_create_plus_sums,
+        m.formula_combined_growth,
+        m.pct_max_only.toFixed(2),
+        m.pct_max_plus_sums.toFixed(2),
+        m.pct_create_plus_sums.toFixed(2),
+        m.pct_combined_growth.toFixed(2),
+        m.unique_api_calls,
+        `"${m.text_preview.replace(/"/g, '""')}"`,
+    ].join(','));
+    return [headers.join(','), ...rows].join('\n');
+}
+function printSummary(result) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log('ANALYSIS SUMMARY');
+    console.log('='.repeat(60));
+    console.log('\n--- Session Info ---');
+    console.log(`Session ID: ${result.session_id}`);
+    console.log(`Duration: ${result.duration_ms}ms`);
+    console.log(`Subagents: ${result.used_subagents ? 'ENABLED' : 'DISABLED'}`);
+    console.log(`Total unique API calls: ${result.summary.unique_api_calls}`);
+    console.log('\n--- Raw Totals ---');
+    console.log(`max(cache_read): ${result.summary.final_max_cache_read}`);
+    console.log(`sum(cache_create): ${result.summary.final_sum_cache_create}`);
+    console.log(`sum(input): ${result.summary.final_sum_input}`);
+    console.log(`sum(output): ${result.summary.final_sum_output}`);
+    console.log('\n--- Combined Metric (cache_read + cache_create) ---');
+    const s = result.summary;
+    console.log(`first(r+c):             ${s.first_combined_rc.toLocaleString().padStart(10)}`);
+    console.log(`max(r+c):               ${s.final_max_combined_rc.toLocaleString().padStart(10)}`);
+    console.log(`growth:                 ${s.calculated_combined_growth.toLocaleString().padStart(10)}`);
+    if (result.final) {
+        console.log('\n--- Actual /context Output ---');
+        console.log(`Total:    ${(result.final.total_tokens || 0).toLocaleString().padStart(10)} (${result.final.total_percent}%)`);
+        console.log(`Messages: ${(result.final.messages_tokens || 0).toLocaleString().padStart(10)}`);
+        console.log(`System:   ${(result.final.system_tokens || 0).toLocaleString().padStart(10)}`);
+        // THE NEW FORMULA: baseline + max(r+c) - first(r+c)
+        if (result.baseline && result.messages.length > 0) {
+            const baselineTotal = result.baseline.total_tokens;
+            const actual = result.final.total_tokens || 0;
+            console.log(`\n${'='.repeat(60)}`);
+            console.log('★ THE FORMULA: baseline + max(r+c) - first(r+c) + sum(i+o) ★');
+            console.log('='.repeat(60));
+            console.log(`Baseline total:         ${baselineTotal.toLocaleString().padStart(10)}`);
+            console.log(`max(cache_read+create): ${s.final_max_combined_rc.toLocaleString().padStart(10)}`);
+            console.log(`first(cache_read+create): ${s.first_combined_rc.toLocaleString().padStart(9)} (subtract)`);
+            console.log(`sum(input):             ${s.final_sum_input.toLocaleString().padStart(10)}`);
+            console.log(`sum(output):            ${s.final_sum_output.toLocaleString().padStart(10)}`);
+            const formulaNew = baselineTotal + s.calculated_combined_growth + s.final_sum_input + s.final_sum_output;
+            const diffNew = formulaNew - actual;
+            const pctErrorNew = (diffNew / actual) * 100;
+            console.log(`─────────────────────────────────────`);
+            console.log(`Calculated:             ${formulaNew.toLocaleString().padStart(10)}`);
+            console.log(`Actual (/context):      ${actual.toLocaleString().padStart(10)}`);
+            console.log(`Difference:             ${diffNew >= 0 ? '+' : ''}${diffNew.toLocaleString().padStart(9)} (${pctErrorNew >= 0 ? '+' : ''}${pctErrorNew.toFixed(2)}%)`);
+            // Also show the old formula for comparison
+            console.log('\n--- Old Formula Comparison ---');
+            const firstCacheCreate = result.messages[0].cache_create;
+            const formulaOld = baselineTotal +
+                (s.final_sum_cache_create - firstCacheCreate) +
+                s.final_sum_input +
+                s.final_sum_output;
+            const diffOld = formulaOld - actual;
+            const pctErrorOld = (diffOld / actual) * 100;
+            console.log(`Old (baseline + sum(create) - first(create) + in + out):`);
+            console.log(`  Calculated: ${formulaOld.toLocaleString().padStart(10)}, Error: ${diffOld >= 0 ? '+' : ''}${pctErrorOld.toFixed(2)}%`);
+            // Summary comparison
+            console.log('\n--- Formula Accuracy Comparison ---');
+            console.log(`NEW (baseline + max(r+c) - first(r+c)):  ${Math.abs(pctErrorNew).toFixed(2)}% error`);
+            console.log(`OLD (baseline + Σcache_create - first): ${Math.abs(pctErrorOld).toFixed(2)}% error`);
+        }
+    }
+    console.log(`\n${'='.repeat(60)}`);
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    const args = process.argv.slice(2);
+    const useSubagents = args.includes('--subagents');
+    const outputPrefix = args.find((a) => a.startsWith('--output='))?.split('=')[1] || 'context-analysis';
+    let numPrompts = 3;
+    const promptsArg = args.find((a) => a.startsWith('--prompts='));
+    if (promptsArg) {
+        numPrompts = parseInt(promptsArg.split('=')[1], 10) || 3;
+    }
+    const prompts = useSubagents
+        ? TEST_PROMPTS_WITH_SUBAGENT.slice(0, numPrompts)
+        : TEST_PROMPTS_NO_SUBAGENT.slice(0, numPrompts);
+    const cwd = process.cwd();
+    const analyzer = new ContextAnalyzer(cwd, useSubagents);
+    try {
+        const result = await analyzer.run(prompts);
+        // Print summary
+        printSummary(result);
+        // Save outputs
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const jsonFile = `${outputPrefix}-${timestamp}.json`;
+        const csvFile = `${outputPrefix}-${timestamp}.csv`;
+        fs.writeFileSync(jsonFile, JSON.stringify(result, null, 2));
+        console.log(`\nJSON output saved to: ${jsonFile}`);
+        fs.writeFileSync(csvFile, toCSV(result.messages));
+        console.log(`CSV output saved to: ${csvFile}`);
+    }
+    catch (error) {
+        console.error('Analysis failed:', error);
+        process.exit(1);
+    }
+}
+main().catch(console.error);

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};