@statforge/claudestat 1.3.0 → 1.5.0

package/dist/config.d.ts

@@ -25,6 +25,7 @@ export interface ClaudestatConfig {
     warnThresholds: number[];
     weeklyWarnThresholds: number[];
     resetReminderMins: number;
+    sessionCostLimitUsd: number;
     plan: ClaudePlan | null;
     reportsEnabled: boolean;
     reportFrequency: ReportFrequency;

package/dist/config.js

@@ -36,6 +36,7 @@ const DEFAULTS = {
     warnThresholds: [70, 85, 95],
     weeklyWarnThresholds: [50, 75, 90],
     resetReminderMins: 10,
+    sessionCostLimitUsd: 0,
     plan: null,
     reportsEnabled: false,
     reportFrequency: 'weekly',
@@ -92,6 +93,11 @@ function validateConfig(raw) {
         if (typeof v !== 'number' || isNaN(v) || v < 0 || v > 60)
             return 'resetReminderMins must be a number between 0 and 60';
     }
+    if ('sessionCostLimitUsd' in cfg) {
+        const v = cfg.sessionCostLimitUsd;
+        if (typeof v !== 'number' || isNaN(v) || v < 0)
+            return 'sessionCostLimitUsd debe ser un número >= 0 (0 = desactivado)';
+    }
     if ('alertsEnabled' in cfg && typeof cfg.alertsEnabled !== 'boolean')
         return 'alertsEnabled debe ser boolean';
     if ('reportsEnabled' in cfg && typeof cfg.reportsEnabled !== 'boolean')

package/dist/cost-projector.d.ts

@@ -0,0 +1,24 @@
+export interface CostProjection {
+    trend: 'up' | 'down' | 'stable';
+    slope: number;
+    rSquared: number;
+    weekly: PeriodProjection;
+    monthly: PeriodProjection;
+    dailyHistory: DayPoint[];
+}
+export interface PeriodProjection {
+    projected: number;
+    lower80: number;
+    upper80: number;
+    daysWithData: number;
+    costSoFar: number;
+    avgPerDay: number;
+}
+export interface DayPoint {
+    date: string;
+    dayIndex: number;
+    cost: number;
+    fitted: number | null;
+}
+export declare function computeProjection(days?: number): CostProjection;
+export declare function formatProjection(p: CostProjection): string;

package/dist/cost-projector.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeProjection = computeProjection;
+exports.formatProjection = formatProjection;
+const db_1 = require("./db");
+function leastSquares(xs, ys) {
+    const n = xs.length;
+    if (n < 2)
+        return { slope: 0, intercept: 0, rSquared: 0 };
+    const sumX = xs.reduce((a, b) => a + b, 0);
+    const sumY = ys.reduce((a, b) => a + b, 0);
+    const sumX2 = xs.reduce((a, b) => a + b * b, 0);
+    const sumXY = xs.reduce((a, b, i) => a + b * ys[i], 0);
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 1e-12)
+        return { slope: 0, intercept: 0, rSquared: 0 };
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    const yMean = sumY / n;
+    const ssRes = ys.reduce((a, y, i) => a + (y - (slope * xs[i] + intercept)) ** 2, 0);
+    const ssTot = ys.reduce((a, y) => a + (y - yMean) ** 2, 0);
+    const rSquared = ssTot > 1e-12 ? 1 - ssRes / ssTot : 0;
+    return { slope, intercept, rSquared };
+}
+function standardError(xs, ys, slope, intercept) {
+    const n = xs.length;
+    if (n < 3)
+        return 0;
+    const residuals = xs.map((x, i) => (ys[i] - (slope * x + intercept)) ** 2);
+    const sse = residuals.reduce((a, b) => a + b, 0);
+    const mse = sse / (n - 2);
+    const sumX = xs.reduce((a, b) => a + b, 0);
+    const sumX2 = xs.reduce((a, b) => a + b * b, 0);
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 1e-12)
+        return 0;
+    const seSlope = Math.sqrt(mse * n / denom);
+    return seSlope;
+}
+function tCrit80(n) {
+    if (n <= 2)
+        return 0;
+    const df = n - 2;
+    if (df >= 120)
+        return 1.289;
+    if (df >= 60)
+        return 1.296;
+    if (df >= 40)
+        return 1.303;
+    if (df >= 30)
+        return 1.310;
+    if (df >= 20)
+        return 1.325;
+    if (df >= 15)
+        return 1.341;
+    if (df >= 10)
+        return 1.372;
+    if (df >= 8)
+        return 1.397;
+    if (df >= 6)
+        return 1.440;
+    if (df >= 5)
+        return 1.476;
+    return 0;
+}
+function computeProjection(days = 90) {
+    const since = Date.now() - days * 86400000;
+    const daily = db_1.dbOps.getAnalyticsDaily(since);
+    const dayPoints = daily.map((d, i) => ({
+        date: d.date,
+        dayIndex: i,
+        cost: d.cost,
+        fitted: null,
+    }));
+    const costs = dayPoints.map(d => d.cost);
+    const indices = dayPoints.map(d => d.dayIndex);
+    const { slope, intercept, rSquared } = leastSquares(indices, costs);
+    const se = standardError(indices, costs, slope, intercept);
+    const t80 = tCrit80(indices.length);
+    dayPoints.forEach((d, i) => {
+        d.fitted = slope * i + intercept;
+    });
+    const daysWithData = dayPoints.length;
+    const costSoFar = costs.reduce((a, b) => a + b, 0);
+    const avgPerDay = daysWithData > 0 ? costSoFar / daysWithData : 0;
+    const next7 = indices.length;
+    const next30 = indices.length + 23;
+    const weeklyProj = slope * next7 + intercept;
+    const monthlyProj = slope * next30 + intercept;
+    const weeklyProjected = Math.max(0, weeklyProj * 7);
+    const monthlyProjected = Math.max(0, monthlyProj * 30);
+    const weeklySE = se * Math.sqrt(7);
+    const monthlySE = se * Math.sqrt(30);
+    const weeklyCI = t80 > 0 ? t80 * weeklySE * 7 : weeklyProjected * 0.5;
+    const monthlyCI = t80 > 0 ? t80 * monthlySE * 30 : monthlyProjected * 0.5;
+    const trend = slope > 0.001 ? 'up' : slope < -0.001 ? 'down' : 'stable';
+    return {
+        trend,
+        slope,
+        rSquared: Math.round(rSquared * 10000) / 10000,
+        weekly: {
+            projected: Math.round(weeklyProjected * 100) / 100,
+            lower80: Math.max(0, Math.round((weeklyProjected - weeklyCI) * 100) / 100),
+            upper80: Math.round((weeklyProjected + weeklyCI) * 100) / 100,
+            daysWithData,
+            costSoFar: Math.round(costSoFar * 100) / 100,
+            avgPerDay: Math.round(avgPerDay * 10000) / 10000,
+        },
+        monthly: {
+            projected: Math.round(monthlyProjected * 100) / 100,
+            lower80: Math.max(0, Math.round((monthlyProjected - monthlyCI) * 100) / 100),
+            upper80: Math.round((monthlyProjected + monthlyCI) * 100) / 100,
+            daysWithData,
+            costSoFar: Math.round(costSoFar * 100) / 100,
+            avgPerDay: Math.round(avgPerDay * 10000) / 10000,
+        },
+        dailyHistory: dayPoints,
+    };
+}
+function formatProjection(p) {
+    const trendChar = p.trend === 'up' ? '↑' : p.trend === 'down' ? '↓' : '→';
+    const trendLabel = p.trend === 'up' ? 'increasing' : p.trend === 'down' ? 'decreasing' : 'stable';
+    let out = `Cost Projection (R²=${p.rSquared.toFixed(3)}, trend=${trendChar} ${trendLabel})\n`;
+    out += `${'─'.repeat(42)}\n`;
+    out += `  Weekly  | projected: $${p.weekly.projected.toFixed(2)}  `;
+    out += `(80% CI: $${p.weekly.lower80.toFixed(2)}–$${p.weekly.upper80.toFixed(2)})\n`;
+    out += `          | avg $${p.weekly.avgPerDay.toFixed(4)}/day over ${p.weekly.daysWithData} days\n`;
+    out += `  Monthly | projected: $${p.monthly.projected.toFixed(2)}  `;
+    out += `(80% CI: $${p.monthly.lower80.toFixed(2)}–$${p.monthly.upper80.toFixed(2)})\n`;
+    out += `          | avg $${p.monthly.avgPerDay.toFixed(4)}/day over ${p.monthly.daysWithData} days\n`;
+    out += `${'─'.repeat(42)}`;
+    return out;
+}

