@statforge/claudestat 1.6.1 → 1.8.0

package/dist/routes/opencode-reader.js

@@ -35,13 +35,49 @@ exports.opencodeReaderRouter.get('/api/opencode/session/:id', (req, res) => {
     try {
         const { id: sessionId } = req.params;
         const db = openDb();
-        // Get all messages for this session ordered by time
+        // ── Find all related session IDs (OpenCode creates one session per prompt) ──
+        // Look up directory for this session
+        const sessionRow = db.prepare(`
+      SELECT directory, time_created FROM session WHERE id = ?
+    `).get(sessionId);
+        let sessionIds = [sessionId];
+        if (sessionRow?.directory) {
+            // Find sessions with same directory, ordered by creation time
+            const sameDir = db.prepare(`
+        SELECT id, time_created FROM session
+        WHERE directory = ? AND time_archived IS NULL
+        ORDER BY time_created ASC
+      `).all(sessionRow.directory);
+            if (sameDir.length > 1) {
+                // Locate our session in the sorted list
+                let idx = sameDir.findIndex(s => s.id === sessionId);
+                if (idx !== -1) {
+                    // Expand forward: consecutive sessions with gap < 60s
+                    let end = idx;
+                    for (let i = idx + 1; i < sameDir.length; i++) {
+                        if (sameDir[i].time_created - sameDir[i - 1].time_created > 300000)
+                            break;
+                        end = i;
+                    }
+                    // Expand backward
+                    let begin = idx;
+                    for (let i = idx - 1; i >= 0; i--) {
+                        if (sameDir[begin].time_created - sameDir[i].time_created > 300000)
+                            break;
+                        begin = i;
+                    }
+                    sessionIds = sameDir.slice(begin, end + 1).map(s => s.id);
+                }
+            }
+        }
+        // ── Query messages from ALL sessions in the group ──
+        const placeholders = sessionIds.map(() => '?').join(',');
         const messages = db.prepare(`
       SELECT id, time_created, time_updated, data
       FROM message
-      WHERE session_id = ?
+      WHERE session_id IN (${placeholders})
       ORDER BY time_created ASC
-    `).all(sessionId);
+    `).all(...sessionIds);
         const events = [];
         const prompts = [];
         let totalParts = 0;

package/dist/routes/projects.js

@@ -13,6 +13,7 @@ const db_1 = require("../db");
 const projects_cache_1 = require("../cache/projects-cache");
 const pattern_analyzer_1 = require("../pattern-analyzer");
 const helpers_1 = require("./helpers");
+const config_1 = require("../config");
 exports.projectsRouter = (0, express_1.Router)();
 /** Infiere el proyecto activo mirando los eventos de archivo de una sesión */
 function inferProjectCwd(events) {
@@ -125,14 +126,31 @@ exports.projectsRouter.get('/projects', (_req, res) => {
             jsonl_source: useJSONL,
         });
     }
+    // CLI hours per project (source breakdown from DB)
+    const cliHoursRows = db_1.dbOps.getProjectCliHours();
+    const cliHoursMap = new Map();
+    for (const row of cliHoursRows) {
+        if (!cliHoursMap.has(row.project_path))
+            cliHoursMap.set(row.project_path, {});
+        cliHoursMap.get(row.project_path)[row.source] = row.total_ms / 3600000;
+    }
     // Attach pattern insights per project (only if DB has enough data)
+    const cfg = (0, config_1.readConfig)();
     const projects = [...projectMap.values()].map(p => {
         const toolCounts = db_1.dbOps.getProjectToolCounts(p.path);
         const sessionStats = db_1.dbOps.getProjectSessionStats(p.path);
         const insights = (sessionStats && sessionStats.session_count >= 2)
             ? (0, pattern_analyzer_1.analyzePatterns)(toolCounts, sessionStats)
             : [];
-        return { ...p, insights };
+        const cli_hours = cliHoursMap.get(p.path);
+        const aliasName = cfg.projectAliases[p.path];
+        return {
+            ...p,
+            name: aliasName ?? p.name,
+            alias: aliasName ?? null,
+            insights,
+            ...(cli_hours ? { cli_hours } : {}),
+        };
     })
         .sort((a, b) => (b.last_active ?? 0) - (a.last_active ?? 0));
     res.json({ projects, active_project: activeProject });

package/dist/routes/replay.d.ts

@@ -0,0 +1 @@
+export declare const replayRouter: import("express-serve-static-core").Router;

package/dist/routes/replay.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayRouter = void 0;
+const express_1 = require("express");
+const db_1 = require("../db");
+exports.replayRouter = (0, express_1.Router)();
+const CONTEXT_WINDOW = 200000;
+exports.replayRouter.get('/session/:id/replay', (req, res) => {
+    const { id } = req.params;
+    const turns = db_1.dbOps.getAssistantTurns(id);
+    res.json({ turns, context_window: CONTEXT_WINDOW });
+});
+function buildTree(sessionId, depth = 0) {
+    if (depth > 5)
+        return { id: sessionId, started_at: 0, children: [] };
+    const session = db_1.dbOps.getSession(sessionId);
+    const children = db_1.dbOps.getChildSessions(sessionId);
+    return {
+        id: sessionId,
+        dominant_model: session?.dominant_model ?? undefined,
+        total_cost_usd: session?.total_cost_usd ?? undefined,
+        started_at: session?.started_at ?? 0,
+        children: children.map(c => buildTree(c.id, depth + 1)),
+    };
+}
+exports.replayRouter.get('/session/:id/agent-tree', (req, res) => {
+    const { id } = req.params;
+    res.json(buildTree(id));
+});

package/dist/routes/reports.js

@@ -61,6 +61,13 @@ exports.reportsRouter.get('/api/analytics', (req, res) => {
         },
     });
 });
+// ─── GET /api/analytics/coach — eventos combinados para el coach multi-source ─
+exports.reportsRouter.get('/api/analytics/coach', (req, res) => {
+    const raw = req.query.session_ids;
+    const sessionIds = raw ? raw.split(',').map(s => s.trim()).filter(Boolean) : [];
+    const events = db_1.dbOps.getCoachEvents(sessionIds);
+    res.json({ events });
+});
 // ─── POST /api/weekly-reports/generate-now — generar informe inmediatamente ───
 exports.reportsRouter.post('/api/weekly-reports/generate-now', (_req, res) => {
     const cfg = (0, config_1.readConfig)();

package/dist/routes/top.js

@@ -8,18 +8,25 @@ exports.topRouter.get('/api/top', (req, res) => {
     const by = req.query.by ?? 'cost';
     const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
     const days = Math.min(parseInt(req.query.days, 10) || 30, 365);
+    const source = req.query.source ?? 'all';
     if (!['cost', 'count', 'duration'].includes(by)) {
         res.status(400).json({ error: 'Invalid "by" parameter. Use: cost, count, duration' });
         return;
     }
-    const tools = db_1.dbOps.getTopTools(days, by, limit);
+    if (!['all', 'claude-code', 'opencode'].includes(source)) {
+        res.status(400).json({ error: 'Invalid "source" parameter. Use: all, claude-code, opencode' });
+        return;
+    }
+    const tools = db_1.dbOps.getTopTools(days, by, limit, source);
     const totalCost = tools.reduce((s, t) => s + t.total_cost_usd, 0);
     const totalCount = tools.filter(t => t.tool_name !== 'Other').reduce((s, t) => s + t.count, 0);
     res.json({
         by,
         days,
+        source,
         tools: tools.map(t => ({
             tool: t.tool_name,
+            source: t.source,
             count: t.count,
             totalDurationMs: t.total_duration_ms,
             estimatedCostUsd: t.total_cost_usd,

package/dist/service.js

@@ -8,6 +8,14 @@ exports.uninstallService = uninstallService;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+function buildEnvPath() {
+    const current = process.env.PATH ?? '/usr/local/bin:/usr/bin:/bin';
+    const nvmDir = process.env.NVM_DIR;
+    if (!nvmDir)
+        return current;
+    const nvmBin = path_1.default.join(nvmDir, 'versions', 'node', `v${process.versions.node}`, 'bin');
+    return current.includes(nvmBin) ? current : `${nvmBin}:${current}`;
+}
 const PLIST_LABEL = 'com.statforge.claudestat';
 const PLIST_PATH = path_1.default.join(process.env.HOME ?? '~', 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
 const SYSTEMD_DIR = path_1.default.join(process.env.HOME ?? '~', '.config', 'systemd', 'user');
@@ -37,6 +45,8 @@ function makePlist() {
   <dict>
     <key>CLAUDESTAT_DAEMON</key>
     <string>1</string>
+    <key>PATH</key>
+    <string>${buildEnvPath()}</string>
   </dict>
   <key>StandardOutPath</key>
   <string>/tmp/claudestat-daemon.log</string>
@@ -56,6 +66,7 @@ ExecStart=${serviceCommand()} start
 Restart=on-failure
 RestartSec=5
 Environment=CLAUDESTAT_DAEMON=1
+Environment=PATH=${buildEnvPath()}
 
 [Install]
 WantedBy=default.target`;

package/dist/watchers/adapter.d.ts

@@ -33,6 +33,7 @@ export interface WatcherAdapter {
 export interface PollSession {
     sessionId: string;
     cost: CostUpdate;
+    cwd?: string;
 }
 /** Adapters que no usan archivos JSONL sino una DB o API propia */
 export interface PollableAdapter extends WatcherAdapter {

package/dist/watchers/claude-code.d.ts

@@ -6,8 +6,23 @@
  */
 import { type WatcherAdapter } from './adapter';
 import type { BlockCostEntry } from '../db';
-export declare function getContextWindow(model: string): number;
 export declare const claudeCodeAdapter: WatcherAdapter;
+export interface AssistantTurn {
+    turn_index: number;
+    ts?: number;
+    text_preview: string;
+    tool_calls: string[];
+    error_count: number;
+    output_chars: number;
+    context_used: number;
+}
+export interface SemanticData {
+    turns: AssistantTurn[];
+    avg_output_chars: number;
+    error_block_count: number;
+}
+export declare function findJSONLForSession(sessionId: string): Promise<string | null>;
+export declare function extractSemanticData(filePath: string): Promise<SemanticData | null>;
 export declare function getAllBlockCostsForSession(sessionId: string): Promise<BlockCostEntry[]>;
 export interface SessionPrompt {
     index: number;

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;