estela 0.3.4 → 0.4.1

package/dist/metrics/spend.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spendByUnit = spendByUnit;
+exports.realFromMonths = realFromMonths;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const index_js_1 = require("../i18n/index.js");
+const paths_js_1 = require("../paths.js");
+/** Agentes cuyo transcript no trae tokens: su trabajo cuenta horas pero no coste. */
+const UNPRICED_AGENTS = new Set(["copilot"]);
+function spendByUnit(input, by) {
+    const reports = [];
+    // Como en `amortize`: el denominador nunca baja de lo imputado ese mes, o un
+    // mes sin turnos guardados le daría la cuota entera a cada unidad.
+    const assignedByMonth = new Map();
+    for (const e of input.entries) {
+        const month = (0, amortize_js_1.monthOf)(e.startedAt);
+        assignedByMonth.set(month, (assignedByMonth.get(month) ?? 0) + e.aiCost.microUsd);
+    }
+    for (const project of input.projects) {
+        const entries = input.entries.filter((e) => e.projectId === project.id);
+        if (entries.length === 0)
+            continue;
+        const prsByBranch = mergedPrs(input.merges, project.repoPaths);
+        const groups = new Map();
+        for (const entry of entries) {
+            const a = attribute(entry, project.tracker ?? null, prsByBranch);
+            const key = by === "branch" ? entry.branch : a.items.length ? a.items.join(",") : null;
+            const id = key ?? "\u0000";
+            let acc = groups.get(id);
+            if (!acc) {
+                acc = newAcc(key);
+                groups.set(id, acc);
+            }
+            add(acc, entry, a, by);
+        }
+        const units = [...groups.values()].map((acc) => finish(acc, input, assignedByMonth));
+        units.sort((x, y) => (x.key === null ? 1 : 0) - (y.key === null ? 1 : 0)
+            || y.consumption.microUsd - x.consumption.microUsd || y.seconds - x.seconds);
+        reports.push({ project, units, total: sumUnits(units) });
+    }
+    return reports;
+}
+/** PRs fusionados por rama, de los merges de los repos del proyecto. */
+function mergedPrs(merges, repos) {
+    const out = new Map();
+    for (const m of merges) {
+        if (!m.sourceBranch || !m.ref)
+            continue;
+        if (!repos.some((r) => (0, paths_js_1.isSameOrInside)(m.repoPath, r) || (0, paths_js_1.isSameOrInside)(r, m.repoPath)))
+            continue;
+        const list = out.get(m.sourceBranch) ?? [];
+        if (!list.includes(m.ref))
+            list.push(m.ref);
+        out.set(m.sourceBranch, list);
+    }
+    return out;
+}
+/**
+ * Los tickets de una imputación y en qué se basan. Primero los que ya tiene
+ * (rama, commits o a mano); si no tiene ninguno, el PR con que se fusionó su
+ * rama. Un PR no sustituye a un ticket que ya se conoce: son cosas distintas.
+ */
+function attribute(entry, tracker, prsByBranch) {
+    const prs = entry.branch ? prsByBranch.get(entry.branch) ?? [] : [];
+    const known = entry.workItems ?? [];
+    if (known.length) {
+        const fromBranch = new Set((0, shared_1.extractWorkItems)(entry.branch, [], tracker));
+        const itemBasis = entry.workItemsManual
+            ? ["manual"]
+            : known.map((k) => (fromBranch.has(k) ? "branch-name" : "commit-message"));
+        return { items: [...known], prs, itemBasis };
+    }
+    if (prs.length)
+        return { items: [...prs], prs, itemBasis: ["merge"] };
+    return { items: [], prs, itemBasis: [] };
+}
+function newAcc(key) {
+    return { key, branches: new Set(), items: new Set(), prs: new Set(), basis: new Set(),
+        seconds: 0, microUsd: 0, byMonth: new Map(), unpricedAgents: false };
+}
+function add(acc, entry, a, by) {
+    acc.seconds += entry.seconds;
+    acc.microUsd += entry.aiCost.microUsd;
+    // El mes de started_at, el mismo que usa `estela ai-cost` para repartir.
+    const month = (0, amortize_js_1.monthOf)(entry.startedAt);
+    acc.byMonth.set(month, (acc.byMonth.get(month) ?? 0) + entry.aiCost.microUsd);
+    if (entry.agents.some((x) => UNPRICED_AGENTS.has(x)))
+        acc.unpricedAgents = true;
+    if (entry.branch)
+        acc.branches.add(entry.branch);
+    // Por rama, los PRs van en su sitio: el del merge no se repite como ticket.
+    const fromMerge = a.itemBasis.length === 1 && a.itemBasis[0] === "merge";
+    if (by === "item" || !fromMerge)
+        for (const i of a.items)
+            acc.items.add(i);
+    for (const p of a.prs)
+        acc.prs.add(p);
+    if (by === "branch") {
+        if (entry.branch)
+            acc.basis.add(entry.agents.length ? "agent-branch" : "commit-branch");
+    }
+    else if (a.items.length) {
+        for (const b of a.itemBasis)
+            acc.basis.add(b);
+    }
+}
+/**
+ * Dinero real: la cuota del mes por la fracción de todo el consumo de ese mes
+ * que es de esta parte. La fórmula de `amortize`, solo que con una parte
+ * cualquiera (una rama, unas sesiones) en vez del proyecto; redondea por parte,
+ * así que la suma puede diferir en un céntimo de la de `ai-cost`.
+ *
+ * `partial`: algún mes con consumo no tenía cuota, y `real` cuenta solo el resto.
+ */
+function realFromMonths(byMonth, subscriptions, monthTotal) {
+    let real = null;
+    let partial = false;
+    if (!subscriptions.length)
+        return { real, partial };
+    for (const [month, micro] of byMonth) {
+        const fee = (0, amortize_js_1.feeForMonth)(subscriptions, month);
+        if (!fee) {
+            if (micro > 0)
+                partial = true;
+            continue;
+        }
+        const total = Math.max(monthTotal(month), micro);
+        const part = total === 0 ? 0 : Math.round(fee.amount * (micro / total));
+        if (real && real.currency !== fee.currency) {
+            throw new TypeError((0, index_js_1.tr) `Suscripciones en monedas distintas en el periodo (${real.currency} y ${fee.currency}). ` +
+                (0, index_js_1.tr) `Unifica la moneda de las suscripciones: no se convierten automáticamente.`);
+        }
+        real = (0, shared_1.money)((real?.amount ?? 0) + part, fee.currency);
+    }
+    return { real, partial };
+}
+function finish(acc, input, assignedByMonth) {
+    const { real, partial } = realFromMonths(acc.byMonth, input.subscriptions, (month) => Math.max(input.monthTotals.get(month)?.microUsd ?? 0, assignedByMonth.get(month) ?? 0));
+    return {
+        key: acc.key,
+        branches: [...acc.branches].sort(),
+        items: [...acc.items],
+        prs: [...acc.prs],
+        basis: [...acc.basis],
+        seconds: acc.seconds,
+        consumption: { microUsd: acc.microUsd },
+        real,
+        realPartial: partial,
+        unpricedAgents: acc.unpricedAgents,
+    };
+}
+function sumUnits(units) {
+    let real = null;
+    for (const u of units) {
+        if (u.real)
+            real = (0, shared_1.money)((real?.amount ?? 0) + u.real.amount, u.real.currency);
+    }
+    return {
+        seconds: units.reduce((s, u) => s + u.seconds, 0),
+        consumption: { microUsd: units.reduce((s, u) => s + u.consumption.microUsd, 0) },
+        real,
+        realPartial: units.some((u) => u.realPartial),
+        unpricedAgents: units.some((u) => u.unpricedAgents),
+    };
+}
+//# sourceMappingURL=spend.js.map

