@statforge/claudestat 1.0.1

package/dist/export.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExport = runExport;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const db_1 = require("./db");
+function parseDate(str, endOfDay = false) {
+    const ms = Date.parse(str);
+    if (isNaN(ms))
+        throw new Error(`Invalid date: "${str}" — expected YYYY-MM-DD`);
+    return endOfDay ? ms + 86399999 : ms;
+}
+function csvField(value) {
+    const s = value == null ? '' : String(value);
+    return s.includes(',') || s.includes('"') || s.includes('\n') ? `"${s.replace(/"/g, '""')}"` : s;
+}
+const CSV_HEADERS = [
+    'id', 'started_at', 'cwd', 'project_path',
+    'total_cost_usd', 'total_input_tokens', 'total_output_tokens',
+    'efficiency_score', 'loops_detected',
+];
+function toRow(s) {
+    return {
+        id: s.id,
+        started_at: new Date(s.started_at).toISOString(),
+        cwd: s.cwd ?? '',
+        project_path: s.project_path ?? '',
+        total_cost_usd: s.total_cost_usd ?? 0,
+        total_input_tokens: s.total_input_tokens ?? 0,
+        total_output_tokens: s.total_output_tokens ?? 0,
+        efficiency_score: s.efficiency_score ?? 100,
+        loops_detected: s.loops_detected ?? 0,
+    };
+}
+function runExport(opts) {
+    let fromMs;
+    let toMs;
+    try {
+        if (opts.from)
+            fromMs = parseDate(opts.from);
+        if (opts.to)
+            toMs = parseDate(opts.to, true);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    const sessions = db_1.dbOps.getAllSessions().filter(s => {
+        if (fromMs !== undefined && s.started_at < fromMs)
+            return false;
+        if (toMs !== undefined && s.started_at > toMs)
+            return false;
+        if (opts.project) {
+            if (!s.project_path)
+                return false;
+            if (!s.project_path.toLowerCase().includes(opts.project.toLowerCase()))
+                return false;
+        }
+        return true;
+    });
+    const rows = sessions.map(toRow);
+    let output;
+    if (opts.format === 'csv') {
+        const lines = [
+            CSV_HEADERS.join(','),
+            ...rows.map(r => CSV_HEADERS.map(h => csvField(r[h])).join(',')),
+        ];
+        output = lines.join('\n') + '\n';
+    }
+    else {
+        output = JSON.stringify(rows, null, 2) + '\n';
+    }
+    const date = new Date().toISOString().slice(0, 10);
+    const dest = path_1.default.resolve(opts.output ?? path_1.default.join(os_1.default.homedir(), 'Downloads', `claudestat-export-${date}.${opts.format}`));
+    fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+    fs_1.default.writeFileSync(dest, output);
+    console.log(`✓ Exported ${rows.length} session(s) → ${dest}`);
+}

package/dist/git.d.ts

@@ -0,0 +1,22 @@
+/**
+ * git.ts — Información de git por proyecto (branch, dirty, ahead/behind)
+ *
+ * Diseño: módulo puro, síncrono, sin efectos secundarios.
+ * Usa child_process.execSync con timeout corto (3s) y stderr silenciado.
+ * Retorna null si el directorio no es un repo git o git no está disponible.
+ *
+ * Por qué síncrono: las llamadas son rápidas (<50ms en repos locales) y
+ * se invoca solo bajo demanda, no en el hot path de SSE.
+ */
+export interface GitInfo {
+    branch: string;
+    dirty: boolean;
+    ahead: number;
+    behind: number;
+    hasRemote: boolean;
+}
+/**
+ * Obtiene información de git para un directorio de proyecto.
+ * Retorna null si no es un repo git, git no está en PATH, o hay error.
+ */
+export declare function getGitInfo(projectPath: string): GitInfo | null;

package/dist/git.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * git.ts — Información de git por proyecto (branch, dirty, ahead/behind)
+ *
+ * Diseño: módulo puro, síncrono, sin efectos secundarios.
+ * Usa child_process.execSync con timeout corto (3s) y stderr silenciado.
+ * Retorna null si el directorio no es un repo git o git no está disponible.
+ *
+ * Por qué síncrono: las llamadas son rápidas (<50ms en repos locales) y
+ * se invoca solo bajo demanda, no en el hot path de SSE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitInfo = getGitInfo;
+const child_process_1 = require("child_process");
+const EXEC_OPTS = (cwd) => ({
+    cwd,
+    encoding: 'utf8',
+    timeout: 3000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+});
+/**
+ * Obtiene información de git para un directorio de proyecto.
+ * Retorna null si no es un repo git, git no está en PATH, o hay error.
+ */
+function getGitInfo(projectPath) {
+    try {
+        // ─ Branch ─
+        const branchRaw = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', EXEC_OPTS(projectPath)).trim();
+        let branch;
+        if (!branchRaw || branchRaw === 'HEAD') {
+            // Detached HEAD — mostrar SHA corto
+            const sha = (0, child_process_1.execSync)('git rev-parse --short HEAD', EXEC_OPTS(projectPath)).trim();
+            return { branch: `(${sha})`, dirty: false, ahead: 0, behind: 0, hasRemote: false };
+        }
+        branch = branchRaw;
+        // ─ Dirty status ─
+        const statusOut = (0, child_process_1.execSync)('git status --porcelain', EXEC_OPTS(projectPath)).trim();
+        const dirty = statusOut.length > 0;
+        // ─ Ahead / behind respecto al upstream ─
+        let ahead = 0, behind = 0, hasRemote = false;
+        try {
+            // --left-right: <upstream>...HEAD → "behind\tahead"
+            const ab = (0, child_process_1.execSync)('git rev-list --left-right --count @{upstream}...HEAD', EXEC_OPTS(projectPath)).trim();
+            const parts = ab.split(/\s+/);
+            behind = parseInt(parts[0] ?? '0', 10) || 0;
+            ahead = parseInt(parts[1] ?? '0', 10) || 0;
+            hasRemote = true;
+        }
+        catch {
+            // No hay upstream configurado — común en branches nuevos
+        }
+        return { branch, dirty, ahead, behind, hasRemote };
+    }
+    catch {
+        return null; // no es un repo git o git no disponible
+    }
+}

package/dist/github.d.ts

@@ -0,0 +1,27 @@
+/**
+ * github.ts — Estado de PR y CI vía GitHub CLI (`gh`)
+ *
+ * Usa `gh pr view` para obtener PR asociado al branch actual.
+ * Retorna null si no hay PR abierto, gh no está disponible, o no es GitHub.
+ *
+ * Por qué gh CLI y no la API directamente:
+ * - gh maneja autenticación automáticamente
+ * - Sin necesidad de tokens adicionales
+ * - Ya disponible en la mayoría de entornos de desarrollo
+ *
+ * Nota: `gh pr view` hace una llamada de red → puede ser lento (~500ms-2s).
+ * El daemon cachea el resultado 5 minutos por proyecto.
+ */
+export interface PRStatus {
+    number: number;
+    title: string;
+    state: 'OPEN' | 'CLOSED' | 'MERGED';
+    url: string;
+    branch: string;
+    ciState: 'SUCCESS' | 'FAILURE' | 'PENDING' | null;
+}
+/**
+ * Obtiene el estado del PR del branch actual en el repo de GitHub.
+ * Retorna null si no hay PR, gh no está disponible, o no es un repo GitHub.
+ */
+export declare function getPRStatus(projectPath: string): PRStatus | null;

package/dist/github.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * github.ts — Estado de PR y CI vía GitHub CLI (`gh`)
+ *
+ * Usa `gh pr view` para obtener PR asociado al branch actual.
+ * Retorna null si no hay PR abierto, gh no está disponible, o no es GitHub.
+ *
+ * Por qué gh CLI y no la API directamente:
+ * - gh maneja autenticación automáticamente
+ * - Sin necesidad de tokens adicionales
+ * - Ya disponible en la mayoría de entornos de desarrollo
+ *
+ * Nota: `gh pr view` hace una llamada de red → puede ser lento (~500ms-2s).
+ * El daemon cachea el resultado 5 minutos por proyecto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPRStatus = getPRStatus;
+const child_process_1 = require("child_process");
+const EXEC_OPTS = (cwd) => ({
+    cwd,
+    encoding: 'utf8',
+    timeout: 8000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+});
+/**
+ * Obtiene el estado del PR del branch actual en el repo de GitHub.
+ * Retorna null si no hay PR, gh no está disponible, o no es un repo GitHub.
+ */
+function getPRStatus(projectPath) {
+    try {
+        const out = (0, child_process_1.execSync)('gh pr view --json number,title,state,url,headRefName,statusCheckRollup', EXEC_OPTS(projectPath));
+        const pr = JSON.parse(out);
+        // ─ Determinar estado de CI desde statusCheckRollup ─
+        // Cada check puede tener `state` (PENDING/SUCCESS/FAILURE/ERROR) o
+        // `conclusion` (success/failure/cancelled/skipped) según el tipo de check.
+        const checks = pr.statusCheckRollup ?? [];
+        let ciState = checks.length > 0 ? 'PENDING' : null;
+        if (checks.length > 0) {
+            const statuses = checks.map((c) => (c.state ?? c.conclusion ?? '').toUpperCase());
+            if (statuses.some(s => s === 'FAILURE' || s === 'ERROR' || s === 'CANCELLED')) {
+                ciState = 'FAILURE';
+            }
+            else if (statuses.every(s => s === 'SUCCESS' || s === 'SKIPPED')) {
+                ciState = 'SUCCESS';
+            }
+            else {
+                ciState = 'PENDING';
+            }
+        }
+        return {
+            number: pr.number,
+            title: pr.title,
+            state: pr.state,
+            url: pr.url,
+            branch: pr.headRefName,
+            ciState,
+        };
+    }
+    catch {
+        return null; // no hay PR, gh no disponible, o no es GitHub
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * index.ts — Entry point del CLI
+ *
+ * Suprimimos el ExperimentalWarning de node:sqlite antes de importar nada.
+ * El módulo funciona perfectamente — el warning es solo informativo.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * index.ts — Entry point del CLI
+ *
+ * Suprimimos el ExperimentalWarning de node:sqlite antes de importar nada.
+ * El módulo funciona perfectamente — el warning es solo informativo.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Filtrar solo el warning de SQLite, dejar pasar el resto
+process.on('warning', (w) => {
+    if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite'))
+        return;
+    process.stderr.write(`${w.name}: ${w.message}\n`);
+});
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const daemon_1 = require("./daemon");
+const watchdog_1 = require("./watchdog");
+const watch_1 = require("./watch");
+const install_1 = require("./install");
+const export_1 = require("./export");
+const config_1 = require("./config");
+const doctor_1 = require("./doctor");
+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;
+const PID_FILE = (0, paths_1.getPidFile)();
+function spawnDaemon() {
+    const child = (0, child_process_1.spawn)(process.execPath, [process.argv[1], 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env, CLAUDESTAT_DAEMON: '1' },
+    });
+    child.unref();
+    console.log(`✅ claudestat daemon started (pid ${child.pid})`);
+    console.log(`   Dashboard → http://localhost:7337`);
+}
+function removePidFile() {
+    try {
+        fs_1.default.unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+async function stopDaemon() {
+    try {
+        const res = await fetch('http://localhost:7337/shutdown', {
+            method: 'POST',
+            signal: AbortSignal.timeout(2000),
+        });
+        if (res.ok) {
+            console.log('✅ claudestat daemon stopped');
+            removePidFile();
+            return;
+        }
+    }
+    catch { }
+    try {
+        const pid = parseInt(fs_1.default.readFileSync(PID_FILE, 'utf8').trim(), 10);
+        process.kill(pid, 'SIGTERM');
+        console.log(`✅ claudestat daemon stopped (pid ${pid})`);
+        removePidFile();
+    }
+    catch (e) {
+        removePidFile();
+        if (e.code === 'ENOENT')
+            throw new Error('Daemon is not running (no PID file found)');
+        if (e.code === 'ESRCH')
+            throw new Error('Daemon process not found — stale PID file removed');
+        throw new Error(`Error stopping daemon: ${e.message}`);
+    }
+}
+// Warn if the active binary is outside the current npm global prefix (NVM conflict)
+if (process.env.NVM_DIR || process.env.NVM_HOME) {
+    try {
+        const npmPrefix = (0, child_process_1.execSync)('npm prefix -g', { stdio: 'pipe' }).toString().trim();
+        const runningFrom = process.argv[1];
+        if (runningFrom && !runningFrom.startsWith(npmPrefix)) {
+            const refreshCmd = paths_1.isWindows ? 'refreshenv' : 'hash -r claudestat';
+            process.stderr.write(`\x1b[33m⚠️  claudestat is running from ${runningFrom}\x1b[0m\n` +
+                `   This binary may not match the active Node version (${process.version}).\n` +
+                `   Fix: \x1b[36mnvm use default && npm install -g @deibygs/claudestat\x1b[0m\n` +
+                `   Then restart your terminal or run: \x1b[36m${refreshCmd}\x1b[0m\n\n`);
+        }
+    }
+    catch { }
+}
+program
+    .name('claudestat')
+    .description('Real-time execution trace and cost intelligence for Claude Code')
+    .version(PKG_VERSION);
+program
+    .command('start')
+    .description('Start the background daemon (receives Claude Code hook events)')
+    .option('--watchdog', 'Auto-restart daemon if it crashes')
+    .action((opts) => {
+    if (process.env.CLAUDESTAT_DAEMON) {
+        (0, daemon_1.startDaemon)();
+        if (opts.watchdog)
+            (0, watchdog_1.startWatchdog)();
+    }
+    else {
+        spawnDaemon();
+        process.exit(0);
+    }
+});
+program
+    .command('watch')
+    .description('Live terminal trace view')
+    .action(() => (0, watch_1.startWatch)().catch(err => {
+    console.error('\n❌ Error:', err.message);
+    process.exit(1);
+}));
+program
+    .command('install')
+    .description('Install hooks into Claude Code settings')
+    .action(install_1.runInstall);
+program
+    .command('uninstall')
+    .description('Remove hooks from Claude Code')
+    .action(install_1.uninstallHooks);
+program
+    .command('export [format]')
+    .description('Export session data (json | csv, default: json). Max 500 sessions.')
+    .option('--from <date>', 'Start date YYYY-MM-DD (inclusive)')
+    .option('--to <date>', 'End date YYYY-MM-DD (inclusive)')
+    .option('--project <name>', 'Filter by project path (case-insensitive substring)')
+    .option('--output <path>', 'Write to file instead of stdout')
+    .action((format, opts) => {
+    const fmt = (format ?? 'json').toLowerCase();
+    if (fmt !== 'json' && fmt !== 'csv') {
+        console.error('Error: format must be "json" or "csv"');
+        process.exit(1);
+    }
+    (0, export_1.runExport)({ format: fmt, ...opts });
+    process.exit(0);
+});
+program
+    .command('status')
+    .description('Show current quota, cost and burn rate')
+    .option('--json', 'Output raw JSON instead of formatted text')
+    .action(async (opts) => {
+    try {
+        const [quotaRes, healthRes] = await Promise.all([
+            fetch('http://localhost:7337/quota'),
+            fetch('http://localhost:7337/health'),
+        ]);
+        if (!quotaRes.ok)
+            throw new Error('Daemon unavailable');
+        const q = await quotaRes.json();
+        const _h = await healthRes.json().catch(() => ({}));
+        if (opts.json) {
+            console.log(JSON.stringify({
+                cyclePrompts: q.cyclePrompts,
+                cycleLimit: q.cycleLimit,
+                cyclePct: q.cyclePct,
+                cycleResetMs: q.cycleResetMs,
+                plan: q.detectedPlan,
+                weeklyHoursSonnet: q.weeklyHoursSonnet,
+                weeklyLimitSonnet: q.weeklyLimitSonnet,
+                weeklyHoursOpus: q.weeklyHoursOpus,
+                weeklyLimitOpus: q.weeklyLimitOpus,
+                burnRateTokensPerMin: q.burnRateTokensPerMin,
+            }));
+            return;
+        }
+        const R = '\x1b[0m';
+        const pctColor = q.cyclePct >= 95 ? '\x1b[31m'
+            : q.cyclePct >= 85 ? '\x1b[33m'
+                : q.cyclePct >= 70 ? '\x1b[33m'
+                    : '\x1b[32m';
+        const resetMin = Math.ceil(q.cycleResetMs / 60000);
+        const resetLabel = resetMin >= 60
+            ? `${Math.floor(resetMin / 60)}h ${resetMin % 60}m`
+            : `${resetMin}m`;
+        const burnLabel = q.burnRateTokensPerMin > 0
+            ? ` │ 🔥 ${q.burnRateTokensPerMin.toLocaleString()} tok/min`
+            : '';
+        const burnRow = q.burnRateTokensPerMin > 0
+            ? `  Burn rate   ${q.burnRateTokensPerMin.toLocaleString()} tok/min\n`
+            : '';
+        console.log(`\n📊 claudestat status\n` +
+            `──────────────────────────────────────────\n` +
+            `  Quota 5h    ${pctColor}${q.cyclePrompts}/${q.cycleLimit} prompts (${q.cyclePct}%)${R}  │  resets in ${resetLabel}\n` +
+            `  Plan        ${q.detectedPlan.toUpperCase()}\n` +
+            `  Sonnet      ${q.weeklyHoursSonnet}h / ${q.weeklyLimitSonnet}h  this week\n` +
+            (q.weeklyLimitOpus > 0
+                ? `  Opus        ${q.weeklyHoursOpus}h / ${q.weeklyLimitOpus}h  this week\n`
+                : '') +
+            `${burnRow}` +
+            `──────────────────────────────────────────\n`);
+        process.exit(0);
+    }
+    catch {
+        console.error('\n❌ Daemon is not running. Start it with: claudestat start\n');
+        process.exit(1);
+    }
+});
+program
+    .command('config')
+    .description('View or edit configuration (~/.claudestat/config.json)')
+    .option('--kill-switch <bool>', 'Enable/disable kill switch: true|false')
+    .option('--threshold <number>', 'Quota percentage to trigger the kill switch (default: 95)')
+    .option('--plan <plan>', 'Force plan detection: pro|max5|max20|auto')
+    .option('--alerts <bool>', 'Enable/disable daemon rate limit alerts: true|false')
+    .action((opts) => {
+    const cfg = (0, config_1.readConfig)();
+    let changed = false;
+    if (opts.killSwitch !== undefined) {
+        cfg.killSwitchEnabled = opts.killSwitch === 'true';
+        changed = true;
+    }
+    if (opts.threshold !== undefined) {
+        const t = parseInt(opts.threshold, 10);
+        if (!isNaN(t) && t > 0 && t <= 100) {
+            cfg.killSwitchThreshold = t;
+            changed = true;
+        }
+        else
+            console.warn('  ⚠️  threshold must be a number between 1 and 100');
+    }
+    if (opts.plan !== undefined) {
+        if (['pro', 'max5', 'max20', 'auto'].includes(opts.plan)) {
+            cfg.plan = opts.plan === 'auto' ? null : opts.plan;
+            changed = true;
+        }
+        else {
+            console.warn('  ⚠️  plan must be: pro | max5 | max20 | auto');
+        }
+    }
+    if (opts.alerts !== undefined) {
+        cfg.alertsEnabled = opts.alerts === 'true';
+        changed = true;
+    }
+    if (changed) {
+        (0, config_1.writeConfig)(cfg);
+        console.log('✅ Config saved to ~/.claudestat/config.json');
+    }
+    // Always show current config
+    console.log('\n📋 Current config:');
+    console.log(`   killSwitchEnabled:  ${cfg.killSwitchEnabled}`);
+    console.log(`   killSwitchThreshold: ${cfg.killSwitchThreshold}%`);
+    console.log(`   warnThresholds:     ${cfg.warnThresholds.join('%, ')}%`);
+    console.log(`   alertsEnabled:      ${cfg.alertsEnabled}`);
+    console.log(`   plan:               ${cfg.plan ?? 'auto-detect'}\n`);
+    process.exit(0);
+});
+program
+    .command('stop')
+    .description('Stop the claudestat daemon')
+    .action(async () => {
+    await stopDaemon().catch((e) => { console.error(`❌ ${e.message}`); process.exit(1); });
+    process.exit(0);
+});
+program
+    .command('restart')
+    .description('Restart the claudestat daemon')
+    .action(async () => {
+    setTimeout(() => process.exit(0), 5000).unref();
+    await stopDaemon().catch(() => { console.log('  Daemon was not running, starting fresh…'); });
+    await new Promise(r => setTimeout(r, 500));
+    spawnDaemon();
+    process.exit(0);
+});
+program
+    .command('top')
+    .description('Rank tools by cost, frequency, or duration')
+    .option('--by <metric>', 'Sort by: cost, count, duration (default: cost)')
+    .option('--limit <number>', 'Number of tools to show (default: 10)')
+    .option('--days <number>', 'Look back N days (default: 30)')
+    .action(async (opts) => {
+    try {
+        const by = opts.by ?? 'cost';
+        const limit = opts.limit ?? 10;
+        const days = opts.days ?? 30;
+        const url = `http://localhost:7337/api/top?by=${by}&limit=${limit}&days=${days}`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error('Daemon unavailable');
+        const data = await res.json();
+        const label = by === 'count' ? 'calls' : by === 'duration' ? 'duration' : 'est. cost';
+        console.log(`\n🏆 claudestat top — by ${label} (last ${days} days)\n`);
+        console.log('  #  Tool              Calls    Duration   Est. Cost      %');
+        console.log('  ── ───────────────── ──────── ───────────── ───────── ────');
+        for (let i = 0; i < data.tools.length; i++) {
+            const t = data.tools[i];
+            const isOther = t.tool === 'Other';
+            const dur = isOther ? '—'
+                : t.totalDurationMs >= 60000
+                    ? `${(t.totalDurationMs / 60000).toFixed(1)}m`
+                    : `${(t.totalDurationMs / 1000).toFixed(0)}s`;
+            const cost = t.estimatedCostUsd < 0.01
+                ? `$${t.estimatedCostUsd.toFixed(4)}`
+                : `$${t.estimatedCostUsd.toFixed(2)}`;
+            const pct = by === 'cost' ? `${t.pctCost}%` : isOther ? '' : `${t.pctCount}%`;
+            const countStr = isOther ? '—' : String(t.count);
+            console.log(`  ${(i + 1).toString().padStart(2)}  ${t.tool.padEnd(18)} ${countStr.padStart(8)} ${dur.padStart(13)} ${cost.padStart(9)} ${pct.padStart(4)}`);
+        }
+        console.log();
+        process.exit(0);
+    }
+    catch {
+        console.error('\n❌ Daemon is not running. Start it with: claudestat start\n');
+        process.exit(1);
+    }
+});
+program
+    .command('doctor')
+    .description('Check installation health and diagnose common issues')
+    .action(() => (0, doctor_1.runDoctor)().catch(err => {
+    console.error('\n❌ Error:', err.message);
+    process.exit(1);
+}));
+program.parse();

package/dist/install.d.ts

@@ -0,0 +1,14 @@
+/**
+ * install.ts — Instalador de hooks en Claude Code
+ *
+ * Claude Code permite definir hooks en ~/.claude/settings.json.
+ * Este comando modifica ese archivo para agregar nuestros hooks
+ * sin pisar los que ya existan.
+ *
+ * IMPORTANTE: Hacemos un backup antes de modificar.
+ */
+export declare function installHooks(): void;
+export declare function runInstall(): Promise<void>;
+export declare function runWizard(): Promise<void>;
+export declare function showInstallStatus(): void;
+export declare function uninstallHooks(): void;