estela 0.2.3 → 0.3.0

package/dist/plan-blocks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Los bloqueos que Claude Code dejó escritos en sus transcripts.
+ *
+ * Los transcripts no traen los porcentajes de límite, pero cuando Claude Code
+ * recibe un 429 guarda la respuesta con un bloque `quotaLimits`: qué ventana
+ * fue (`five_hour` o `seven_day`) y cuándo se reinicia. Es un dato oficial y
+ * llega a antes de la 0.2.4, así que `estela plan` lo enseña como una línea
+ * aparte. No entra en el cálculo de equivalencias, que es solo de porcentajes.
+ *
+ * Los transcripts de un mes pueden pesar cientos de MB: se leen una vez y
+ * después solo lo nuevo de cada fichero, con lo visto guardado al lado de la
+ * base (`plan-blocks.json`).
+ */
+export interface RateLimitBlock {
+    readonly type: "five_hour" | "seven_day";
+    /** `resetsAt` (epoch en s). */
+    readonly reset: number;
+    /** El primer 429 de esa ventana (epoch en ms). */
+    readonly at: number;
+}
+export declare function blocksCachePath(dbPath: string): string;
+/** Lee lo nuevo de los transcripts y devuelve todos los bloqueos conocidos. */
+export declare function scanBlocks(root: string, cacheFile: string, now: Date): RateLimitBlock[];
+/** Los bloqueos de un texto JSONL. Solo se parsean las líneas que traen `quotaLimits`. */
+export declare function blocksIn(text: string): RateLimitBlock[];
+//# sourceMappingURL=plan-blocks.d.ts.map