package/dist/metrics/undelivered.d.ts

@@ -0,0 +1,104 @@
+import type { AiCost, AgentKind, Money, Subscription } from "@estela/shared";
+/**
+ * Gasto de IA sin entrega: lo que no ha llegado (todavía) a la rama principal.
+ *
+ * Es una señal para revisar, no un juicio. Explorar, probar y descartar es
+ * trabajo, y una sesión en la que Claude cambia algo cinco veces antes de que
+ * lo des por bueno vale lo mismo aunque aún no tenga commit. Por eso nada de
+ * esto resta horas ni toca imputaciones: solo pone una cifra al lado.
+ *
+ * Se mide sobre los turnos, no sobre las imputaciones: una sesión es un rato
+ * de un chat, y una imputación es un día de una rama que puede juntar varias.
+ * Dos bloques que no se pisan:
+ *
+ *  1. Sesiones sin commit: un rato de trabajo de un chat (sin pausas de más de
+ *     30 min) en el que no hiciste ningún commit en ese repo, ni en los 30 min
+ *     siguientes. Se separan las que luego sí tuvieron commit en su rama. Las
+ *     anteriores a tu primer commit conocido en el repo no se juzgan: quizá
+ *     commiteabas con otro correo.
+ *  2. Ramas sin fusionar: el resto del coste de una rama que sigue existiendo,
+ *     no está integrada y lleva N días sin actividad. Una rama borrada sin
+ *     merge registrado puede ser un squash: su estado es "desconocido" y no
+ *     cuenta, porque contarla inflaría la cifra.
+ */
+export interface UndeliveredTurn {
+    readonly projectId: string;
+    readonly sessionId: string;
+    readonly at: Date;
+    /** Raíz git (el repo principal, también para un worktree). */
+    readonly root: string;
+    readonly branch: string | null;
+    readonly microUsd: number;
+    readonly agent: AgentKind;
+}
+/** Un commit tuyo, con su raíz git ya resuelta igual que la de los turnos. */
+export interface CommitFact {
+    readonly root: string;
+    readonly at: Date;
+    readonly branch: string | null;
+}
+export interface BranchFacts {
+    /** Integrada: la rama base, `git branch --merged` o un commit de merge. */
+    readonly merged: boolean;
+    /** `null` si el repo ya no se puede leer: no se sabe. */
+    readonly exists: boolean | null;
+}
+export interface UndeliveredInput {
+    readonly turns: readonly UndeliveredTurn[];
+    readonly commits: readonly CommitFact[];
+    readonly branchFacts: (root: string, branch: string) => BranchFacts;
+    readonly staleDays: number;
+    readonly now: Date;
+    /** Fechas locales; sin ellas, todo. Se mira la fecha de inicio de la sesión. */
+    readonly from?: string;
+    readonly to?: string;
+    readonly subscriptions: readonly Subscription[];
+    readonly monthTotals: ReadonlyMap<string, AiCost>;
+}
+export interface Spend {
+    readonly consumption: AiCost;
+    readonly real: Money | null;
+    readonly realPartial: boolean;
+}
+export type BranchState = "unmerged" | "open" | "unknown";
+export interface BranchLine extends Spend {
+    readonly branch: string;
+    readonly state: BranchState;
+    /** Días desde la última actividad (turno o commit) en la rama. */
+    readonly idleDays: number;
+}
+export interface UndeliveredReport {
+    readonly projectId: string;
+    /** Todo el gasto del periodo en el proyecto: la base del porcentaje. */
+    readonly total: Spend;
+    /**
+     * Sesiones sin commit que no se pueden juzgar: no se conoce ningún commit tuyo
+     * en ese repo, o la sesión es anterior al primero. Puede ser que commitearas
+     * con otro correo (ver `estela author`), así que no cuentan.
+     */
+    readonly unverifiable: Spend & {
+        readonly count: number;
+    };
+    readonly sessionsWithoutCommit: Spend & {
+        readonly count: number;
+        /** De ellas, las que luego tuvieron commit en su rama (dentro de N días). */
+        readonly laterCommitted: Spend & {
+            readonly count: number;
+        };
+    };
+    /** Ramas que cuentan: sin fusionar tras N días. */
+    readonly unmerged: Spend & {
+        readonly branches: readonly BranchLine[];
+    };
+    /** No cuentan: abiertas hace menos de N días, o de estado desconocido. */
+    readonly notCounted: readonly BranchLine[];
+    /** Suma de los dos bloques que cuentan. */
+    readonly undelivered: Spend;
+    readonly unpricedAgents: boolean;
+}
+/** Ramas donde se integra: trabajar directamente en ellas ya es entregar. */
+export declare const BASE_BRANCHES: Set<string>;
+export declare function undeliveredSpend(input: UndeliveredInput): UndeliveredReport[];
+/** El porcentaje de una parte sobre el total, en tanto por ciento. `null` sin total. */
+export declare function shareOf(part: Spend, total: Spend): number | null;
+//# sourceMappingURL=undelivered.d.ts.map

