estela 0.3.4 → 0.4.1

package/dist/delivery/gitlab.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabPlanSource = exports.runGlab = void 0;
+exports.closingIssues = closingIssues;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const shared_1 = require("@estela/shared");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const runGlab = async (args, cwd) => {
+    const { stdout } = await run("glab", [...args], { cwd, timeout: 60_000, maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+};
+exports.runGlab = runGlab;
+const PER_PAGE = 100;
+/** Tope de páginas por lista: 10.000 elementos. Más es otro tipo de proyecto. */
+const MAX_PAGES = 100;
+class GitLabPlanSource {
+    cwd;
+    glab;
+    system = "gitlab";
+    constructor(cwd, glab = exports.runGlab) {
+        this.cwd = cwd;
+        this.glab = glab;
+    }
+    async availability() {
+        try {
+            await this.glab(["--version"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "missing", detail: errorText(error) };
+        }
+        try {
+            await this.glab(["auth", "status"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "auth", detail: errorText(error) };
+        }
+        try {
+            await this.glab(["api", "projects/:fullpath"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "repo", detail: errorText(error) };
+        }
+        return { ok: true };
+    }
+    async fetch(query) {
+        // GitLab no filtra por fecha de merge o de cierre: se piden las tocadas
+        // desde el día antes (cerrar o fusionar también es tocar) y se filtra aquí.
+        const since = new Date(new Date(`${query.from}T00:00:00Z`).getTime() - 86_400_000).toISOString();
+        const inPeriod = (i) => !!i.closedAt && (0, shared_1.localDate)(i.closedAt) >= query.from && (0, shared_1.localDate)(i.closedAt) <= query.to;
+        const lists = [
+            this.list("merge_requests", { state: "merged", updated_after: since }).then((l) => l.filter(inPeriod)),
+            this.list("issues", { state: "closed", updated_after: since }).then((l) => l.filter(inPeriod)),
+        ];
+        const plan = query.plan;
+        if (plan?.label) {
+            lists.push(this.list("issues", { labels: plan.label }));
+            lists.push(this.list("merge_requests", { labels: plan.label }));
+        }
+        else if (plan?.milestone) {
+            lists.push(this.list("issues", { milestone: plan.milestone }));
+            lists.push(this.list("merge_requests", { milestone: plan.milestone }));
+        }
+        const prefix = query.clientLabelPrefix?.toLowerCase();
+        if (prefix) {
+            // Las MR en curso: una sin etiqueta que cierra la issue de un cliente
+            // también es trabajo para ese cliente.
+            lists.push(this.list("merge_requests", { state: "opened" }));
+            // GitLab no busca etiquetas por prefijo: primero cuáles existen.
+            const labels = (await this.pages("labels", {}))
+                .map((l) => l.name).filter((n) => n.toLowerCase().startsWith(prefix));
+            for (const label of labels) {
+                lists.push(this.list("issues", { labels: label }));
+                lists.push(this.list("merge_requests", { labels: label }));
+            }
+        }
+        // Una issue o una MR puede salir en dos listas: se queda una vez.
+        const items = new Map();
+        for (const list of await Promise.all(lists))
+            for (const item of list)
+                items.set(`${item.kind}:${item.key}`, item);
+        return [...items.values()];
+    }
+    async list(kind, params) {
+        const rows = await this.pages(kind, params);
+        return rows.map((r) => (kind === "issues" ? normalizeIssue(r) : normalizeMr(r)));
+    }
+    /** Todas las páginas de `projects/:fullpath/<path>`. */
+    async pages(path, params) {
+        const out = [];
+        for (let page = 1; page <= MAX_PAGES; page++) {
+            const qs = new URLSearchParams({ ...params, per_page: String(PER_PAGE), page: String(page) });
+            const rows = JSON.parse((await this.glab(["api", `projects/:fullpath/${path}?${qs}`], this.cwd)) || "[]");
+            out.push(...rows);
+            if (rows.length < PER_PAGE)
+                break;
+        }
+        return out;
+    }
+}
+exports.GitLabPlanSource = GitLabPlanSource;
+const date = (s) => (s ? new Date(s) : null);
+const labelsOf = (raw) => (raw.labels ?? []).map((l) => (typeof l === "string" ? l : l.name));
+function normalizeMr(raw) {
+    const merged = raw.state === "merged" || !!raw.merged_at;
+    return {
+        key: `gitlab:!${raw.iid}`, kind: "pr", number: raw.iid, title: raw.title,
+        state: merged ? "merged" : raw.state === "opened" ? "open" : "closed",
+        completed: merged, closedAt: date(raw.merged_at) ?? date(raw.closed_at),
+        branch: raw.source_branch || null,
+        closes: closingIssues(raw.description ?? "").map((n) => `gitlab:${n}`),
+        labels: labelsOf(raw), milestone: raw.milestone?.title ?? null, url: raw.web_url,
+    };
+}
+function normalizeIssue(raw) {
+    const closed = raw.state === "closed";
+    return {
+        key: `gitlab:${raw.iid}`, kind: "issue", number: raw.iid, title: raw.title,
+        state: closed ? "closed" : "open",
+        // GitLab no distingue hecha de "no se hará". Movida a otro proyecto, no es de aquí.
+        completed: closed && !raw.moved_to_id,
+        closedAt: date(raw.closed_at), branch: null, closes: [],
+        labels: labelsOf(raw), milestone: raw.milestone?.title ?? null, url: raw.web_url,
+    };
+}
+/**
+ * Las issues de este proyecto que cierra una descripción, con el patrón por
+ * defecto de GitLab: "Closes #12", "Fixes #12, #13", "Resolves issue #12 and #14",
+ * "Implements #12". Las de otro proyecto (`grupo/otro#12`) no.
+ */
+function closingIssues(description) {
+    const out = new Set();
+    const verbs = /\b(?:clos(?:e[sd]?|ing)|fix(?:e[sd]|ing)?|resolv(?:e[sd]?|ing)|implement(?:s|ed|ing)?):?((?:\s*,?\s*(?:and\s+)?(?:issues?\s+)?#\d+\b)+)/gi;
+    for (const m of description.matchAll(verbs)) {
+        for (const n of m[1].matchAll(/(?<![\w/])#(\d+)/g))
+            out.add(Number(n[1]));
+    }
+    return [...out];
+}
+function errorText(error) {
+    const e = error;
+    if (e.code === "ENOENT")
+        return "glab no está instalado";
+    return (e.stderr || e.message || String(error)).trim().split("\n")[0] ?? "";
+}
+//# sourceMappingURL=gitlab.js.map

package/dist/delivery/report.d.ts

@@ -0,0 +1,55 @@
+import type { AiCost, Money, Subscription, TimeEntry } from "@estela/shared";
+import type { MergeRecord } from "../watchers/git.js";
+import type { PlanFilter, TrackerItem } from "./source.js";
+/**
+ * Planificado frente a entregado, con el coste de IA de cada parte.
+ *
+ *  - Planificado y entregado: lo del plan que se cerró como hecho, o cuyo PR
+ *    se fusionó, dentro del periodo.
+ *  - Planificado sin entregar: el resto del plan, con su estado.
+ *  - Entregado sin planificar: PRs fusionados e issues cerradas como hechas en
+ *    el periodo que no son del plan ni lo cierran.
+ *
+ * El coste de una issue o un PR es el de las imputaciones que se le unen:
+ * las de la rama del PR, las que llevan su número (rama, commit o a mano) y,
+ * para una issue, las de los PRs que la cierran. Es el coste de toda esa
+ * entrega, aunque parte se trabajara antes del periodo. Una imputación que se
+ * une a dos cosas a la vez cuenta en las dos líneas, pero una sola vez en el
+ * total de cada bloque.
+ */
+export interface DeliveryInput {
+    readonly items: readonly TrackerItem[];
+    readonly plan: PlanFilter | null;
+    readonly from: string;
+    readonly to: string;
+    readonly entries: readonly TimeEntry[];
+    readonly merges: readonly MergeRecord[];
+    readonly subscriptions: readonly Subscription[];
+    readonly monthTotals: ReadonlyMap<string, AiCost>;
+}
+export interface Cost {
+    readonly seconds: number;
+    readonly consumption: AiCost;
+    readonly real: Money | null;
+    readonly realPartial: boolean;
+}
+export interface DeliveryLine extends Cost {
+    readonly item: TrackerItem;
+    /** PRs del periodo que cierran esta issue. */
+    readonly deliveredBy: readonly TrackerItem[];
+    /** Cómo se unió el coste: "branch" (rama del PR) y/o "item" (número en la rama, un commit o a mano). */
+    readonly basis: readonly ("branch" | "item")[];
+}
+export interface DeliveryBlock extends Cost {
+    readonly lines: readonly DeliveryLine[];
+}
+export interface DeliveryReport {
+    /** `null` sin plan configurado: solo hay entregado. */
+    readonly planned: {
+        readonly delivered: DeliveryBlock;
+        readonly pending: DeliveryBlock;
+    } | null;
+    readonly unplanned: DeliveryBlock;
+}
+export declare function deliveryReport(input: DeliveryInput): DeliveryReport;
+//# sourceMappingURL=report.d.ts.map

package/dist/delivery/report.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliveryReport = deliveryReport;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const spend_js_1 = require("../metrics/spend.js");
+function deliveryReport(input) {
+    const inPeriod = (d) => {
+        if (!d)
+            return false;
+        const day = (0, shared_1.localDate)(d);
+        return day >= input.from && day <= input.to;
+    };
+    const isPlanned = (i) => !!input.plan && ((input.plan.label !== undefined && i.labels.includes(input.plan.label)) ||
+        (input.plan.milestone !== undefined && i.milestone === input.plan.milestone));
+    const prsDelivered = input.items.filter((i) => i.kind === "pr" && i.completed && inPeriod(i.closedAt));
+    const closersOf = (issue) => prsDelivered.filter((pr) => pr.closes.includes(issue.key));
+    const deliveredInPeriod = (i) => i.kind === "pr"
+        ? i.completed && inPeriod(i.closedAt)
+        : (i.completed && inPeriod(i.closedAt)) || closersOf(i).length > 0;
+    // Lo que se cerró antes del periodo ya no es plan de este periodo.
+    const planned = input.items.filter((i) => isPlanned(i) && !(i.closedAt && (0, shared_1.localDate)(i.closedAt) < input.from
+        && !deliveredInPeriod(i)));
+    const plannedKeys = new Set(planned.map((i) => i.key));
+    const unplanned = input.items.filter((i) => {
+        if (isPlanned(i) || !deliveredInPeriod(i))
+            return false;
+        // Un PR que entrega algo del plan es la entrega de ese plan, no un extra.
+        if (i.kind === "pr" && i.closes.some((k) => plannedKeys.has(k)))
+            return false;
+        // Una issue cerrada por un PR extra ya va con su PR.
+        if (i.kind === "issue" && closersOf(i).length > 0)
+            return false;
+        return true;
+    });
+    const costs = new EntryIndex(input);
+    const line = (item) => {
+        const deliveredBy = item.kind === "issue" ? closersOf(item) : [];
+        const { ids, basis } = costs.entriesOf(item, deliveredBy);
+        return { item, deliveredBy, basis, ...costs.cost(ids) };
+    };
+    const block = (items) => {
+        const lines = items.map(line).sort((a, b) => b.consumption.microUsd - a.consumption.microUsd
+            || a.item.number - b.item.number);
+        const ids = new Set();
+        for (const i of items)
+            for (const id of costs.entriesOf(i, i.kind === "issue" ? closersOf(i) : []).ids)
+                ids.add(id);
+        return { lines, ...costs.cost(ids) };
+    };
+    return {
+        planned: input.plan ? {
+            delivered: block(planned.filter(deliveredInPeriod)),
+            pending: block(planned.filter((i) => !deliveredInPeriod(i))),
+        } : null,
+        unplanned: block(unplanned),
+    };
+}
+// ---------------------------------------------------------------------------
+/** Qué imputaciones se unen a cada issue o PR, y lo que cuestan. */
+class EntryIndex {
+    input;
+    byId = new Map();
+    byBranch = new Map();
+    byItem = new Map();
+    assignedByMonth = new Map();
+    constructor(input) {
+        this.input = input;
+        const push = (map, k, id) => {
+            const list = map.get(k) ?? [];
+            if (!list.includes(id))
+                list.push(id);
+            map.set(k, list);
+        };
+        // El PR de un merge registrado en git también une su rama con su número.
+        const prOfBranch = new Map();
+        for (const m of input.merges)
+            if (m.sourceBranch && m.ref)
+                prOfBranch.set(m.sourceBranch, m.ref);
+        for (const e of input.entries) {
+            this.byId.set(e.id, e);
+            if (e.branch)
+                push(this.byBranch, e.branch, e.id);
+            for (const k of e.workItems ?? [])
+                push(this.byItem, k, e.id);
+            const pr = e.branch ? prOfBranch.get(e.branch) : undefined;
+            if (pr)
+                push(this.byItem, pr, e.id);
+            const month = (0, amortize_js_1.monthOf)(e.startedAt);
+            this.assignedByMonth.set(month, (this.assignedByMonth.get(month) ?? 0) + e.aiCost.microUsd);
+        }
+    }
+    entriesOf(item, deliveredBy) {
+        const ids = new Set();
+        const basis = new Set();
+        for (const i of [item, ...deliveredBy]) {
+            const fromBranch = i.kind === "pr" && i.branch ? this.byBranch.get(i.branch) ?? [] : [];
+            const fromItem = this.byItem.get(i.key) ?? [];
+            if (fromBranch.length)
+                basis.add("branch");
+            if (fromItem.length)
+                basis.add("item");
+            for (const id of [...fromBranch, ...fromItem])
+                ids.add(id);
+        }
+        // Siempre en el mismo orden: la rama primero.
+        return { ids, basis: ["branch", "item"].filter((b) => basis.has(b)) };
+    }
+    cost(ids) {
+        let seconds = 0;
+        let micro = 0;
+        const byMonth = new Map();
+        for (const id of ids) {
+            const e = this.byId.get(id);
+            seconds += e.seconds;
+            micro += e.aiCost.microUsd;
+            const month = (0, amortize_js_1.monthOf)(e.startedAt);
+            byMonth.set(month, (byMonth.get(month) ?? 0) + e.aiCost.microUsd);
+        }
+        const { real, partial } = (0, spend_js_1.realFromMonths)(byMonth, this.input.subscriptions, (month) => Math.max(this.input.monthTotals.get(month)?.microUsd ?? 0, this.assignedByMonth.get(month) ?? 0));
+        return { seconds, consumption: { microUsd: micro }, real, realPartial: partial };
+    }
+}
+//# sourceMappingURL=report.js.map

package/dist/delivery/source.d.ts

@@ -0,0 +1,68 @@
+import type { TrackerSystem } from "@estela/shared";
+/**
+ * De dónde sale lo planificado y lo entregado de un periodo.
+ *
+ * Una interfaz y no GitHub a pelo: el plan de un equipo vive en GitHub, en
+ * Linear o en Jira, y lo que Estela hace con él (compararlo con lo entregado y
+ * ponerle el coste de IA) es lo mismo en los tres. Hoy solo existe GitHub.
+ *
+ * Una fuente es la única parte de Estela que habla con un servicio externo, y
+ * solo cuando quien la usa ejecuta el comando en un proyecto que la tiene
+ * configurada. Lo que lee se guarda en la base (tracker_items) para poder
+ * repetir el informe sin conexión.
+ */
+/** Una issue o un PR, ya normalizado. */
+export interface TrackerItem {
+    /** Clave como las de los tickets de las imputaciones: `github:12`. */
+    readonly key: string;
+    readonly kind: "issue" | "pr";
+    readonly number: number;
+    readonly title: string;
+    readonly state: "open" | "closed" | "merged";
+    /** Cerrada como hecha (issue) o fusionado (PR). Cerrar como "no se hará" no es entregar. */
+    readonly completed: boolean;
+    /** Cuándo se cerró o se fusionó. */
+    readonly closedAt: Date | null;
+    /** Rama del PR. Es lo que une un squash con el trabajo de su rama. */
+    readonly branch: string | null;
+    /** Issues que cierra este PR (`github:12`). */
+    readonly closes: readonly string[];
+    readonly labels: readonly string[];
+    readonly milestone: string | null;
+    readonly url: string;
+}
+/** Qué cuenta como planificado: una etiqueta o un milestone. */
+export interface PlanFilter {
+    readonly label?: string;
+    readonly milestone?: string;
+}
+export interface FetchQuery {
+    /** Fechas locales, inclusive. */
+    readonly from: string;
+    readonly to: string;
+    readonly plan: PlanFilter | null;
+    /**
+     * Prefijo de las etiquetas de cliente (`cliente:`). Con él se traen también
+     * las issues y PRs que las llevan, en cualquier estado: lo pedido por un
+     * cliente cuesta mientras se trabaja, no solo al entregarse.
+     */
+    readonly clientLabelPrefix?: string;
+}
+export type Availability = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "missing" | "auth" | "repo";
+    readonly detail: string;
+};
+export interface PlanSource {
+    readonly system: TrackerSystem;
+    /** Si se puede leer ahora: instalado, con sesión y con un repo que la fuente entienda. */
+    availability(): Promise<Availability>;
+    /**
+     * Lo planificado (según el filtro, en cualquier estado) más lo entregado en
+     * el periodo (PRs fusionados e issues cerradas).
+     */
+    fetch(query: FetchQuery): Promise<TrackerItem[]>;
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/delivery/source.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=source.js.map

package/dist/export/csv.d.ts

@@ -1,9 +1,23 @@
 import type { Client, Invoice, Project, TimeEntry } from "@estela/shared";
 import { formatMoney } from "@estela/shared";
+import type { SpendBy, SpendProject, SpendProjectReport } from "../metrics/spend.js";
+import { type UndeliveredReport } from "../metrics/undelivered.js";
 export declare function timeEntriesToCsv(entries: readonly TimeEntry[], project: Project, client: Client, hourlyRateOf: (at: Date) => {
     amount: number;
     currency: string;
 } | null): string;
 export declare function invoiceToCsv(invoice: Invoice, client: Client, project: Project): string;
+/**
+ * `estela ai-cost --by … --csv`: una fila por rama o ticket. "Sin atribuir"
+ * va con la unidad vacía y atribuido = no, para que una tabla dinámica no la
+ * confunda con una rama que se llame así.
+ */
+export declare function spendToCsv(reports: readonly SpendProjectReport[], by: SpendBy): string;
+/**
+ * `estela ai-cost --undelivered --csv`: una fila por bloque y por rama. La
+ * columna "cuenta" dice si suma al gasto sin entrega: las ramas abiertas o de
+ * estado desconocido se listan, pero no cuentan.
+ */
+export declare function undeliveredToCsv(reports: readonly UndeliveredReport[], projects: ReadonlyMap<string, SpendProject>): string;
 export { formatMoney };
 //# sourceMappingURL=csv.d.ts.map

package/dist/export/csv.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatMoney = void 0;
 exports.timeEntriesToCsv = timeEntriesToCsv;
 exports.invoiceToCsv = invoiceToCsv;
+exports.spendToCsv = spendToCsv;
+exports.undeliveredToCsv = undeliveredToCsv;
 const shared_1 = require("@estela/shared");
 Object.defineProperty(exports, "formatMoney", { enumerable: true, get: function () { return shared_1.formatMoney; } });
 const localize_js_1 = require("../billing/localize.js");
 const index_js_1 = require("../i18n/index.js");
+const undelivered_js_1 = require("../metrics/undelivered.js");
 /**
  * Export a CSV.
  *
@@ -33,6 +36,14 @@ const COLUMNS = {
         lineHeader: ["concepto", "horas", "tarifa", "importe"],
         subtotal: "subtotal", aiBilled: "coste_ia_repercutido", total: "total",
         aiUsage: "consumo_ia_usd_equiv_api",
+        spend: ["proyecto", "cliente", "unidad", "atribuido", "ramas", "tickets", "pr", "segun", "horas",
+            "coste_ia_usd_equiv_api", "gasto_real", "moneda", "gasto_real_parcial", "incluye_copilot_sin_coste"],
+        undelivered: ["proyecto", "cliente", "bloque", "detalle", "cuenta", "dias_sin_actividad",
+            "coste_ia_usd_equiv_api", "gasto_real", "moneda", "gasto_real_parcial", "pct_del_gasto"],
+        blocks: { total: "gasto_del_periodo", sessions: "sesiones_sin_commit", later: "de_ellas_con_commit_despues",
+            unverifiable: "sesiones_sin_datos_de_commits",
+            unmerged: "rama_sin_fusionar", open: "rama_abierta", unknown: "rama_desconocida",
+            undelivered: "sin_entrega_total" },
     },
     en: {
         entries: ["date", "start", "end", "hours", "description", "project", "client",
@@ -44,6 +55,14 @@ const COLUMNS = {
         lineHeader: ["item", "hours", "rate", "amount"],
         subtotal: "subtotal", aiBilled: "ai_cost_passed_on", total: "total",
         aiUsage: "ai_usage_usd_api_equiv",
+        spend: ["project", "client", "unit", "attributed", "branches", "tickets", "pr", "basis", "hours",
+            "ai_cost_usd_api_equiv", "real_spend", "currency", "real_spend_partial", "includes_unpriced_copilot"],
+        undelivered: ["project", "client", "block", "detail", "counts", "idle_days",
+            "ai_cost_usd_api_equiv", "real_spend", "currency", "real_spend_partial", "pct_of_spend"],
+        blocks: { total: "period_spend", sessions: "sessions_without_commit", later: "of_which_committed_later",
+            unverifiable: "sessions_without_commit_data",
+            unmerged: "unmerged_branch", open: "open_branch", unknown: "unknown_branch",
+            undelivered: "undelivered_total" },
     },
 };
 /** Escapa un campo. Sin esto, un commit con una coma parte la fila en dos. */
@@ -113,4 +132,63 @@ function invoiceToCsv(invoice, client, project) {
     lines.push([c.aiUsage, "", "", (invoice.aiCost.microUsd / 1_000_000).toFixed(4)]);
     return rows(lines);
 }
+/**
+ * `estela ai-cost --by … --csv`: una fila por rama o ticket. "Sin atribuir"
+ * va con la unidad vacía y atribuido = no, para que una tabla dinámica no la
+ * confunda con una rama que se llame así.
+ */
+function spendToCsv(reports, by) {
+    const c = COLUMNS[(0, index_js_1.getLang)()];
+    const lines = [[...c.spend]];
+    for (const r of reports) {
+        for (const u of r.units) {
+            lines.push([
+                r.project.name,
+                r.project.clientName,
+                u.key === null ? "" : by === "branch" ? u.key : u.items.map(shared_1.formatWorkItem).join(" "),
+                u.key === null ? c.no : c.yes,
+                u.branches.join(" "),
+                u.items.map(shared_1.formatWorkItem).join(" "),
+                u.prs.map(shared_1.formatWorkItem).join(" "),
+                u.basis.join(" "),
+                (u.seconds / 3600).toFixed(4),
+                (u.consumption.microUsd / 1_000_000).toFixed(4),
+                u.real ? (u.real.amount / 10 ** shared_1.MINOR_UNIT_DIGITS[u.real.currency]).toFixed(shared_1.MINOR_UNIT_DIGITS[u.real.currency]) : "",
+                u.real?.currency ?? "",
+                u.realPartial ? c.yes : c.no,
+                u.unpricedAgents ? c.yes : c.no,
+            ]);
+        }
+    }
+    return rows(lines);
+}
+/**
+ * `estela ai-cost --undelivered --csv`: una fila por bloque y por rama. La
+ * columna "cuenta" dice si suma al gasto sin entrega: las ramas abiertas o de
+ * estado desconocido se listan, pero no cuentan.
+ */
+function undeliveredToCsv(reports, projects) {
+    const c = COLUMNS[(0, index_js_1.getLang)()];
+    const lines = [[...c.undelivered]];
+    const amount = (s) => s.real
+        ? (s.real.amount / 10 ** shared_1.MINOR_UNIT_DIGITS[s.real.currency]).toFixed(shared_1.MINOR_UNIT_DIGITS[s.real.currency]) : "";
+    for (const r of reports) {
+        const p = projects.get(r.projectId);
+        const push = (block, detail, counts, idle, s) => lines.push([
+            p?.name ?? r.projectId, p?.clientName ?? "", block, detail, counts ? c.yes : c.no, idle ?? "",
+            (s.consumption.microUsd / 1_000_000).toFixed(4), amount(s), s.real?.currency ?? "",
+            s.realPartial ? c.yes : c.no, (0, undelivered_js_1.shareOf)(s, r.total)?.toFixed(2) ?? "",
+        ]);
+        push(c.blocks.total, "", false, null, r.total);
+        push(c.blocks.sessions, String(r.sessionsWithoutCommit.count), true, null, r.sessionsWithoutCommit);
+        push(c.blocks.later, String(r.sessionsWithoutCommit.laterCommitted.count), false, null, r.sessionsWithoutCommit.laterCommitted);
+        push(c.blocks.unverifiable, String(r.unverifiable.count), false, null, r.unverifiable);
+        for (const b of r.unmerged.branches)
+            push(c.blocks.unmerged, b.branch, true, b.idleDays, b);
+        for (const b of r.notCounted)
+            push(b.state === "open" ? c.blocks.open : c.blocks.unknown, b.branch, false, b.idleDays, b);
+        push(c.blocks.undelivered, "", false, null, r.undelivered);
+    }
+    return rows(lines);
+}
 //# sourceMappingURL=csv.js.map

package/dist/export/finance.d.ts

@@ -0,0 +1,79 @@
+import type { Currency } from "@estela/shared";
+import type { Cost } from "../delivery/report.js";
+/**
+ * El informe para finanzas: el gasto de IA de un periodo contado para alguien
+ * que no programa.
+ *
+ * Los titulares hablan de dinero pagado, clientes y entregas; "tokens",
+ * "sesiones" y "precio de API" solo aparecen al final, en cómo se calcula.
+ * Junta lo que ya calculan los demás informes (ai-cost --by, --undelivered,
+ * delivery) sin calcular nada nuevo: aquí solo se ordena y se escribe.
+ */
+export interface FinanceProject {
+    readonly id: string;
+    readonly name: string;
+    readonly cost: Cost;
+}
+export interface FinanceClient {
+    readonly id: string;
+    readonly name: string;
+    readonly cost: Cost;
+    readonly projects: readonly FinanceProject[];
+}
+export interface FinanceDelivery {
+    readonly label: string;
+    readonly cost: Cost;
+}
+export interface FinanceDeliveries {
+    readonly projectName: string;
+    readonly clientName: string;
+    /** "github"/"gitlab": lo leído del gestor con `estela delivery`; "git": solo merges y squash. */
+    readonly source: "github" | "gitlab" | "git";
+    readonly fetchedAt: Date | null;
+    readonly delivered: readonly FinanceDelivery[];
+    readonly plan: {
+        readonly label: string;
+        readonly delivered: number;
+        readonly total: number;
+        readonly pending: Cost;
+        readonly unplanned: Cost;
+    } | null;
+    readonly requests: readonly {
+        readonly name: string;
+        readonly mapped: boolean;
+        readonly cost: Cost;
+    }[] | null;
+    readonly requestsRest: Cost | null;
+}
+export interface FinanceUndelivered {
+    readonly projectName: string;
+    readonly total: Cost;
+    readonly undelivered: Cost;
+    readonly withoutCommit: Cost;
+    readonly unmergedBranches: Cost;
+    readonly unmergedCount: number;
+}
+export interface FinanceSummary {
+    readonly from: string;
+    readonly to: string;
+    /** La moneda de la cuota; `null` sin suscripción registrada (todo va a precio de API). */
+    readonly currency: Currency | null;
+    /** Todo el gasto de la máquina en el periodo, con o sin proyecto. */
+    readonly paid: Cost;
+    readonly unassigned: Cost;
+    readonly clients: readonly FinanceClient[];
+    readonly deliveries: readonly FinanceDeliveries[];
+    readonly undelivered: readonly FinanceUndelivered[];
+    readonly staleDays: number;
+    /** Hubo trabajo con Copilot, cuyo coste no se conoce. */
+    readonly unpricedAgents: boolean;
+}
+/** "octubre de 2026" si el periodo es un mes entero; si no, las dos fechas. */
+export declare function periodName(from: string, to: string): string;
+export declare function financeToMarkdown(s: FinanceSummary): string;
+/** Suma dos costes. El importe real se suma solo si los dos están en la misma moneda. */
+export declare function sum(a: Cost, b: Cost): Cost;
+/** Una fila por cifra, con la sección delante: se filtra en una hoja de cálculo. */
+export declare function financeToCsv(s: FinanceSummary): string;
+export declare function financeToJson(s: FinanceSummary): unknown;
+//# sourceMappingURL=finance.d.ts.map