package/dist/plan-blocks.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blocksCachePath = blocksCachePath;
+exports.scanBlocks = scanBlocks;
+exports.blocksIn = blocksIn;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MAX_AGE_MS = 120 * 86_400_000;
+function blocksCachePath(dbPath) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "plan-blocks.json");
+}
+/** Lee lo nuevo de los transcripts y devuelve todos los bloqueos conocidos. */
+function scanBlocks(root, cacheFile, now) {
+    let cache = { files: {}, blocks: [] };
+    try {
+        cache = JSON.parse((0, node_fs_1.readFileSync)(cacheFile, "utf8"));
+    }
+    catch { /* primera vez */ }
+    const byKey = new Map(cache.blocks.map((b) => [`${b.type}|${b.reset}`, b]));
+    for (const file of jsonlFiles(root, now.getTime() - MAX_AGE_MS)) {
+        let size;
+        try {
+            size = (0, node_fs_1.statSync)(file).size;
+        }
+        catch {
+            continue;
+        }
+        const offset = cache.files[file] ?? 0;
+        const start = offset <= size ? offset : 0;
+        if (start >= size)
+            continue;
+        const { text, end } = readFrom(file, start, size);
+        for (const b of blocksIn(text)) {
+            const key = `${b.type}|${b.reset}`;
+            const prev = byKey.get(key);
+            if (!prev || b.at < prev.at)
+                byKey.set(key, b);
+        }
+        cache.files[file] = end;
+    }
+    const blocks = [...byKey.values()].filter((b) => b.at >= now.getTime() - MAX_AGE_MS).sort((a, b) => a.at - b.at);
+    try {
+        (0, node_fs_1.writeFileSync)(cacheFile, JSON.stringify({ files: cache.files, blocks }));
+    }
+    catch { /* sin caché se relee */ }
+    return blocks;
+}
+/** Los bloqueos de un texto JSONL. Solo se parsean las líneas que traen `quotaLimits`. */
+function blocksIn(text) {
+    const out = [];
+    let i = text.indexOf('"quotaLimits"');
+    while (i >= 0) {
+        const startLine = text.lastIndexOf("\n", i) + 1;
+        const endLine = text.indexOf("\n", i);
+        const line = text.slice(startLine, endLine < 0 ? text.length : endLine);
+        try {
+            const d = JSON.parse(line);
+            const q = d["quotaLimits"];
+            const type = q?.["rateLimitType"];
+            const reset = q?.["resetsAt"];
+            const at = Date.parse(String(d["timestamp"]));
+            if ((type === "five_hour" || type === "seven_day") && typeof reset === "number" && !Number.isNaN(at) &&
+                (d["apiErrorStatus"] === 429 || q?.["status"] === "rejected")) {
+                out.push({ type, reset, at });
+            }
+        }
+        catch { /* línea rota o a medias */ }
+        i = endLine < 0 ? -1 : text.indexOf('"quotaLimits"', endLine);
+    }
+    return out;
+}
+/** Hasta el último salto de línea: una línea a medias se lee entera la próxima vez. */
+function readFrom(file, start, size) {
+    const fd = (0, node_fs_1.openSync)(file, "r");
+    try {
+        const buf = Buffer.alloc(size - start);
+        (0, node_fs_1.readSync)(fd, buf, 0, buf.length, start);
+        const nl = buf.lastIndexOf(0x0a);
+        if (nl < 0)
+            return { text: "", end: start };
+        return { text: buf.subarray(0, nl + 1).toString("utf8"), end: start + nl + 1 };
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+}
+function jsonlFiles(dir, modifiedAfter) {
+    const out = [];
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = (0, node_path_1.join)(dir, e.name);
+        if (e.isDirectory())
+            out.push(...jsonlFiles(p, modifiedAfter));
+        else if (e.name.endsWith(".jsonl")) {
+            try {
+                if ((0, node_fs_1.statSync)(p).mtimeMs >= modifiedAfter)
+                    out.push(p);
+            }
+            catch { /* se borró mientras tanto */ }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=plan-blocks.js.map

package/dist/plan-prices.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Los planes de Claude que analiza `estela plan`: lo único que Estela sabe de
+ * ellos, en un solo sitio y con su fuente.
+ *
+ * - El multiplicador por sesión de 5 h es el que publica Anthropic: Max 5x da
+ *   5 veces la cuota por sesión de Pro, y Max 20x, 20 veces.
+ * - Del límite semanal Anthropic no publica la relación entre planes, así que
+ *   aquí no hay ningún número para él, y no se compara.
+ * - Los precios son los de la suscripción web, en USD al mes, y caducan:
+ *   `estela plan` avisa si la fecha de comprobación tiene más de 90 días.
+ */
+export type ClaudePlanId = "pro" | "max5" | "max20";
+export interface ClaudePlan {
+    readonly id: ClaudePlanId;
+    readonly name: string;
+    /** Veces la cuota por sesión de 5 h de Pro. */
+    readonly sessionMultiplier: number;
+    readonly monthlyUsd: number;
+}
+export declare const CLAUDE_PLANS: readonly ClaudePlan[];
+export declare const MULTIPLIER_SOURCE = "https://support.claude.com/en/articles/11049741-what-is-the-max-plan";
+export declare const PRICES_SOURCE = "https://claude.com/pricing";
+/** Cuándo se comprobaron los precios en `PRICES_SOURCE`. */
+export declare const PRICES_CHECKED_AT = "2026-10-19";
+export declare const PRICES_STALE_DAYS = 90;
+export declare function planById(id: string): ClaudePlan | null;
+//# sourceMappingURL=plan-prices.d.ts.map

package/dist/plan-prices.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Los planes de Claude que analiza `estela plan`: lo único que Estela sabe de
+ * ellos, en un solo sitio y con su fuente.
+ *
+ * - El multiplicador por sesión de 5 h es el que publica Anthropic: Max 5x da
+ *   5 veces la cuota por sesión de Pro, y Max 20x, 20 veces.
+ * - Del límite semanal Anthropic no publica la relación entre planes, así que
+ *   aquí no hay ningún número para él, y no se compara.
+ * - Los precios son los de la suscripción web, en USD al mes, y caducan:
+ *   `estela plan` avisa si la fecha de comprobación tiene más de 90 días.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRICES_STALE_DAYS = exports.PRICES_CHECKED_AT = exports.PRICES_SOURCE = exports.MULTIPLIER_SOURCE = exports.CLAUDE_PLANS = void 0;
+exports.planById = planById;
+exports.CLAUDE_PLANS = [
+    { id: "pro", name: "Pro", sessionMultiplier: 1, monthlyUsd: 20 },
+    { id: "max5", name: "Max 5x", sessionMultiplier: 5, monthlyUsd: 100 },
+    { id: "max20", name: "Max 20x", sessionMultiplier: 20, monthlyUsd: 200 },
+];
+exports.MULTIPLIER_SOURCE = "https://support.claude.com/en/articles/11049741-what-is-the-max-plan";
+exports.PRICES_SOURCE = "https://claude.com/pricing";
+/** Cuándo se comprobaron los precios en `PRICES_SOURCE`. */
+exports.PRICES_CHECKED_AT = "2026-10-19";
+exports.PRICES_STALE_DAYS = 90;
+function planById(id) {
+    return exports.CLAUDE_PLANS.find((p) => p.id === id) ?? null;
+}
+//# sourceMappingURL=plan-prices.js.map

package/dist/plan-report.d.ts

@@ -0,0 +1,96 @@
+import type { PlanAnalysis } from "./metrics/plan.js";
+/**
+ * Lo que enseña `estela plan`: el texto (es/en) y el JSON.
+ *
+ * Aparte de cli.ts para poder comprobar cada frase: ninguna puede decir
+ * cuánto te queda ni hablar de tokens. Lo que hay son los porcentajes que
+ * mandó Claude Code y las equivalencias por el multiplicador publicado.
+ */
+export interface BlockCounts {
+    readonly fiveHour: number;
+    readonly sevenDay: number;
+}
+export interface ReportOptions {
+    readonly color: boolean;
+    readonly now: Date;
+    /** Bloqueos 429 de los transcripts en el período, si se pudieron leer. */
+    readonly blocks: BlockCounts | null;
+}
+export declare function renderPlanReport(a: PlanAnalysis, o: ReportOptions): string;
+export declare function recommendationText(a: PlanAnalysis): string;
+export declare function pricesStale(now: Date): boolean;
+/** Sin plan declarado: cómo declararlo. */
+export declare function renderNoPlan(): string;
+export declare function renderNoData(a: PlanAnalysis, apiKey: boolean, color: boolean): string;
+/**
+ * `estela plan --json`. Estructura estable (documentada en el README):
+ * campos nuevos se pueden añadir, ninguno cambia de nombre ni de significado.
+ */
+export declare function planToJson(a: PlanAnalysis, o: {
+    readonly blocks: BlockCounts | null;
+    readonly now: Date;
+}): {
+    version: number;
+    plan: {
+        id: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        since: string;
+        sessionMultiplier: number;
+    };
+    period: {
+        from: string;
+        to: string;
+        days: number;
+        daysWithData: number;
+        samples: number;
+    };
+    dataState: import("./metrics/plan.js").DataState;
+    fiveHour: {
+        windows: number;
+        medianPeak: number | null;
+        p90Peak: number | null;
+        maxPeak: number | null;
+        caps: number;
+        stoppedMinutesUpperBound: number;
+    };
+    week: {
+        weeks: number;
+        medianPeak: number | null;
+        maxPeak: number | null;
+        weeksAtOrAbove90: number;
+    };
+    blocks429: BlockCounts | null;
+    alternatives: {
+        plan: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        direction: "lower" | "higher";
+        monthlyUsd: number;
+        monthlyDiffUsd: number;
+        p90Equivalent: number | null;
+        maxEquivalent: number | null;
+        blockedWindows: number;
+        capsAvoided: number;
+    }[];
+    recommendation: {
+        kind: "tight" | "enough" | "almost" | "fits";
+        provisional: boolean;
+        plan: import("./plan-prices.js").ClaudePlanId | null;
+        blockedWindows: number | null;
+        capsAvoided: number | null;
+        text: string;
+    } | null;
+    weeklyBetweenPlans: string;
+    sources: {
+        sessionMultiplier: string;
+        prices: string;
+        pricesCheckedAt: string;
+        pricesStale: boolean;
+    };
+    plans: {
+        id: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        sessionMultiplier: number;
+        monthlyUsd: number;
+    }[];
+};
+//# sourceMappingURL=plan-report.d.ts.map

package/dist/plan-report.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPlanReport = renderPlanReport;
+exports.recommendationText = recommendationText;
+exports.pricesStale = pricesStale;
+exports.renderNoPlan = renderNoPlan;
+exports.renderNoData = renderNoData;
+exports.planToJson = planToJson;
+const index_js_1 = require("./i18n/index.js");
+const plan_prices_js_1 = require("./plan-prices.js");
+const statusline_js_1 = require("./statusline.js");
+const ESC = "\x1b[";
+const JADE = `${ESC}38;2;70;192;167m`; // #46C0A7, como en la status line
+const AMBER = `${ESC}38;2;221;168;90m`;
+const DIM = `${ESC}90m`;
+const RESET = `${ESC}0m`;
+const LABEL = 21;
+function renderPlanReport(a, o) {
+    const paint = (code, text) => (o.color ? `${code}${text}${RESET}` : text);
+    const row = (label, value) => `${label.padEnd(LABEL)}${value}`;
+    const out = [];
+    out.push(header(a, paint));
+    out.push("");
+    const f = a.fiveHour;
+    out.push(row((0, index_js_1.tr) `Ventanas de 5 h`, f.windows.length === 0
+        ? (0, index_js_1.tr) `ninguna completa todavía`
+        : (0, index_js_1.tr) `${f.windows.length} ventanas · pico mediano ${pct(f.medianPeak)} % · p90 ${pct(f.p90Peak)} % · máximo ${pct(f.maxPeak)} %`));
+    out.push(row((0, index_js_1.tr) `Topes (≥95 %)`, String(f.caps)));
+    if (f.stoppedMs > 0) {
+        out.push(row((0, index_js_1.tr) `Parado tras topes`, (0, index_js_1.tr) `hasta ${(0, statusline_js_1.compactDuration)(f.stoppedMs / 1000)} (estimado: no sabemos si seguías trabajando)`));
+    }
+    const w = a.week;
+    out.push(row((0, index_js_1.tr) `Semana`, w.weeks.length === 0
+        ? (0, index_js_1.tr) `sin datos de la semana`
+        : (0, index_js_1.tr) `pico mediano ${pct(w.medianPeak)} % · máximo ${pct(w.maxPeak)} % · ${w.weeksAtOrAbove90} semanas ≥ 90 %`));
+    if (o.blocks) {
+        out.push(row((0, index_js_1.tr) `Bloqueos (429)`, (0, index_js_1.tr) `${o.blocks.fiveHour} de 5 h · ${o.blocks.sevenDay} semanales, según los transcripts de Claude Code`));
+    }
+    if (f.windows.length > 0) {
+        out.push("");
+        out.push((0, index_js_1.tr) `Si estuvieras en…`);
+        for (const alt of [...a.alternatives].sort((x, y) => x.plan.monthlyUsd - y.plan.monthlyUsd)) {
+            out.push(`  ${`${alt.plan.name} (${usd(alt.plan.monthlyUsd)})`.padEnd(LABEL - 2)}${alternativeText(alt, a)}`);
+        }
+    }
+    out.push("");
+    if (a.dataState === "insufficient") {
+        out.push(paint(AMBER, (0, index_js_1.tr) `Datos de ${a.daysWithData} días. La recomendación necesita al menos 14.`));
+    }
+    else if (a.recommendation) {
+        const label = a.dataState === "provisional"
+            ? (0, index_js_1.tr) `Recomendación (provisional, ${a.daysWithData} días)`
+            : (0, index_js_1.tr) `Recomendación`;
+        const text = recommendationText(a);
+        out.push(row(label, paint(a.recommendation.kind === "tight" ? AMBER : JADE, text)));
+        const diff = priceDiffText(a);
+        if (diff)
+            out.push(row("", paint(DIM, diff)));
+    }
+    out.push("");
+    out.push((0, index_js_1.tr) `Límite semanal entre planes: Anthropic no publica la relación. No lo estimamos.`);
+    out.push((0, index_js_1.tr) `Basado en el multiplicador por sesión publicado por Anthropic:`);
+    out.push(plan_prices_js_1.MULTIPLIER_SOURCE);
+    out.push((0, index_js_1.tr) `Anthropic puede cambiar los límites; repite el análisis cada mes.`);
+    out.push((0, index_js_1.tr) `Precios según la web de Anthropic a ${plan_prices_js_1.PRICES_CHECKED_AT}; compruébalo: ${plan_prices_js_1.PRICES_SOURCE}`);
+    if (pricesStale(o.now))
+        out.push(paint(AMBER, (0, index_js_1.tr) `Esa fecha tiene más de ${plan_prices_js_1.PRICES_STALE_DAYS} días: los precios pueden estar desactualizados.`));
+    return out.join("\n");
+}
+function header(a, paint) {
+    return `${paint(JADE, "estela")} plan · ${a.plan.name} ${(0, index_js_1.tr) `(desde ${day(a.since)})`} · ${(0, index_js_1.tr) `${a.daysWithData} días con datos`}`;
+}
+function alternativeText(alt, a) {
+    const n = a.fiveHour.windows.length;
+    if (alt.direction === "higher") {
+        if (a.fiveHour.caps === 0)
+            return (0, index_js_1.tr) `sin topes, igual que ahora`;
+        return (0, index_js_1.tr) `p90 equivalente ${pct(alt.p90Equivalent)} % · habrías evitado ${alt.capsAvoided} de ${a.fiveHour.caps} topes (con el uso que llegó a registrarse)`;
+    }
+    return alt.blockedWindows === 0
+        ? (0, index_js_1.tr) `p90 equivalente ${pct(alt.p90Equivalent)} % · no te habría bloqueado en ninguna de las ${n} ventanas`
+        : (0, index_js_1.tr) `p90 equivalente ${pct(alt.p90Equivalent)} % · te habría bloqueado en ${alt.blockedWindows} de ${n} ventanas`;
+}
+function recommendationText(a) {
+    const r = a.recommendation;
+    if (!r)
+        return "";
+    switch (r.kind) {
+        case "tight":
+            return r.higher && r.capsAvoided !== null
+                ? (0, index_js_1.tr) `Vas justo con tu plan. Con ${r.higher.name} habrías evitado ${r.capsAvoided} de ${a.fiveHour.caps} topes.`
+                : (0, index_js_1.tr) `Vas justo con tu plan.`;
+        case "enough":
+            return (0, index_js_1.tr) `Con los datos de estas ${r.weeks} semanas, el plan ${r.plan.name} te habría bastado en todas las ventanas de 5 h.`;
+        case "almost":
+            return (0, index_js_1.tr) `El plan ${r.plan.name} te habría bastado casi siempre: te habría bloqueado ${r.blocked} veces en estas semanas.`;
+        case "fits":
+            return (0, index_js_1.tr) `Tu plan actual encaja con tu uso.`;
+    }
+}
+/** La diferencia de precio de lo que se recomienda, si es cambiar de plan. */
+function priceDiffText(a) {
+    const r = a.recommendation;
+    const other = r?.kind === "enough" || r?.kind === "almost" ? r.plan
+        : r?.kind === "tight" ? r.higher : null;
+    if (!other)
+        return null;
+    const diff = other.monthlyUsd - a.plan.monthlyUsd;
+    return diff < 0
+        ? (0, index_js_1.tr) `${usd(-diff)} menos al mes, según la web de Anthropic a ${plan_prices_js_1.PRICES_CHECKED_AT}; compruébalo.`
+        : (0, index_js_1.tr) `${usd(diff)} más al mes, según la web de Anthropic a ${plan_prices_js_1.PRICES_CHECKED_AT}; compruébalo.`;
+}
+function pricesStale(now) {
+    return now.getTime() - Date.parse(`${plan_prices_js_1.PRICES_CHECKED_AT}T00:00:00Z`) > plan_prices_js_1.PRICES_STALE_DAYS * 86_400_000;
+}
+/** Sin plan declarado: cómo declararlo. */
+function renderNoPlan() {
+    return [
+        (0, index_js_1.tr) `estela plan compara tu uso real de Claude con los otros planes. Primero dime cuál pagas:`,
+        "",
+        "  estela plan set pro",
+        "  estela plan set max5",
+        "  estela plan set max20",
+        "",
+        (0, index_js_1.tr) `Si ya lo tenías antes de hoy, añade desde cuándo: --since AAAA-MM-DD`,
+    ].join("\n");
+}
+function renderNoData(a, apiKey, color) {
+    const paint = (code, text) => (color ? `${code}${text}${RESET}` : text);
+    return [
+        header(a, paint), "",
+        apiKey
+            ? (0, index_js_1.tr) `Este análisis solo funciona con planes Pro o Max.`
+            : (0, index_js_1.tr) `Aún no hay datos. Instala la status line (estela statusline install) y vuelve en unos días.`,
+        ...(apiKey ? [] : [(0, index_js_1.tr) `Solo se recogen en Claude Code en la terminal: la extensión de VS Code no ejecuta la status line.`]),
+    ].join("\n");
+}
+// ---------------------------------------------------------------------------
+/**
+ * `estela plan --json`. Estructura estable (documentada en el README):
+ * campos nuevos se pueden añadir, ninguno cambia de nombre ni de significado.
+ */
+function planToJson(a, o) {
+    const r1 = (n) => (n === null ? null : Math.round(n * 10) / 10);
+    const rec = a.recommendation;
+    return {
+        version: 1,
+        plan: { id: a.plan.id, name: a.plan.name, since: a.since.toISOString(), sessionMultiplier: a.plan.sessionMultiplier },
+        period: { from: a.from.toISOString(), to: a.to.toISOString(), days: a.days, daysWithData: a.daysWithData, samples: a.samples },
+        dataState: a.dataState,
+        fiveHour: {
+            windows: a.fiveHour.windows.length,
+            medianPeak: r1(a.fiveHour.medianPeak), p90Peak: r1(a.fiveHour.p90Peak), maxPeak: r1(a.fiveHour.maxPeak),
+            caps: a.fiveHour.caps,
+            stoppedMinutesUpperBound: Math.round(a.fiveHour.stoppedMs / 60_000),
+        },
+        week: {
+            weeks: a.week.weeks.length,
+            medianPeak: r1(a.week.medianPeak), maxPeak: r1(a.week.maxPeak),
+            weeksAtOrAbove90: a.week.weeksAtOrAbove90,
+        },
+        blocks429: o.blocks,
+        alternatives: [...a.alternatives].sort((x, y) => x.plan.monthlyUsd - y.plan.monthlyUsd).map((x) => ({
+            plan: x.plan.id, name: x.plan.name, direction: x.direction,
+            monthlyUsd: x.plan.monthlyUsd, monthlyDiffUsd: x.plan.monthlyUsd - a.plan.monthlyUsd,
+            p90Equivalent: r1(x.p90Equivalent), maxEquivalent: r1(x.maxEquivalent),
+            blockedWindows: x.blockedWindows, capsAvoided: x.capsAvoided,
+        })),
+        recommendation: rec === null ? null : {
+            kind: rec.kind,
+            provisional: a.dataState === "provisional",
+            plan: rec.kind === "enough" || rec.kind === "almost" ? rec.plan.id : rec.kind === "tight" ? rec.higher?.id ?? null : null,
+            blockedWindows: rec.kind === "almost" ? rec.blocked : null,
+            capsAvoided: rec.kind === "tight" ? rec.capsAvoided : null,
+            text: recommendationText(a),
+        },
+        weeklyBetweenPlans: "not_published",
+        sources: {
+            sessionMultiplier: plan_prices_js_1.MULTIPLIER_SOURCE,
+            prices: plan_prices_js_1.PRICES_SOURCE, pricesCheckedAt: plan_prices_js_1.PRICES_CHECKED_AT, pricesStale: pricesStale(o.now),
+        },
+        plans: plan_prices_js_1.CLAUDE_PLANS.map((p) => ({ id: p.id, name: p.name, sessionMultiplier: p.sessionMultiplier, monthlyUsd: p.monthlyUsd })),
+    };
+}
+function pct(n) { return Math.round(n); }
+function usd(n) { return (0, index_js_1.tr) `${n} $`; }
+function day(d) {
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+//# sourceMappingURL=plan-report.js.map

package/dist/rate-history.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `~/.estela/rate-limits.jsonl`: el historial de los porcentajes de límite que
+ * Claude Code manda a la status line. Es lo que analiza `estela plan`.
+ *
+ * Solo se guarda lo que manda Claude Code, tal cual: el porcentaje usado y el
+ * reinicio de cada ventana, y su versión. Ni sesión, ni rutas, ni proyectos.
+ * Estela no estima ningún límite: sin `rate_limits` en la entrada (API key, o
+ * la primera respuesta de la sesión aún no llegó), no se guarda nada.
+ *
+ * Los transcripts no traen estos porcentajes, así que no hay forma de
+ * recuperar el pasado: el historial empieza el día que se instala la 0.2.4. Y
+ * solo se recoge con Claude Code en la terminal; la extensión de VS Code no
+ * ejecuta la status line.
+ *
+ * Va por el camino rápido de la status line (100 ms): sin `node:sqlite`, una
+ * línea por `appendFileSync`, y cualquier error se ignora.
+ */
+export interface RateSample {
+    /** Epoch en ms de la muestra. */
+    readonly ts: number;
+    readonly src: "claude-code";
+    readonly w5?: number;
+    /** `resets_at` tal cual (epoch en s). */
+    readonly w5_reset?: number;
+    readonly w7?: number;
+    readonly w7_reset?: number;
+    /** Versión de Claude Code, si viene. */
+    readonly cc?: string;
+}
+export declare const KEEP_DAYS = 120;
+export declare function historyPath(dbPath: string): string;
+/**
+ * La muestra que sale del JSON de la status line, o null si no trae ningún
+ * porcentaje. Cada ventana que falte se omite: nunca se escribe un 0.
+ */
+export declare function sampleOf(raw: unknown, now: Date): RateSample | null;
+/**
+ * Si vale la pena guardar la muestra: han pasado 5 minutos desde la última,
+ * algún porcentaje cambió al menos un punto, o empezó una ventana nueva.
+ */
+export declare function shouldWrite(last: RateSample | undefined, s: RateSample): boolean;
+/**
+ * Lo que hace la status line en cada evento. Nunca lanza: es un historial, y
+ * la línea tiene que salir igual aunque no se pueda escribir.
+ *
+ * Solo escribe si ya existe el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
+ */
+export declare function recordSample(dbPath: string, raw: unknown, now: Date): void;
+/** Lee el historial. Las líneas rotas se saltan. */
+export declare function readSamples(file: string): RateSample[];
+/**
+ * Quita las muestras de hace más de 120 días. Reescribe en un fichero aparte y
+ * lo renombra encima: un corte a mitad no deja el historial a medias.
+ * Devuelve cuántas quitó.
+ *
+ * Corre desde la status line una vez al día, así que lo normal (nada que
+ * quitar) tiene que costar casi nada: el fichero se escribe en orden, y si la
+ * primera muestra no ha caducado, ninguna lo ha hecho. Solo entonces se lee
+ * entero, y el `ts` se saca del principio de cada línea sin parsear el JSON.
+ */
+export declare function pruneSamples(file: string, now: Date, keepDays?: number): number;
+//# sourceMappingURL=rate-history.d.ts.map