package/dist/metrics/undelivered.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_BRANCHES = void 0;
+exports.undeliveredSpend = undeliveredSpend;
+exports.shareOf = shareOf;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const spend_js_1 = require("./spend.js");
+/** El mismo hueco que separa bloques de trabajo (ver sessionize). */
+const GAP_MS = 30 * 60_000;
+const DAY_MS = 86_400_000;
+const UNPRICED_AGENTS = new Set(["copilot"]);
+/** Ramas donde se integra: trabajar directamente en ellas ya es entregar. */
+exports.BASE_BRANCHES = new Set(["main", "master", "develop", "trunk"]);
+function undeliveredSpend(input) {
+    const byProject = new Map();
+    for (const t of input.turns) {
+        const list = byProject.get(t.projectId) ?? [];
+        list.push(t);
+        byProject.set(t.projectId, list);
+    }
+    const reports = [];
+    for (const [projectId, turns] of byProject) {
+        const report = projectReport(projectId, turns, input);
+        if (report.total.consumption.microUsd > 0 || report.unpricedAgents)
+            reports.push(report);
+    }
+    return reports.sort((a, b) => a.projectId.localeCompare(b.projectId));
+}
+function projectReport(projectId, all, input) {
+    const inPeriod = (d) => {
+        const day = (0, shared_1.localDate)(d);
+        return (!input.from || day >= input.from) && (!input.to || day <= input.to);
+    };
+    const spend = new SpendAcc(input);
+    // Ratos de cada chat: mismo session_id y repo, cortados por pausas largas.
+    const sittings = [];
+    const bySession = new Map();
+    for (const t of all) {
+        const key = `${t.sessionId}\0${t.root}`;
+        const list = bySession.get(key) ?? [];
+        list.push(t);
+        bySession.set(key, list);
+    }
+    for (const list of bySession.values()) {
+        list.sort((a, b) => a.at.getTime() - b.at.getTime());
+        let current = [];
+        for (const t of list) {
+            const last = current[current.length - 1];
+            if (last && t.at.getTime() - last.at.getTime() > GAP_MS) {
+                sittings.push({ turns: current, root: last.root });
+                current = [];
+            }
+            current.push(t);
+        }
+        if (current.length)
+            sittings.push({ turns: current, root: current[0].root });
+    }
+    // El primer commit tuyo de cada repo: antes de él, no hay con qué comparar.
+    const firstCommit = new Map();
+    for (const c of input.commits) {
+        firstCommit.set(c.root, Math.min(firstCommit.get(c.root) ?? Infinity, c.at.getTime()));
+    }
+    const total = spend.empty();
+    const unverifiable = spend.empty();
+    let unverifiableCount = 0;
+    const noCommit = spend.empty();
+    const later = spend.empty();
+    let noCommitCount = 0;
+    let laterCount = 0;
+    const counted = new Set();
+    for (const s of sittings) {
+        const first = s.turns[0];
+        if (!inPeriod(first.at))
+            continue;
+        for (const t of s.turns)
+            spend.add(total, t);
+        const start = first.at.getTime();
+        const end = s.turns[s.turns.length - 1].at.getTime();
+        const committed = input.commits.some((c) => c.root === s.root && c.at.getTime() >= start && c.at.getTime() <= end + GAP_MS);
+        if (committed)
+            continue;
+        if (start < (firstCommit.get(s.root) ?? Infinity)) {
+            unverifiableCount++;
+            for (const t of s.turns) {
+                spend.add(unverifiable, t);
+                counted.add(t);
+            }
+            continue;
+        }
+        noCommitCount++;
+        for (const t of s.turns) {
+            spend.add(noCommit, t);
+            counted.add(t);
+        }
+        const branches = new Set(s.turns.map((t) => t.branch).filter((b) => !!b));
+        const afterwards = input.commits.some((c) => c.root === s.root && c.branch !== null
+            && branches.has(c.branch) && c.at.getTime() > end && c.at.getTime() <= end + input.staleDays * DAY_MS);
+        if (afterwards) {
+            laterCount++;
+            for (const t of s.turns)
+                spend.add(later, t);
+        }
+    }
+    // Ramas: el coste que no está ya en una sesión sin commit.
+    const lastActivity = new Map();
+    const touch = (root, branch, at) => {
+        const k = `${root}\0${branch}`;
+        lastActivity.set(k, Math.max(lastActivity.get(k) ?? 0, at.getTime()));
+    };
+    for (const t of all)
+        if (t.branch)
+            touch(t.root, t.branch, t.at);
+    const roots = new Set(all.map((t) => t.root));
+    for (const c of input.commits)
+        if (c.branch && roots.has(c.root))
+            touch(c.root, c.branch, c.at);
+    const lines = new Map();
+    for (const s of sittings) {
+        if (!inPeriod(s.turns[0].at))
+            continue;
+        for (const t of s.turns) {
+            if (counted.has(t) || !t.branch || t.branch === "HEAD" || exports.BASE_BRANCHES.has(t.branch))
+                continue;
+            const k = `${t.root}\0${t.branch}`;
+            let line = lines.get(k);
+            if (!line) {
+                line = { branch: t.branch, root: t.root, acc: spend.empty() };
+                lines.set(k, line);
+            }
+            spend.add(line.acc, t);
+        }
+    }
+    const unmergedAcc = spend.empty();
+    const unmergedLines = [];
+    const notCounted = [];
+    for (const [k, { branch, root, acc }] of lines) {
+        const facts = input.branchFacts(root, branch);
+        if (facts.merged)
+            continue;
+        const idleDays = Math.floor((input.now.getTime() - (lastActivity.get(k) ?? 0)) / DAY_MS);
+        const state = facts.exists !== true ? "unknown" : idleDays >= input.staleDays ? "unmerged" : "open";
+        const line = { branch, state, idleDays, ...spend.finish(acc) };
+        if (state === "unmerged") {
+            unmergedLines.push(line);
+            spend.merge(unmergedAcc, acc);
+        }
+        else {
+            notCounted.push(line);
+        }
+    }
+    const byCost = (a, b) => b.consumption.microUsd - a.consumption.microUsd;
+    const undelivered = spend.empty();
+    spend.merge(undelivered, noCommit);
+    spend.merge(undelivered, unmergedAcc);
+    return {
+        projectId,
+        total: spend.finish(total),
+        unverifiable: { ...spend.finish(unverifiable), count: unverifiableCount },
+        sessionsWithoutCommit: {
+            ...spend.finish(noCommit), count: noCommitCount,
+            laterCommitted: { ...spend.finish(later), count: laterCount },
+        },
+        unmerged: { ...spend.finish(unmergedAcc), branches: unmergedLines.sort(byCost) },
+        notCounted: notCounted.sort(byCost),
+        undelivered: spend.finish(undelivered),
+        unpricedAgents: total.unpriced,
+    };
+}
+/** Suma coste por mes, para repartir la cuota igual que `ai-cost`. */
+class SpendAcc {
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    empty() { return { microUsd: 0, byMonth: new Map(), unpriced: false }; }
+    add(acc, t) {
+        acc.microUsd += t.microUsd;
+        const month = (0, amortize_js_1.monthOf)(t.at);
+        acc.byMonth.set(month, (acc.byMonth.get(month) ?? 0) + t.microUsd);
+        if (UNPRICED_AGENTS.has(t.agent))
+            acc.unpriced = true;
+    }
+    merge(into, from) {
+        into.microUsd += from.microUsd;
+        for (const [m, v] of from.byMonth)
+            into.byMonth.set(m, (into.byMonth.get(m) ?? 0) + v);
+        into.unpriced ||= from.unpriced;
+    }
+    finish(acc) {
+        const { real, partial } = (0, spend_js_1.realFromMonths)(acc.byMonth, this.input.subscriptions, (month) => this.input.monthTotals.get(month)?.microUsd ?? 0);
+        return { consumption: { microUsd: acc.microUsd }, real, realPartial: partial };
+    }
+}
+/** El porcentaje de una parte sobre el total, en tanto por ciento. `null` sin total. */
+function shareOf(part, total) {
+    return total.consumption.microUsd === 0 ? null : (part.consumption.microUsd / total.consumption.microUsd) * 100;
+}
+//# sourceMappingURL=undelivered.js.map

