estela 0.2.1 → 0.2.2

package/README.md

@@ -288,7 +288,9 @@ Hours measured today on this project (the same number the report will
 give), this project's share of your Claude Code usage this week, and — only
 if Claude Code sends them — its own weekly and 5-hour limit percentages, as
 they come. Estela never estimates a limit or counts down to a reset. The
-5-hour figure turns amber from 80%. On a narrow terminal the line drops the
+5-hour figure turns amber from 80%. A new session shows the last figures Claude
+Code sent until fresh ones arrive, if that window hasn't reset yet. On a
+narrow terminal the line drops the
 5-hour figure first, then the week, then shortens the name, then this
 project, then today; `estela` always stays. It runs in about 50 ms and only
 reads what's new in the current session's transcript.

package/dist/statusline-cache.d.ts

@@ -3,31 +3,60 @@
  * llamadas.
  *
  *  - `files`: hasta qué byte se leyó cada transcript, para leer solo lo nuevo.
- *  - `fiveHour`: el último `rate_limits.five_hour.resets_at` que mandó Claude
- *    Code, y cuándo se vio. `estela quota` lo usa para saber dónde empieza de
- *    verdad la ventana de 5 h en vez de estimarla.
+ *  - `fiveHour` y `sevenDay`: lo último que mandó Claude Code en rate_limits
+ *    (porcentaje y reinicio) y cuándo se vio. La status line lo enseña al
+ *    arrancar una sesión, antes de que lleguen datos nuevos, y `estela quota`
+ *    usa el reinicio de la 5 h para saber dónde empieza de verdad la ventana.
  *
  * Es una caché: si se pierde o se corrompe, todo sigue funcionando, solo que
  * relee más o vuelve a estimar.
  */
+/** Una ventana de límite tal como la mandó Claude Code, y cuándo se vio. */
+export interface SeenLimit {
+    resetsAt: string;
+    seenAt: string;
+    /** El porcentaje usado. Falta si Claude Code mandó el reinicio sin él. */
+    usedPercentage?: number;
+}
 export interface StatuslineCache {
     files: Record<string, {
         offset: number;
         seenAt: string;
     }>;
-    fiveHour?: {
-        resetsAt: string;
-        seenAt: string;
-    };
+    fiveHour?: SeenLimit;
+    sevenDay?: SeenLimit;
 }
 export declare function cachePath(dbPath: string): string;
 export declare function loadCache(dbPath: string): StatuslineCache;
 export declare function saveCache(dbPath: string, cache: StatuslineCache): void;
+/** Lo que llega de rate_limits para una ventana (cualquiera de los dos puede faltar). */
+export interface LimitInput {
+    readonly usedPercentage: number | null;
+    readonly resetsAt: Date | null;
+}
 /**
- * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
- * de Estela: la status line no es quien empieza a guardar datos.
+ * Guarda lo nuevo de rate_limits y, para la ventana que no venga, devuelve el
+ * último porcentaje guardado si su reinicio aún no ha llegado.
+ *
+ * Es para el arranque de una sesión: Claude Code no manda rate_limits hasta la
+ * primera respuesta, y mientras tanto la línea perdía la semana y la 5 h que se
+ * sabían hace un momento. Un valor guardado cuyo reinicio ya pasó es de una
+ * ventana que terminó: no se enseña. En cuanto llega un dato nuevo, lo
+ * reemplaza.
+ *
+ * Usar lo guardado no cuenta como verlo otra vez: `seenAt` solo cambia con un
+ * dato nuevo, que es lo que `estela quota` mira para fiarse de la ventana.
+ *
+ * Solo escribe si existe ya el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
  */
-export declare function recordFiveHourReset(dbPath: string, resetsAt: Date, now: Date): void;
+export declare function rememberLimits(dbPath: string, input: {
+    readonly fiveHour: LimitInput;
+    readonly sevenDay: LimitInput;
+}, now: Date): {
+    fiveHour: number | null;
+    sevenDay: number | null;
+};
 export declare function readFiveHourReset(dbPath: string): {
     resetsAt: Date;
     seenAt: Date;

package/dist/statusline-cache.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachePath = cachePath;
 exports.loadCache = loadCache;
 exports.saveCache = saveCache;
-exports.recordFiveHourReset = recordFiveHourReset;
+exports.rememberLimits = rememberLimits;
 exports.readFiveHourReset = readFiveHourReset;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const MAX_FILES = 30;
-/** Con el mismo reinicio, no se reescribe más a menudo que esto. */
-const FIVE_HOUR_REFRESH_MS = 10 * 60_000;
+/** Con el mismo reinicio y el mismo porcentaje, no se reescribe más a menudo que esto. */
+const REFRESH_MS = 10 * 60_000;
 function cachePath(dbPath) {
     return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "statusline.json");
 }
@@ -33,19 +33,52 @@ function saveCache(dbPath, cache) {
     catch { /* sin caché, la próxima vez se relee: más lento, no incorrecto */ }
 }
 /**
- * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
- * de Estela: la status line no es quien empieza a guardar datos.
+ * Guarda lo nuevo de rate_limits y, para la ventana que no venga, devuelve el
+ * último porcentaje guardado si su reinicio aún no ha llegado.
+ *
+ * Es para el arranque de una sesión: Claude Code no manda rate_limits hasta la
+ * primera respuesta, y mientras tanto la línea perdía la semana y la 5 h que se
+ * sabían hace un momento. Un valor guardado cuyo reinicio ya pasó es de una
+ * ventana que terminó: no se enseña. En cuanto llega un dato nuevo, lo
+ * reemplaza.
+ *
+ * Usar lo guardado no cuenta como verlo otra vez: `seenAt` solo cambia con un
+ * dato nuevo, que es lo que `estela quota` mira para fiarse de la ventana.
+ *
+ * Solo escribe si existe ya el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
  */
