@statforge/claudestat 1.6.1 → 1.7.0

package/dist/watchers/claude-code.js

@@ -10,7 +10,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeCodeAdapter = void 0;
-exports.getContextWindow = getContextWindow;
+exports.findJSONLForSession = findJSONLForSession;
+exports.extractSemanticData = extractSemanticData;
 exports.getAllBlockCostsForSession = getAllBlockCostsForSession;
 exports.getSessionPrompts = getSessionPrompts;
 const path_1 = __importDefault(require("path"));
@@ -20,14 +21,6 @@ const adapter_1 = require("./adapter");
 const paths_1 = require("../paths");
 const pricing_1 = require("../pricing");
 function projectsDir() { return path_1.default.join((0, paths_1.getClaudeDir)(), 'projects'); }
-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;
-}
 const fileOffsets = new Map();
 const FILE_OFFSET_TTL = 30 * 60000;
 function cleanupStaleOffsets() {
@@ -38,80 +31,106 @@ function cleanupStaleOffsets() {
     }
 }
 async function processJSONL(filePath) {
-    let fileContent;
+    let fd;
     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;
-    let firstTs;
-    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;
-            if (!msg?.usage)
+        fd = await promises_1.default.open(filePath, 'r');
+        const currentSize = (await fd.stat()).size;
+        // File was truncated (e.g., /compact) — drop cached state and re-read from start
+        let state = fileOffsets.get(filePath);
+        if (state && currentSize < state.offset) {
+            fileOffsets.delete(filePath);
+            state = undefined;
+        }
+        const fromByte = state?.offset ?? 0;
+        // Nothing new — return cached totals without lastEntry to avoid duplicate SSE
+        if (currentSize === fromByte && state)
+            return { ...state.totals, lastEntry: undefined };
+        // Read only the new bytes since last processed offset
+        const buf = Buffer.alloc(currentSize - fromByte);
+        await fd.read(buf, 0, buf.length, fromByte);
+        const newContent = buf.toString('utf8');
+        // Accumulate on top of previous totals (or start from zero on first read)
+        const prevTotals = state?.totals;
+        const totals = {
+            input_tokens: prevTotals?.input_tokens ?? 0,
+            output_tokens: prevTotals?.output_tokens ?? 0,
+            cache_read: prevTotals?.cache_read ?? 0,
+            cache_creation: prevTotals?.cache_creation ?? 0,
+            cost_usd: prevTotals?.cost_usd ?? 0,
+            context_used: prevTotals?.context_used ?? 0,
+            context_window: prevTotals?.context_window ?? 200000,
+            firstTs: prevTotals?.firstTs,
+            lastModel: prevTotals?.lastModel,
+        };
+        let lastInputUsd = 0;
+        let lastOutputUsd = 0;
+        let lastInputTokens = 0;
+        let lastOutputTokens = 0;
+        let hasNewAssistant = false;
+        for (const raw of newContent.split('\n')) {
+            const line = raw.trim();
+            if (!line)
                 continue;
-            const usage = msg.usage;
-            const model = msg.model ?? 'claude-sonnet-4-6';
-            if (firstTs === undefined && obj.timestamp) {
-                try {
-                    firstTs = new Date(obj.timestamp).getTime();
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type !== 'assistant')
+                    continue;
+                const msg = obj.message;
+                if (!msg?.usage)
+                    continue;
+                const usage = msg.usage;
+                const model = msg.model ?? 'claude-sonnet-4-6';
+                hasNewAssistant = true;
+                if (obj.timestamp) {
+                    try {
+                        const ts = new Date(obj.timestamp).getTime();
+                        if (totals.firstTs === undefined)
+                            totals.firstTs = ts;
+                        totals.lastTs = ts;
+                    }
+                    catch { /* ignore */ }
                 }
-                catch { /* ignore */ }
+                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;
+                totals.cost_usd += (0, pricing_1.calcCost)(model, usage);
+                totals.context_used = (usage.input_tokens ?? 0)
+                    + (usage.cache_read_input_tokens ?? 0)
+                    + (usage.cache_creation_input_tokens ?? 0);
+                totals.context_window = (0, pricing_1.getContextWindow)(model);
+                const price = pricing_1.PRICING[model] ?? pricing_1.DEFAULT_PRICING;
+                const M = 1000000;
+                const inp = usage.input_tokens ?? 0;
+                const cacheRead = usage.cache_read_input_tokens ?? 0;
+                const cacheCreate = usage.cache_creation_input_tokens ?? 0;
+                const out = usage.output_tokens ?? 0;
+                lastInputUsd = (inp * price.input + cacheRead * price.cacheRead + cacheCreate * price.cacheCreate) / M;
+                lastOutputUsd = out * price.output / M;
+                lastInputTokens = inp + cacheRead + cacheCreate;
+                lastOutputTokens = out;
+                totals.lastModel = model;
             }
-            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;
-            totals.cost_usd += (0, pricing_1.calcCost)(model, usage);
-            totals.context_used = (usage.input_tokens ?? 0)
-                + (usage.cache_read_input_tokens ?? 0)
-                + (usage.cache_creation_input_tokens ?? 0);
-            totals.context_window = getContextWindow(model);
-            const price = pricing_1.PRICING[model] ?? pricing_1.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 { /* skip malformed lines */ }
+        }
+        // lastEntry only when there are new API calls — drives the block_cost SSE event
+        if (hasNewAssistant && lastInputUsd + lastOutputUsd > 0) {
+            const totalUsd = lastInputUsd + lastOutputUsd;
+            totals.lastEntry = {
+                inputUsd: lastInputUsd, outputUsd: lastOutputUsd,
+                totalUsd,
+                inputTokens: lastInputTokens, outputTokens: lastOutputTokens,
+            };
         }
-        catch { /* skip malformed lines */ }
+        fileOffsets.set(filePath, { offset: currentSize, lastAccess: Date.now(), totals });
+        return totals;
     }