package/dist/server.js

@@ -129,6 +129,7 @@ async function importOnce(dbPath) {
             if (!root)
                 continue;
             store.saveCommits(db, await (0, git_js_1.readCommits)(root, {}));
+            store.saveMerges(db, await (0, git_js_1.readMerges)(root, {}));
         }
         // Todo lo conocido, no solo lo leído ahora (ver knownTurns), y los correos
         // de todos esos repos: sin ellos, un día antiguo perdería sus commits.
@@ -757,10 +758,20 @@ function buildSummary(db, from, to) {
            SUM(approved)     AS approved,
            MIN(local_date)   AS first_day,
            MAX(local_date)   AS last_day,
-           COUNT(DISTINCT local_date) AS days
+           COUNT(DISTINCT local_date) AS days,
+           SUM(CASE WHEN invoice_id IS NOT NULL THEN seconds ELSE 0 END) AS invoiced,
+           SUM(CASE WHEN invoice_id IS NULL AND billable = 1 THEN seconds ELSE 0 END) AS unbilled,
+           SUM(CASE WHEN invoice_id IS NULL AND billable = 0 THEN seconds ELSE 0 END) AS not_billable
     FROM time_entries
     WHERE local_date >= ? AND local_date <= ? AND ${VISIBLE}
     GROUP BY project_id
+  `).all(from, to);
+    // En qué facturas está lo ya facturado del periodo, para nombrarlas.
+    const invoiceNumbers = db.prepare(`
+    SELECT DISTINCT t.project_id, i.number
+    FROM time_entries t JOIN invoices i ON i.id = t.invoice_id
+    WHERE t.local_date >= ? AND t.local_date <= ? AND ${VISIBLE.replace("project_id", "t.project_id")}
+    ORDER BY i.number
   `).all(from, to);
     const projects = new Map(store.listProjects(db).map((p) => [p.id, p]));
     const clients = new Map(store.listClients(db).map((c) => [c.id, c]));
@@ -783,6 +794,15 @@ function buildSummary(db, from, to) {
             aiMicroUsd: r.micro,
             amountMinor: rate ? Math.round((rate.amount * r.seconds) / 3600) : null,
             hourlyMinor: rate?.amount ?? null,
+            // Lo trabajado en el periodo, por dónde está: ya en una factura, pendiente
+            // de facturar (lo mismo que cuenta Informes, con su misma cuenta) o
+            // marcado como no facturable. Sin esto, el total del Resumen y lo
+            // pendiente de Informes parecen no cuadrar.
+            invoicedSeconds: r.invoiced,
+            invoices: invoiceNumbers.filter((i) => i.project_id === r.project_id).map((i) => i.number),
+            unbilledSeconds: r.unbilled,
+            unbilledMinor: rate ? Math.round((rate.amount * r.unbilled) / 3600) : null,
+            notBillableSeconds: r.not_billable,
         };
     }).sort((a, b) => b.seconds - a.seconds);
     // Actividad reciente entre todos los proyectos, para ver el pulso del conjunto.

package/dist/watchers/git.d.ts

@@ -4,6 +4,41 @@ export declare function readCommits(repoPath: string, options?: {
     authorEmail?: string;
     authorEmails?: readonly string[];
 }): Promise<CommitRecord[]>;
+/** Un commit de merge: qué rama se integró y, si lo dice, con qué PR. */
+export interface MergeRecord {
+    readonly repoPath: string;
+    readonly hash: string;
+    readonly at: Date;
+    readonly sourceBranch: string | null;
+    /** `github:12` o `gitlab:!45` (las MR de GitLab llevan `!`). `null` en un merge local sin PR. */
+    readonly ref: string | null;
+    readonly subject: string;
+}
+/**
+ * Commits de merge de todas las ramas.
+ *
+ * Es lo único en git que une una rama con su PR sin preguntar a GitHub: el
+ * mensaje lo escribe la plataforma con un formato fijo. Un squash no deja
+ * merge (solo "Título (#12)" en la rama principal), así que de él no se sabe
+ * qué rama fue.
+ */
+export declare function readMerges(repoPath: string, options?: {
+    since?: Date;
+}): Promise<MergeRecord[]>;
+/**
+ * La rama y el PR de un mensaje de merge, con los formatos que escriben las
+ * plataformas y git:
+ *
+ *   Merge pull request #12 from ana/feat/login          (GitHub)
+ *   Merge branch 'feat/login' into 'main' + "See merge request grupo/app!45"  (GitLab)
+ *   Merge branch 'feat/login' [into main]               (git, sin PR)
+ *
+ * Cualquier otro mensaje (alguien lo reescribió) no se adivina.
+ */
+export declare function parseMergeMessage(subject: string, body?: string): {
+    sourceBranch: string | null;
+    ref: string | null;
+};
 /**
  * Raíz del repositorio.
  *
@@ -32,6 +67,11 @@ export declare function rootCommitFingerprint(path: string): Promise<string | nu
  * otros en `develop`— y equivocarse la marcaría todo como abierto.
  */
 export declare function mergedBranches(path: string): Promise<Set<string>>;
+/**
+ * Ramas que existen hoy, locales y remotas, sin el prefijo del remoto. `null`
+ * si el repositorio no se puede leer (se borró o se movió): entonces no se sabe.
+ */
+export declare function branchNames(path: string): Promise<Set<string> | null>;
 /** Rama donde el equipo integra. `develop` gana a `main` si existe. */
 export declare function integrationBranch(root: string): Promise<string | null>;
 /** Rama activa del repositorio. Ya no se usa para etiquetar commits. */

package/dist/watchers/git.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readCommits = readCommits;
+exports.readMerges = readMerges;
+exports.parseMergeMessage = parseMergeMessage;
 exports.repoRoot = repoRoot;
 exports.rootCommitFingerprint = rootCommitFingerprint;
 exports.mergedBranches = mergedBranches;
+exports.branchNames = branchNames;
 exports.integrationBranch = integrationBranch;
 exports.currentBranch = currentBranch;
 exports.repoAuthors = repoAuthors;
@@ -102,6 +105,68 @@ async function readCommits(repoPath, options = {}) {
     }
     return commits;
 }
+/**
+ * Commits de merge de todas las ramas.
+ *
+ * Es lo único en git que une una rama con su PR sin preguntar a GitHub: el
+ * mensaje lo escribe la plataforma con un formato fijo. Un squash no deja
+ * merge (solo "Título (#12)" en la rama principal), así que de él no se sabe
+ * qué rama fue.
+ */
+async function readMerges(repoPath, options = {}) {
+    const root = await repoRoot(repoPath);
+    if (!root)
+        return [];
+    const format = RECORD + ["%H", "%aI", "%s", "%b"].join(SEP);
+    const args = ["log", "--all", "--merges", `--pretty=format:${format}`];
+    if (options.since)
+        args.push(`--since=${options.since.toISOString()}`);
+    let stdout;
+    try {
+        ({ stdout } = await run("git", args, { cwd: root, maxBuffer: 64 * 1024 * 1024 }));
+    }
+    catch {
+        return [];
+    }
+    const merges = [];
+    for (const chunk of stdout.split(RECORD)) {
+        const [hash, iso, subject = "", body = ""] = chunk.split(SEP);
+        if (!hash || !iso)
+            continue;
+        const at = new Date(iso);
+        if (Number.isNaN(at.getTime()))
+            continue;
+        const { sourceBranch, ref } = parseMergeMessage(subject.trim(), body);
+        merges.push({ repoPath: root, hash: hash.trim(), at, sourceBranch, ref, subject: subject.trim() });
+    }
+    return merges;
+}
+/**
+ * La rama y el PR de un mensaje de merge, con los formatos que escriben las
+ * plataformas y git:
+ *
+ *   Merge pull request #12 from ana/feat/login          (GitHub)
+ *   Merge branch 'feat/login' into 'main' + "See merge request grupo/app!45"  (GitLab)
+ *   Merge branch 'feat/login' [into main]               (git, sin PR)
+ *
+ * Cualquier otro mensaje (alguien lo reescribió) no se adivina.
+ */
+function parseMergeMessage(subject, body = "") {
+    const github = /^Merge pull request #(\d+) from (\S+)/.exec(subject);
+    if (github) {
+        // "from <dueño>/<rama>": la rama puede llevar barras, el dueño no.
+        const from = github[2];
+        const slash = from.indexOf("/");
+        return { sourceBranch: slash === -1 ? from : from.slice(slash + 1), ref: `github:${github[1]}` };
+    }
+    const branch = /^Merge (?:remote-tracking )?branch '([^']+)'/.exec(subject);
+    if (branch) {
+        const gitlab = /See merge request \S*!(\d+)/.exec(body);
+        const name = branch[1].replace(/^origin\//, "");
+        return { sourceBranch: name, ref: gitlab ? `gitlab:!${gitlab[1]}` : null };
+    }
+    return { sourceBranch: null, ref: null };
+}
 /**
  * Raíz del repositorio.
  *
@@ -174,6 +239,28 @@ async function mergedBranches(path) {
     }
     return merged;
 }
+/**
+ * Ramas que existen hoy, locales y remotas, sin el prefijo del remoto. `null`
+ * si el repositorio no se puede leer (se borró o se movió): entonces no se sabe.
+ */
+async function branchNames(path) {
+    const root = await repoRoot(path);
+    if (!root)
+        return null;
+    try {
+        const { stdout } = await run("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/remotes"], { cwd: root });
+        const names = new Set();
+        for (const line of stdout.split("\n")) {
+            const name = line.trim().replace(/^refs\/(heads|remotes\/[^/]+)\//, "");
+            if (name && name !== "HEAD")
+                names.add(name);
+        }
+        return names;
+    }
+    catch {
+        return null;
+    }
+}
 /** Rama donde el equipo integra. `develop` gana a `main` si existe. */
 async function integrationBranch(root) {
     for (const candidate of ["develop", "main", "master"]) {