@statforge/claudestat 1.0.1

package/dist/doctor.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+async function runDoctor() {
+    const checks = [];
+    const G = '\x1b[32m✓\x1b[0m';
+    const R = '\x1b[31m✗\x1b[0m';
+    const W = '\x1b[33m⚠\x1b[0m';
+    // 1. Node.js version
+    const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+    checks.push({
+        label: `Node.js version (${process.versions.node})`,
+        ok: nodeMajor >= 18,
+        note: nodeMajor >= 22 ? 'node:sqlite supported ✓'
+            : nodeMajor >= 18 ? 'Works — Node 22+ recommended for native node:sqlite'
+                : undefined,
+        fix: nodeMajor < 18 ? 'Install Node.js 18 or later: https://nodejs.org' : undefined,
+    });
+    // 2. Claude Code installed
+    const claudeOk = (() => { try {
+        (0, child_process_1.execSync)('claude --version', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    } })();
+    checks.push({
+        label: 'Claude Code installed',
+        ok: claudeOk,
+        fix: claudeOk ? undefined : 'npm install -g @anthropic-ai/claude-code',
+    });
+    // 3. Hooks wired into Claude Code settings
+    const settingsPath = path_1.default.join((0, paths_1.getClaudeDir)(), 'settings.json');
+    let hooksOk = false;
+    try {
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'));
+        const required = ['PreToolUse', 'PostToolUse', 'SessionStart', 'Stop'];
+        hooksOk = required.every(type => settings.hooks?.[type]?.some((entry) => entry.hooks?.some((h) => typeof h.command === 'string' && h.command.includes('claudestat'))));
+    }
+    catch { }
+    checks.push({
+        label: 'Hooks installed in Claude Code',
+        ok: hooksOk,
+        note: hooksOk ? undefined : `Expected hooks in ${settingsPath}`,
+        fix: hooksOk ? undefined : 'claudestat install',
+    });
+    // 4. Data directory
+    const dataDir = (0, paths_1.getClaudestatDir)();
+    const dataDirOk = fs_1.default.existsSync(dataDir);
+    checks.push({
+        label: '~/.claudestat/ data directory exists',
+        ok: dataDirOk,
+        fix: dataDirOk ? undefined : 'Run "claudestat start" once to create it automatically',
+    });
+    // 5. Hook script deployed
+    const hookFile = path_1.default.join(dataDir, 'hooks', 'event.js');
+    const hookOk = fs_1.default.existsSync(hookFile);
+    checks.push({
+        label: 'Hook script deployed (~/.claudestat/hooks/event.js)',
+        ok: hookOk,
+        fix: hookOk ? undefined : 'claudestat install',
+    });
+    // 6. Daemon reachable
+    const daemonOk = await (async () => { try {
+        const res = await fetch('http://localhost:7337/health');
+        return res.ok;
+    }
+    catch {
+        return false;
+    } })();
+    checks.push({
+        label: 'Daemon running (localhost:7337)',
+        ok: daemonOk,
+        fix: daemonOk ? undefined : 'claudestat start',
+    });
+    // 7. Global CLI symlink valid (no stale link from old installs)
+    let symlinkOk = false;
+    let symlinkNote;
+    let activeBinary = '';
+    try {
+        activeBinary = (0, child_process_1.execSync)((0, paths_1.whichCmd)('claudestat'), { stdio: 'pipe' }).toString().trim();
+        const realPath = fs_1.default.realpathSync(activeBinary);
+        symlinkOk = fs_1.default.existsSync(realPath);
+        if (!symlinkOk)
+            symlinkNote = `Symlink points to missing file: ${realPath}`;
+    }
+    catch {
+        symlinkNote = 'claudestat not found in PATH';
+    }
+    checks.push({
+        label: 'Global CLI symlink valid',
+        ok: symlinkOk,
+        note: symlinkNote,
+        fix: symlinkOk ? undefined : 'npm install -g @deibygs/claudestat',
+    });
+    // 8. No duplicate claudestat binaries in PATH
+    let duplicatesOk = true;
+    let duplicatesNote;
+    try {
+        const allBinaries = (0, child_process_1.execSync)((0, paths_1.whichAllCmd)('claudestat'), { stdio: 'pipe' })
+            .toString().trim().split('\n').filter(Boolean);
+        if (allBinaries.length > 1) {
+            duplicatesOk = false;
+            duplicatesNote = `Found ${allBinaries.length} binaries:\n${allBinaries.map(p => `         ${p}`).join('\n')}`;
+        }
+    }
+    catch { }
+    checks.push({
+        label: 'No duplicate claudestat binaries in PATH',
+        ok: duplicatesOk,
+        note: duplicatesNote,
+        fix: duplicatesOk ? undefined :
+            `npm uninstall -g @deibygs/claudestat && npm install -g @deibygs/claudestat\n       Then restart your terminal or run: ${paths_1.isWindows ? 'refreshenv' : 'hash -r claudestat'}`,
+    });
+    // 9. Active binary version matches installed package
+    let versionOk = true;
+    let versionNote;
+    const installedVersion = (() => {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'package.json'), 'utf8')).version;
+        }
+        catch {
+            return 'unknown';
+        }
+    })();
+    if (activeBinary) {
+        try {
+            const runningVersion = (0, child_process_1.execSync)(`${activeBinary} --version`, { stdio: 'pipe' })
+                .toString().trim().replace(/^v?/, '');
+            versionOk = runningVersion === installedVersion;
+            if (!versionOk) {
+                versionNote = `Active binary reports v${runningVersion}, installed package is v${installedVersion}`;
+            }
+        }
+        catch { }
+    }
+    checks.push({
+        label: `Version match (installed: v${installedVersion})`,
+        ok: versionOk,
+        note: versionNote,
+        fix: versionOk ? undefined :
+            `${paths_1.isWindows ? 'refreshenv' : 'hash -r claudestat'}  (or restart terminal)\n       If persists: npm uninstall -g @deibygs/claudestat && npm install -g @deibygs/claudestat`,
+    });
+    // 10. NVM prefix sanity (only when NVM is active)
+    if ((process.env.NVM_DIR || process.env.NVM_HOME) && activeBinary) {
+        let nvmOk = true;
+        let nvmNote;
+        try {
+            const npmPrefix = (0, child_process_1.execSync)('npm prefix -g', { stdio: 'pipe' }).toString().trim();
+            if (!activeBinary.startsWith(npmPrefix)) {
+                nvmOk = false;
+                nvmNote = `Binary at ${activeBinary}\n         Expected under: ${npmPrefix}/bin/`;
+            }
+        }
+        catch { }
+        checks.push({
+            label: 'NVM prefix matches active binary',
+            ok: nvmOk,
+            note: nvmNote,
+            fix: nvmOk ? undefined :
+                `nvm use default && npm install -g @deibygs/claudestat\n       Then restart terminal`,
+        });
+    }
+    // ── Print results ───────────────────────────────────────────
+    console.log('\n🩺 claudestat doctor\n' + '─'.repeat(46));
+    for (const c of checks) {
+        console.log(`  ${c.ok ? G : R}  ${c.label}`);
+        if (!c.ok) {
+            if (c.note)
+                console.log(`       ${W}  ${c.note}`);
+            if (c.fix)
+                console.log(`       \x1b[36mfix:\x1b[0m  ${c.fix}`);
+        }
+    }
+    console.log('─'.repeat(46));
+    const failed = checks.filter(c => !c.ok).length;
+    if (failed === 0) {
+        console.log('  \x1b[32mAll checks passed — claudestat is healthy!\x1b[0m\n');
+    }
+    else {
+        console.log(`  \x1b[31m${failed} check(s) failed — see fixes above\x1b[0m\n`);
+        process.exit(1);
+    }
+}