-function recordFiveHourReset(dbPath, resetsAt, now) {
-    if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
-        return;
+function rememberLimits(dbPath, input, now) {
     const cache = loadCache(dbPath);
-    const prev = cache.fiveHour;
-    const same = prev && new Date(prev.resetsAt).getTime() === resetsAt.getTime();
-    if (same && now.getTime() - new Date(prev.seenAt).getTime() < FIVE_HOUR_REFRESH_MS)
-        return;
-    cache.fiveHour = { resetsAt: resetsAt.toISOString(), seenAt: now.toISOString() };
-    saveCache(dbPath, cache);
+    let changed = false;
+    const pick = (key, fresh) => {
+        const prev = cache[key];
+        if (fresh.resetsAt) {
+            const sameReset = !!prev && new Date(prev.resetsAt).getTime() === fresh.resetsAt.getTime();
+            // Un reinicio sin porcentaje de la misma ventana no borra el que había.
+            const pct = fresh.usedPercentage ?? (sameReset ? prev.usedPercentage ?? null : null);
+            const samePct = (prev?.usedPercentage ?? null) === pct;
+            const recent = !!prev && now.getTime() - new Date(prev.seenAt).getTime() < REFRESH_MS;
+            if (!(sameReset && samePct && recent)) {
+                cache[key] = {
+                    resetsAt: fresh.resetsAt.toISOString(), seenAt: now.toISOString(),
+                    ...(pct !== null ? { usedPercentage: pct } : {}),
+                };
+                changed = true;
+            }
+        }
+        if (fresh.usedPercentage !== null)
+            return fresh.usedPercentage;
+        // Sin dato nuevo: lo último que se vio, si su ventana sigue abierta.
+        const last = cache[key];
+        if (!last || last.usedPercentage === undefined)
+            return null;
+        return new Date(last.resetsAt) > now ? last.usedPercentage : null;
+    };
+    const out = { fiveHour: pick("fiveHour", input.fiveHour), sevenDay: pick("sevenDay", input.sevenDay) };
+    if (changed && (0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
+        saveCache(dbPath, cache);
+    return out;
 }
 function readFiveHourReset(dbPath) {
     const f = loadCache(dbPath).fiveHour;

package/dist/statusline-run.js

@@ -55,13 +55,17 @@ async function runStatusline(argv) {
         const reserved = extra ? (0, statusline_js_1.stripAnsi)(extra).length + 3 : 0;
         const columns = Number(process.env["COLUMNS"]) || null;
         const now = new Date();
-        if (input.fiveHourResetsAt) {
-            try {
-                (0, statusline_cache_js_1.recordFiveHourReset)(flags.db, input.fiveHourResetsAt, now);
-            }
-            catch { /* es una caché */ }
+        // Lo nuevo de rate_limits se guarda; lo que no venga (al arrancar una
+        // sesión) se toma de lo último visto, si su ventana sigue abierta.
+        let limits = { fiveHour: input.fiveHour, sevenDay: input.sevenDay };
+        try {
+            limits = (0, statusline_cache_js_1.rememberLimits)(flags.db, {
+                fiveHour: { usedPercentage: input.fiveHour, resetsAt: input.fiveHourResetsAt ?? null },
+                sevenDay: { usedPercentage: input.sevenDay, resetsAt: input.sevenDayResetsAt ?? null },
+            }, now);
         }
-        const data = computeStatus(input, flags.db, now);
+        catch { /* es una caché: sin ella, la línea sale con lo que llegó */ }
+        const data = computeStatus({ ...input, ...limits }, flags.db, now);
         const ours = (0, statusline_js_1.renderStatus)(data, { columns, color: flags.color, reserved });
         process.stdout.write((extra ? `${ours}${flags.color ? "\x1b[90m | \x1b[0m" : " | "}${extra}` : ours) + "\n");
     }
@@ -83,7 +87,7 @@ function parseFlags(argv) {
 }
 /** Ejecutado a mano en una terminal, sin nada por stdin: el directorio actual. */
 function manualInput() {
-    return { dir: process.cwd(), transcriptPath: null, fiveHour: null, sevenDay: null, fiveHourResetsAt: null };
+    return { dir: process.cwd(), transcriptPath: null, fiveHour: null, sevenDay: null, fiveHourResetsAt: null, sevenDayResetsAt: null };
 }
 function readStdin() {
     if (process.stdin.isTTY)

package/dist/statusline.d.ts

@@ -21,6 +21,8 @@ export interface StatusInput {
      * atrás): se guarda para que `estela quota` sepa dónde empieza la ventana.
      */
     readonly fiveHourResetsAt?: Date | null;
+    /** `rate_limits.seven_day.resets_at`: tampoco se enseña nunca. */
+    readonly sevenDayResetsAt?: Date | null;
 }
 /**
  * Lee la entrada. Lanza si no es un objeto JSON: quien llama imprime

package/dist/statusline.js

@@ -23,6 +23,7 @@ function parseStatusInput(text) {
         fiveHour: pct(obj(limits["five_hour"])["used_percentage"]),
         sevenDay: pct(obj(limits["seven_day"])["used_percentage"]),
         fiveHourResetsAt: epoch(obj(limits["five_hour"])["resets_at"]),
+        sevenDayResetsAt: epoch(obj(limits["seven_day"])["resets_at"]),
     };
 }
 /** Segundos desde 1970 (lo que manda Claude Code); por si acaso, también milisegundos. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "estela",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Time tracking you never fill in: rebuilds your billable hours from Claude Code, Codex and GitHub Copilot sessions and your Git history, and splits what the AI cost per project.",
   "keywords": [
     "time-tracking",