package/dist/daemon.js

@@ -94,7 +94,7 @@ app.get('/health', (_req, res) => {
     res.json({ status: 'ok', port: PORT, clients: (0, stream_1.getSseClientsSize)() });
 });
 // ─── Dashboard React (servir estáticos del build de Vite) ────────────────────
-const DASHBOARD_DIST = path_1.default.join(__dirname, '..', 'dashboard', 'dist');
+const DASHBOARD_DIST = (0, paths_1.getDashboardDir)();
 app.use(express_1.default.static(DASHBOARD_DIST, {
     setHeaders(res, filePath) {
         if (filePath.endsWith('.html')) {

package/dist/db.d.ts

@@ -23,6 +23,9 @@ export interface SessionRow {
     efficiency_score?: number;
     loops_detected?: number;
     ai_summary?: string;
+    dominant_model?: string;
+    parent_session_id?: string;
+    source?: string;
 }
 export interface EventRow {
     id?: number;
@@ -35,6 +38,7 @@ export interface EventRow {
     cwd?: string;
     duration_ms?: number;
     skill_parent?: string;
+    source?: string;
 }
 export interface BlockCostEntry {
     inputUsd: number;

package/dist/db.js

@@ -111,11 +111,19 @@ try {
     db.exec(`ALTER TABLE sessions ADD COLUMN parent_session_id TEXT`);
 }
 catch { }
+try {
+    db.exec(`ALTER TABLE sessions ADD COLUMN source TEXT DEFAULT 'claude-code'`);
+}
+catch { }
+try {
+    db.exec(`ALTER TABLE events ADD COLUMN source TEXT DEFAULT 'claude-code'`);
+}
+catch { }
 // ─── Prepared statements (se compilan una vez al iniciar) ─────────────────────
 const stmts = {
     upsertSession: db.prepare(`
-    INSERT INTO sessions (id, cwd, started_at, last_event_at)
-    VALUES (?, ?, ?, ?)
+    INSERT INTO sessions (id, cwd, started_at, last_event_at, source)
+    VALUES (?, ?, ?, ?, COALESCE(?, 'claude-code'))
     ON CONFLICT(id) DO UPDATE SET last_event_at = excluded.last_event_at
   `),
     updateSessionCost: db.prepare(`
@@ -131,8 +139,8 @@ const stmts = {
     WHERE id = ?
   `),
     insertEvent: db.prepare(`
-    INSERT INTO events (session_id, type, tool_name, tool_input, ts, cwd, skill_parent)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO events (session_id, type, tool_name, tool_input, ts, cwd, skill_parent, source)
+    VALUES (?, ?, ?, ?, ?, ?, ?, COALESCE(?, 'claude-code'))
   `),
     pairPost: db.prepare(`
     UPDATE events SET type = 'Done', tool_response = ?, duration_ms = ?
@@ -471,10 +479,10 @@ const stmts = {
 // ─── Operaciones públicas ─────────────────────────────────────────────────────
 exports.dbOps = {
     upsertSession(s) {
-        stmts.upsertSession.run(s.id, s.cwd ?? null, s.started_at, s.last_event_at ?? s.started_at);
+        stmts.upsertSession.run(s.id, s.cwd ?? null, s.started_at, s.last_event_at ?? s.started_at, s.source ?? null);
     },
     insertEvent(e) {
-        const res = stmts.insertEvent.run(e.session_id, e.type, e.tool_name ?? null, e.tool_input ?? null, e.ts, e.cwd ?? null, e.skill_parent ?? null);
+        const res = stmts.insertEvent.run(e.session_id, e.type, e.tool_name ?? null, e.tool_input ?? null, e.ts, e.cwd ?? null, e.skill_parent ?? null, e.source ?? null);
         return Number(res.lastInsertRowid);
     },
     /**

package/dist/enricher.d.ts

@@ -1,34 +1,26 @@
 /**
- * enricher.ts — Enriquecedor de coste desde JSONL de Claude Code
+ * enricher.ts — Watcher multi-CLI usando adapters
  *
- * Claude Code escribe los tokens de cada respuesta en:
- *   ~/.claude/projects/{project-hash}/{session-id}.jsonl
+ * En lugar de hardcodear la lógica de Claude Code, usa el adapter pattern
+ * para soportar múltiples coding CLIs (Claude Code, Codex, OpenCode, etc.).
  *
- * Cada línea de tipo "assistant" contiene:
- *   message.usage.input_tokens
- *   message.usage.output_tokens
- *   message.usage.cache_read_input_tokens
- *   message.usage.cache_creation_input_tokens
- *   message.model
- *
- * El enricher observa cambios en esos archivos (con chokidar),
- * calcula el coste acumulado por sesión y llama al callback
- * para que el daemon actualice la DB y haga broadcast via SSE.
+ * Cada adapter implementa WatcherAdapter (src/watchers/adapter.ts):
+ * - detect()      → si el CLI está instalado
+ * - getWatchPaths() → qué archivos observar
+ * - parseEvent()   → parsear una línea de trace
+ * - getSessionCost() → calcular costos acumulados
  */
+import './watchers/claude-code';
+import './watchers/codex';
+import './watchers/opencode';
+import './watchers/amp';
+import './watchers/droid';
+import './watchers/codebuff';
 import type { CostUpdate } from './db';
-export declare function getContextWindow(model: string): number;
-import type { BlockCostEntry } from './db';
-export declare function getAllBlockCostsForSession(sessionId: string): Promise<BlockCostEntry[]>;
-export interface SessionPrompt {
-    index: number;
-    ts: number;
-    text: string;
-}
-export declare function getSessionPrompts(sessionId: string): Promise<SessionPrompt[]>;
-export type CostUpdateCallback = (sessionId: string, cost: CostUpdate) => void;
+export { getAllBlockCostsForSession, getContextWindow, getSessionPrompts } from './watchers/claude-code';
+export type CostUpdateCallback = (sessionId: string, cost: CostUpdate, source?: string) => void;
 export type CompactDetectedCallback = (sessionId: string) => void;
-export type SessionEndCallback = (sessionId: string) => void;
-export declare function startEnricher(onUpdate: CostUpdateCallback, onCompact?: CompactDetectedCallback, onSessionEnd?: SessionEndCallback): void;
+export declare function startEnricher(onUpdate: CostUpdateCallback, onCompact?: CompactDetectedCallback): void;
 export declare function stopEnricher(): void;
 export declare function cleanupSession(sessionId: string): void;
-export declare function processLatestForSession(sessionId: string, onUpdate: CostUpdateCallback): Promise<void>;
+export declare function processLatestForSession(sessionId: string, onUpdate: CostUpdateCallback, source?: string): Promise<void>;