@statforge/claudestat 1.0.1

package/dist/summarizer.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * summarizer.ts — Resumen de sesión con IA (opcional)
+ *
+ * Solo se activa si ANTHROPIC_API_KEY está disponible en el entorno.
+ * Si no hay key → retorna null silenciosamente, sin errores ni warnings.
+ *
+ * Usa claude-haiku-4-5 (el modelo más económico) para minimizar coste.
+ * Un resumen de sesión consume ~200 tokens → ~$0.0002 por resumen.
+ *
+ * El cliente de Anthropic se carga con dynamic import para que el daemon
+ * no falle si @anthropic-ai/sdk no está instalado o la key no existe.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSession = summarizeSession;
+const path_1 = __importDefault(require("path"));
+// Lazy-loaded — se inicializa solo en el primer uso con API key disponible
+let client = null;
+async function getClient() {
+    if (!process.env.ANTHROPIC_API_KEY)
+        return null;
+    if (client)
+        return client;
+    try {
+        const { Anthropic } = await Promise.resolve().then(() => __importStar(require('@anthropic-ai/sdk')));
+        client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        return client;
+    }
+    catch {
+        return null; // SDK no instalado — falla silenciosamente
+    }
+}
+// ─── Contexto de sesión para el prompt ───────────────────────────────────────
+function buildContext(events, costUsd, projectName) {
+    // Herramientas únicas usadas, ordenadas por frecuencia
+    const toolCounts = new Map();
+    for (const e of events) {
+        if (e.tool_name && e.type === 'Done') {
+            toolCounts.set(e.tool_name, (toolCounts.get(e.tool_name) ?? 0) + 1);
+        }
+    }
+    const topTools = [...toolCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 6)
+        .map(([t, n]) => `${t}(${n})`)
+        .join(', ');
+    const toolCount = events.filter(e => e.type === 'Done').length;
+    const durationMin = events.length > 1
+        ? Math.round((events[events.length - 1].ts - events[0].ts) / 60000)
+        : 0;
+    // Intentar inferir archivos tocados desde tool_input
+    const filesSet = new Set();
+    for (const e of events) {
+        if (!e.tool_input)
+            continue;
+        try {
+            const inp = JSON.parse(e.tool_input);
+            const fp = inp.file_path || inp.path;
+            if (typeof fp === 'string' && fp.startsWith('/')) {
+                filesSet.add(path_1.default.basename(fp));
+            }
+        }
+        catch { /* ignorar */ }
+    }
+    const files = [...filesSet].slice(0, 5).join(', ');
+    return [
+        projectName ? `Proyecto: ${projectName}` : '',
+        `Duración: ${durationMin}min · ${toolCount} operaciones · $${costUsd.toFixed(4)}`,
+        topTools ? `Herramientas: ${topTools}` : '',
+        files ? `Archivos: ${files}` : '',
+    ].filter(Boolean).join('\n');
+}
+// ─── Función principal ────────────────────────────────────────────────────────
+/**
+ * Genera un resumen de 10-15 palabras de lo que hizo Claude en la sesión.
+ * Retorna null si no hay API key o falla la llamada.
+ */
+async function summarizeSession(events, costUsd, projectName) {
+    const c = await getClient();
+    if (!c)
+        return null;
+    // No resumir sesiones demasiado cortas (< 3 tool calls)
+    if (events.filter(e => e.type === 'Done').length < 3)
+        return null;
+    const context = buildContext(events, costUsd, projectName);
+    try {
+        const msg = await c.messages.create({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 60,
+            messages: [{
+                    role: 'user',
+                    content: `Resume en máximo 12 palabras en español qué hizo Claude en esta sesión:\n${context}\n\nResponde solo el resumen, sin comillas ni explicaciones.`,
+                }],
+        });
+        const text = msg.content?.[0]?.type === 'text' ? msg.content[0].text.trim() : null;
+        return text || null;
+    }
+    catch {
+        return null; // error de API — falla silenciosamente
+    }
+}

package/dist/watch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * watch.ts — Cliente SSE + renderizador (Phase 2)
+ *
+ * Novedades:
+ * - Maneja el evento 'cost_update' que llega del enricher
+ * - Actualiza cost en estado y redibuja con datos reales
+ */
+export declare function startWatch(): Promise<void>;

