estela 0.1.40 → 0.2.1

package/README.md

@@ -116,6 +116,11 @@ Two things trip people up before Estela even starts:
   the standalone Node, then `nvm install lts` and `nvm use lts` from an
   administrator terminal. `where.exe npm` should list a single path.
 
+A session in a subfolder or a git worktree counts for its repository's
+project. If an import would add hours to what you had already imported, Estela
+shows you how many per project and asks first (`estela import --yes` skips the
+question); it never moves hours between projects or touches an approved day.
+
 ## Reporting to a client
 
 Projects are created as internal and without a rate, because making one up
@@ -238,8 +243,9 @@ expect it and nothing tells you where it went. `estela quota` splits it by
 project:
 
 ```sh
-estela quota          # current 5-hour window and this week, per project
-estela quota --json   # the same, for scripts
+estela quota              # current 5-hour window and this week, per project
+estela quota --weighted   # the % by list price instead of by tokens
+estela quota --json       # the same, for scripts
 ```
 
 Tokens (input, output, cache read and cache write) per project, for the current
@@ -248,6 +254,13 @@ week against the average of your previous 4 over the same stretch. Claude Code
 and Codex are shown separately: they draw on different quotas. It's also a card
 in the Summary tab of `estela web`, and it's free.
 
+A session in a subfolder or in a git worktree counts for its repo's project;
+a folder that isn't a project shows up under its git root's name. The % is
+by tokens by default; `--weighted` splits it by each model's list price
+instead, which is not how the provider counts your limit. With the status
+line installed (below), the 5-hour window is the one Claude Code reports
+rather than an estimate.
+
 What it never does is tell you how much you have left: Anthropic and OpenAI
 don't publish their plans' limits, so any "X tokens left" would be made up. The
 5-hour window is an estimate — how its start is rounded isn't public, and
@@ -255,6 +268,37 @@ anything you use on claude.ai or another machine counts too but isn't on this
 one. Copilot is left out because it doesn't record reliable tokens. Everything
 is calculated on your machine.
 
