@statforge/claudestat 1.2.0 → 1.2.3

package/dist/quota-tracker.js

@@ -19,6 +19,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshFromApi = refreshFromApi;
 exports.computeQuota = computeQuota;
 exports.invalidateQuotaCache = invalidateQuotaCache;
 const fs_1 = __importDefault(require("fs"));
@@ -35,33 +36,6 @@ const PLAN_LIMITS = {
 const CYCLE_MS = 5 * 60 * 60 * 1000; // 5 horas en ms
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const WINDOW_5MIN = 5 * 60 * 1000; // ventana de 5 min para agrupar actividad por modelo
-/**
- * Calcula el timestamp de reset usando ventana rolling real.
- *
- * Claude Code NO usa floor(now/5h) desde epoch UTC — usa una ventana rolling
- * que empieza desde el primer mensaje del ciclo actual.
- *
- * Enfoque: buscar el primer mensaje humano en los últimos 5h de actividad.
- * resetAt = primerMensaje.ts + 5h
- *
- * Si no hay mensajes en las últimas 5h → el ciclo ya reseteó, el próximo
- * reset es en 5h desde el primer mensaje futuro (mostramos ~5h).
- */
-function computeResetAt(entries, now) {
-    const fiveHoursAgo = now - CYCLE_MS;
-    const recentHuman = entries
-        .filter(e => e.type === 'human' && e.ts >= fiveHoursAgo)
-        .sort((a, b) => a.ts - b.ts);
-    if (recentHuman.length > 0) {
-        // Usamos el PRIMER mensaje humano (más antiguo) + 5h
-        // = momento en que el primer prompt de la ventana actual expira → cuota empieza a liberarse
-        // Los mensajes tool_result de sub-agentes ya están filtrados en el caller
-        return recentHuman[0].ts + CYCLE_MS;
-    }
-    // Sin actividad en las últimas 5h → cuota ya libre, no hay reset pendiente
-    // Retornar `now` hace que cycleResetMs = 0, la UI puede mostrar "Disponible"
-    return now;
-}
 function getWeekStart(now) {
     // Lunes 00:00 hora local
     const d = new Date(now);
@@ -210,6 +184,63 @@ function readAllEntries(sinceTs) {
     catch { /* PROJECTS_DIR inaccesible */ }
     return all;
 }
+// ─── API de uso de Anthropic (datos exactos = claude.ai/settings/usage) ──────
+const USAGE_API_URL = 'https://api.anthropic.com/api/oauth/usage';
+const USAGE_API_BETA = 'oauth-2025-04-20';
+const API_CACHE_TTL = 5 * 60000; // 5 minutes
+const API_DISK_CACHE = path_1.default.join((0, paths_1.getClaudestatDir)(), 'api-cache.json');
+let apiCache = null;
+/**
+ * Llama a la API de Anthropic para obtener los % de quota exactos que muestra claude.ai.
+ * Actualiza apiCache si la llamada tiene éxito; de lo contrario, no hace nada (silent fallback).
+ * Debe llamarse periódicamente desde el daemon y al inicio del MCP server.
+ */
+async function refreshFromApi() {
+    // Shared disk cache: all processes (daemon + MCP) read/write the same file.
+    // This ensures at most 1 API call per API_CACHE_TTL across all processes.
+    try {
+        const raw = fs_1.default.readFileSync(API_DISK_CACHE, 'utf8');
+        const disk = JSON.parse(raw);
+        if (disk && Date.now() - disk.ts < API_CACHE_TTL) {
+            apiCache = disk;
+            invalidateQuotaCache();
+            return;
+        }
+    }
+    catch { /* no disk cache yet — proceed to API */ }
+    const token = (0, claude_auth_1.getOAuthAccessToken)();
+    if (!token)
+        return;
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 3000);
+        const res = await fetch(USAGE_API_URL, {
+            headers: { Authorization: `Bearer ${token}`, 'anthropic-beta': USAGE_API_BETA },
+            signal: ctrl.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok) {
+            process.stderr.write(`[claudestat] API quota fetch failed: HTTP ${res.status}\n`);
+            return;
+        }
+        const data = await res.json();
+        const fh = data.five_hour;
+        if (fh == null)
+            return;
+        apiCache = {
+            cyclePct: Math.round(fh.utilization),
+            weeklyPctAll: data.seven_day != null ? Math.round(data.seven_day.utilization) : 0,
+            cycleResetAt: fh.resets_at ? new Date(fh.resets_at).getTime() : 0,
+            ts: Date.now(),
+        };
+        try {
+            fs_1.default.writeFileSync(API_DISK_CACHE, JSON.stringify(apiCache), 'utf8');
+        }
+        catch { }
+        invalidateQuotaCache();
+    }
+    catch { /* no network or keychain — silent fallback to JSONL */ }
+}
 // ─── Caché de 30 segundos ─────────────────────────────────────────────────────
 let cache = null;
 const CACHE_TTL = 30000; // 30 segundos
@@ -225,6 +256,16 @@ function computeQuota(forcePlan) {
     if (!forcePlan && cache && now - cache.ts < CACHE_TTL) {
         return cache.data;
     }
+    // Load API data from disk cache if in-memory is stale (shared across processes)
+    if (!apiCache || now - apiCache.ts >= API_CACHE_TTL) {
+        try {
+            const raw = fs_1.default.readFileSync(API_DISK_CACHE, 'utf8');
+            const disk = JSON.parse(raw);
+            if (disk && now - disk.ts < API_CACHE_TTL)
+                apiCache = disk;
+        }
+        catch { }
+    }
     const weekStart = getWeekStart(now);
     const thirtyMinAgo = now - 30 * 60 * 1000;
     // Leer entradas relevantes (última semana + un poco más para detección de plan)
@@ -251,7 +292,7 @@ function computeQuota(forcePlan) {
     const limits = PLAN_LIMITS[plan];
     // ─ Ciclo 5h: ventana deslizante [now-5h, now] ─
     const fiveHAgo = now - CYCLE_MS;
-    const cycleResetAt = computeResetAt(entries, now);
+    const cycleResetAt = (Math.floor(now / CYCLE_MS) + 1) * CYCLE_MS; // epoch-aligned, matches claude.ai
     const cycleStart = fiveHAgo; // inicio real de la ventana de conteo
     // Basado en tokens (como claude.ai/settings/usage)
     const cycleEntries = entries.filter(e => e.ts >= fiveHAgo);
@@ -297,14 +338,20 @@ function computeQuota(forcePlan) {
     const weeklyPctAll = limits.weeklyHoursSonnet + limits.weeklyHoursOpus > 0
         ? Math.min(100, Math.round((weeklyHoursSonnet + weeklyHoursOpus) / (limits.weeklyHoursSonnet + limits.weeklyHoursOpus) * 100))
         : 0;
+    // Override with API data if fresh — matches claude.ai exactly
+    const apiFresh = apiCache != null && Date.now() - apiCache.ts < API_CACHE_TTL;
+    const resolvedCyclePct = apiFresh ? apiCache.cyclePct : cyclePct;
+    const resolvedWeeklyPctAll = apiFresh ? apiCache.weeklyPctAll : weeklyPctAll;
+    const resolvedCycleResetAt = (apiFresh && apiCache.cycleResetAt > 0) ? apiCache.cycleResetAt : cycleResetAt;
+    const resolvedCycleResetMs = Math.max(0, resolvedCycleResetAt - now);
     const data = {
         cyclePrompts: cycleEntries.filter(e => e.type === 'human').length,
         cycleLimit: limits.prompts5h,
-        cyclePct,
+        cyclePct: resolvedCyclePct,
         cycleTokens,
         cycleLimitTokens: limits.tokens5h,
-        cycleResetMs,
-        cycleResetAt,
+        cycleResetMs: resolvedCycleResetMs,
+        cycleResetAt: resolvedCycleResetAt,
         cycleStartTs: cycleStart,
         weeklyHoursSonnet,
         weeklyHoursOpus,
@@ -314,7 +361,7 @@ function computeQuota(forcePlan) {
         weeklyTokensHaiku,
         weeklyLimitSonnet: limits.weeklyHoursSonnet,
         weeklyLimitOpus: limits.weeklyHoursOpus,
-        weeklyPctAll,
+        weeklyPctAll: resolvedWeeklyPctAll,
         burnRateTokensPerMin,
         detectedPlan: plan,
         planSource,

package/dist/roast.js

@@ -2,54 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRoast = runRoast;
 const db_js_1 = require("./db.js");
-function formatMinutes(totalMinutes) {
-    if (totalMinutes < 60)
-        return `${Math.round(totalMinutes)} minutes`;
-    const hours = Math.floor(totalMinutes / 60);
-    if (hours < 24)
-        return `${hours} hours`;
-    const days = Math.floor(hours / 24);
-    return `${days} days`;
-}
 function getRoastRating(avgEfficiency) {
     if (avgEfficiency >= 90)
-        return "You're a machine. Or maybe you're just not using Claude enough. 😏";
+        return "You're a machine. Or maybe you're just not using Claude enough.";
     if (avgEfficiency >= 70)
         return "Solid. Not great, not terrible. The AI equivalent of a C+ student.";
     if (avgEfficiency >= 50)
-        return "Room for growth, champ. 📈";
-    return "Oof. That's a lot of money down the drain. Are you okay? 💀";
+        return "Room for growth, champ.";
+    return "Oof. That's a lot of money down the drain. Are you okay?";
 }
-function getRoastMessage(data) {
-    const lines = [];
-    lines.push('🔥 Your Claude Code Roast');
-    lines.push('');
+function getRoastCards(data) {
+    const cards = [];
     if (data.totalBashCalls > 0) {
         const minutesPerCall = (data.days * 24 * 60) / data.totalBashCalls;
         if (minutesPerCall < 60) {
-            lines.push(`  You called Bash ${data.totalBashCalls} times in ${data.days} days.`);
-            lines.push(`  That's once every ${minutesPerCall.toFixed(1)} minutes.`);
-            lines.push('  Are you okay?');
-            lines.push('');
+            cards.push(`  🖥️  BASH OVERLOAD\n` +
+                `  ${data.totalBashCalls} calls in ${data.days}d — once every ${minutesPerCall.toFixed(1)} min\n` +
+                `  Are you okay?`);
         }
     }
     if (data.contextHits > 0) {
-        lines.push(`  You hit 90%+ context in ${data.contextHits} sessions.`);
-        lines.push('  Claude was writing with amnesia half the time.');
-        lines.push('');
+        cards.push(`  🧠  CONTEXT AMNESIA\n` +
+            `  ${data.contextHits} sessions at 90%+ context\n` +
+            `  Claude was writing with amnesia half the time.`);
     }
     if (data.totalLoops > 0) {
         const loopCost = data.totalCost * 0.15;
-        lines.push(`  You spent $${loopCost.toFixed(2)} on loops you never noticed.`);
         const coffees = Math.floor(loopCost / 0.3);
-        if (coffees > 0) {
-            lines.push(`  That's ${coffees} coffees. Just saying.`);
-            lines.push('');
-        }
+        cards.push(`  🔄  LOOP MONEY PIT\n` +
+            `  $${loopCost.toFixed(2)} wasted on loops${coffees > 0 ? ` — that's ${coffees} coffees` : ''}\n` +
+            `  Just saying.`);
     }
-    lines.push(`  Efficiency score: ${Math.round(data.avgEfficiency)}/100`);
-    lines.push(`  ${getRoastRating(data.avgEfficiency)}`);
-    return lines.join('\n');
+    return cards;
 }
 async function runRoast(opts) {
     const days = opts.months ?? 30;
@@ -58,8 +42,10 @@ async function runRoast(opts) {
     let totalBashCalls = 0;
     let totalLoops = 0;
     let contextHits = 0;
+    let totalTokens = 0;
     for (const session of sessions) {
         totalLoops += session.loops_detected || 0;
+        totalTokens += (session.total_input_tokens || 0) + (session.total_output_tokens || 0) + (session.total_cache_read || 0);
         if ((session.total_input_tokens || 0) + (session.total_output_tokens || 0) > 150000) {
             contextHits++;
         }
@@ -71,6 +57,10 @@ async function runRoast(opts) {
     const avgEfficiency = sessions.length > 0
         ? sessions.reduce((a, s) => a + (s.efficiency_score || 0), 0) / sessions.length
         : 100;
+    const avgCostPerSession = sessions.length > 0 ? totalCost / sessions.length : 0;
+    const topTools = db_js_1.dbOps.getTopTools(days, 'cost', 1);
+    const topTool = topTools[0]?.tool_name ?? 'Unknown';
+    const topToolPct = totalCost > 0 ? Math.round((topTools[0]?.total_cost_usd ?? 0) / totalCost * 100) : 0;
     const data = {
         totalCost,
         totalSessions: sessions.length,
@@ -79,17 +69,116 @@ async function runRoast(opts) {
         avgEfficiency,
         contextHits,
         days,
+        totalTokens,
+        avgCostPerSession,
+        topTool,
+        topToolPct,
+    };
+    const R = '\x1b[0m';
+    const B = '\x1b[1m';
+    const D = '\x1b[2m';
+    const G = '\x1b[32m';
+    const Y = '\x1b[33m';
+    const C = '\x1b[36m';
+    const M = '\x1b[35m';
+    const bar = (pct, width = 20) => {
+        const filled = Math.round(Math.min(pct, 100) / 100 * width);
+        const color = pct >= 90 ? '\x1b[31m' : pct >= 70 ? '\x1b[33m' : '\x1b[32m';
+        return `${color}${'█'.repeat(filled)}${R}${D}${'░'.repeat(width - filled)}${R}`;
+    };
+    const fmtTok = (n) => {
+        if (n >= 1000000)
+            return `${(n / 1000000).toFixed(1)}M`;
+        if (n >= 1000)
+            return `${Math.round(n / 1000)}K`;
+        return n.toString();
     };
     if (opts.stats) {
-        console.log(`=== Claude Code Stats (${days} days) ===`);
-        console.log(`Sessions: ${sessions.length}`);
-        console.log(`Total cost: $${totalCost.toFixed(2)}`);
-        console.log(`Bash calls: ${totalBashCalls}`);
-        console.log(`Loops: ${totalLoops}`);
-        console.log(`Effficiency: ${Math.round(avgEfficiency)}/100`);
+        const effPct = Math.round(avgEfficiency);
+        const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+        const padVisual = (s, target) => {
+            const visible = stripAnsi(s).length;
+            return s + ' '.repeat(Math.max(0, target - visible));
+        };
+        const rows = [
+            { label: 'Sessions', value: `${B}${sessions.length}${R}`, barPct: Math.min(sessions.length / 50 * 100, 100) },
+            { label: 'Total cost', value: `${B}$${totalCost.toFixed(2)}${R}`, barPct: Math.min(totalCost / 200 * 100, 100) },
+            { label: 'Bash calls', value: `${B}${totalBashCalls}${R}`, barPct: Math.min(totalBashCalls / 500 * 100, 100) },
+            { label: 'Loops', value: `${B}${totalLoops}${R}`, barPct: Math.min(totalLoops / 200 * 100, 100) },
+            { label: 'Efficiency', value: `${B}${effPct}/100${R}`, barPct: effPct },
+        ];
+        const lines = [];
+        lines.push(`\n${B}📊 Claude Code Stats${R}  ${D}(${days} days)${R}`);
+        lines.push('━'.repeat(42));
+        lines.push('');
+        for (let i = 0; i < rows.length; i++) {
+            const r = rows[i];
+            const labelCol = `  ${r.label}`.padEnd(14);
+            const valueCol = padVisual(r.value, 12);
+            lines.push(`${labelCol}${valueCol}${bar(r.barPct)}`);
+            if (i < rows.length - 1)
+                lines.push('');
+        }
+        lines.push('');
+        console.log(lines.join('\n'));
         return;
     }
-    console.log(getRoastMessage(data));
-    console.log('');
-    console.log('  github.com/DeibyGS/claudestat');
+    const rating = Math.round(avgEfficiency);
+    const stars = rating >= 90 ? '★★★★★' : rating >= 70 ? '★★★★☆' : rating >= 50 ? '★★★☆☆' : '★★☆☆☆';
+    const lines = [];
+    lines.push(`\n${B}🔥 Your Claude Code Roast${R}  ${D}(${days} days)${R}`);
+    lines.push('━'.repeat(44));
+    lines.push('');
+    lines.push(`  ${B}Score${R}  ${bar(rating)}  ${B}${rating}/100${R}  ${Y}${stars}${R}`);
+    lines.push('');
+    lines.push(`  ${B}Scorecard${R}`);
+    lines.push(`  ┌─────────────────┬──────────────┬──────────────┐`);
+    lines.push(`  │ ${D}Metric${R}            │ ${D}Value${R}          │ ${D}Rating${R}         │`);
+    lines.push(`  ├─────────────────┼──────────────┼──────────────┤`);
+    const sessionLabel = `${data.totalSessions}`;
+    const sessionRating = data.totalSessions > 30 ? `${Y}prolific${R}` : `${G}normal${R}`;
+    lines.push(`  │ Sessions        │ ${sessionLabel.padEnd(12)} │ ${sessionRating}`.padEnd(46) + '│');
+    const costLabel = `$${totalCost.toFixed(2)}`;
+    const costRating = totalCost > 100 ? `${Y}💸 burning${R}` : totalCost > 20 ? `${G}reasonable${R}` : `${G}frugal${R}`;
+    lines.push(`  │ Total cost      │ ${costLabel.padEnd(12)} │ ${costRating}`.padEnd(46) + '│');
+    const avgLabel = `$${avgCostPerSession.toFixed(2)}/session`;
+    const avgRating = avgCostPerSession > 10 ? `${Y}expensive${R}` : `${G}efficient${R}`;
+    lines.push(`  │ Avg/session     │ ${avgLabel.padEnd(12)} │ ${avgRating}`.padEnd(46) + '│');
+    const bashLabel = `${totalBashCalls}`;
+    const bashRating = totalBashCalls > 200 ? `${Y}🔨 overload${R}` : `${G}normal${R}`;
+    lines.push(`  │ Bash calls      │ ${bashLabel.padEnd(12)} │ ${bashRating}`.padEnd(46) + '│');
+    const loopLabel = `${totalLoops}`;
+    const loopRating = totalLoops > 50 ? `${Y}🔄 looping${R}` : `${G}clean${R}`;
+    lines.push(`  │ Loops           │ ${loopLabel.padEnd(12)} │ ${loopRating}`.padEnd(46) + '│');
+    const effLabel = `${Math.round(avgEfficiency)}/100`;
+    const effRating = avgEfficiency >= 90 ? `${G}🏆 elite${R}` : avgEfficiency >= 70 ? `${Y}decent${R}` : `${Y}needs work${R}`;
+    lines.push(`  │ Efficiency      │ ${effLabel.padEnd(12)} │ ${effRating}`.padEnd(46) + '│');
+    const tokLabel = fmtTok(totalTokens);
+    lines.push(`  │ Tokens          │ ${tokLabel.padEnd(12)} │ ${D}—${R}`.padEnd(46) + '│');
+    const toolLabel = `${topTool} ${topToolPct}%`;
+    lines.push(`  │ Top tool        │ ${toolLabel.padEnd(12)} │ ${D}—${R}`.padEnd(46) + '│');
+    lines.push(`  └─────────────────┴──────────────┴──────────────┘`);
+    lines.push('');
+    const cards = getRoastCards(data);
+    if (cards.length > 0) {
+        lines.push(`  ${B}Roast Cards${R}`);
+        lines.push('');
+        for (const card of cards) {
+            const cardLines = card.split('\n');
+            const maxLen = Math.max(...cardLines.map(l => l.length));
+            lines.push(`  ┌${'─'.repeat(maxLen + 2)}┐`);
+            for (const cl of cardLines) {
+                lines.push(`  │ ${cl.padEnd(maxLen)} │`);
+            }
+            lines.push(`  └${'─'.repeat(maxLen + 2)}┘`);
+            lines.push('');
+        }
+    }
+    lines.push(`  ${B}Verdict${R}`);
+    lines.push(`  ${getRoastRating(avgEfficiency)}`);
+    lines.push('');
+    lines.push('━'.repeat(44));
+    lines.push(`  ${D}github.com/DeibyGS/claudestat${R}`);
+    lines.push('');
+    console.log(lines.join('\n'));
 }

package/dist/routes/events.js

@@ -267,6 +267,6 @@ exports.onCostUpdate = onCostUpdate;
 // ─── Callback de auto-compact ────────────────────────────────────────────────
 const onCompactDetected = (sessionId) => {
     (0, stream_1.broadcast)({ type: 'compact_detected', payload: { session_id: sessionId, ts: Date.now() } });
-    console.log(`[daemon] Auto-compact detectado para sesión ${sessionId.slice(0, 8)}`);
+    console.log(`[daemon] Auto-compact detected for session ${sessionId.slice(0, 8)}`);
 };
 exports.onCompactDetected = onCompactDetected;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.2.0",
+  "version": "1.2.3",
   "description": "Observability layer for Claude Code — live token tracking, cost analytics, quota guard, loop detection, and usage dashboard. The htop for Claude Code.",
   "keywords": [
     "claude-code",