package/dist/watch.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * watch.ts — Cliente SSE + renderizador (Phase 2)
+ *
+ * Novedades:
+ * - Maneja el evento 'cost_update' que llega del enricher
+ * - Actualiza cost en estado y redibuja con datos reales
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatch = startWatch;
+const http_1 = __importDefault(require("http"));
+const render_1 = require("./render");
+const weekly_1 = require("./weekly");
+const DAEMON_HOST = 'localhost';
+const DAEMON_PORT = 7337;
+function clearScreen() { process.stdout.write('\x1b[2J\x1b[H'); }
+async function checkDaemon() {
+    return new Promise(resolve => {
+        const req = http_1.default.get(`http://${DAEMON_HOST}:${DAEMON_PORT}/health`, res => {
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.setTimeout(1500, () => { req.destroy(); resolve(false); });
+    });
+}
+function connectSSE(onMessage) {
+    return new Promise((_, reject) => {
+        const req = http_1.default.request({
+            hostname: DAEMON_HOST, port: DAEMON_PORT, path: '/stream', method: 'GET',
+            headers: { Accept: 'text/event-stream', 'Cache-Control': 'no-cache' }
+        }, res => {
+            let buffer = '';
+            res.on('data', (chunk) => {
+                buffer += chunk.toString();
+                const parts = buffer.split('\n\n');
+                buffer = parts.pop() || '';
+                for (const part of parts) {
+                    for (const line of part.split('\n')) {
+                        if (line.startsWith('data: ')) {
+                            try {
+                                onMessage(JSON.parse(line.slice(6)));
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            });
+            res.on('end', () => reject(new Error('Stream closed')));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+async function startWatch() {
+    const alive = await checkDaemon();
+    if (!alive) {
+        console.error('\n❌ Daemon is not running.');
+        console.error('   Run: \x1b[36mclaudestat start\x1b[0m\n');
+        process.exit(1);
+    }
+    let state = {
+        sessionId: '', cwd: '', startedAt: Date.now(), events: [],
+        weekly: (0, weekly_1.readWeeklyStats)()
+    };
+    // Refrescar stats semanales cada 5 minutos
+    setInterval(() => { state.weekly = (0, weekly_1.readWeeklyStats)(); }, 5 * 60 * 1000);
+    function draw() {
+        if (state.sessionId) {
+            clearScreen();
+            process.stdout.write((0, render_1.renderTrace)(state));
+        }
+    }
+    function handleMessage(msg) {
+        if (msg.type === 'init') {
+            if (msg.session) {
+                state = {
+                    sessionId: msg.session.id,
+                    cwd: msg.session.cwd || '',
+                    startedAt: msg.session.started_at,
+                    events: (msg.events || []),
+                    cost: buildCostFromSession(msg.session)
+                };
+            }
+        }
+        else if (msg.type === 'event') {
+            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: [] };
+            }
+            else if (!state.sessionId && evt.session_id) {
+                state.sessionId = evt.session_id;
+                state.cwd = evt.cwd || '';
+                state.startedAt = evt.ts;
+            }
+            if (evt.type === 'Done' && evt.tool_name) {
+                // Actualizar el PreToolUse pendiente a Done
+                const pending = [...state.events].reverse()
+                    .find(e => e.type === 'PreToolUse' && e.tool_name === evt.tool_name);
+                if (pending) {
+                    pending.type = 'Done';
+                    pending.duration_ms = evt.ts - pending.ts;
+                }
+            }
+            else {
+                state.events.push(evt);
+            }
+        }
+        else if (msg.type === 'cost_update') {
+            // El enricher calculó el coste real desde el JSONL — actualizar estado
+            const p = msg.payload;
+            if (p.session_id === state.sessionId) {
+                state.cost = {
+                    cost_usd: p.cost_usd,
+                    input_tokens: p.input_tokens,
+                    output_tokens: p.output_tokens,
+                    cache_read: p.cache_read,
+                    cache_creation: p.cache_creation,
+                    efficiency_score: p.efficiency_score,
+                    context_used: p.context_used,
+                    context_window: p.context_window,
+                    loops: p.loops || [],
+                    summary: p.summary
+                };
+            }
+        }
+        draw();
+    }
+    clearScreen();
+    process.stdout.write('\x1b[36m● claudestat watch\x1b[0m — connecting...\n');
+    while (true) {
+        try {
+            await connectSSE(handleMessage);
+        }
+        catch {
+            clearScreen();
+            console.log('\x1b[33m⚠ Connection lost. Reconnecting in 2s...\x1b[0m');
+            await new Promise(r => setTimeout(r, 2000));
+        }
+    }
+}
+function buildCostFromSession(session) {
+    if (!session?.total_cost_usd)
+        return undefined;
+    return {
+        cost_usd: session.total_cost_usd ?? 0,
+        input_tokens: session.total_input_tokens ?? 0,
+        output_tokens: session.total_output_tokens ?? 0,
+        cache_read: session.total_cache_read ?? 0,
+        cache_creation: session.total_cache_creation ?? 0,
+        efficiency_score: session.efficiency_score ?? 100,
+        loops: []
+    };
+}

package/dist/watchdog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * watchdog.ts — Daemon auto-restart mechanism
+ *
+ * If the daemon process crashes or is killed unexpectedly, the watchdog
+ * detects the stale PID file and relaunches the daemon automatically.
+ *
+ * Usage: `claudestat start --watchdog`
+ * The watchdog runs as a separate lightweight process that periodically
+ * checks if the daemon PID is still alive.
+ */
+export declare function startWatchdog(): void;

package/dist/watchdog.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * watchdog.ts — Daemon auto-restart mechanism
+ *
+ * If the daemon process crashes or is killed unexpectedly, the watchdog
+ * detects the stale PID file and relaunches the daemon automatically.
+ *
+ * Usage: `claudestat start --watchdog`
+ * The watchdog runs as a separate lightweight process that periodically
+ * checks if the daemon PID is still alive.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatchdog = startWatchdog;
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+const PID_FILE = (0, paths_1.getPidFile)();
+const CHECK_INTERVAL_MS = 10000;
+const RESTART_COOLDOWN_MS = 30000;
+let lastRestart = 0;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readPid() {
+    try {
+        const raw = fs_1.default.readFileSync(PID_FILE, 'utf8').trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+function restartDaemon() {
+    const now = Date.now();
+    if (now - lastRestart < RESTART_COOLDOWN_MS)
+        return;
+    lastRestart = now;
+    console.log(`[watchdog] Daemon not running — restarting...`);
+    const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1] ?? 'claudestat', 'start'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    console.log(`[watchdog] Daemon restarted (pid ${child.pid})`);
+}
+function startWatchdog() {
+    console.log(`[watchdog] Starting — monitoring daemon every ${CHECK_INTERVAL_MS / 1000}s`);
+    const interval = setInterval(() => {
+        const pid = readPid();
+        if (pid === null) {
+            restartDaemon();
+            return;
+        }
+        if (!isProcessAlive(pid)) {
+            console.log(`[watchdog] Daemon pid ${pid} is dead`);
+            try {
+                fs_1.default.unlinkSync(PID_FILE);
+            }
+            catch { }
+            restartDaemon();
+        }
+    }, CHECK_INTERVAL_MS);
+    process.on('SIGTERM', () => { clearInterval(interval); process.exit(0); });
+    process.on('SIGINT', () => { clearInterval(interval); process.exit(0); });
+}

package/dist/weekly.d.ts

@@ -0,0 +1,13 @@
+/**
+ * weekly.ts — Tokens semanales desde stats-cache.json de Claude Code
+ * No necesita daemon ni API — lee el archivo directamente.
+ */
+export interface WeeklyStats {
+    totalTokens: number;
+    byDay: {
+        date: string;
+        tokens: number;
+    }[];
+    lastUpdated: string | null;
+}
+export declare function readWeeklyStats(): WeeklyStats;

package/dist/weekly.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * weekly.ts — Tokens semanales desde stats-cache.json de Claude Code
+ * No necesita daemon ni API — lee el archivo directamente.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readWeeklyStats = readWeeklyStats;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+const STATS_PATH = path_1.default.join((0, paths_1.getClaudeDir)(), 'stats-cache.json');
+function readWeeklyStats() {
+    try {
+        const raw = fs_1.default.readFileSync(STATS_PATH, 'utf8');
+        const data = JSON.parse(raw);
+        const byDay = [];
+        // Tomar los últimos 7 días disponibles (sin filtrar por fecha actual,
+        // porque stats-cache.json puede estar desactualizado por días/semanas)
+        const allEntries = (data.dailyModelTokens || [])
+            .map((entry) => ({
+            date: entry.date,
+            tokens: Object.values(entry.tokensByModel)
+                .reduce((sum, n) => sum + n, 0)
+        }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+        byDay.push(...allEntries.slice(-7));
+        return {
+            totalTokens: byDay.reduce((s, d) => s + d.tokens, 0),
+            byDay,
+            lastUpdated: data.lastComputedDate ?? null
+        };
+    }
+    catch {
+        return { totalTokens: 0, byDay: [], lastUpdated: null };
+    }
+}

package/hooks/event.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Hook universal de claudetrace.
+ * Claude Code lo ejecuta en cada evento del ciclo de vida.
+ * Recibe el JSON del evento por stdin y lo reenvía al daemon.
+ *
+ * Uso: node event.js <TipoEvento>
+ * Ejemplo: node event.js PreToolUse
+ *
+ * Kill switch (Phase 6):
+ * Para PreToolUse, después de enviar el evento al daemon, consulta GET /kill-switch.
+ * Si el daemon responde { blocked: true }, este hook termina con exit(2),
+ * lo que hace que Claude Code cancele la acción del tool antes de ejecutarla.
+ */
+
+const eventType = process.argv[2] || 'Unknown'
+const DAEMON_URL     = 'http://localhost:7337/event'
+const KILL_SWITCH_URL = 'http://localhost:7337/kill-switch'
+
+let rawData = ''
+process.stdin.on('data', chunk => { rawData += chunk })
+process.stdin.on('end', () => {
+  let hookData = {}
+  try { hookData = JSON.parse(rawData) } catch (_) {}
+
+  const payload = {
+    type: eventType,
+    ts: Date.now(),
+    ...hookData
+  }
+
+  // Para PreToolUse: enviamos el evento Y consultamos el kill-switch en paralelo.
+  // Si el daemon bloquea, salimos con exit(2) para cancelar la acción.
+  if (eventType === 'PreToolUse') {
+    Promise.all([
+      // 1. Registrar el evento (fire-and-forget, no nos importa el resultado)
+      fetch(DAEMON_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(1500),
+      }).catch(() => null),
+
+      // 2. Consultar el kill-switch con timeout corto para no retrasar a Claude
+      fetch(KILL_SWITCH_URL, {
+        signal: AbortSignal.timeout(1500),
+      })
+        .then(r => r.json())
+        .catch(() => {
+          // Si el daemon no responde, loggeamos en stderr (visible en logs de Claude)
+          // pero NO bloqueamos — un fallo del daemon no debe interrumpir el trabajo
+          process.stderr.write(`[claudetrace] daemon no disponible — kill-switch desactivado\n`)
+          return { blocked: false }
+        }),
+    ])
+    .then(([_, ks]) => {
+      if (ks && ks.blocked) {
+        // Claude Code muestra este stderr al usuario antes de cancelar la acción
+        process.stderr.write(`\n🚫 claudetrace kill switch activado\n`)
+        process.stderr.write(`   ${ks.reason ?? 'Cuota de uso superada.'}\n\n`)
+        process.exit(2)
+      } else {
+        process.exit(0)
+      }
+    })
+    .catch(() => process.exit(0))  // cualquier error → no bloquear
+
+  } else {
+    // Para todos los demás tipos (SessionStart, PostToolUse, Stop):
+    // enviar el evento y siempre salir con 0 — NUNCA bloquear a Claude.
+    fetch(DAEMON_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(2000),
+    })
+    .catch(() => {})  // error silencioso
+    .finally(() => process.exit(0))
+  }
+})

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@statforge/claudestat",
+  "version": "1.0.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",
+    "claude",
+    "anthropic",
+    "claude-monitoring",
+    "token-tracker",
+    "cost-tracker",
+    "ai-observability",
+    "claude-dashboard",
+    "quota-guard",
+    "rate-limit",
+    "ai-agent",
+    "llm-cost",
+    "token-usage",
+    "claude-hooks",
+    "ai-productivity",
+    "terminal-dashboard",
+    "developer-tools",
+    "cli",
+    "monitoring",
+    "analytics",
+    "claude-pro",
+    "claude-max",
+    "ai-coding",
+    "agentic-workflow",
+    "observability"
+  ],
+  "homepage": "https://github.com/DeibyGS/claudestat#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DeibyGS/claudestat.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DeibyGS/claudestat/issues"
+  },
+  "license": "MIT",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/DeibyGS"
+  },
+  "files": [
+    "dist/",
+    "hooks/",
+    "dashboard/dist/"
+  ],
+  "bin": {
+    "claudestat": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run build:dashboard",
+    "build:dashboard": "cd dashboard && npm install && npm run build",
+    "prepublishOnly": "npm run build",
+    "prepack": "npm run build",
+    "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"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.88.0",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.12.0",
+    "tsx": "^4.7.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}