+## A line under every Claude Code session
+
+```sh
+npm install -g estela        # the status line needs estela on your PATH
+estela statusline install
+```
+
+In a repository that isn't a project yet it shows `estela · web (no project) ·
+estela setup`, and outside git just `estela · no project` — plus the week and
+5-hour figures when Claude Code sends them. Each Claude Code
+session in a project shows a line like this:
+
+```
+estela · Brightside Health › brightside-portal · today 2h14 · this project 21% · week 38% · 5h 62%
+```
+
+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 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.
+
+`install` merges the block into `~/.claude/settings.json` without touching
+anything else, after making a backup. If you already have a status line it
+won't overwrite it: `--force` replaces it, `--append` shows yours after
+Estela's. `estela statusline uninstall` removes it (and puts yours back if
+you used `--append`).
+
 ## Hours no import will infer
 
 Meetings, travel, research, and development without an agent that didn't leave

package/dist/billing/assign.d.ts

@@ -0,0 +1,45 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { TimeEntry } from "@estela/shared";
+import { type WorkBlock } from "./sessionize.js";
+/**
+ * De bloques de trabajo a imputaciones: a qué proyecto va cada uno y con qué
+ * id se guarda. Lo usan `estela import` y el import automático del panel, que
+ * antes lo tenían copiado cada uno por su lado.
+ *
+ * La raíz git (worktrees, subcarpetas de un repo sin la carpeta exacta
+ * registrada) recupera horas que antes se perdían, con tres reglas:
+ *
+ *  1. Solo se reasigna lo que hoy NO tiene proyecto. La carpeta tal cual se
+ *     mira primero, así que nada de lo ya asignado cambia de proyecto.
+ *  2. Un día aprobado o facturado de ese proyecto no se toca: las horas que se
+ *     recuperarían ahí se informan (`blocked`), no se aplican.
+ *  3. Recuperar es opcional (`recover`): la primera vez lo confirma la persona.
+ */
+export interface PlannedEntry {
+    readonly entry: Omit<TimeEntry, "id"> & {
+        id: string;
+    };
+    /** Segundos que esta imputación gana por la raíz git (0 si no cambia). */
+    readonly recoveredSeconds: number;
+}
+export interface RecoveryBlocked {
+    readonly projectId: string;
+    readonly day: string;
+    readonly seconds: number;
+}
+export interface AssignmentPlan {
+    readonly entries: readonly PlannedEntry[];
+    /** Bloques tras agrupar por rama y día, con y sin proyecto. */
+    readonly grouped: number;
+    /** De esos, los que siguen sin proyecto. */
+    readonly unassigned: number;
+    /** Segundos recuperados que SÍ se aplican, por proyecto. */
+    readonly recovered: ReadonlyMap<string, number>;
+    /** Lo que se recuperaría en días aprobados o facturados: no se aplica. */
+    readonly blocked: readonly RecoveryBlocked[];
+}
+export declare function entryId(projectId: string, day: string, branch: string | null): string;
+export declare function planEntries(db: DatabaseSync, raw: readonly WorkBlock[], options: {
+    readonly recover: boolean;
+}): AssignmentPlan;
+//# sourceMappingURL=assign.d.ts.map

package/dist/billing/assign.js

@@ -0,0 +1,159 @@
+"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.entryId = entryId;
+exports.planEntries = planEntries;
+const shared_1 = require("@estela/shared");
+const store = __importStar(require("../db/store.js"));
+const project_of_js_1 = require("../project-of.js");
+const sessionize_js_1 = require("./sessionize.js");
+function entryId(projectId, day, branch) {
+    // Determinista (proyecto + día + rama) para que reimportar actualice en vez
+    // de duplicar. La fecha, la LOCAL: la misma que usa el servidor.
+    const slug = (branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
+    return `te_${projectId}_${day}_${slug}`;
+}
+function planEntries(db, raw, options) {
+    const ownerOf = (0, project_of_js_1.ownerResolver)(db);
+    const direct = (repo) => (repo ? store.projectForRepo(db, repo) : null);
+    const viaRoot = (repo) => {
+        if (!repo)
+            return null;
+        const o = ownerOf(repo);
+        return o.kind === "project" ? o.projectId : null;
+    };
+    // Lo de siempre: la carpeta tal cual. Se agrupa por PROYECTO, no por ruta:
+    // `repo/` y `repo/src/UI` son el mismo proyecto, y agrupar por ruta daba dos
+    // bloques que luego se pisaban al guardarse con el mismo id.
+    const keyDirect = (b) => direct(b.repoPath) ?? b.repoPath ?? "";
+    const groupedBase = (0, sessionize_js_1.groupByBranchAndDay)(raw, keyDirect);
+    const base = byId(groupedBase, direct);
+    if (!options.recover) {
+        return {
+            entries: [...base.values()].map((g) => ({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: 0 })),
+            grouped: groupedBase.length,
+            unassigned: groupedBase.filter((b) => !direct(b.repoPath)).length,
+            recovered: new Map(), blocked: [],
+        };
+    }
+    // Con la raíz git, pero solo para lo que no tenía proyecto (regla 1).
+    const assigned = (repo) => direct(repo) ?? viaRoot(repo);
+    const keyFull = (b) => assigned(b.repoPath) ?? b.repoPath ?? "";
+    const groupedFull = (0, sessionize_js_1.groupByBranchAndDay)(raw, keyFull);
+    const full = byId(groupedFull, assigned);
+    // Qué imputaciones cambian: las que reciben algún bloque recuperado.
+    const touched = new Set();
+    for (const b of raw) {
+        if (direct(b.repoPath))
+            continue;
+        const p = viaRoot(b.repoPath);
+        if (p)
+            touched.add(entryId(p, (0, shared_1.localDate)(b.startedAt), b.branch));
+    }
+    const lockedDays = new Map();
+    const locked = (projectId, day) => {
+        const k = `${projectId}\0${day}`;
+        if (!lockedDays.has(k)) {
+            lockedDays.set(k, !!db.prepare(`SELECT 1 FROM time_entries WHERE project_id = ? AND local_date = ?
+           AND (approved = 1 OR invoice_id IS NOT NULL) LIMIT 1`).get(projectId, day));
+        }
+        return lockedDays.get(k);
+    };
+    const entries = [];
+    const recovered = new Map();
+    const blocked = [];
+    for (const [id, g] of full) {
+        const before = base.get(id);
+        if (!touched.has(id)) {
+            entries.push({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: 0 });
+            continue;
+        }
+        const gain = Math.max(0, g.block.seconds - (before?.block.seconds ?? 0));
+        const day = (0, shared_1.localDate)(g.block.startedAt);
+        if (locked(g.projectId, day)) {
+            // Regla 2: el día se queda como estaba; si antes no había nada, nada.
+            if (before)
+                entries.push({ entry: toEntry(db, before.projectId, before.block), recoveredSeconds: 0 });
+            if (gain > 0)
+                blocked.push({ projectId: g.projectId, day, seconds: gain });
+            continue;
+        }
+        entries.push({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: gain });
+        if (gain > 0)
+            recovered.set(g.projectId, (recovered.get(g.projectId) ?? 0) + gain);
+    }
+    return {
+        entries, grouped: groupedFull.length,
+        unassigned: groupedFull.filter((b) => !assigned(b.repoPath)).length,
+        recovered, blocked,
+    };
+}
+/** Los bloques agrupados con proyecto, por el id con el que se guardarían. */
+function byId(blocks, projectOf) {
+    const out = new Map();
+    for (const block of blocks) {
+        const projectId = projectOf(block.repoPath);
+        if (!projectId)
+            continue;
+        out.set(entryId(projectId, (0, shared_1.localDate)(block.startedAt), block.branch), { projectId, block });
+    }
+    return out;
+}
+function toEntry(db, projectId, block) {
+    const project = store.getProject(db, projectId);
+    return {
+        id: entryId(projectId, (0, shared_1.localDate)(block.startedAt), block.branch),
+        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 ? [...(block.agents ?? ["claude-code"])] : [],
+        source: block.turnCount > 0 ? "agent" : "commit",
+        kind: "development",
+        branch: block.branch,
+        // El ticket se saca aquí: en la base solo quedan los hashes de los
+        // commits, y es en sus mensajes donde va el `AB#1234`.
+        workItems: (0, shared_1.extractWorkItems)(block.branch, block.commits.map((c) => c.subject), project.tracker),
+    };
+}
+//# sourceMappingURL=assign.js.map

