estela 0.1.0

package/dist/cli.js

@@ -0,0 +1,1091 @@
+#!/usr/bin/env node
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.breakdownOfTurn = void 0;
+const node_path_1 = require("node:path");
+// `node:sqlite` avisa de que es experimental en cada arranque. Es ruido para
+// quien solo quiere su factura, y el aviso no le dice nada accionable.
+process.removeAllListeners("warning");
+process.on("warning", (w) => {
+    if (w.name !== "ExperimentalWarning")
+        console.warn(w);
+});
+const shared_1 = require("@estela/shared");
+const node_fs_1 = require("node:fs");
+const amortize_js_1 = require("./billing/amortize.js");
+const invoice_js_1 = require("./billing/invoice.js");
+const sessionize_js_1 = require("./billing/sessionize.js");
+const schema_js_1 = require("./db/schema.js");
+const store = __importStar(require("./db/store.js"));
+const doctor_js_1 = require("./doctor.js");
+const setup_js_1 = require("./setup.js");
+const csv_js_1 = require("./export/csv.js");
+const invoice_pdf_js_1 = require("./export/invoice-pdf.js");
+const panel_js_1 = require("./export/panel.js");
+const share_js_1 = require("./export/share.js");
+const server_js_1 = require("./server.js");
+const auth_js_1 = require("./cloud/auth.js");
+const client_js_1 = require("./cloud/client.js");
+const cost_js_1 = require("./pricing/cost.js");
+Object.defineProperty(exports, "breakdownOfTurn", { enumerable: true, get: function () { return cost_js_1.breakdownOfTurn; } });
+const claude_js_1 = require("./watchers/claude.js");
+const git_js_1 = require("./watchers/git.js");
+const identity_js_1 = require("./watchers/identity.js");
+const team_js_1 = require("./metrics/team.js");
+const HELP = `
+estela — registro de horas para desarrollo asistido por IA
+
+  estela setup
+        Primera ejecución: detecta tus agentes y repositorios, y reconstruye
+        tu historial. Dos minutos, sin preguntas y sin cuenta.
+
+  estela import [--since YYYY-MM-DD] [--repo <ruta>]
+        Reconstruye tu historial desde los transcripts de los agentes y git.
+
+  estela client add --id <id> --name <nombre> --currency <EUR|USD|...>
+  estela project add --id <id> --client <id> --name <nombre> --repo <ruta>
+                     [--rounding <min>] [--ai-cost absorbed|passthrough]
+  estela rate set --project <id> --rate <importe> [--from YYYY-MM-DD]
+  estela budget --project <id> [--amount <dólares>|none]
+        Presupuesto mensual de IA. Sin --amount, consulta el actual. Alimenta
+        el aviso de la pestaña Equipo.
+
+  estela subscription add --id <id> --name <nombre> --fee <cuota> [--currency USD]
+        Registra una cuota fija (Claude Max, Cursor...). Con suscripción, el
+        gasto real es la cuota repartida por consumo, no la suma por token.
+
+  estela log --project <id> --hours <n> --what "<qué hiciste>"
+             [--kind development|meeting|research|review|travel|support|other]
+             [--date YYYY-MM-DD] [--minutes <n>]
+        Horas que ningún import va a deducir: reuniones, viajes, investigación,
+        y desarrollo sin agente que tampoco dejó commits.
+
+  estela author --project <id> [--email <a@b.com>[,otro@c.com]]
+        Con qué correo commiteas en ese proyecto. Sin --email, lista los
+        autores del repositorio para que elijas el tuyo.
+
+  estela web [--port 4319]            Abre el panel en tu navegador.
+  estela doctor                       Revisa los datos y avisa de lo que
+                                      rompería una demo. Úsalo antes de publicar.
+  estela status                       Qué hay capturado y sin imputar.
+  estela entries --project <id>       Bloques imputados a un proyecto.
+  estela ai-cost                      Reparto de tu cuota entre proyectos.
+  estela share --project <id> [--from YYYY-MM-DD] [--to YYYY-MM-DD]
+               [--author <tu nombre>] [--with-amounts] [--out <fichero.html>]
+        Informe compartible en un solo fichero HTML. Horas y commits; sin
+        consumo de IA, que es tuyo mientras la pagues tú.
+
+  estela publish --project <id> [--author <tu nombre>] [--with-amounts]
+                 [--base-url https://tu-dominio] [--token <existente>]
+                 [--no-team] [--site https://getestela.dev]
+        Panel de solo lectura para que tu cliente USE el producto, no solo
+        reciba un documento. Un fichero estático con enlace no adivinable.
+
+  estela login --email <tú@dominio.com> [--api <url>]
+        Vincula esta máquina a tu cuenta. Sin esto, Estela sigue siendo 100%
+        local: nada de lo de abajo cambia lo que ya haces sin cuenta.
+  estela logout
+        Desvincula esta máquina. Tus datos locales no se tocan.
+
+  estela export --project <id> [--out <fichero.csv>]
+
+  estela report --project <id> --cutoff YYYY-MM-DD [--dry-run]
+                [--pdf <fichero.pdf>] [--csv <fichero.csv>] [--fx <tipo>]
+                [--from-name <tu nombre>] [--from-email <email>]
+        Informe de horas y commits para respaldar tu trabajo. No es una
+        factura: Estela no emite documentos fiscales.
+
+Opciones globales:  --db <ruta>   (por defecto ${schema_js_1.DEFAULT_DB_PATH})
+`;
+function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith("--")) {
+            positional.push(arg);
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith("--")) {
+            flags[key] = next;
+            i++;
+        }
+        else
+            flags[key] = true;
+    }
+    return { _: positional, flags };
+}
+function str(args, key) {
+    const value = args.flags[key];
+    return typeof value === "string" ? value : undefined;
+}
+function required(args, key) {
+    const value = str(args, key);
+    if (!value)
+        throw new UserError(`Falta --${key}`);
+    return value;
+}
+class UserError extends Error {
+}
+// ---------------------------------------------------------------------------
+/**
+ * `estela web` — abre el panel local.
+ *
+ * Quien instala la CLI no tiene forma de arrancar el servidor: hasta ahora
+ * vivía en un script del repositorio, que solo existe si te lo has clonado.
+ */
+async function cmdWeb(args, dbPath) {
+    const port = Number(str(args, "port") ?? 4319);
+    const url = await (0, server_js_1.startServer)({ port, dbPath });
+    console.log(`\n  Estela  ${url}`);
+    console.log(`  Datos:  ${dbPath}`);
+    console.log(`\n  Ctrl+C para parar.\n`);
+    // No devuelve: el servidor se queda escuchando.
+    await new Promise(() => { });
+}
+const DEFAULT_API_BASE_URL = "https://api.getestela.dev";
+async function cmdLogin(args, dbPath) {
+    const email = required(args, "email");
+    const apiBaseUrl = str(args, "api") ?? process.env["ESTELA_API_BASE_URL"] ?? DEFAULT_API_BASE_URL;
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        await (0, auth_js_1.login)(db, email, apiBaseUrl);
+    }
+    finally {
+        db.close();
+    }
+}
+async function cmdLogout(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        await (0, auth_js_1.logout)(db);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * `estela setup` — la primera ejecución.
+ *
+ * Dos minutos, sin preguntas y sin cuenta. Si al terminar esa persona no ve
+ * algo cierto sobre su propio trabajo, no habrá una segunda ejecución.
+ */
+async function cmdSetup(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        console.log("\nEstela\n");
+        console.log("Leyendo lo que tus agentes ya guardaron en disco…");
+        const scan = await (0, claude_js_1.scanClaudeCode)({});
+        const turns = (0, claude_js_1.resolveScratchpads)(scan.turns);
+        if (turns.length === 0) {
+            console.log("\n  No se han encontrado sesiones de Claude Code en ~/.claude.");
+            console.log("  Estela lee lo que el agente ya escribe; sin sesiones no hay nada");
+            console.log("  que reconstruir todavía. Vuelve tras trabajar un rato.\n");
+            return;
+        }
+        store.saveTurns(db, turns);
+        store.logScan(db, "claude-code", scan.report);
+        console.log(`  ${scan.report.turnsAccepted} turnos · ` +
+            `${scan.report.producerVersions.length} versiones de Claude Code`);
+        const repos = new Set();
+        for (const turn of turns)
+            if (turn.repoPath)
+                repos.add(turn.repoPath);
+        console.log(`\nBuscando repositorios… (${repos.size})`);
+        const plans = await (0, setup_js_1.planSetup)(db, [...repos], await (0, git_js_1.gitUserEmail)(process.cwd()));
+        const nuevos = (0, setup_js_1.applySetup)(db, plans);
+        for (const plan of plans.filter((x) => !x.existing)) {
+            console.log(`  + ${plan.name}` +
+                (plan.emails.length ? `  (commiteas como ${plan.emails[0]})` : "  ⚠ sin autor claro"));
+        }
+        const yaEstaban = plans.filter((x) => x.existing).length;
+        if (yaEstaban)
+            console.log(`  ${yaEstaban} ya estaban configurados y no se tocan`);
+        console.log("\nReconstruyendo tu historial…");
+        await cmdImport({ _: [], flags: { ...(args.flags["db"] ? { db: args.flags["db"] } : {}) } }, dbPath);
+        const s = (0, setup_js_1.summarize)(db);
+        console.log(`\n${"─".repeat(66)}`);
+        console.log(`  ${(0, setup_js_1.summaryLine)(s)}`);
+        if (s.from)
+            console.log(`  del ${s.from} al ${s.to}`);
+        if (s.people > 1) {
+            console.log(`  ${s.people} personas han commiteado en esos repositorios`);
+        }
+        console.log(`${"─".repeat(66)}\n`);
+        const sinAutor = plans.filter((p) => !p.existing && p.emails.length === 0);
+        if (sinAutor.length) {
+            console.log(`  ⚠ En ${sinAutor.length} repositorio(s) no se ha podido saber con qué`);
+            console.log(`    correo commiteas, así que ahí no se ha capturado nada tuyo:`);
+            for (const p of sinAutor.slice(0, 3)) {
+                console.log(`      estela author --project ${p.projectId}`);
+            }
+            console.log("");
+        }
+        console.log("  Ábrelo:        estela web");
+        console.log("  Revísalo:      estela doctor");
+        if (nuevos > 0) {
+            console.log("\n  Los proyectos se han creado como internos y sin tarifa. Si alguno");
+            console.log("  es de un cliente al que facturas, ponle la suya y podrás emitir");
+            console.log("  informes:  estela rate set --project <id> --rate 50\n");
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+async function cmdImport(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const sinceRaw = str(args, "since");
+        const since = sinceRaw ? new Date(`${sinceRaw}T00:00:00Z`) : undefined;
+        if (since && Number.isNaN(since.getTime()))
+            throw new UserError(`Fecha inválida: ${sinceRaw}`);
+        const repoFilter = str(args, "repo");
+        const repoPaths = repoFilter ? [(0, node_path_1.resolve)(repoFilter)] : undefined;
+        console.log("Leyendo transcripts de agentes…");
+        const scan = await (0, claude_js_1.scanClaudeCode)({
+            ...(since ? { since } : {}),
+            ...(repoPaths ? { repoPaths } : {}),
+        });
+        const report = scan.report;
+        // Devolver al repositorio el trabajo hecho en scratchpads, o esas horas
+        // quedan sin proyecto y desaparecen del parte.
+        const turns = (0, claude_js_1.resolveScratchpads)(scan.turns);
+        const rescued = turns.filter((t, i) => t.repoPath !== scan.turns[i].repoPath).length;
+        const savedTurns = store.saveTurns(db, turns);
+        store.logScan(db, "claude-code", report);
+        console.log(`  ${report.filesRead} archivos · ${report.recordsSeen} registros`);
+        console.log(`  ${report.turnsAccepted} turnos aceptados · ${savedTurns} nuevos`);
+        console.log(`  ${report.duplicatesDropped} duplicados descartados` +
+            (report.turnsAccepted > 0
+                ? ` (${(report.duplicatesDropped / (report.turnsAccepted + report.duplicatesDropped) * 100).toFixed(0)}% de las filas)`
+                : ""));
+        console.log(`  ${report.unknownRecords} registros internos ignorados · ${report.malformedRecords} malformados`);
+        if (report.producerVersions.length) {
+            console.log(`  versiones de Claude Code: ${report.producerVersions.join(", ")}`);
+        }
+        for (const warning of report.warnings)
+            console.warn(`  ⚠ ${warning}`);
+        // Commits de cada repositorio que aparece en los transcripts.
+        const repos = new Set();
+        for (const turn of turns)
+            if (turn.repoPath)
+                repos.add(turn.repoPath);
+        // Se guardan TODOS los autores: es lo que alimenta la vista de equipo. El
+        // filtro por tus correos va más abajo, justo antes de imputar horas.
+        let savedCommits = 0;
+        for (const repo of repos) {
+            const root = await (0, git_js_1.repoRoot)(repo);
+            if (!root)
+                continue;
+            savedCommits += store.saveCommits(db, await (0, git_js_1.readCommits)(root, since ? { since } : {}));
+        }
+        const mine = await (0, identity_js_1.myEmailsByRepo)(db, repos);
+        if (rescued > 0) {
+            console.log(`  ${rescued} turnos de scratchpad devueltos a su repositorio`);
+        }
+        console.log(`Git: ${repos.size} repositorios · ${savedCommits} commits nuevos`);
+        // Agrupar en bloques, fusionar por rama y día, e imputar a los proyectos.
+        // Trabajo deducido de los agentes, y además el de los commits que no
+        // solapan con ninguno: quien programa sin IA solo deja ese rastro.
+        // Solo TUS commits derivan horas tuyas. Sin este filtro, los commits de un
+        // compañero se convertirían en tiempo facturable a tu nombre.
+        const commitsAll = (0, identity_js_1.onlyMine)(await allCommits(db), mine);
+        const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(turns), commitsAll);
+        const fromCommits = (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commitsAll), fromAgents);
+        const raw = [...fromAgents, ...fromCommits];
+        const blocks = (0, sessionize_js_1.groupByBranchAndDay)(raw);
+        if (fromCommits.length) {
+            console.log(`  ${fromCommits.length} bloques deducidos solo de commits (sin agente)`);
+        }
+        let entries = 0;
+        let unassigned = 0;
+        for (const block of blocks) {
+            const projectId = block.repoPath ? store.projectForRepo(db, block.repoPath) : null;
+            if (!projectId) {
+                unassigned++;
+                continue;
+            }
+            const project = store.getProject(db, projectId);
+            const entry = {
+                projectId,
+                startedAt: block.startedAt,
+                endedAt: block.endedAt,
+                seconds: block.seconds,
+                description: (0, sessionize_js_1.describeBlock)(block),
+                billable: project.billable,
+                invoiceId: null,
+                aiCost: block.aiCost,
+                // Un bloque deducido solo de commits no tuvo agente: ni segundos de
+                // agente ni agente al que atribuirlos.
+                agentSeconds: block.turnCount > 0 ? block.seconds : 0,
+                commitHashes: block.commits.map((c) => c.hash),
+                agents: block.turnCount > 0 ? ["claude-code"] : [],
+                source: block.turnCount > 0 ? "agent" : "commit",
+                kind: "development",
+                branch: block.branch,
+            };
+            // El id es determinista (proyecto + día + rama) para que reimportar
+            // actualice la imputación en vez de duplicarla. La fecha tiene que ser la
+            // LOCAL y la misma que usa el servidor: con toISOString() se generaba un
+            // id distinto para el mismo bloque y el día se contaba dos veces.
+            const day = (0, shared_1.localDate)(block.startedAt);
+            const slug = (block.branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
+            store.saveTimeEntry(db, { ...entry, id: `te_${projectId}_${day}_${slug}` });
+            entries++;
+        }
+        console.log(`Bloques: ${raw.length} detectados → ${blocks.length} tras agrupar por rama y día · ` +
+            `${entries} imputados · ${unassigned} sin proyecto`);
+        if (unassigned > 0) {
+            console.log(`\nHay ${unassigned} bloques sin proyecto asignado. Regístralos con:`);
+            console.log(`  estela project add --id <id> --client <id> --name <nombre> --repo <ruta>`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+async function allCommits(db) {
+    const rows = db.prepare("SELECT * FROM commits").all();
+    return rows.map((r) => ({
+        repoPath: r["repo_path"],
+        hash: r["hash"],
+        at: new Date(r["at"]),
+        authorEmail: r["author_email"],
+        authorName: r["author_name"] ?? "",
+        branch: r["branch"] ?? null,
+        subject: r["subject"],
+        linesAdded: r["lines_added"],
+        linesDeleted: r["lines_deleted"],
+        files: String(r["files"] ?? "").split("\n").filter(Boolean),
+    }));
+}
+function cmdClientAdd(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const currency = required(args, "currency").toUpperCase();
+        store.upsertClient(db, {
+            id: required(args, "id"),
+            name: required(args, "name"),
+            currency,
+            ...(str(args, "tax-id") ? { taxId: str(args, "tax-id") } : {}),
+            ...(str(args, "email") ? { email: str(args, "email") } : {}),
+        });
+        console.log(`Cliente "${required(args, "name")}" guardado. Factura en ${currency}.`);
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdProjectAdd(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const clientId = required(args, "client");
+        if (!store.getClient(db, clientId)) {
+            throw new UserError(`No existe el cliente "${clientId}". Créalo primero con: estela client add`);
+        }
+        const repo = str(args, "repo");
+        store.upsertProject(db, {
+            id: required(args, "id"),
+            clientId,
+            name: required(args, "name"),
+            repoPaths: repo ? [(0, node_path_1.resolve)(repo)] : [],
+            billable: str(args, "billable") !== "false",
+            roundingMinutes: Number(str(args, "rounding") ?? 0),
+            aiCostPolicy: (str(args, "ai-cost") ?? "absorbed"),
+            kind: (str(args, "kind") ?? "client"),
+        });
+        console.log(`Proyecto "${required(args, "name")}" guardado.`);
+        if (repo)
+            console.log(`  repositorio: ${(0, node_path_1.resolve)(repo)}`);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Presupuesto mensual de IA de un proyecto.
+ *
+ * En dólares, que es la moneda en la que facturan los modelos, aunque le
+ * cobres al cliente en euros. Mezclarlo con la moneda del cliente obligaría a
+ * un tipo de cambio para comparar el gasto con su propio límite.
+ *
+ * Sin presupuesto no hay aviso. Es distinto de un presupuesto de cero, que
+ * avisaría siempre.
+ */
+function cmdBudget(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const raw = str(args, "amount");
+        if (raw === undefined) {
+            const current = db.prepare("SELECT ai_budget_micro_usd AS b FROM projects WHERE id = ?").get(projectId);
+            console.log(current.b === null
+                ? `"${project.name}" no tiene presupuesto de IA.`
+                : `"${project.name}": $${(current.b / 1e6).toFixed(2)} al mes.`);
+            return;
+        }
+        if (raw === "none") {
+            db.prepare("UPDATE projects SET ai_budget_micro_usd = NULL WHERE id = ?").run(projectId);
+            console.log(`Presupuesto de "${project.name}" retirado.`);
+            return;
+        }
+        const dollars = Number(raw.replace(",", "."));
+        if (!Number.isFinite(dollars) || dollars < 0) {
+            throw new UserError(`Importe inválido: ${raw}`);
+        }
+        db.prepare("UPDATE projects SET ai_budget_micro_usd = ? WHERE id = ?")
+            .run(Math.round(dollars * 1e6), projectId);
+        console.log(`Presupuesto de IA de "${project.name}": $${dollars.toFixed(2)} al mes.`);
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdRateSet(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const client = store.getClient(db, project.clientId);
+        const currency = str(args, "currency")?.toUpperCase() ?? client.currency;
+        const rate = (0, shared_1.parseMoney)(required(args, "rate"), currency);
+        const fromRaw = str(args, "from");
+        const effectiveFrom = fromRaw ? new Date(`${fromRaw}T00:00:00Z`) : new Date(0);
+        store.addRatePeriod(db, { projectId, hourlyRate: rate, effectiveFrom, effectiveTo: null });
+        console.log(`Tarifa de "${project.name}": ${(0, shared_1.formatMoney)(rate)}/hora` +
+            (fromRaw ? ` desde ${fromRaw}.` : " (aplica a todo el histórico)."));
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdStatus(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const turns = db.prepare("SELECT COUNT(*) n, SUM(cost_micro_usd) c, MIN(at) a, MAX(at) b FROM agent_turns").get();
+        console.log(`Base de datos: ${dbPath}\n`);
+        console.log(`Turnos de agente:  ${turns.n}`);
+        if (turns.a)
+            console.log(`Periodo:           ${turns.a.slice(0, 10)} → ${turns.b.slice(0, 10)}`);
+        console.log(`Coste de IA total: ${(0, shared_1.formatAiCost)({ microUsd: turns.c ?? 0 })}\n`);
+        const clients = store.listClients(db);
+        if (clients.length === 0) {
+            console.log("Sin clientes configurados. Empieza con:");
+            console.log("  estela client add --id <id> --name <nombre> --currency EUR");
+            return;
+        }
+        for (const client of clients) {
+            console.log(`${client.name}  [${client.currency}]`);
+            for (const project of store.listProjects(db).filter((p) => p.clientId === client.id)) {
+                const entries = store.getTimeEntries(db, project.id);
+                const pending = entries.filter((e) => e.billable && e.invoiceId === null);
+                const seconds = pending.reduce((s, e) => s + e.seconds, 0);
+                const ai = pending.reduce((s, e) => s + e.aiCost.microUsd, 0);
+                const rate = (0, invoice_js_1.rateAt)(store.getRates(db, project.id), project.id, new Date());
+                console.log(`  ${project.name}`);
+                console.log(`    tarifa:          ${rate ? `${(0, shared_1.formatMoney)(rate)}/h` : "— sin definir —"}`);
+                console.log(`    sin facturar:    ${(0, shared_1.formatDuration)(seconds)} en ${pending.length} bloques`);
+                if (rate && seconds > 0) {
+                    const amount = { amount: Math.round((rate.amount * seconds) / 3600), currency: rate.currency };
+                    console.log(`    importe:         ${(0, shared_1.formatMoney)(amount)}`);
+                }
+                console.log(`    coste de IA:     ${(0, shared_1.formatAiCost)({ microUsd: ai })}`);
+            }
+            console.log("");
+        }
+        const scan = db.prepare("SELECT * FROM scan_log ORDER BY id DESC LIMIT 1")
+            .get();
+        if (scan && String(scan["warnings"])) {
+            console.warn(`⚠ ${scan["warnings"]}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdEntries(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const entries = store.getTimeEntries(db, projectId);
+        if (entries.length === 0) {
+            console.log("Sin bloques imputados. Ejecuta: estela import");
+            return;
+        }
+        console.log(`${project.name}\n`);
+        for (const e of entries) {
+            const flag = e.invoiceId ? "facturado" : e.billable ? "pendiente" : "no facturable";
+            console.log(`${e.startedAt.toISOString().slice(0, 16).replace("T", " ")}  ` +
+                `${(0, shared_1.formatDuration)(e.seconds).padStart(8)}  ` +
+                `${(0, shared_1.formatAiCost)(e.aiCost).padStart(9)}  ` +
+                `${flag.padEnd(14)}  ${e.description.slice(0, 44)}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Genera el informe compartible.
+ *
+ * El fichero es autónomo a propósito: se manda por correo y se abre sin cuenta,
+ * sin instalar nada y sin depender de que esta máquina esté encendida.
+ */
+function cmdShare(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const client = store.getClient(db, project.clientId);
+        const to = str(args, "to") ?? (0, shared_1.localDate)(new Date());
+        const from = str(args, "from") ?? to.slice(0, 8) + "01";
+        const rates = store.getRates(db, projectId);
+        const html = (0, share_js_1.buildShareReport)({
+            project, client,
+            entries: store.getTimeEntries(db, projectId),
+            from, to,
+            ...(str(args, "author") ? { authorName: str(args, "author") } : {}),
+            withAmounts: args.flags["with-amounts"] === true,
+            rateAt: (at) => (0, invoice_js_1.rateAt)(rates, projectId, at),
+            // La IA la pagas tú mientras no haya una organización detrás, así que su
+            // consumo no entra en el informe. No es una opción: no hay bandera.
+            aiPayer: "self",
+            commitsOf: (hashes) => hashes.length
+                ? db.prepare(`SELECT hash, subject FROM commits WHERE hash IN (${hashes.map(() => "?").join(",")})`).all(...hashes)
+                : [],
+        });
+        const out = str(args, "out") ?? `informe-${projectId}-${to}.html`;
+        (0, node_fs_1.writeFileSync)(out, html, "utf8");
+        console.log(`\nInforme: ${out}`);
+        console.log(`  ${project.name} · ${client.name} · ${from} al ${to}`);
+        console.log(`  Un solo fichero. Se abre sin instalar nada y sin depender de tu máquina.`);
+        if (args.flags["with-amounts"] !== true) {
+            console.log(`\n  Incluye horas y commits. Sin importes (añade --with-amounts) y sin`);
+            console.log(`  consumo de IA, que es tuyo mientras la pagues tú.`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Registra tiempo a mano.
+ *
+ * Un proyecto no son solo commits. Reuniones, desplazamientos, investigación y
+ * spikes son horas reales que se facturan igual, y sin poder anotarlas el parte
+ * del día miente por omisión: enseña solo lo que dejó rastro en Git y hace
+ * parecer que el resto del trabajo no ocurrió.
+ */
+function cmdLog(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project) {
+            const known = store.listProjects(db).map((p) => p.id).join(", ") || "(ninguno)";
+            throw new UserError(`No existe el proyecto "${projectId}". Los que hay: ${known}`);
+        }
+        const kind = (str(args, "kind") ?? "meeting");
+        if (!(kind in shared_1.WORK_KIND_LABELS)) {
+            throw new UserError(`Tipo "${kind}" no reconocido. Usa uno de: ${Object.keys(shared_1.WORK_KIND_LABELS).join(", ")}`);
+        }
+        const hoursRaw = str(args, "hours");
+        const minutesRaw = str(args, "minutes");
+        if (!hoursRaw && !minutesRaw)
+            throw new UserError("Indica --hours o --minutes");
+        const seconds = Math.round((hoursRaw ? Number(hoursRaw.replace(",", ".")) * 3600 : 0) +
+            (minutesRaw ? Number(minutesRaw) * 60 : 0));
+        if (!Number.isFinite(seconds) || seconds <= 0) {
+            throw new UserError(`Duración inválida: ${hoursRaw ?? minutesRaw}`);
+        }
+        const day = str(args, "date") ?? (0, shared_1.localDate)(new Date());
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(day))
+            throw new UserError(`Fecha inválida: ${day}`);
+        // A media mañana: no sabemos la hora real y fingir precisión sería peor.
+        const startedAt = new Date(`${day}T10:00:00`);
+        const what = str(args, "what") ?? shared_1.WORK_KIND_LABELS[kind];
+        const id = store.saveTimeEntry(db, {
+            projectId,
+            startedAt,
+            endedAt: new Date(startedAt.getTime() + seconds * 1000),
+            seconds,
+            description: what,
+            billable: str(args, "billable") !== "false",
+            invoiceId: null,
+            aiCost: { microUsd: 0 },
+            agentSeconds: 0,
+            commitHashes: [],
+            agents: [],
+            source: "manual",
+            kind,
+            branch: null,
+        });
+        const rate = (0, invoice_js_1.rateAt)(store.getRates(db, projectId), projectId, startedAt);
+        const amount = rate
+            ? ` · ${(0, shared_1.formatMoney)({ amount: Math.round((rate.amount * seconds) / 3600), currency: rate.currency })}`
+            : "";
+        console.log(`\n${shared_1.WORK_KIND_LABELS[kind]} · ${(0, shared_1.formatDuration)(seconds)}${amount}`);
+        console.log(`  ${what}`);
+        console.log(`  ${project.name} · ${day}`);
+        console.log(`\n  Registro manual: un import no lo va a tocar.  (${id})`);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Publica el proyecto como panel de solo lectura.
+ *
+ * Genera un directorio con el token en la ruta, listo para subir a un servidor
+ * estático. Se entrega el enlace completo para que no haya que componerlo a
+ * mano y equivocarse.
+ *
+ * El token es lo único que protege la página: quien tenga la URL, entra. Por eso
+ * son 128 bits y por eso revocar el acceso es borrar la carpeta del servidor —
+ * una caducidad comprobada en el navegador no protegería de nada.
+ */
+async function cmdPublish(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const client = store.getClient(db, project.clientId);
+        const rates = store.getRates(db, projectId);
+        // Reutilizar el token si se republica: el cliente ya tiene ese enlace
+        // guardado y cambiárselo sin avisar le rompe el marcador.
+        const token = str(args, "token") ?? (0, panel_js_1.newPanelToken)();
+        // Las métricas necesitan los commits del proyecto y saber qué ramas están
+        // integradas. Sin lo segundo no se puede distinguir entregado de en curso.
+        const projectCommits = commitsOfProject(db, project.repoPaths);
+        const merged = project.repoPaths[0]
+            ? await (0, git_js_1.mergedBranches)(project.repoPaths[0]) : null;
+        // El equipo del proyecto. Se enseña porque el repositorio es del cliente y
+        // esos nombres ya los tiene en su git; lo que no sale de aquí son las horas
+        // ajenas, que se quitan ANTES de construir el fichero. Ocultarlas al pintar
+        // dejaría el dato en el código fuente, que es no ocultarlas.
+        const myEntries = store.getTimeEntries(db, projectId);
+        const mineByRepo = await (0, identity_js_1.myEmailsByRepo)(db, project.repoPaths);
+        const myEmails = new Set();
+        for (const set of mineByRepo.values())
+            for (const email of set)
+                myEmails.add(email);
+        // Acotado al periodo que cubre el panel. Sin esto se compara el historial
+        // entero del repositorio con las semanas que llevas tú: salían 523 commits
+        // de un compañero frente a 11 tuyos, y el panel que venía a respaldar tu
+        // trabajo te dejaba a la altura del betún. Además mete gente que ya no está
+        // en el proyecto.
+        const worked = myEntries.map((e) => (0, shared_1.localDate)(e.startedAt)).sort((a, b) => a.localeCompare(b));
+        const from = worked[0] ?? "0000-01-01";
+        const to = worked[worked.length - 1] ?? "9999-12-31";
+        const inPeriod = projectCommits.filter((c) => {
+            const day = (0, shared_1.localDate)(c.at);
+            return day >= from && day <= to;
+        });
+        const team = (0, team_js_1.teamView)(inPeriod, { myEmails, myEntries }).map((p) => ({
+            name: p.name,
+            isMe: p.isMe,
+            ...(p.isMe ? { seconds: p.seconds } : {}),
+            commits: p.commits,
+            branches: p.branches.length,
+            lastDay: p.lastDay,
+        }));
+        const html = (0, panel_js_1.buildPanel)({
+            project, client,
+            entries: myEntries,
+            ...(args.flags["no-team"] === true ? {} : { team }),
+            ...(str(args, "site") ? { siteUrl: str(args, "site") } : {}),
+            ...(str(args, "author") ? { authorName: str(args, "author") } : {}),
+            withAmounts: args.flags["with-amounts"] === true,
+            rateAt: (at) => (0, invoice_js_1.rateAt)(rates, projectId, at),
+            aiPayer: "self",
+            commits: projectCommits,
+            ...(merged ? { merged } : {}),
+            commitsOf: (hashes) => hashes.length
+                ? db.prepare(`SELECT hash, subject FROM commits WHERE hash IN (${hashes.map(() => "?").join(",")})`).all(...hashes)
+                : [],
+        });
+        store.recordPublication(db, projectId, token, str(args, "base-url") ?? null);
+        const outDir = (0, node_path_1.join)(str(args, "out") ?? "./publicar", "e", token);
+        (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, "index.html"), html, "utf8");
+        const base = (str(args, "base-url") ?? "https://TU-DOMINIO").replace(/\/$/, "");
+        console.log(`\nPanel publicable generado.\n`);
+        console.log(`  Carpeta:  ${outDir}`);
+        console.log(`  Enlace:   ${base}/e/${token}/\n`);
+        console.log(`  Súbelo con:`);
+        console.log(`    rsync -av ${str(args, "out") ?? "./publicar"}/ usuario@tu-droplet:/var/www/estela/\n`);
+        console.log(`  El token es lo único que protege la página: quien tenga el enlace, entra.`);
+        console.log(`  Para revocar el acceso, borra la carpeta e/${token}/ del servidor.`);
+        console.log(`  Al republicar, pasa --token ${token} o el cliente perderá su enlace.`);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Configura con qué correos commiteas en un proyecto.
+ *
+ * Sin argumento `--email`, enseña los autores del repositorio para que elijas:
+ * en el repositorio de un cliente hay varios compañeros y tu correo global no
+ * aparece por ningún lado.
+ */
+async function cmdAuthor(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const emails = (str(args, "email") ?? "").split(",").map((e) => e.trim()).filter(Boolean);
+        if (emails.length === 0) {
+            const repo = project.repoPaths[0];
+            if (!repo)
+                throw new UserError("El proyecto no tiene repositorio asignado.");
+            console.log(`\nAutores en ${project.name}:\n`);
+            for (const a of await (0, git_js_1.repoAuthors)(repo)) {
+                console.log(`  ${a.email.padEnd(38)} ${String(a.commits).padStart(5)} commits, hasta ${a.lastAt}`);
+            }
+            const current = store.getProjectAuthors(db, projectId);
+            console.log(`\nConfigurado ahora: ${current.length ? current.join(", ") : "— nada —"}`);
+            console.log(`\nElige el tuyo con:`);
+            console.log(`  estela author --project ${projectId} --email tu@correo.com`);
+            return;
+        }
+        store.setProjectAuthors(db, projectId, emails);
+        console.log(`\n${project.name}: commits filtrados por ${emails.join(", ")}`);
+        console.log(`Ejecuta "estela import" para recoger los que faltaban.`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** Commits de los repositorios de un proyecto, con sus ficheros. */
+function commitsOfProject(db, repoPaths) {
+    if (repoPaths.length === 0)
+        return [];
+    const like = repoPaths.map(() => "repo_path LIKE ?").join(" OR ");
+    const rows = db.prepare(`SELECT * FROM commits WHERE ${like}`)
+        .all(...repoPaths.map((p) => `${p}%`));
+    return rows.map((r) => ({
+        repoPath: r["repo_path"], hash: r["hash"],
+        at: new Date(r["at"]), authorEmail: r["author_email"],
+        authorName: r["author_name"] ?? "",
+        branch: r["branch"] ?? null, subject: r["subject"],
+        linesAdded: r["lines_added"], linesDeleted: r["lines_deleted"],
+        files: String(r["files"] ?? "").split("\n").filter(Boolean),
+    }));
+}
+/** Revisa los datos y avisa de lo que rompería una demo. */
+function cmdDoctor(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const findings = (0, doctor_js_1.diagnose)(db);
+        console.log((0, doctor_js_1.renderFindings)(findings));
+        if (findings.some((f) => f.severity === "error"))
+            process.exitCode = 1;
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdExport(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const client = store.getClient(db, project.clientId);
+        const rates = store.getRates(db, projectId);
+        const csv = (0, csv_js_1.timeEntriesToCsv)(store.getTimeEntries(db, projectId), project, client, (at) => (0, invoice_js_1.rateAt)(rates, projectId, at));
+        const out = str(args, "out");
+        if (out) {
+            (0, node_fs_1.writeFileSync)(out, csv, "utf8");
+            console.log(`CSV: ${out}`);
+        }
+        else {
+            process.stdout.write(csv);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdSubscriptionAdd(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const currency = (str(args, "currency")?.toUpperCase() ?? "USD");
+        const fee = (0, shared_1.parseMoney)(required(args, "fee"), currency);
+        const fromRaw = str(args, "from");
+        store.upsertSubscription(db, {
+            id: required(args, "id"),
+            name: str(args, "name") ?? required(args, "id"),
+            monthlyFee: fee,
+            effectiveFrom: fromRaw ? new Date(`${fromRaw}T00:00:00Z`) : new Date(0),
+            effectiveTo: null,
+        });
+        console.log(`Suscripción "${str(args, "name") ?? required(args, "id")}": ${(0, shared_1.formatMoney)(fee)}/mes.`);
+        console.log("Se repartirá entre proyectos según lo que consumió cada uno.");
+    }
+    finally {
+        db.close();
+    }
+}
+/** Reparto de la cuota entre proyectos, mes a mes. */
+function cmdAiCost(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const subs = store.listSubscriptions(db);
+        const rows = store.consumptionByProjectMonth(db);
+        if (rows.length === 0) {
+            console.log("Sin consumo registrado. Ejecuta: estela import");
+            return;
+        }
+        if (subs.length === 0) {
+            console.log("Sin suscripciones registradas: el coste se muestra a tarifa API.\n");
+            console.log("Si pagas cuota fija, regístrala para ver el gasto real:");
+            console.log('  estela subscription add --id claude-max --name "Claude Max" --fee 200\n');
+        }
+        const shares = (0, amortize_js_1.amortize)(rows, subs, store.totalConsumptionByMonth(db));
+        const names = new Map(store.listProjects(db).map((p) => [p.id, p.name]));
+        let month = "";
+        for (const s of shares) {
+            if (s.month !== month) {
+                month = s.month;
+                console.log(`\n${month}   (consumo total: ${(0, shared_1.formatAiCost)(s.monthTotal)} equiv. API)`);
+            }
+            const label = (names.get(s.projectId) ?? s.projectId).slice(0, 34).padEnd(36);
+            const pct = `${(s.share * 100).toFixed(1)}%`.padStart(7);
+            const real = subs.length ? (0, shared_1.formatMoney)(s.amount).padStart(11) : "—".padStart(11);
+            console.log(`  ${label}${(0, shared_1.formatAiCost)(s.consumption).padStart(10)}${pct}${real}`);
+        }
+        if (subs.length > 0) {
+            console.log(`\nLa última columna es dinero real: tu cuota repartida por consumo.`);
+            console.log(`La primera es la tarifa API equivalente, útil solo como medida de uso.`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function cmdInvoice(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const project = store.getProject(db, projectId);
+        if (!project)
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        const client = store.getClient(db, project.clientId);
+        const cutoffRaw = required(args, "cutoff");
+        const cutoffAt = new Date(`${cutoffRaw}T23:59:59Z`);
+        if (Number.isNaN(cutoffAt.getTime()))
+            throw new UserError(`Fecha inválida: ${cutoffRaw}`);
+        const dryRun = args.flags["dry-run"] === true;
+        const number = str(args, "number") ?? store.nextInvoiceNumber(db, "INF");
+        const fx = str(args, "fx");
+        const entries = store.getTimeEntries(db, projectId);
+        // El reparto de la cuota se calcula AHORA y viaja con el informe. Si se
+        // recalculara al reimprimirlo, un documento de agosto daría otra cifra en
+        // diciembre, cuando ya se conoce más consumo.
+        const subs = store.listSubscriptions(db);
+        const months = new Set();
+        for (const e of entries) {
+            if (e.billable && e.invoiceId === null && e.endedAt <= cutoffAt)
+                months.add((0, amortize_js_1.monthOf)(e.startedAt));
+        }
+        const amortized = subs.length
+            ? (0, amortize_js_1.shareForProject)((0, amortize_js_1.amortize)(store.consumptionByProjectMonth(db), subs, store.totalConsumptionByMonth(db)), projectId, [...months])
+            : null;
+        const invoice = (0, invoice_js_1.issueInvoice)({
+            client, project,
+            rates: store.getRates(db, projectId),
+            entries, cutoffAt, number,
+            ...(fx ? { usdFxRate: Number(fx) } : {}),
+            ...(amortized ? { aiAmortized: amortized } : {}),
+        });
+        console.log((0, invoice_js_1.renderInvoice)(invoice, client, project));
+        // Coste real de IA del periodo: la cuota de tus suscripciones repartida
+        // por consumo. Es lo que de verdad te costó, frente a la tarifa API.
+        if (invoice.aiAmortized) {
+            console.log(`Coste real de IA imputado desde tu suscripción: ${(0, shared_1.formatMoney)(invoice.aiAmortized)}`);
+        }
+        if (subs.length === 0) {
+            console.log("\nSin suscripciones registradas. Si pagas cuota fija, el importe de arriba");
+            console.log("es tarifa API equivalente, no lo que gastaste. Regístrala con:");
+            console.log('  estela subscription add --id claude-max --name "Claude Max" --fee 200');
+        }
+        if (fx) {
+            const m = (0, invoice_js_1.marginOf)(invoice, Number(fx));
+            console.log(`\nMargen a tarifa API: ${(0, shared_1.formatMoney)(m.margin)} de ${(0, shared_1.formatMoney)(m.revenue)} ` +
+                `(${m.marginPct.toFixed(1)}%)`);
+        }
+        // --- Exportables ---------------------------------------------------------
+        const pdfPath = str(args, "pdf");
+        if (pdfPath) {
+            const issuerName = str(args, "from-name");
+            const pdf = (0, invoice_pdf_js_1.invoiceToPdf)(invoice, client, project, {
+                ...(issuerName ? {
+                    issuer: {
+                        name: issuerName,
+                        ...(str(args, "from-tax-id") ? { taxId: str(args, "from-tax-id") } : {}),
+                        ...(str(args, "from-email") ? { email: str(args, "from-email") } : {}),
+                    },
+                } : {}),
+                ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
+            });
+            (0, node_fs_1.writeFileSync)(pdfPath, pdf);
+            console.log(`\nPDF: ${pdfPath}  (${(pdf.length / 1024).toFixed(1)} KB, ${invoice.lines.length} conceptos)`);
+        }
+        const csvPath = str(args, "csv");
+        if (csvPath) {
+            (0, node_fs_1.writeFileSync)(csvPath, (0, csv_js_1.invoiceToCsv)(invoice, client, project), "utf8");
+            console.log(`CSV: ${csvPath}`);
+        }
+        if (dryRun) {
+            console.log("\n[--dry-run] No se guardó nada. Repite sin --dry-run para emitirlo.");
+            return;
+        }
+        const billed = entries
+            .filter((e) => e.billable && e.invoiceId === null && e.endedAt <= cutoffAt)
+            .map((e) => e.id);
+        store.saveInvoice(db, invoice, billed);
+        console.log(`\nInforme ${invoice.number} emitido. ${billed.length} bloques marcados como informados.`);
+    }
+    finally {
+        db.close();
+    }
+}
+// ---------------------------------------------------------------------------
+async function main() {
+    const argv = process.argv.slice(2);
+    const args = parseArgs(argv);
+    const dbPath = str(args, "db") ?? schema_js_1.DEFAULT_DB_PATH;
+    const command = args._.join(" ");
+    switch (command) {
+        case "setup":
+            await cmdSetup(args, dbPath);
+            break;
+        case "web":
+            await cmdWeb(args, dbPath);
+            break;
+        case "import":
+            await cmdImport(args, dbPath);
+            break;
+        case "client add":
+            cmdClientAdd(args, dbPath);
+            break;
+        case "project add":
+            cmdProjectAdd(args, dbPath);
+            break;
+        case "rate set":
+            cmdRateSet(args, dbPath);
+            break;
+        case "budget":
+            cmdBudget(args, dbPath);
+            break;
+        case "subscription add":
+            cmdSubscriptionAdd(args, dbPath);
+            break;
+        case "ai-cost":
+            cmdAiCost(dbPath);
+            break;
+        case "status":
+            cmdStatus(dbPath);
+            break;
+        case "doctor":
+            cmdDoctor(dbPath);
+            break;
+        case "entries":
+            cmdEntries(args, dbPath);
+            break;
+        case "log":
+            cmdLog(args, dbPath);
+            break;
+        case "author":
+            await cmdAuthor(args, dbPath);
+            break;
+        case "share":
+            cmdShare(args, dbPath);
+            break;
+        case "publish":
+            await cmdPublish(args, dbPath);
+            break;
+        case "export":
+            cmdExport(args, dbPath);
+            break;
+        case "report":
+            cmdInvoice(args, dbPath);
+            break;
+        case "login":
+            await cmdLogin(args, dbPath);
+            break;
+        case "logout":
+            await cmdLogout(dbPath);
+            break;
+        case "":
+        case "help":
+            console.log(HELP);
+            break;
+        default:
+            console.error(`Comando desconocido: "${command}"\n${HELP}`);
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    if (error instanceof UserError || error instanceof invoice_js_1.InvoiceError || error instanceof client_js_1.CloudError) {
+        console.error(`\n${error.message}\n`);
+    }
+    else {
+        console.error(error);
+    }
+    process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map