package/dist/enricher.d.ts

@@ -0,0 +1,34 @@
+/**
+ * enricher.ts — Enriquecedor de coste desde JSONL de Claude Code
+ *
+ * Claude Code escribe los tokens de cada respuesta en:
+ *   ~/.claude/projects/{project-hash}/{session-id}.jsonl
+ *
+ * Cada línea de tipo "assistant" contiene:
+ *   message.usage.input_tokens
+ *   message.usage.output_tokens
+ *   message.usage.cache_read_input_tokens
+ *   message.usage.cache_creation_input_tokens
+ *   message.model
+ *
+ * El enricher observa cambios en esos archivos (con chokidar),
+ * calcula el coste acumulado por sesión y llama al callback
+ * para que el daemon actualice la DB y haga broadcast via SSE.
+ */
+import type { CostUpdate } from './db';
+export declare function getContextWindow(model: string): number;
+import type { BlockCostEntry } from './db';
+export declare function getAllBlockCostsForSession(sessionId: string): Promise<BlockCostEntry[]>;
+export interface SessionPrompt {
+    index: number;
+    ts: number;
+    text: string;
+}
+export declare function getSessionPrompts(sessionId: string): Promise<SessionPrompt[]>;
+export type CostUpdateCallback = (sessionId: string, cost: CostUpdate) => void;
+export type CompactDetectedCallback = (sessionId: string) => void;
+export type SessionEndCallback = (sessionId: string) => void;
+export declare function startEnricher(onUpdate: CostUpdateCallback, onCompact?: CompactDetectedCallback, onSessionEnd?: SessionEndCallback): void;
+export declare function stopEnricher(): void;
+export declare function cleanupSession(sessionId: string): void;
+export declare function processLatestForSession(sessionId: string, onUpdate: CostUpdateCallback): Promise<void>;