-    if (lastInputUsd + lastOutputUsd > 0) {
-        totals.lastEntry = {
-            inputUsd: lastInputUsd, outputUsd: lastOutputUsd,
-            totalUsd: lastInputUsd + lastOutputUsd,
-            inputTokens: lastInputTokens, outputTokens: lastOutputTokens,
-        };
+    catch {
+        return null;
+    }
+    finally {
+        await fd?.close();
     }
-    totals.lastModel = lastModel;
-    totals.firstTs = firstTs;
-    fileOffsets.set(filePath, { offset: currentSize, lastAccess: Date.now() });
-    return totals;
 }
 exports.claudeCodeAdapter = {
     name: 'claude-code',
@@ -152,6 +171,112 @@ exports.claudeCodeAdapter = {
 };
 setInterval(cleanupStaleOffsets, 5 * 60000).unref();
 (0, adapter_1.registerAdapter)(exports.claudeCodeAdapter);
+async function findJSONLForSession(sessionId) {
+    try {
+        if (!fs_1.default.existsSync(projectsDir()))
+            return null;
+        const dirs = await promises_1.default.readdir(projectsDir());
+        for (const dir of dirs) {
+            const dirPath = path_1.default.join(projectsDir(), 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);
+                return filePath;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+async function extractSemanticData(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf8');
+        const turns = [];
+        let pendingTurn = null;
+        let totalErrorBlocks = 0;
+        let turnIndex = 0;
+        for (const raw of content.split('\n')) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === 'assistant') {
+                    if (pendingTurn)
+                        turns.push(pendingTurn);
+                    const msgContent = obj.message?.content;
+                    if (!Array.isArray(msgContent)) {
+                        pendingTurn = null;
+                        continue;
+                    }
+                    let outputChars = 0;
+                    const textParts = [];
+                    const toolCalls = [];
+                    for (const block of msgContent) {
+                        if (block?.type === 'text' && typeof block.text === 'string') {
+                            outputChars += block.text.length;
+                            textParts.push(block.text);
+                        }
+                        else if (block?.type === 'tool_use' && typeof block.name === 'string') {
+                            toolCalls.push(block.name);
+                        }
+                    }
+                    let ts;
+                    if (obj.timestamp) {
+                        try {
+                            ts = new Date(obj.timestamp).getTime();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    const usage = obj.message?.usage;
+                    const contextUsed = usage
+                        ? ((usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0))
+                        : 0;
+                    pendingTurn = {
+                        turn_index: turnIndex++,
+                        ts,
+                        text_preview: textParts.join('\n').slice(0, 500),
+                        tool_calls: toolCalls,
+                        error_count: 0,
+                        output_chars: outputChars,
+                        context_used: contextUsed,
+                    };
+                }
+                else if ((obj.type === 'human' || obj.type === 'user') && pendingTurn) {
+                    const msgContent = obj.message?.content;
+                    if (!Array.isArray(msgContent))
+                        continue;
+                    for (const block of msgContent) {
+                        if (block?.type === 'tool_result' && block.is_error === true) {
+                            pendingTurn.error_count++;
+                            totalErrorBlocks++;
+                        }
+                    }
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+        if (pendingTurn)
+            turns.push(pendingTurn);
+        const totalOutputChars = turns.reduce((sum, t) => sum + t.output_chars, 0);
+        const avg_output_chars = turns.length > 0 ? Math.round(totalOutputChars / turns.length) : 0;
+        return { turns, avg_output_chars, error_block_count: totalErrorBlocks };
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Session-level utilities (used by routes/stream and routes/misc) ───────────
 const blockCostCache = new Map();
 const costCacheLocks = new Map();

package/dist/watchers/opencode.d.ts

@@ -7,3 +7,4 @@
  */
 import { type PollableAdapter } from './adapter';
 export declare const opencodeAdapter: PollableAdapter;
+export declare function isSessionArchived(sessionId: string): boolean;

package/dist/watchers/opencode.js

@@ -11,9 +11,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.opencodeAdapter = void 0;
+exports.isSessionArchived = isSessionArchived;
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const adapter_1 = require("./adapter");
 const paths_1 = require("../paths");
+const pricing_1 = require("../pricing");
+const db_1 = require("../db");
+const helpers_1 = require("../routes/helpers");
 function openDb() {
     const { DatabaseSync } = require('node:sqlite');
     return new DatabaseSync((0, paths_1.getOpencodeDb)(), { open: true });
@@ -29,6 +34,101 @@ function parseModel(raw) {
         return 'unknown';
     }
 }
+const HOME = os_1.default.homedir();
+function inferProjectFromParts(db, sessionId) {
+    if (!db)
+        return undefined;
+    const parts = db.prepare(`
+    SELECT p.data FROM part p
+    JOIN message m ON p.message_id = m.id
+    WHERE m.session_id = ?
+    AND json_extract(p.data, '$.type') = 'tool'
+    AND json_extract(p.data, '$.tool') IN ('read', 'write', 'edit', 'glob', 'grep')
+    ORDER BY p.time_created DESC
+    LIMIT 30
+  `).all(sessionId);
+    const roots = new Map();
+    for (const { data } of parts) {
+        try {
+            const input = JSON.parse(data).state?.input;
+            if (!input)
+                continue;
+            const filePath = input.filePath || input.path || input.file_path;
+            if (!filePath || typeof filePath !== 'string' || !filePath.startsWith('/'))
+                continue;
+            const root = (0, helpers_1.findProjectCwdForFile)(filePath);
+            if (root)
+                roots.set(root, (roots.get(root) ?? 0) + 1);
+        }
+        catch { }
+    }
+    if (roots.size === 0)
+        return undefined;
+    return [...roots.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+function importToolEvents(ocDb, sessionId, targetSessionId) {
+    const parts = ocDb.prepare(`
+    SELECT p.id, p.data, p.time_created
+    FROM part p
+    JOIN message m ON p.message_id = m.id
+    WHERE m.session_id = ?
+    AND json_extract(p.data, '$.type') = 'tool'
+    AND json_extract(p.data, '$.state') IS NOT NULL
+  `).all(sessionId);
+    const destId = targetSessionId ?? sessionId;
+    for (const part of parts) {
+        try {
+            const toolName = JSON.parse(part.data).tool;
+            if (!toolName)
+                continue;
+            db_1.dbOps.insertOcEvent(destId, toolName, part.time_created, part.id);
+        }
+        catch { }
+    }
+}
+// ─── Session grouping: merge consecutive OC sessions from same conversation ────
+// OpenCode creates a new session row per prompt, even within the same conversation.
+// We group sessions by directory + close time_created (<60s apart) into one.
+function groupOcSessions(rows) {
+    const sorted = [...rows].sort((a, b) => a.time_created - b.time_created);
+    const groups = new Map(); // master id → group
+    const grouped = new Set();
+    for (let i = 0; i < sorted.length; i++) {
+        if (grouped.has(sorted[i].id))
+            continue;
+        const group = [sorted[i]];
+        grouped.add(sorted[i].id);
+        for (let j = i + 1; j < sorted.length; j++) {
+            const prev = group[group.length - 1];
+            const curr = sorted[j];
+            if (grouped.has(curr.id))
+                continue;
+            if (curr.directory !== prev.directory)
+                continue;
+            const gap = curr.time_created - prev.time_created;
+            if (gap > 60000)
+                break; // too far apart, stop looking
+            group.push(curr);
+            grouped.add(curr.id);
+        }
+        groups.set(group[0].id, group);
+    }
+    // Flatten: return only master (first) rows, with aggregated cost/tokens
+    return [...groups.values()].map(group => {
+        const master = { ...group[0] };
+        for (let k = 1; k < group.length; k++) {
+            const s = group[k];
+            master.cost += s.cost;
+            master.tokens_input += s.tokens_input;
+            master.tokens_output += s.tokens_output;
+            master.tokens_cache_read += s.tokens_cache_read;
+            master.tokens_cache_write += s.tokens_cache_write;
+            if (s.time_updated > master.time_updated)
+                master.time_updated = s.time_updated;
+        }
+        return master;
+    });
+}
 exports.opencodeAdapter = {
     name: 'opencode',
     label: 'OpenCode',
@@ -54,23 +154,50 @@ exports.opencodeAdapter = {
         let db = null;
         try {
             db = openDb();
-            const rows = db.prepare(`SELECT id, model, cost, tokens_input, tokens_output, tokens_cache_read, tokens_cache_write, time_updated
+            const rows = db.prepare(`SELECT id, directory, model, cost, tokens_input, tokens_output, tokens_cache_read, tokens_cache_write,
+                time_created, time_updated
          FROM session
          WHERE time_updated >= ?
          AND time_archived IS NULL`).all(since);
-            return rows.map(row => ({
-                sessionId: row.id,
-                cost: {
-                    input_tokens: row.tokens_input,
-                    output_tokens: row.tokens_output,
-                    cache_read: row.tokens_cache_read,
-                    cache_creation: row.tokens_cache_write,
-                    cost_usd: row.cost,
-                    context_used: 0,
-                    context_window: 200000,
-                    lastModel: parseModel(row.model),
-                },
-            }));
+            const grouped = groupOcSessions(rows);
+            // Build master lookup: original session id → master session id
+            const masterMap = new Map();
+            for (let i = 0; i < rows.length; i++) {
+                const masterId = grouped.find(g => g.id === rows[i].id)?.id
+                    ?? rows[i].id;
+                masterMap.set(rows[i].id, masterId);
+            }
+            // Import tool events into the master session ID
+            for (const s of rows) {
+                const masterId = masterMap.get(s.id) ?? s.id;
+                try {
+                    importToolEvents(db, s.id, masterId);
+                }
+                catch { }
+            }
+            return grouped.map(row => {
+                const modelId = parseModel(row.model);
+                const dir = row.directory;
+                const shouldInfer = !dir || dir === HOME || dir.split('/').filter(Boolean).length <= 3;
+                const inferred = shouldInfer ? inferProjectFromParts(db, row.id) : undefined;
+                const projectCwd = inferred ?? dir ?? undefined;
+                return {
+                    sessionId: row.id,
+                    cwd: projectCwd,
+                    cost: {
+                        input_tokens: row.tokens_input,
+                        output_tokens: row.tokens_output,
+                        cache_read: row.tokens_cache_read,
+                        cache_creation: row.tokens_cache_write,
+                        cost_usd: row.cost,
+                        context_used: row.tokens_input + row.tokens_cache_read + row.tokens_cache_write,
+                        context_window: (0, pricing_1.getContextWindow)(modelId),
+                        lastModel: modelId,
+                        firstTs: row.time_created,
+                        lastTs: row.time_updated,
+                    },
+                };
+            });
         }
         catch {
             return [];
@@ -80,4 +207,15 @@ exports.opencodeAdapter = {
         }
     },
 };
+function isSessionArchived(sessionId) {
+    try {
+        const db = openDb();
+        const row = db.prepare('SELECT time_archived FROM session WHERE id = ?').get(sessionId);
+        db.close();
+        return row === undefined || row.time_archived !== null;
+    }
+    catch {
+        return false;
+    }
+}
 (0, adapter_1.registerAdapter)(exports.opencodeAdapter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "private": false,
   "publishConfig": {
     "access": "public"