package/dist/bin.js

@@ -20,7 +20,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_version_js_1 = require("./node-version.js");
 const index_js_1 = require("./i18n/index.js");
 const MIN_NODE = "22.5.0";
-if ((0, node_version_js_1.tooOld)(process.version, MIN_NODE)) {
+// `estela statusline` (y no `statusline install|uninstall`, que son de la CLI):
+// lo ejecuta Claude Code en cada evento de la sesión y tiene 100 ms. Va por un
+// camino aparte que no carga cli.js, y en un Node viejo imprime "estela" y
+// sale con 0 en vez de un error: la status line no se rompe nunca.
+const sub = process.argv[3];
+const esStatusline = process.argv[2] === "statusline" &&
+    !["install", "uninstall", "help", "--help"].includes(sub ?? "");
+if (esStatusline) {
+    // El aviso de que node:sqlite es experimental iría a stderr en cada evento.
+    process.removeAllListeners("warning");
+    process.on("warning", () => { });
+    if ((0, node_version_js_1.tooOld)(process.version, MIN_NODE)) {
+        process.stdout.write("estela\n");
+    }
+    else {
+        const i = process.argv.indexOf("--lang");
+        (0, index_js_1.setLang)((0, index_js_1.detectLang)({ flag: i >= 0 ? process.argv[i + 1] : undefined, env: process.env, platform: process.platform }));
+        void import("./statusline-run.js")
+            .then((m) => m.runStatusline(process.argv.slice(3)))
+            .catch(() => { process.stdout.write("estela\n"); });
+    }
+}
+else if ((0, node_version_js_1.tooOld)(process.version, MIN_NODE)) {
     // Aquí aún no se ha leído ningún argumento: `--lang` se busca a mano.
     const i = process.argv.indexOf("--lang");
     (0, index_js_1.setLang)((0, index_js_1.detectLang)({ flag: i >= 0 ? process.argv[i + 1] : undefined, env: process.env, platform: process.platform }));