@statforge/claudestat 1.0.1 → 1.1.1

package/README.md

@@ -12,7 +12,7 @@ Works with Claude Pro, Max 5, and Max 20. Zero cloud dependencies. Pure Node.js.
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D22-brightgreen)](https://nodejs.org)
 [![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows-brightgreen)]()
-[![Tests](https://img.shields.io/badge/tests-208%2F208-brightgreen)]()
+[![Tests](https://img.shields.io/badge/tests-214%2F214-brightgreen)]()
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](CONTRIBUTING.md)
 
 [Installation](#installation) • [Quick Start](#quick-start) • [Commands](#commands) • [Dashboard](#dashboard) • [Contributing](#contributing)
@@ -33,6 +33,8 @@ Works with Claude Pro, Max 5, and Max 20. Zero cloud dependencies. Pure Node.js.
 
 ## Why?
 
+You're burning tokens right now and you have no idea how many, on what, or whether Claude is stuck in a loop.
+
 Claude Code is powerful — but it's a black box while it runs. You can't see what it's spending, how deep the context is, whether it's looping, or if you're about to hit your quota limit.
 
 **claudestat fixes that.** It taps into Claude Code's hook system to capture every event, stores it locally in SQLite, and shows you everything in a live dashboard or terminal trace.
@@ -43,6 +45,8 @@ Claude Code is powerful — but it's a black box while it runs. You can't see wh
 - Per-session cost breakdown + cache savings + burn rate
 - AI-generated weekly usage reports
 
+> If claudestat is useful, give it a ⭐ — it helps other developers find it.
+
 ---
 
 ## How it works
@@ -133,9 +137,12 @@ That's it. Start a Claude Code session and watch the events flow in.
 | `claudestat uninstall` | Remove hooks from Claude Code |
 | `claudestat watch` | Live terminal trace view |
 | `claudestat status` | Show quota, cost, and burn rate |
+| `claudestat status --compact` | One-line output for tmux status bar |
 | `claudestat config` | View or edit configuration |
 | `claudestat top` | Rank tools by cost, call count, or duration |
 | `claudestat export [format]` | Export session data to JSON or CSV |
+| `claudestat share [session-id]` | Generate shareable session card (ASCII/JSON) |
+| `claudestat roast` | Sarcastic usage analysis with roast jokes |
 | `claudestat doctor` | Check installation health and diagnose issues |
 
 ### `claudestat watch`
@@ -187,6 +194,68 @@ claudestat status
   Burn rate   1,240 tok/min
 ```
 
+### `claudestat status --compact`
+
+One-line output for tmux status bar or scripting. Shows the 5h cycle quota percentage.
+
+```bash
+claudestat status --compact
+Current 45%🟡 pro
+```
+
+### `claudestat share`
+
+Generate a shareable session card — perfect for sharing on social media or in bug reports.
+
+```bash
+claudestat share
+╔═══════════════════════════════════╗
+║     Session Report · claudestat   ║
+╠═══════════════════════════════════╣
+║  Project     my-project          ║
+║  Duration   2h 14m               ║
+║  Tools      847 calls            ║
+║  Cost       $0.84                ║
+║  Cache hit  27% saved ($0.31)    ║
+║  Top tool  Bash (38%)            ║
+║  Efficiency 91 / 100             ║
+╚═══════════════════════════════════╝
+  github.com/DeibyGS/claudestat
+```
+
+Options:
+- `--format ascii|json` — output format (default: ascii)
+- `--copy` — copy to clipboard automatically (macOS only)
+
+### `claudestat roast`
+
+Get a sarcastic analysis of your Claude Code usage — humor with insights.
+
+```bash
+claudestat roast
+
+=== Claude Code Stats (last 30 days) ===
+Sessions: 47
+Total cost: $12.40
+Bash calls: 1,240
+Loops: 8
+Efficiency: 72/100
+
+🔥 Your Claude Code Roast
+
+  You called Bash 1,240 times last month.
+  That's once every 2.3 minutes.
+  Are you okay?
+
+  You hit 90%+ context in 12 sessions.
+  Claude was writing with amnesia half the time.
+
+  You spent $4.20 on loops you never noticed.
+  That's 14 coffees. Just saying.
+
+  Efficiency: 72/100 — room for growth, champ.
+```
+
 ### `claudestat doctor`
 
 Diagnoses common installation problems — useful if `claudestat start` fails or hooks are not firing.
@@ -432,6 +501,33 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for full guidelines.
 
 ---
 
+## FAQ
+
+**What is claudestat?**
+claudestat is a real-time token monitoring and cost analytics tool for Claude Code.
+It captures every tool call, token usage, and API cost as it happens — locally, with zero cloud dependencies.
+
+**How do I monitor Claude Code token usage?**
+Install with `npm install -g @statforge/claudestat`, run `claudestat start`, and open `http://localhost:7337` for the live dashboard.
+
+**How do I track Claude Code costs?**
+claudestat records every session's token usage and estimates API cost per tool call.
+Use `claudestat status` for a quick summary or `claudestat export` for full data export.
+
+**How do I get alerted when Claude Code hits the rate limit?**
+claudestat polls your quota every 60 seconds and sends desktop notifications when you cross 70%, 85%, or 95%. Configure with `claudestat config --alerts true`.
+
+**Does claudestat work with Claude Pro, Max 5, and Max 20?**
+Yes. claudestat auto-detects your plan. You can also force it with `claudestat config --plan max5`.
+
+**Is my data sent to any server?**
+No. All data is stored locally in SQLite at `~/.claudestat/`. Zero cloud dependencies.
+
+**Does claudestat work on Windows?**
+Yes — macOS, Linux, and Windows are all supported.
+
+---
+
 ## License
 
 MIT — use it, fork it, ship it.

package/dist/daemon.js

@@ -79,7 +79,7 @@ function migrateSessionProjects() {
     const sessions = db_1.dbOps.getAllSessions();
     let tagged = 0;
     for (const session of sessions) {
-        if (session.project_path)
+        if (session?.project_path)
             continue;
         const events = db_1.dbOps.getSessionEvents(session.id);
         const projectCwd = (0, projects_1.inferProjectCwd)(events);
@@ -97,7 +97,7 @@ function migrateSessionProjects() {
  */
 async function migrateSessionSummaries(limit = 5) {
     const sessions = db_1.dbOps.getAllSessions()
-        .filter(s => !s.ai_summary)
+        .filter(s => !s?.ai_summary)
         .slice(0, limit);
     for (const s of sessions) {
         try {
@@ -192,8 +192,10 @@ function startDaemon() {
     _server = app.listen(PORT, '127.0.0.1', () => {
         writePid();
         process.on('exit', cleanPid);
-        process.on('SIGTERM', () => { shutdown(_server); process.exit(0); });
-        process.on('SIGINT', () => { shutdown(_server); process.exit(0); });
+        process.on('SIGTERM', () => { if (_server)
+            shutdown(_server); process.exit(0); });
+        process.on('SIGINT', () => { if (_server)
+            shutdown(_server); process.exit(0); });
         console.log(`\n● claudestat daemon  →  http://localhost:${PORT}`);
         console.log(`  Waiting for Claude Code events...\n`);
         console.log(`  In another terminal: \x1b[36mclaudestat watch\x1b[0m\n`);

package/dist/enricher.js

@@ -32,13 +32,7 @@ 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'];
+const pricing_1 = require("./pricing");
 // ─── Context window dinámico ──────────────────────────────────────────────────
 const KNOWN_CONTEXT_WINDOWS = {
     'claude-opus-4-6': 200000,
@@ -48,16 +42,8 @@ const KNOWN_CONTEXT_WINDOWS = {
 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 fileLocks = new Map(); // Lock per file
 const FILE_OFFSET_TTL = 30 * 60000; // 30 minutos
 function cleanupStaleOffsets() {
     const now = Date.now();
@@ -67,6 +53,10 @@ function cleanupStaleOffsets() {
     }
 }
 async function processJSONL(filePath) {
+    // Skip if already processing this file
+    if (fileLocks.has(filePath))
+        return null;
+    fileLocks.set(filePath, Promise.resolve());
     let fileContent;
     try {
         fileContent = await promises_1.default.readFile(filePath, 'utf8');
@@ -99,27 +89,27 @@ async function processJSONL(filePath) {
             if (obj.type !== 'assistant')
                 continue;
             const msg = obj.message;
-            const usage = msg?.usage;
-            const model = msg?.model ?? undefined;
-            if (!usage)
+            if (!msg?.usage)
                 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();
                 }
-                catch { }
+                catch (e) { /* ignore invalid timestamp */ }
             }
             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.cost_usd += (0, pricing_1.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 price = pricing_1.PRICING[resolvedModel] ?? pricing_1.DEFAULT_PRICING;
             const M = 1000000;
             lastInputUsd = ((usage.input_tokens ?? 0) * price.input +
                 (usage.cache_read_input_tokens ?? 0) * price.cacheRead +
@@ -129,7 +119,9 @@ async function processJSONL(filePath) {
             lastOutputTokens = usage.output_tokens ?? 0;
             lastModel = model ?? lastModel;
         }
-        catch { }
+        catch (e) {
+            console.warn('[enricher] Error calculating cost:', e);
+        }
     }
     if (lastInputUsd + lastOutputUsd > 0) {
         totals.lastEntry = {
@@ -143,14 +135,21 @@ async function processJSONL(filePath) {
     totals.lastModel = lastModel;
     totals.firstTs = firstTs;
     fileOffsets.set(filePath, { offset: currentSize, lastAccess: Date.now() });
+    fileLocks.delete(filePath);
     return totals;
 }
 const blockCostCache = new Map();
+const costCacheLocks = new Map(); // Simple lock flag
 const BLOCK_COST_TTL = 5 * 60000;
 async function getAllBlockCostsForSession(sessionId) {
+    // Return cached if available and not expired
     const cached = blockCostCache.get(sessionId);
     if (cached && Date.now() - cached.ts < BLOCK_COST_TTL)
         return cached.data;
+    // Skip if already calculating for this session
+    if (costCacheLocks.get(sessionId))
+        return cached?.data ?? [];
+    costCacheLocks.set(sessionId, true);
     try {
         if (!fs_1.default.existsSync(PROJECTS_DIR))
             return [];
@@ -199,7 +198,7 @@ async function getAllBlockCostsForSession(sessionId) {
                         const model = obj.message?.model ?? 'claude-sonnet-4-6';
                         if (!usage)
                             continue;
-                        const price = PRICING[model] ?? DEFAULT_PRICING;
+                        const price = pricing_1.PRICING[model] ?? pricing_1.DEFAULT_PRICING;
                         const M = 1000000;
                         const inUsd = ((usage.input_tokens ?? 0) * price.input +
                             (usage.cache_read_input_tokens ?? 0) * price.cacheRead +
@@ -214,15 +213,22 @@ async function getAllBlockCostsForSession(sessionId) {
                         current.outputTokens += outTok;
                     }
                 }
-                catch { }
+                catch (e) {
+                    console.warn('[enricher] Error reading JSONL block:', e);
+                }
             }
             const filtered = result.filter(b => b.totalUsd > 0);
             blockCostCache.set(sessionId, { data: filtered, ts: Date.now() });
             return filtered;
         }
     }
-    catch { }
-    return [];
+    catch (e) {
+        console.warn('[enricher] Error calculating block costs:', e);
+    }
+    finally {
+        costCacheLocks.delete(sessionId);
+    }
+    return cached?.data ?? [];
 }
 async function getSessionPrompts(sessionId) {
     try {

package/dist/index.js

@@ -27,6 +27,8 @@ const install_1 = require("./install");
 const export_1 = require("./export");
 const config_1 = require("./config");
 const doctor_1 = require("./doctor");
+const share_1 = require("./share");
+const roast_1 = require("./roast");
 const paths_1 = require("./paths");
 const program = new commander_1.Command();
 const PKG_VERSION = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -144,6 +146,7 @@ program
     .command('status')
     .description('Show current quota, cost and burn rate')
     .option('--json', 'Output raw JSON instead of formatted text')
+    .option('--compact', 'One-line output for tmux')
     .action(async (opts) => {
     try {
         const [quotaRes, healthRes] = await Promise.all([
@@ -154,6 +157,12 @@ program
             throw new Error('Daemon unavailable');
         const q = await quotaRes.json();
         const _h = await healthRes.json().catch(() => ({}));
+        if (opts.compact) {
+            const pctCycle = q.cyclePct;
+            const cycleEmoji = pctCycle >= 95 ? '🔴' : pctCycle >= 70 ? '🟡' : '🟢';
+            console.log(`Current ${pctCycle}%${cycleEmoji} ${q.detectedPlan}`);
+            process.exit(0);
+        }
         if (opts.json) {
             console.log(JSON.stringify({
                 cyclePrompts: q.cyclePrompts,
@@ -167,7 +176,7 @@ program
                 weeklyLimitOpus: q.weeklyLimitOpus,
                 burnRateTokensPerMin: q.burnRateTokensPerMin,
             }));
-            return;
+            process.exit(0);
         }
         const R = '\x1b[0m';
         const pctColor = q.cyclePct >= 95 ? '\x1b[31m'
@@ -316,4 +325,37 @@ program
     console.error('\n❌ Error:', err.message);
     process.exit(1);
 }));
+program
+    .command('share [session-id]')
+    .description('Generate a shareable session card (ASCII or JSON)')
+    .option('--format <type>', 'Output format: ascii, json (default: ascii)')
+    .option('--copy', 'Copy to clipboard (macOS only)')
+    .action(async (sessionId, opts) => {
+    try {
+        const format = (opts.format ?? 'ascii');
+        const copy = !!opts.copy;
+        await (0, share_1.runShare)({ sessionId, format, copy });
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('\n❌ Error:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('roast')
+    .description('Roast your Claude Code usage habits')
+    .option('--stats', 'Show raw stats only, no roast')
+    .option('--months <n>', 'Look back N months (default: 1)', String, '1')
+    .action(async (opts) => {
+    try {
+        const months = parseInt(opts.months || '1', 10);
+        await (0, roast_1.runRoast)({ stats: !!opts.stats, months });
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('\n❌ Error:', err.message);
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/pricing.d.ts

@@ -0,0 +1,20 @@
+/**
+ * pricing.ts — Model pricing constants and cost calculation
+ *
+ * Centralized pricing data to avoid duplication across enricher.ts and project-scanner.ts.
+ * Prices are in USD per million tokens.
+ */
+export interface ModelPricing {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreate: number;
+}
+export declare const PRICING: Record<string, ModelPricing>;
+export declare const DEFAULT_PRICING: ModelPricing;
+export declare function calcCost(model: string, usage: {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+    cache_creation_input_tokens: number;
+}): number;

package/dist/pricing.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * pricing.ts — Model pricing constants and cost calculation
+ *
+ * Centralized pricing data to avoid duplication across enricher.ts and project-scanner.ts.
+ * Prices are in USD per million tokens.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRICING = exports.PRICING = void 0;
+exports.calcCost = calcCost;
+exports.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 },
+};
+exports.DEFAULT_PRICING = exports.PRICING['claude-sonnet-4-6'];
+function calcCost(model, usage) {
+    const price = exports.PRICING[model] ?? exports.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);
+}

package/dist/project-scanner.js

@@ -19,6 +19,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const paths_1 = require("./paths");
+const pricing_1 = require("./pricing");
 // ─── Decode ───────────────────────────────────────────────────────────────────
 /**
  * Decodifica el nombre de directorio de Claude Code al path real.
@@ -143,22 +144,6 @@ function parseHandoffProgress(content) {
 }
 // ─── JSONL stats (datos históricos sin daemon) ────────────────────────────────
 const PROJECTS_DIR = path_1.default.join((0, paths_1.getClaudeDir)(), 'projects');
-// Precios en USD por millón de tokens (misma tabla que enricher.ts)
-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'];
-function calcCost(model, usage) {
-    const p = PRICING[model] ?? DEFAULT_PRICING;
-    const M = 1000000;
-    return ((usage.input_tokens * p.input) / M +
-        (usage.output_tokens * p.output) / M +
-        (usage.cache_read_input_tokens * p.cacheRead) / M +
-        (usage.cache_creation_input_tokens * p.cacheCreate) / M);
-}
 /**
  * Lee todos los JSONL del directorio codificado de un proyecto y acumula
  * tokens y coste. No requiere que el daemon haya estado corriendo.
@@ -196,7 +181,7 @@ function getJSONLStats(encodedDir) {
                             continue;
                         hasAssistant = true;
                         const tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-                        totalCost += calcCost(model, usage);
+                        totalCost += (0, pricing_1.calcCost)(model, usage);
                         totalTokens += tokens;
                         if (model.includes('opus'))
                             modelUsage.opusTokens += tokens;
@@ -314,7 +299,7 @@ function getJSONLStatsByProject(dirPath) {
                         continue;
                     hasAssistant = true;
                     const t = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-                    cost += calcCost(model, usage);
+                    cost += (0, pricing_1.calcCost)(model, usage);
                     tokens += t;
                     if (model.includes('opus'))
                         mu.opusTokens += t;

package/dist/quota-tracker.d.ts

@@ -19,6 +19,8 @@ export interface QuotaData {
     cyclePrompts: number;
     cycleLimit: number;
     cyclePct: number;
+    cycleTokens: number;
+    cycleLimitTokens: number;
     cycleResetMs: number;
     cycleResetAt: number;
     cycleStartTs: number;

package/dist/quota-tracker.js

@@ -26,10 +26,10 @@ const path_1 = __importDefault(require("path"));
 const claude_auth_1 = require("./claude-auth");
 const paths_1 = require("./paths");
 const PLAN_LIMITS = {
-    free: { prompts5h: 10, weeklyHoursSonnet: 40, weeklyHoursOpus: 0 },
-    pro: { prompts5h: 45, weeklyHoursSonnet: 80, weeklyHoursOpus: 0 },
-    max5: { prompts5h: 225, weeklyHoursSonnet: 280, weeklyHoursOpus: 35 },
-    max20: { prompts5h: 900, weeklyHoursSonnet: 480, weeklyHoursOpus: 40 },
+    free: { prompts5h: 10, tokens5h: 100000, weeklyHoursSonnet: 40, weeklyHoursOpus: 0 },
+    pro: { prompts5h: 45, tokens5h: 382000, weeklyHoursSonnet: 80, weeklyHoursOpus: 0 },
+    max5: { prompts5h: 225, tokens5h: 2000000, weeklyHoursSonnet: 280, weeklyHoursOpus: 35 },
+    max20: { prompts5h: 900, tokens5h: 8000000, weeklyHoursSonnet: 480, weeklyHoursOpus: 40 },
 };
 // ─── Helpers de ventanas temporales ──────────────────────────────────────────
 const CYCLE_MS = 5 * 60 * 60 * 1000; // 5 horas en ms
@@ -253,8 +253,10 @@ function computeQuota(forcePlan) {
     const fiveHAgo = now - CYCLE_MS;
     const cycleResetAt = computeResetAt(entries, now);
     const cycleStart = fiveHAgo; // inicio real de la ventana de conteo
-    const cyclePrompts = entries.filter(e => e.type === 'human' && e.ts >= fiveHAgo).length;
-    const cyclePct = Math.min(100, Math.round(cyclePrompts / limits.prompts5h * 100));
+    // Basado en tokens (como claude.ai/settings/usage)
+    const cycleEntries = entries.filter(e => e.ts >= fiveHAgo);
+    const cycleTokens = cycleEntries.reduce((sum, e) => sum + (e.inputTokens ?? 0) + (e.outputTokens ?? 0), 0);
+    const cyclePct = Math.min(100, Math.round(cycleTokens / limits.tokens5h * 100));
     const cycleResetMs = Math.max(0, cycleResetAt - now);
     // ─ Semanal por modelo: ventanas de 5 min con actividad ─
     // Contamos ventanas de 5 min distintas con al menos 1 respuesta por modelo
@@ -292,9 +294,11 @@ function computeQuota(forcePlan) {
         ? Math.round(totalRecentTok / 30)
         : 0;
     const data = {
-        cyclePrompts,
+        cyclePrompts: cycleEntries.filter(e => e.type === 'human').length,
         cycleLimit: limits.prompts5h,
         cyclePct,
+        cycleTokens,
+        cycleLimitTokens: limits.tokens5h,
         cycleResetMs,
         cycleResetAt,
         cycleStartTs: cycleStart,

package/dist/render.d.ts

@@ -51,5 +51,6 @@ export interface RenderState {
     events: TraceEvent[];
     cost?: CostInfo;
     weekly?: WeeklyStats;
+    cyclePct?: number;
 }
 export declare function renderTrace(state: RenderState): string;

package/dist/render.js

@@ -136,10 +136,10 @@ function renderTrace(state) {
         const remaining = 100 - pct;
         lines.push(`  ${C.dim}auto-compact en:${C.reset} ${bar}  ` +
             `${barColor}${remaining}% restante${C.reset}  ` +
-            `${C.dim}${fmtTok(cost.context_used)} / ${fmtTok(cost.context_window)} tokens usados${C.reset}`);
+            `${C.dim}${fmtTok(cost.context_used)} / ${fmtTok(cost.context_window)} tokens used${C.reset}`);
     }
     else {
-        lines.push(`  ${C.dim}contexto: calculando...${C.reset}`);
+        lines.push(`  ${C.dim}context: calculating...${C.reset}`);
     }
     lines.push(C.dim + '─'.repeat(72) + C.reset);
     // ── Bloques de respuesta ──────────────────────────────────────────────────
@@ -199,20 +199,25 @@ function renderTrace(state) {
         const score = (cost.efficiency_score === 0 && cost.cost_usd < 0.001) ? 100 : cost.efficiency_score;
         const scoreColor = score >= 90 ? C.green : score >= 70 ? C.yellow : C.red;
         const scoreBar = progressBar(score, 14, scoreColor);
+        // Barra de current cycle (5h quota)
+        const cyclePct = state.cyclePct ?? 0;
+        const pctColor = cyclePct >= 90 ? C.red : cyclePct >= 70 ? C.yellow : C.green;
+        const pctBar = progressBar(cyclePct, 7, pctColor);
         // Tokens
         const tokenLine = `${C.dim}↑${C.reset}${fmtTok(cost.input_tokens)} ` +
             `${C.dim}↓${C.reset}${fmtTok(cost.output_tokens)} ` +
             `${C.dim}🗄${C.reset}${fmtTok(cost.cache_read)}`;
         lines.push(`  ${C.bold}💰 $${cost.cost_usd.toFixed(4)}${C.reset}   ` +
             `${tokenLine}   ` +
-            `eficiencia: ${scoreBar} ${scoreColor}${score}/100${C.reset}`);
+            `current: ${pctBar} ${pctColor}${cyclePct}%  |  efficiency: ${scoreBar} ${scoreColor}${score}/100${C.reset}`);
     }
     else {
         const totalDone = events.filter(e => e.type === 'Done').length;
         const elapsed = fmtMs((events.at(-1)?.ts ?? startedAt) - startedAt);
-        lines.push(`  ${C.dim}⏱ ${elapsed}  ✅ ${totalDone} tools  💰 calculando...${C.reset}`);
+        const cyclePct = state.cyclePct ?? 0;
+        lines.push(`  ${C.dim}⏱ ${elapsed}  ✅ ${totalDone} tools  💰 calculating... current: ${cyclePct}%${C.reset}`);
     }
-    // ── Barra semanal (stats-cache.json) ──────────────────────────────────────
+    // ── Weekly bar (stats-cache.json) ──────────────────────────────────────
     if (state.weekly && state.weekly.totalTokens > 0) {
         const { totalTokens, byDay, lastUpdated } = state.weekly;
         // Mini sparkline: un char por día de la semana
@@ -220,9 +225,9 @@ function renderTrace(state) {
         const BARS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
         const spark = byDay.map(d => BARS[Math.min(7, Math.floor(d.tokens / maxDay * 7))]).join('');
         const padded = spark.padStart(7, '▁'); // garantizar 7 chars (1 por día)
-        lines.push(`  ${C.dim}semanal:${C.reset}  ${C.cyan}${padded}${C.reset}  ` +
+        lines.push(`  ${C.dim}weekly:${C.reset}  ${C.cyan}${padded}${C.reset}  ` +
             `${C.bold}${fmtTok(totalTokens)} tokens${C.reset}  ` +
-            `${C.dim}(últimos 7 días${lastUpdated ? ' · datos al ' + lastUpdated : ''})${C.reset}`);
+            `${C.dim}(last 7 days${lastUpdated ? ' · data from ' + lastUpdated : ''})${C.reset}`);
     }
     lines.push('');
     return lines.join('\n');

package/dist/roast.d.ts

@@ -0,0 +1,4 @@
+export declare function runRoast(opts: {
+    stats: boolean;
+    months: number;
+}): Promise<void>;

package/dist/roast.js

@@ -0,0 +1,95 @@
+"use strict";
+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. 😏";
+    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? 💀";
+}
+function getRoastMessage(data) {
+    const lines = [];
+    lines.push('🔥 Your Claude Code Roast');
+    lines.push('');
+    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('');
+        }
+    }
+    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('');
+    }
+    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('');
+        }
+    }
+    lines.push(`  Efficiency score: ${Math.round(data.avgEfficiency)}/100`);
+    lines.push(`  ${getRoastRating(data.avgEfficiency)}`);
+    return lines.join('\n');
+}
+async function runRoast(opts) {
+    const days = opts.months ?? 30;
+    const sinceMs = Date.now() - days * 24 * 60 * 60 * 1000;
+    const sessions = db_js_1.dbOps.getAllSessions(500).filter(s => s.started_at >= sinceMs);
+    let totalBashCalls = 0;
+    let totalLoops = 0;
+    let contextHits = 0;
+    for (const session of sessions) {
+        totalLoops += session.loops_detected || 0;
+        if ((session.total_input_tokens || 0) + (session.total_output_tokens || 0) > 150000) {
+            contextHits++;
+        }
+        const events = db_js_1.dbOps.getSessionEvents(session.id);
+        const bashCalls = events.filter(e => e.type === 'Done' && e.tool_name === 'Bash').length;
+        totalBashCalls += bashCalls;
+    }
+    const totalCost = sessions.reduce((a, s) => a + (s.total_cost_usd || 0), 0);
+    const avgEfficiency = sessions.length > 0
+        ? sessions.reduce((a, s) => a + (s.efficiency_score || 0), 0) / sessions.length
+        : 100;
+    const data = {
+        totalCost,
+        totalSessions: sessions.length,
+        totalBashCalls,
+        totalLoops,
+        avgEfficiency,
+        contextHits,
+        days,
+    };
+    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`);
+        return;
+    }
+    console.log(getRoastMessage(data));
+    console.log('');
+    console.log('  github.com/DeibyGS/claudestat');
+}

package/dist/routes/events.js

@@ -93,7 +93,7 @@ exports.eventsRouter.post('/event', (req, res) => {
         // Activar skill parent para los eventos siguientes si este fue un Skill Done
         if (tool_name === 'Skill') {
             try {
-                const inp = typeof tool_input === 'object' ? tool_input : JSON.parse(tool_input ?? '{}');
+                const inp = typeof tool_input === 'object' ? tool_input : (typeof tool_input === 'string' ? JSON.parse(tool_input) : {});
                 activeSkillBySession.set(session_id, inp?.skill || inp?.name || 'skill');
             }
             catch {
@@ -123,9 +123,9 @@ exports.eventsRouter.post('/event', (req, res) => {
     const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep']);
     if (FILE_TOOLS.has(tool_name || '') && tool_input) {
         try {
-            const inp = typeof tool_input === 'string' ? JSON.parse(tool_input) : tool_input;
-            const filePath = (inp.file_path || inp.path);
-            if (filePath?.startsWith('/')) {
+            const inp = typeof tool_input === 'string' ? JSON.parse(tool_input) : (tool_input ?? {});
+            const filePath = inp?.file_path ?? inp?.path;
+            if (typeof filePath === 'string' && filePath.startsWith('/')) {
                 const projectCwd = findProjectCwdForFile(filePath);
                 if (projectCwd)
                     db_1.dbOps.updateSessionProject(session_id, projectCwd);

package/dist/share.d.ts

@@ -0,0 +1,5 @@
+export declare function runShare(args: {
+    sessionId?: string;
+    format: 'ascii' | 'json';
+    copy: boolean;
+}): Promise<void>;

package/dist/share.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShare = runShare;
+const db_js_1 = require("./db.js");
+const child_process_1 = require("child_process");
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        const mins = minutes % 60;
+        return `${hours}h ${mins}m`;
+    }
+    return `${minutes}m`;
+}
+async function getSessionData(sessionId) {
+    const sessions = db_js_1.dbOps.getAllSessions(1);
+    let session;
+    if (sessionId) {
+        session = db_js_1.dbOps.getSession(sessionId);
+        if (!session)
+            return null;
+    }
+    else if (sessions.length > 0) {
+        session = sessions[0];
+    }
+    else {
+        return null;
+    }
+    const events = db_js_1.dbOps.getSessionEvents(session.id);
+    const toolCalls = events.filter((e) => e.type === 'Done' && e.tool_name);
+    const totalTokens = (session.total_input_tokens || 0) + (session.total_output_tokens || 0);
+    const cacheTokens = (session.total_cache_read || 0) + (session.total_cache_creation || 0);
+    const cacheSavedCost = (session.total_cost_usd || 0) * 0.1 * 0.9;
+    const toolCounts = {};
+    toolCalls.forEach((e) => {
+        const tool = e.tool_name || 'Unknown';
+        toolCounts[tool] = (toolCounts[tool] || 0) + 1;
+    });
+    let topTool = '—';
+    let topToolPct = 0;
+    if (Object.keys(toolCounts).length > 0) {
+        const sorted = Object.entries(toolCounts).sort((a, b) => b[1] - a[1]);
+        topTool = sorted[0][0];
+        topToolPct = Math.round((sorted[0][1] / toolCalls.length) * 100);
+    }
+    const durationMs = (session.last_event_at || session.started_at) - session.started_at;
+    const project = session.project_path?.split('/').pop() || 'unknown';
+    return {
+        id: session.id,
+        project: project.length > 18 ? project.slice(0, 15) + '...' : project,
+        duration: formatDuration(durationMs),
+        tools: toolCalls.length,
+        cost: `$${(session.total_cost_usd || 0).toFixed(2)}`,
+        cacheSaved: `$${cacheSavedCost.toFixed(2)}`,
+        cachePct: Math.min(100, totalTokens > 0 ? Math.round((cacheTokens / totalTokens) * 100) : 0),
+        topTool: topTool.length > 12 ? topTool.slice(0, 9) + '...' : topTool,
+        topToolPct,
+        efficiency: session.efficiency_score || 100,
+        efficiencyEmoji: (session.efficiency_score || 100) >= 90 ? '🔥' : (session.efficiency_score || 100) >= 70 ? '👍' : '💀',
+    };
+}
+function generateAsciiCard(data) {
+    const FIELD_WIDTH = 25;
+    const toolsLabel = `${data.tools} calls`;
+    const cacheLabel = `${data.cachePct}% saved (${data.cacheSaved})`;
+    const topLabel = `${data.topTool} (${data.topToolPct}%)`;
+    const effLabel = `${data.efficiency} / 100 ${data.efficiencyEmoji}`;
+    const lines = [
+        '╔═══════════════════════════════════╗',
+        '║     Session Report · claudestat   ║',
+        '╠═══════════════════════════════════╣',
+        `║  Project     ${data.project.padEnd(FIELD_WIDTH)}║`,
+        `║  Duration   ${data.duration.padEnd(FIELD_WIDTH)}║`,
+        `║  Tools      ${toolsLabel.padEnd(FIELD_WIDTH)}║`,
+        `║  Cost       ${data.cost.padEnd(FIELD_WIDTH)}║`,
+        `║  Cache hit  ${cacheLabel.padEnd(FIELD_WIDTH)}║`,
+        `║  Top tool  ${topLabel.padEnd(FIELD_WIDTH)}║`,
+        `║  Efficiency ${effLabel.padEnd(FIELD_WIDTH)}║`,
+        '╚═══════════════════════════════════╝',
+        '  github.com/DeibyGS/claudestat',
+    ];
+    return lines.join('\n');
+}
+function generateJson(data) {
+    return JSON.stringify({
+        project: data.project,
+        duration: data.duration,
+        tools: data.tools,
+        cost: data.cost,
+        cache_saved: data.cacheSaved,
+        cache_pct: data.cachePct,
+        top_tool: data.topTool,
+        top_tool_pct: data.topToolPct,
+        efficiency: data.efficiency,
+    }, null, 2);
+}
+async function runShare(args) {
+    const data = await getSessionData(args.sessionId);
+    if (!data) {
+        console.error('Error: No sessions found. Run Claude Code first.');
+        process.exit(1);
+    }
+    const output = args.format === 'json' ? generateJson(data) : generateAsciiCard(data);
+    console.log(output);
+    if (args.copy) {
+        try {
+            const p = (0, child_process_1.spawn)('pbcopy', [], { stdio: ['pipe', process.stderr, process.stderr] });
+            p.stdin.write(output);
+            p.stdin.end();
+            p.on('close', () => console.log('\n✓ Copied to clipboard'));
+        }
+        catch {
+            console.warn('⚠ Clipboard not available (macOS only)');
+        }
+    }
+}

package/dist/watch.js

@@ -63,8 +63,23 @@ async function startWatch() {
     }
     let state = {
         sessionId: '', cwd: '', startedAt: Date.now(), events: [],
-        weekly: (0, weekly_1.readWeeklyStats)()
+        weekly: (0, weekly_1.readWeeklyStats)(),
+        cyclePct: 0
     };
+    // Fetch quota para cyclePct cada 30 segundos
+    async function fetchQuota() {
+        try {
+            const res = await fetch('http://localhost:7337/quota');
+            if (res.ok) {
+                const q = await res.json();
+                return q.cyclePct;
+            }
+        }
+        catch { }
+        return 0;
+    }
+    fetchQuota().then(pct => { state.cyclePct = pct; });
+    setInterval(async () => { state.cyclePct = await fetchQuota(); }, 30000);
     // Refrescar stats semanales cada 5 minutos
     setInterval(() => { state.weekly = (0, weekly_1.readWeeklyStats)(); }, 5 * 60 * 1000);
     function draw() {
@@ -80,16 +95,19 @@ async function startWatch() {
                     sessionId: msg.session.id,
                     cwd: msg.session.cwd || '',
                     startedAt: msg.session.started_at,
-                    events: (msg.events || []),
-                    cost: buildCostFromSession(msg.session)
+                    events: Array.isArray(msg.events) ? msg.events : [],
+                    cost: buildCostFromSession(msg.session),
+                    cyclePct: state.cyclePct // preservar de inicial o anterior
                 };
             }
         }
         else if (msg.type === 'event') {
+            if (!msg.payload?.session_id)
+                return;
             const evt = msg.payload;
             // Nueva sesión → resetear estado
             if (evt.session_id && evt.session_id !== state.sessionId && state.sessionId !== '') {
-                state = { sessionId: evt.session_id, cwd: evt.cwd || '', startedAt: evt.ts, events: [] };
+                state = { sessionId: evt.session_id, cwd: evt.cwd || '', startedAt: evt.ts, events: [], cyclePct: state.cyclePct };
             }
             else if (!state.sessionId && evt.session_id) {
                 state.sessionId = evt.session_id;
@@ -98,7 +116,7 @@ async function startWatch() {
             }
             if (evt.type === 'Done' && evt.tool_name) {
                 // Actualizar el PreToolUse pendiente a Done
-                const pending = [...state.events].reverse()
+                const pending = [...(state.events ?? [])].reverse()
                     .find(e => e.type === 'PreToolUse' && e.tool_name === evt.tool_name);
                 if (pending) {
                     pending.type = 'Done';
@@ -131,8 +149,12 @@ async function startWatch() {
     }
     clearScreen();
     process.stdout.write('\x1b[36m● claudestat watch\x1b[0m — connecting...\n');
+    // Fetch quota antes del primer render para evitar 0%
+    const initialCyclePct = await fetchQuota();
     while (true) {
         try {
+            // Inicializar state con cyclePct obtenido
+            state.cyclePct = initialCyclePct;
             await connectSSE(handleMessage);
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statforge/claudestat",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "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",
@@ -58,7 +58,7 @@
     "dev": "tsx src/index.ts",
     "dev:full": "tsx src/index.ts start & sleep 1 && cd dashboard && npm run dev",
     "start": "node dist/index.js",
-    "test": "node --require tsx/cjs tests/index.ts"
+    "test": "bash run-tests.sh"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.88.0",