package/dist/enricher.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * enricher.ts — Enriquecedor de coste desde JSONL de Claude Code
+ *
+ * Claude Code escribe los tokens de cada respuesta en:
+ *   ~/.claude/projects/{project-hash}/{session-id}.jsonl
+ *
+ * Cada línea de tipo "assistant" contiene:
+ *   message.usage.input_tokens
+ *   message.usage.output_tokens
+ *   message.usage.cache_read_input_tokens
+ *   message.usage.cache_creation_input_tokens
+ *   message.model
+ *
+ * El enricher observa cambios en esos archivos (con chokidar),
+ * calcula el coste acumulado por sesión y llama al callback
+ * para que el daemon actualice la DB y haga broadcast via SSE.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextWindow = getContextWindow;
+exports.getAllBlockCostsForSession = getAllBlockCostsForSession;
+exports.getSessionPrompts = getSessionPrompts;
+exports.startEnricher = startEnricher;
+exports.stopEnricher = stopEnricher;
+exports.cleanupSession = cleanupSession;
+exports.processLatestForSession = processLatestForSession;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const paths_1 = require("./paths");
+const PRICING = {
+    'claude-opus-4-6': { input: 15, output: 75, cacheRead: 1.50, cacheCreate: 18.75 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cacheRead: 0.30, cacheCreate: 3.75 },
+    'claude-haiku-4-5': { input: 0.80, output: 4, cacheRead: 0.08, cacheCreate: 1.00 },
+    'claude-haiku-4-5-20251001': { input: 0.80, output: 4, cacheRead: 0.08, cacheCreate: 1.00 },
+};
+const DEFAULT_PRICING = PRICING['claude-sonnet-4-6'];
+// ─── Context window dinámico ──────────────────────────────────────────────────
+const KNOWN_CONTEXT_WINDOWS = {
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5': 200000,
+};
+function getContextWindow(model) {
+    return KNOWN_CONTEXT_WINDOWS[model] ?? 200000;
+}
+// ─── Calculo de coste ─────────────────────────────────────────────────────────
+function calcCost(model, usage) {
+    const price = PRICING[model] ?? DEFAULT_PRICING;
+    const M = 1000000;
+    return ((usage.input_tokens * price.input) / M +
+        (usage.output_tokens * price.output) / M +
+        (usage.cache_read_input_tokens * price.cacheRead) / M +
+        (usage.cache_creation_input_tokens * price.cacheCreate) / M);
+}
+const fileOffsets = new Map();
+const FILE_OFFSET_TTL = 30 * 60000; // 30 minutos
+function cleanupStaleOffsets() {
+    const now = Date.now();
+    for (const [key, entry] of fileOffsets) {
+        if (now - entry.lastAccess > FILE_OFFSET_TTL)
+            fileOffsets.delete(key);
+    }
+}
+async function processJSONL(filePath) {
+    let fileContent;
+    try {
+        fileContent = await promises_1.default.readFile(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const currentSize = Buffer.byteLength(fileContent, 'utf8');
+    const knownEntry = fileOffsets.get(filePath);
+    const knownOffset = knownEntry?.offset ?? 0;
+    if (currentSize < knownOffset)
+        fileOffsets.set(filePath, { offset: 0, lastAccess: Date.now() });
+    const totals = {
+        input_tokens: 0, output_tokens: 0,
+        cache_read: 0, cache_creation: 0, cost_usd: 0,
+        context_used: 0, context_window: 200000
+    };
+    let lastInputUsd = 0;
+    let lastOutputUsd = 0;
+    let lastInputTokens = 0;
+    let lastOutputTokens = 0;
+    let lastModel = undefined;
+    let firstTs = undefined;
+    for (const raw of fileContent.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type !== 'assistant')
+                continue;
+            const msg = obj.message;
+            const usage = msg?.usage;
+            const model = msg?.model ?? undefined;
+            if (!usage)
+                continue;
+            if (firstTs === undefined && obj.timestamp) {
+                try {
+                    firstTs = new Date(obj.timestamp).getTime();
+                }
+                catch { }
+            }
+            totals.input_tokens += usage.input_tokens ?? 0;
+            totals.output_tokens += usage.output_tokens ?? 0;
+            totals.cache_read += usage.cache_read_input_tokens ?? 0;
+            totals.cache_creation += usage.cache_creation_input_tokens ?? 0;
+            const resolvedModel = model ?? 'claude-sonnet-4-6';
+            totals.cost_usd += calcCost(resolvedModel, usage);
+            totals.context_used = (usage.input_tokens ?? 0)
+                + (usage.cache_read_input_tokens ?? 0)
+                + (usage.cache_creation_input_tokens ?? 0);
+            totals.context_window = getContextWindow(resolvedModel);
+            const price = PRICING[resolvedModel] ?? DEFAULT_PRICING;
+            const M = 1000000;
+            lastInputUsd = ((usage.input_tokens ?? 0) * price.input +
+                (usage.cache_read_input_tokens ?? 0) * price.cacheRead +
+                (usage.cache_creation_input_tokens ?? 0) * price.cacheCreate) / M;
+            lastOutputUsd = ((usage.output_tokens ?? 0) * price.output) / M;
+            lastInputTokens = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+            lastOutputTokens = usage.output_tokens ?? 0;
+            lastModel = model ?? lastModel;
+        }
+        catch { }
+    }
+    if (lastInputUsd + lastOutputUsd > 0) {
+        totals.lastEntry = {
+            inputUsd: lastInputUsd,
+            outputUsd: lastOutputUsd,
+            totalUsd: lastInputUsd + lastOutputUsd,
+            inputTokens: lastInputTokens,
+            outputTokens: lastOutputTokens,
+        };
+    }
+    totals.lastModel = lastModel;
+    totals.firstTs = firstTs;
+    fileOffsets.set(filePath, { offset: currentSize, lastAccess: Date.now() });
+    return totals;
+}
+const blockCostCache = new Map();
+const BLOCK_COST_TTL = 5 * 60000;
+async function getAllBlockCostsForSession(sessionId) {
+    const cached = blockCostCache.get(sessionId);
+    if (cached && Date.now() - cached.ts < BLOCK_COST_TTL)
+        return cached.data;
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return [];
+        const dirs = await promises_1.default.readdir(PROJECTS_DIR);
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                const stat = await promises_1.default.stat(dirPath);
+                if (!stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const filePath = path_1.default.join(dirPath, `${sessionId}.jsonl`);
+            try {
+                await promises_1.default.access(filePath);
+            }
+            catch {
+                continue;
+            }
+            const result = [];
+            let current = null;
+            const content = await promises_1.default.readFile(filePath, 'utf8');
+            for (const raw of content.split('\n')) {
+                const line = raw.trim();
+                if (!line)
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj.type === 'human' || obj.type === 'user') {
+                        const msgContent = obj.message?.content;
+                        if (Array.isArray(msgContent) && msgContent[0]?.type === 'tool_result')
+                            continue;
+                        const text = typeof msgContent === 'string' ? msgContent
+                            : Array.isArray(msgContent)
+                                ? (msgContent.find((c) => c?.type === 'text')?.text ?? '')
+                                : '';
+                        if (text.includes('<system-reminder>') || text.includes('<command-name>'))
+                            continue;
+                        current = { inputUsd: 0, outputUsd: 0, totalUsd: 0, inputTokens: 0, outputTokens: 0 };
+                        result.push(current);
+                    }
+                    if (obj.type === 'assistant' && current) {
+                        const usage = obj.message?.usage;
+                        const model = obj.message?.model ?? 'claude-sonnet-4-6';
+                        if (!usage)
+                            continue;
+                        const price = PRICING[model] ?? DEFAULT_PRICING;
+                        const M = 1000000;
+                        const inUsd = ((usage.input_tokens ?? 0) * price.input +
+                            (usage.cache_read_input_tokens ?? 0) * price.cacheRead +
+                            (usage.cache_creation_input_tokens ?? 0) * price.cacheCreate) / M;
+                        const outUsd = ((usage.output_tokens ?? 0) * price.output) / M;
+                        const inTok = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+                        const outTok = usage.output_tokens ?? 0;
+                        current.inputUsd += inUsd;
+                        current.outputUsd += outUsd;
+                        current.totalUsd += inUsd + outUsd;
+                        current.inputTokens += inTok;
+                        current.outputTokens += outTok;
+                    }
+                }
+                catch { }
+            }
+            const filtered = result.filter(b => b.totalUsd > 0);
+            blockCostCache.set(sessionId, { data: filtered, ts: Date.now() });
+            return filtered;
+        }
+    }
+    catch { }
+    return [];
+}
+async function getSessionPrompts(sessionId) {
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return [];
+        const dirs = await promises_1.default.readdir(PROJECTS_DIR);
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                const stat = await promises_1.default.stat(dirPath);
+                if (!stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const candidates = [
+                path_1.default.join(dirPath, `${sessionId}.jsonl`),
+            ];
+            for (const file of candidates) {
+                try {
+                    await promises_1.default.access(file);
+                }
+                catch {
+                    continue;
+                }
+                const results = [];
+                const content = await promises_1.default.readFile(file, 'utf8');
+                let index = 0;
+                for (const raw of content.split('\n')) {
+                    const line = raw.trim();
+                    if (!line)
+                        continue;
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.type !== 'human' && obj.type !== 'user')
+                            continue;
+                        const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : 0;
+                        if (!ts || isNaN(ts))
+                            continue;
+                        const msgContent = obj.message?.content;
+                        let text = '';
+                        if (typeof msgContent === 'string') {
+                            text = msgContent;
+                        }
+                        else if (Array.isArray(msgContent)) {
+                            const textBlocks = msgContent.filter(c => c?.type === 'text');
+                            if (textBlocks.length === 0)
+                                continue;
+                            text = textBlocks.map((c) => c.text ?? '').join('\n').trim();
+                        }
+                        if (text.includes('<command-name>') ||
+                            text.includes('<local-command-stdout>') ||
+                            text.includes('<system-reminder>') ||
+                            text.length === 0)
+                            continue;
+                        index++;
+                        results.push({ index, ts, text });
+                    }
+                    catch { }
+                }
+                return results;
+            }
+        }
+    }
+    catch { }
+    return [];
+}
+// ─── Watcher ─────────────────────────────────────────────────────────────────
+const PROJECTS_DIR = path_1.default.join((0, paths_1.getClaudeDir)(), 'projects');
+const prevContextBySession = new Map();
+let watcher = null;
+const pendingFiles = new Map();
+let offsetCleanupInterval = null;
+function startEnricher(onUpdate, onCompact, onSessionEnd) {
+    if (!fs_1.default.existsSync(PROJECTS_DIR)) {
+        console.warn(`[enricher] Directory not found: ${PROJECTS_DIR}`);
+        return;
+    }
+    watcher = chokidar_1.default.watch(`${PROJECTS_DIR}/**/*.jsonl`, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 200,
+            pollInterval: 100
+        }
+    });
+    const handleFile = (filePath) => {
+        const sessionId = path_1.default.basename(filePath, '.jsonl');
+        if (!sessionId.includes('-') || sessionId.length < 10)
+            return;
+        const existing = pendingFiles.get(filePath);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            pendingFiles.delete(filePath);
+            processJSONL(filePath).then(cost => {
+                if (cost && cost.cost_usd >= 0) {
+                    const prev = prevContextBySession.get(sessionId);
+                    if (onCompact && prev !== undefined && prev > 140000 && cost.context_used < prev * 0.5) {
+                        onCompact(sessionId);
+                    }
+                    prevContextBySession.set(sessionId, cost.context_used);
+                    onUpdate(sessionId, cost);
+                }
+            }).catch(err => console.error('[enricher] Error processing JSONL:', err));
+        }, 100);
+        pendingFiles.set(filePath, timer);
+    };
+    watcher.on('change', handleFile);
+    watcher.on('add', handleFile);
+    offsetCleanupInterval = setInterval(cleanupStaleOffsets, 5 * 60000);
+    console.log(`[enricher] Watching ${PROJECTS_DIR}`);
+}
+function stopEnricher() {
+    if (watcher) {
+        watcher.close();
+        watcher = null;
+    }
+    if (offsetCleanupInterval) {
+        clearInterval(offsetCleanupInterval);
+        offsetCleanupInterval = null;
+    }
+    for (const [, timer] of pendingFiles)
+        clearTimeout(timer);
+    pendingFiles.clear();
+    fileOffsets.clear();
+    prevContextBySession.clear();
+    blockCostCache.clear();
+    console.log('[enricher] Stopped');
+}
+function cleanupSession(sessionId) {
+    blockCostCache.delete(sessionId);
+    prevContextBySession.delete(sessionId);
+    for (const [key, entry] of fileOffsets) {
+        if (key.includes(sessionId))
+            fileOffsets.delete(key);
+    }
+}
+async function processLatestForSession(sessionId, onUpdate) {
+    try {
+        if (!fs_1.default.existsSync(PROJECTS_DIR))
+            return;
+        const dirs = await promises_1.default.readdir(PROJECTS_DIR);
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(PROJECTS_DIR, dir);
+            try {
+                const stat = await promises_1.default.stat(dirPath);
+                if (!stat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const filePath = path_1.default.join(dirPath, `${sessionId}.jsonl`);
+            try {
+                await promises_1.default.access(filePath);
+            }
+            catch {
+                continue;
+            }
+            const cost = await processJSONL(filePath);
+            if (cost && cost.cost_usd >= 0)
+                onUpdate(sessionId, cost);
+            return;
+        }
+    }
+    catch { }
+}

package/dist/export.d.ts

@@ -0,0 +1,8 @@
+export interface ExportOpts {
+    format: 'json' | 'csv';
+    from?: string;
+    to?: string;
+    project?: string;
+    output?: string;
+}
+export declare function runExport(opts: ExportOpts): void;