@statforge/claudestat 1.0.1

package/dist/project-scanner.js

@@ -0,0 +1,619 @@
+"use strict";
+/**
+ * project-scanner.ts — Descubrimiento de proyectos desde ~/.claude/projects/
+ *
+ * Escanea los directorios de Claude Code, decodifica sus paths reales,
+ * lee los HANDOFF.md y extrae métricas de progreso.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeProjectDir = decodeProjectDir;
+exports.findRealPath = findRealPath;
+exports.parseHandoffProgress = parseHandoffProgress;
+exports.getJSONLStats = getJSONLStats;
+exports.autoCreateHandoff = autoCreateHandoff;
+exports.discoverProjects = discoverProjects;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const paths_1 = require("./paths");
+// ─── Decode ───────────────────────────────────────────────────────────────────
+/**
+ * Decodifica el nombre de directorio de Claude Code al path real.
+ * "-Users-db-Documents-GitHub-claudestat" → "/Users/db/Documents/GitHub/claudestat"
+ *
+ * Problema: directorios con '-' en el nombre (ej: "gmail-ai-agent") se confunden
+ * con separadores de path. Solución: búsqueda greedy recursiva por el filesystem.
+ */
+function decodeProjectDir(encodedName) {
+    const homeDir = os_1.default.homedir();
+    const encodedHome = (0, paths_1.encodeClaudePath)(homeDir);
+    if (!encodedName.startsWith(encodedHome))
+        return null;
+    const rest = encodedName.slice(encodedHome.length); // "-Documents-GitHub-gmail-ai-agent"
+    if (!rest || rest === '')
+        return null;
+    // Búsqueda greedy: prueba cada posición de '-' como posible '/'
+    // Esto resuelve ambigüedad con nombres de directorio que contienen '-'
+    const found = findRealPath(homeDir, rest.slice(1)); // quitar el '-' inicial
+    return found === homeDir ? null : found;
+}
+/**
+ * Dado un directorio base y un string con segmentos separados por '-',
+ * encuentra el path real en disco probando cada combinación posible.
+ * Ejemplo: base="/Users/db/Documents/GitHub", remaining="gmail-ai-agent"
+ *   → prueba "gmail" (no existe), "gmail-ai" (no existe), "gmail-ai-agent" (✓)
+ */
+function findRealPath(base, remaining, depth = 0) {
+    if (!remaining)
+        return fs_1.default.existsSync(base) ? base : null;
+    if (depth > 10)
+        return null;
+    const parts = remaining.split('-');
+    let segment = '';
+    for (let i = 0; i < parts.length; i++) {
+        segment = segment ? segment + '-' + parts[i] : parts[i];
+        const candidate = path_1.default.join(base, segment);
+        try {
+            if (!fs_1.default.statSync(candidate).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const leftover = parts.slice(i + 1).join('-');
+        if (!leftover)
+            return candidate; // consumido todo → éxito
+        const deeper = findRealPath(candidate, leftover, depth + 1);
+        if (deeper)
+            return deeper;
+    }
+    return null;
+}
+// ─── HANDOFF parser ───────────────────────────────────────────────────────────
+/** Secciones que indican tareas pendientes (case-insensitive) */
+const PENDING_SECTION = /pending|task|feature|todo|por hacer|pendiente/i;
+/** Secciones que indican tareas completadas */
+const DONE_SECTION = /done|completed|finished|completado|hecho/i;
+function parseHandoffProgress(content) {
+    let done = 0, pending = 0;
+    let nextTask = null;
+    // Parsear sección por sección para entender el contexto de cada ítem
+    const lines = content.split('\n');
+    let inPending = false; // estamos dentro de una sección "Pending"
+    let inDone = false; // estamos dentro de una sección "Done"
+    for (const line of lines) {
+        // Detectar cambio de sección (heading ##)
+        const heading = line.match(/^#{1,3}\s+(.+)$/);
+        if (heading) {
+            const h = heading[1];
+            inPending = PENDING_SECTION.test(h);
+            inDone = DONE_SECTION.test(h);
+            continue;
+        }
+        // ── Formato checkbox: - [x] / - [ ] — válido en cualquier sección ──────
+        if (/- \[x\]/i.test(line)) {
+            done++;
+            continue;
+        }
+        if (/- \[ \]/.test(line)) {
+            pending++;
+            if (!nextTask) {
+                const m = line.match(/^[\s]*- \[ \]\s*(.+)$/);
+                if (m)
+                    nextTask = m[1].trim().replace(/^\*\*|\*\*$/g, '');
+            }
+            continue;
+        }
+        // ── Formato emoji: 1. ✅ / 1. 🟡 — válido en cualquier sección ──────────
+        if (/^[\s]*\d+\.\s+✅/.test(line)) {
+            done++;
+            continue;
+        }
+        if (/^[\s]*\d+\.\s+(?:🟡|⬜|☐|🔲)/.test(line)) {
+            pending++;
+            if (!nextTask) {
+                const m = line.match(/^[\s]*\d+\.\s+(?:🟡|⬜|☐|🔲)\s+\*?\*?(.+?)(?:\*\*)?$/);
+                if (m)
+                    nextTask = m[1].trim().replace(/^\*\*|\*\*$/g, '').replace(/\s*—.*$/, '');
+            }
+            continue;
+        }
+        // ── Lista simple (- texto sin checkbox): solo si estamos en sección Pending ──
+        // Esto cubre el formato de CatcherAuto, EvolutFit, etc.
+        if (inPending && /^[\s]*-\s+\S/.test(line) && !/^[\s]*-\s*\[/.test(line)) {
+            pending++;
+            if (!nextTask) {
+                const m = line.match(/^[\s]*-\s+(.+)$/);
+                if (m)
+                    nextTask = m[1].trim().replace(/^\*\*|\*\*$/g, '');
+            }
+            continue;
+        }
+        if (inDone && /^[\s]*-\s+\S/.test(line) && !/^[\s]*-\s*\[/.test(line)) {
+            done++;
+            continue;
+        }
+    }
+    const total = done + pending;
+    const pct = total > 0 ? Math.round(done / total * 100) : 0;
+    return { done, total, pct, nextTask };
+}
+// ─── 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.
+ */
+function getJSONLStats(encodedDir) {
+    const dirPath = path_1.default.join(PROJECTS_DIR, encodedDir);
+    let sessionCount = 0, totalCost = 0, totalTokens = 0, lastActive = null;
+    const modelUsage = { opusTokens: 0, sonnetTokens: 0, haikuTokens: 0 };
+    try {
+        const files = fs_1.default.readdirSync(dirPath);
+        for (const file of files) {
+            if (!file.endsWith('.jsonl'))
+                continue;
+            const sessionId = file.slice(0, -6);
+            if (!sessionId.includes('-') || sessionId.length < 10)
+                continue;
+            const filePath = path_1.default.join(dirPath, file);
+            try {
+                const stat = fs_1.default.statSync(filePath);
+                if (!lastActive || stat.mtimeMs > lastActive)
+                    lastActive = stat.mtimeMs;
+                const content = fs_1.default.readFileSync(filePath, 'utf8');
+                let hasAssistant = false;
+                for (const raw of content.split('\n')) {
+                    const line = raw.trim();
+                    if (!line)
+                        continue;
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj.type !== 'assistant')
+                            continue;
+                        const usage = obj.message?.usage;
+                        const model = obj.message?.model ?? 'claude-sonnet-4-6';
+                        if (!usage)
+                            continue;
+                        hasAssistant = true;
+                        const tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+                        totalCost += calcCost(model, usage);
+                        totalTokens += tokens;
+                        if (model.includes('opus'))
+                            modelUsage.opusTokens += tokens;
+                        else if (model.includes('haiku'))
+                            modelUsage.haikuTokens += tokens;
+                        else
+                            modelUsage.sonnetTokens += tokens;
+                    }
+                    catch { /* línea malformada */ }
+                }
+                if (hasAssistant)
+                    sessionCount++;
+            }
+            catch { /* archivo inaccesible */ }
+        }
+    }
+    catch { /* directorio no encontrado */ }
+    return { session_count: sessionCount, total_cost_usd: totalCost, total_tokens: totalTokens, last_active: lastActive, modelUsage };
+}
+// ─── Inferencia de raíz de proyecto desde JSONL ───────────────────────────────
+/**
+ * Marcadores de raíz de proyecto, en orden de prioridad.
+ * El primer marcador encontrado al subir el árbol determina la raíz.
+ */
+const PROJECT_MARKERS = [
+    'HANDOFF.md', // claudestat — más específico
+    '.git', // git repo — universal
+    'package.json', // Node.js
+    'pyproject.toml', // Python moderno
+    'requirements.txt', // Python clásico
+    'go.mod', // Go
+    'Cargo.toml', // Rust
+    'pom.xml', // Java/Maven
+    'build.gradle', // Java/Gradle
+];
+/**
+ * Sube el árbol de directorios desde un file_path hasta encontrar
+ * el primer marcador de proyecto conocido. Retorna ese directorio.
+ */
+function findProjectRoot(filePath) {
+    let dir = path_1.default.dirname(filePath);
+    for (let i = 0; i < 10; i++) {
+        for (const marker of PROJECT_MARKERS) {
+            if (fs_1.default.existsSync(path_1.default.join(dir, marker)))
+                return dir;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break; // llegamos a '/'
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Para directorios con múltiples proyectos (ej: home dir con sesiones variadas),
+ * lee cada JSONL individualmente, infiere su proyecto y calcula sus stats.
+ *
+ * Retorna un Map de projectRoot → JSONLStats con datos precisos por proyecto.
+ */
+function getJSONLStatsByProject(dirPath) {
+    const result = new Map();
+    const INFER_LINES = 150; // líneas para inferir el proyecto
+    const FILE_TOOLS = new Set(['Read', 'Write', 'Edit', 'Glob', 'Grep', 'MultiEdit']);
+    let jsonlFiles;
+    try {
+        jsonlFiles = fs_1.default.readdirSync(dirPath)
+            .filter(f => f.endsWith('.jsonl') && f.includes('-') && f.length > 10);
+    }
+    catch {
+        return result;
+    }
+    for (const file of jsonlFiles) {
+        const filePath = path_1.default.join(dirPath, file);
+        try {
+            const stat = fs_1.default.statSync(filePath);
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n');
+            // ── Inferir proyecto desde los primeros INFER_LINES ──────────────────
+            const rootCounts = new Map();
+            for (const raw of lines.slice(0, INFER_LINES)) {
+                try {
+                    const obj = JSON.parse(raw.trim());
+                    if (obj.type !== 'assistant')
+                        continue;
+                    const blocks = obj.message?.content;
+                    if (!Array.isArray(blocks))
+                        continue;
+                    for (const block of blocks) {
+                        if (block.type !== 'tool_use' || !FILE_TOOLS.has(block.name))
+                            continue;
+                        const fp = (block.input?.file_path || block.input?.path);
+                        if (!fp || !path_1.default.isAbsolute(fp))
+                            continue;
+                        const root = findProjectRoot(fp);
+                        if (root)
+                            rootCounts.set(root, (rootCounts.get(root) ?? 0) + 1);
+                    }
+                }
+                catch { /* ignorar */ }
+            }
+            if (rootCounts.size === 0)
+                continue;
+            const projectRoot = [...rootCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+            // ── Calcular coste y tokens de este JSONL completo ───────────────────
+            let cost = 0, tokens = 0, hasAssistant = false;
+            const mu = { opusTokens: 0, sonnetTokens: 0, haikuTokens: 0 };
+            for (const raw of lines) {
+                try {
+                    const obj = JSON.parse(raw.trim());
+                    if (obj.type !== 'assistant')
+                        continue;
+                    const usage = obj.message?.usage;
+                    const model = obj.message?.model ?? 'claude-sonnet-4-6';
+                    if (!usage)
+                        continue;
+                    hasAssistant = true;
+                    const t = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+                    cost += calcCost(model, usage);
+                    tokens += t;
+                    if (model.includes('opus'))
+                        mu.opusTokens += t;
+                    else if (model.includes('haiku'))
+                        mu.haikuTokens += t;
+                    else
+                        mu.sonnetTokens += t;
+                }
+                catch { /* ignorar */ }
+            }
+            if (!hasAssistant)
+                continue;
+            // ── Acumular en el mapa de resultados ────────────────────────────────
+            const existing = result.get(projectRoot);
+            if (existing) {
+                existing.session_count++;
+                existing.total_cost_usd += cost;
+                existing.total_tokens += tokens;
+                existing.modelUsage.opusTokens += mu.opusTokens;
+                existing.modelUsage.sonnetTokens += mu.sonnetTokens;
+                existing.modelUsage.haikuTokens += mu.haikuTokens;
+                if (stat.mtimeMs > (existing.last_active ?? 0))
+                    existing.last_active = stat.mtimeMs;
+            }
+            else {
+                result.set(projectRoot, {
+                    session_count: 1, total_cost_usd: cost,
+                    total_tokens: tokens, last_active: stat.mtimeMs, modelUsage: mu,
+                });
+            }
+        }
+        catch { /* archivo inaccesible */ }
+    }
+    return result;
+}
+/**
+ * Encuentra la mejor raíz de proyecto para un directorio dado.
+ * Prioridad: HANDOFF.md (subiendo hasta 4 niveles) → .git → cualquier marker → el dir mismo.
+ *
+ * HANDOFF.md tiene prioridad sobre .git y package.json porque es el marker
+ * que el usuario mantiene conscientemente para claudestat.
+ */
+function findBestProjectRoot(dir) {
+    // 1. Buscar HANDOFF.md subiendo el árbol (hasta 4 niveles)
+    let current = dir;
+    for (let i = 0; i < 4; i++) {
+        if (fs_1.default.existsSync(path_1.default.join(current, 'HANDOFF.md')))
+            return current;
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    // 2. Buscar cualquier otro marker de proyecto
+    const byMarker = findProjectRoot(dir);
+    if (byMarker)
+        return byMarker;
+    // 3. Fallback: usar el dir tal cual
+    return dir;
+}
+// ─── Auto-crear HANDOFF para proyectos sin uno ───────────────────────────────
+/**
+ * Detecta el stack tecnológico de un proyecto desde los archivos presentes.
+ * Retorna una lista de strings legibles como "Node.js", "Python", etc.
+ */
+function detectStack(projectPath) {
+    const markers = [
+        ['package.json', 'Node.js'],
+        ['pyproject.toml', 'Python'],
+        ['requirements.txt', 'Python'],
+        ['go.mod', 'Go'],
+        ['Cargo.toml', 'Rust'],
+        ['pom.xml', 'Java / Maven'],
+        ['build.gradle', 'Java / Gradle'],
+        ['Gemfile', 'Ruby'],
+        ['pubspec.yaml', 'Flutter / Dart'],
+        ['build.gradle.kts', 'Kotlin'],
+        ['AndroidManifest.xml', 'Android'],
+        ['Info.plist', 'iOS / macOS'],
+        ['*.sln', '.NET'],
+    ];
+    const detected = [];
+    for (const [file, label] of markers) {
+        if (file.includes('*')) {
+            try {
+                const ext = file.replace('*.', '.');
+                if (fs_1.default.readdirSync(projectPath).some(f => f.endsWith(ext)))
+                    detected.push(label);
+            }
+            catch { /* ignorar */ }
+        }
+        else {
+            if (fs_1.default.existsSync(path_1.default.join(projectPath, file)))
+                detected.push(label);
+        }
+    }
+    return [...new Set(detected)]; // deduplicar
+}
+/**
+ * Genera y escribe un HANDOFF.md mínimo para proyectos que no tienen uno.
+ * El archivo se marca como auto-generado para que el usuario lo complete.
+ * No sobreescribe si ya existe.
+ */
+function autoCreateHandoff(projectPath, stats) {
+    const handoffPath = path_1.default.join(projectPath, 'HANDOFF.md');
+    if (fs_1.default.existsSync(handoffPath))
+        return; // ya existe, no tocar
+    const name = path_1.default.basename(projectPath);
+    const stack = detectStack(projectPath);
+    const stackStr = stack.length > 0 ? stack.join(', ') : 'no detectado';
+    const cost = stats.total_cost_usd.toFixed(2);
+    const tokens = stats.total_tokens >= 1000000
+        ? `${(stats.total_tokens / 1000000).toFixed(1)}M`
+        : stats.total_tokens >= 1000
+            ? `${Math.round(stats.total_tokens / 1000)}K`
+            : String(stats.total_tokens);
+    const content = `# HANDOFF — ${name}
+<!-- Auto-generado por claudestat. Completá las secciones marcadas con TODO. -->
+
+## Current Status
+- Branch: \`TODO — indicar rama principal\`
+- Last: auto-generado por claudestat (${stats.session_count} sesión${stats.session_count !== 1 ? 'es' : ''} · $${cost} · ${tokens} tokens)
+- State: stack detectado: ${stackStr}
+
+## Pending Tasks
+- [ ] TODO — describir la próxima tarea concreta
+- [ ] TODO — agregar objetivos del proyecto
+
+## Completed
+- [x] Proyecto detectado y registrado por claudestat
+
+## Gotchas
+- TODO — anotar decisiones importantes, bugs conocidos, restricciones
+
+## Session Log
+- **${new Date().toISOString().slice(0, 10)}** — HANDOFF auto-generado por claudestat con ${stats.session_count} sesión${stats.session_count !== 1 ? 'es' : ''} y $${cost} de coste acumulado
+`;
+    try {
+        fs_1.default.writeFileSync(handoffPath, content, 'utf8');
+    }
+    catch { /* sin permisos de escritura — ignorar silenciosamente */ }
+}
+// ─── Scanner principal ────────────────────────────────────────────────────────
+/**
+ * Descubre todos los proyectos en los que se ha trabajado con Claude Code.
+ *
+ * Estrategia (Opción A):
+ * 1. Para cada directorio en ~/.claude/projects/:
+ *    a. Intenta decodificar el nombre (rápido) → busca mejor raíz subiendo árbol
+ *    b. Si falla → infiere desde file paths del JSONL
+ * 2. Agrupa por raíz de proyecto (varios dirs Claude Code → mismo repo)
+ * 3. Para cada raíz única: lee HANDOFF, calcula progreso, suma stats JSONL
+ */
+function discoverProjects() {
+    // Mapa: inodeKey → { bestPath (canónico), encodedDirs[], jsonlStats acumulados }
+    const projectMap = new Map();
+    let dirs;
+    try {
+        dirs = fs_1.default.readdirSync(PROJECTS_DIR);
+    }
+    catch {
+        return [];
+    }
+    for (const encodedDir of dirs) {
+        const dirPath = path_1.default.join(PROJECTS_DIR, encodedDir);
+        try {
+            if (!fs_1.default.statSync(dirPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // ── Paso 1: encontrar la raíz real del proyecto ──────────────────────────
+        let projectRoot = null;
+        // Intento rápido: decodificar el nombre del directorio
+        const decoded = decodeProjectDir(encodedDir);
+        if (decoded && fs_1.default.existsSync(decoded)) {
+            // Subir el árbol buscando HANDOFF.md primero, luego otros markers
+            projectRoot = findBestProjectRoot(decoded);
+        }
+        // ── Paso 2: acumular stats en el mapa ────────────────────────────────────
+        // Clave única por directorio: inode resuelve case en macOS y symlinks en Linux
+        const inodeKey = (p) => {
+            try {
+                const s = fs_1.default.statSync(p);
+                return `${s.dev}:${s.ino}`;
+            }
+            catch {
+                return p;
+            }
+        };
+        // Helper para registrar un projectRoot con sus stats
+        const registerRoot = (root, stats) => {
+            if (root === os_1.default.homedir())
+                return; // nunca registrar el home dir
+            const best = findBestProjectRoot(root);
+            const bestKey = inodeKey(best);
+            const homeKey = inodeKey(os_1.default.homedir());
+            if (bestKey === homeKey)
+                return;
+            const existing = projectMap.get(bestKey);
+            if (existing) {
+                existing.encodedDirs.push(encodedDir);
+                existing.jsonlStats.session_count += stats.session_count;
+                existing.jsonlStats.total_cost_usd += stats.total_cost_usd;
+                existing.jsonlStats.total_tokens += stats.total_tokens;
+                existing.jsonlStats.modelUsage.opusTokens += stats.modelUsage.opusTokens;
+                existing.jsonlStats.modelUsage.sonnetTokens += stats.modelUsage.sonnetTokens;
+                existing.jsonlStats.modelUsage.haikuTokens += stats.modelUsage.haikuTokens;
+                if (stats.last_active && (!existing.jsonlStats.last_active || stats.last_active > existing.jsonlStats.last_active)) {
+                    existing.jsonlStats.last_active = stats.last_active;
+                }
+            }
+            else {
+                projectMap.set(bestKey, {
+                    encodedDirs: [encodedDir],
+                    jsonlStats: { ...stats, modelUsage: { ...stats.modelUsage } },
+                    bestPath: best,
+                });
+            }
+        };
+        if (projectRoot) {
+            registerRoot(projectRoot, getJSONLStats(encodedDir));
+        }
+        else {
+            // Fallback multi-proyecto: stats precisas por JSONL individual
+            const byProject = getJSONLStatsByProject(dirPath);
+            for (const [root, stats] of byProject) {
+                if (fs_1.default.existsSync(root))
+                    registerRoot(root, stats);
+            }
+        }
+    }
+    // ── Paso 3: construir resultados con HANDOFF y progreso ───────────────────
+    const raw = [];
+    for (const [, { bestPath: rootPath, encodedDirs, jsonlStats }] of projectMap) {
+        const handoffPath = path_1.default.join(rootPath, 'HANDOFF.md');
+        // Auto-crear HANDOFF si el proyecto no tiene uno
+        if (!fs_1.default.existsSync(handoffPath)) {
+            autoCreateHandoff(rootPath, jsonlStats);
+        }
+        const hasHandoff = fs_1.default.existsSync(handoffPath);
+        const handoffContent = hasHandoff ? (() => { try {
+            return fs_1.default.readFileSync(handoffPath, 'utf8');
+        }
+        catch {
+            return '';
+        } })() : '';
+        const autoHandoff = hasHandoff && handoffContent.includes('<!-- Auto-generado por claudestat');
+        const progress = hasHandoff
+            ? parseHandoffProgress(handoffContent)
+            : { done: 0, total: 0, pct: 0, nextTask: null };
+        // last_active = max(JSONL mtime, HANDOFF.md mtime)
+        if (hasHandoff) {
+            try {
+                const handoffMtime = fs_1.default.statSync(handoffPath).mtimeMs;
+                if (handoffMtime > (jsonlStats.last_active ?? 0)) {
+                    jsonlStats.last_active = handoffMtime;
+                }
+            }
+            catch { /* ignorar */ }
+        }
+        raw.push({
+            path: rootPath,
+            name: path_1.default.basename(rootPath),
+            encodedDir: encodedDirs[0],
+            hasHandoff,
+            autoHandoff,
+            progress,
+            jsonlStats,
+        });
+    }
+    // Deduplicar por inode: identifica el mismo directorio independientemente del case o symlinks
+    const inodeKey = (p) => {
+        try {
+            const s = fs_1.default.statSync(p);
+            return `${s.dev}:${s.ino}`;
+        }
+        catch {
+            return p;
+        }
+    };
+    const dedup = new Map();
+    for (const r of raw) {
+        const key = inodeKey(r.path);
+        const existing = dedup.get(key);
+        if (existing) {
+            existing.jsonlStats.session_count += r.jsonlStats.session_count;
+            existing.jsonlStats.total_cost_usd += r.jsonlStats.total_cost_usd;
+            existing.jsonlStats.total_tokens += r.jsonlStats.total_tokens;
+            existing.jsonlStats.modelUsage.opusTokens += r.jsonlStats.modelUsage.opusTokens;
+            existing.jsonlStats.modelUsage.sonnetTokens += r.jsonlStats.modelUsage.sonnetTokens;
+            existing.jsonlStats.modelUsage.haikuTokens += r.jsonlStats.modelUsage.haikuTokens;
+            if ((r.jsonlStats.last_active ?? 0) > (existing.jsonlStats.last_active ?? 0))
+                existing.jsonlStats.last_active = r.jsonlStats.last_active;
+        }
+        else {
+            dedup.set(key, r);
+        }
+    }
+    return [...dedup.values()];
+}

package/dist/quota-tracker.d.ts

@@ -0,0 +1,45 @@
+/**
+ * quota-tracker.ts — Seguimiento de cuota de uso de Claude Code
+ *
+ * Calcula en base a los JSONL de ~/.claude/projects/:
+ * - Prompts reales en el ciclo actual de 5 horas (ventana deslizante desde epoch UTC)
+ * - Tiempo hasta el reset del ciclo
+ * - Horas de sesión semanales por modelo (Sonnet vs Opus)
+ * - Burn rate: tokens/min promedio de los últimos 30 minutos
+ * - Plan detectado automáticamente desde el máximo histórico
+ *
+ * Por qué 5h desde epoch UTC (no desde una hora fija):
+ *   Claude Code usa ventanas deslizantes de exactamente 5 horas desde el epoch Unix.
+ *   Ciclo actual = floor(now / 5h) * 5h. El reset ocurre cuando cruza ese límite.
+ *
+ * Caché de 30 segundos para no re-leer todos los JSONL en cada request del dashboard.
+ */
+export type ClaudePlan = 'free' | 'pro' | 'max5' | 'max20';
+export interface QuotaData {
+    cyclePrompts: number;
+    cycleLimit: number;
+    cyclePct: number;
+    cycleResetMs: number;
+    cycleResetAt: number;
+    cycleStartTs: number;
+    weeklyHoursSonnet: number;
+    weeklyHoursOpus: number;
+    weeklyHoursHaiku: number;
+    weeklyTokensSonnet: number;
+    weeklyTokensOpus: number;
+    weeklyTokensHaiku: number;
+    weeklyLimitSonnet: number;
+    weeklyLimitOpus: number;
+    burnRateTokensPerMin: number;
+    detectedPlan: ClaudePlan;
+    planSource: 'config' | 'keychain' | 'inferred';
+    computedAt: number;
+}
+/**
+ * Calcula y retorna QuotaData.
+ * Usa caché de 30s para no re-leer todos los JSONL en cada request del dashboard.
+ * Pasar `forcePlan` para fijar el plan manualmente (por config del usuario).
+ */
+export declare function computeQuota(forcePlan?: ClaudePlan): QuotaData;
+/** Invalida la caché (llamar cuando llega un nuevo evento para que el siguiente /quota sea fresco) */
+export declare function invalidateQuotaCache(): void;