changebook 0.5.0 → 0.7.0

package/dist/import.js

@@ -27,10 +27,35 @@ const SKIP_FILE_PATTERNS = [
     /\.min\.(js|css)$/,
     /\.(png|jpe?g|gif|webp|ico|svg|woff2?|ttf|otf|eot|mp4|mov|pdf|zip)$/i,
 ];
+/** Tope duro de commits por importación. Vive aquí para que la estimación y el
+ *  trabajo real no puedan discrepar: son el mismo número. */
+export const TECHO_COMMITS = 100;
+/** Lo que se importa cuando nadie pide un número. */
+export const COMMITS_POR_DEFECTO = 25;
+/**
+ * Cuántos commits se van a importar de verdad, y qué cuesta.
+ *
+ * SEPARADO DEL TRABAJO A PROPÓSITO, y es lo que hace honesta la pregunta de
+ * B8. La ficha habla de «un repo con 200 commits», pero `importHistory` topa en
+ * 100: enseñar «200 créditos» y gastar 100 sería una estimación falsa, y
+ * enseñar 200 y gastar 200 sería mentir sobre el tope. Este es el ÚNICO sitio
+ * donde se decide el número, y `importHistory` usa el mismo.
+ *
+ * El crédito es la unidad del usuario y la equivalencia está fijada en el
+ * servidor: «every row costs exactly 1 credit, so a row count equals the credit
+ * sum» (`ensureUnderMonthlyCredits`). Un commit analizado es una fila.
+ */
+export function planDeImport(commitsEnElRepo, pedidos) {
+    const quiere = Math.max(1, Math.min(pedidos ?? COMMITS_POR_DEFECTO, TECHO_COMMITS));
+    const aImportar = Math.max(0, Math.min(quiere, commitsEnElRepo));
+    return { aImportar, creditos: aImportar };
+}
 export async function importHistory(db, options = {}) {
     const cwd = path.resolve(options.dir ?? process.cwd());
     const projectName = projectNameFor(cwd);
-    const count = Math.max(1, Math.min(options.commits ?? 25, 100));
+    // El MISMO número que vio el usuario en la estimación. Si esta línea y
+    // `planDeImport` se separan, la cifra que confirmó deja de ser la que se gasta.
+    const count = planDeImport(Number.MAX_SAFE_INTEGER, options.commits).aImportar;
     // A previous run may have been interrupted after submitting: the Anthropic
     // batch keeps running server-side, so finish those before spending more.
     await resumePendingBatches(db);

package/dist/index.js

@@ -19,11 +19,13 @@ import { clearCredentials, credentialsPath } from "./credentials.js";
 import { recordFeed } from "./feed.js";
 import { runGuard } from "./guard.js";
 import { hookStatus, installHook, uninstallHook } from "./hook.js";
-import { importHistory } from "./import.js";
+import { importHistory, planDeImport } from "./import.js";
 import { registerAgents } from "./init.js";
 import { contextHookInstalled, installContextHook, installSettingsHook, printContext, settingsHookInstalled, uninstallContextHook, uninstallSettingsHook, } from "./context.js";
-import { IMPACT_HOOK, printImpact, warmImpactCache } from "./impact.js";
+import { IMPACT_HOOK, informeDeSilencio, printImpact, silenciosAcumulados, warmImpactCache, } from "./impact.js";
 import { login } from "./login.js";
+import { confirmar, hayTerminal, preguntar } from "./pregunta.js";
+import { argumentosDeScan, contarCommits, correrScan, informeParaInit, informeDeRepo, } from "./scan.js";
 import { AUTH_HELP, Supabase } from "./supabase.js";
 import { syncContextFiles } from "./sync.js";
 import { registerTools } from "./tools.js";
@@ -47,7 +49,10 @@ Usage:
                           (pre-commit signal guard)
   changebook guard [dir]    Check staged files against open atlas alerts
                           (what the pre-commit hook runs; exit 3 = block)
-  changebook sync [dir]     Refresh the product map inside CLAUDE.md/AGENTS.md
+  changebook sync [dir] [--yes]
+                          Refresh the product map inside CLAUDE.md/AGENTS.md.
+                          Shows what changes and asks first; --yes skips the
+                          question (as does having no terminal)
   changebook context [dir]  Print the fresh atlas brief as a Claude Code
                           SessionStart hook payload (used by the push hook)
   changebook hook-context install|uninstall|status [dir]
@@ -59,6 +64,17 @@ Usage:
                           Tell the agent who depends on a file BEFORE it edits it,
                           via a PreToolUse hook in .claude/settings.json. Never
                           blocks an edit; silent when there is nothing to say
+  changebook silence [dir]  How often that hook stays quiet, with both raw
+                          numbers. Healthy is 85-95%: below 80% it is noise
+  changebook scan [dir] [--json|--card|--badge]
+                          Coupling report for any repo, from its git history
+                          alone. No account, no network, writes nothing — run it
+                          on a repo you just cloned. --json for machines,
+                          --card for a shareable SVG (redirect it to a file),
+                          --badge to publish the numbers and print the README
+                          snippet (needs an account; --badge --off turns it off).
+                          The badge exposes FOUR NUMBERS and nothing else — not
+                          your code, modules or change summaries
   changebook init [dir]     login + register MCP in every agent found + hook + sync
   changebook open           Open the web atlas in the browser
   changebook serve          Run the MCP server on stdio (default with no arguments)
@@ -121,6 +137,50 @@ function parseImportArgs(args) {
     }
     return { dir, commits };
 }
+/**
+ * B7 · el confirmador de `sync` e `init`. `undefined` significa «escribe sin
+ * preguntar», que es lo que hace el resto del producto.
+ *
+ * SIN TERMINAL SE APLICA, y aquí sí, al revés que al importar. El criterio no es
+ * «preguntar siempre que se pueda»: es qué pasa si nadie contesta. Importar
+ * gasta créditos, así que callar tiene que significar NO. Esto reescribe un
+ * bloque delimitado del propio repo, sin coste y sin salir de la máquina, así
+ * que callar significa SÍ — bloquear un `sync` en CI rompería el refresco del
+ * mapa a cambio de nada.
+ */
+function confirmadorDeEscritura(yes) {
+    if (yes || !hayTerminal())
+        return undefined;
+    return async (cambio) => {
+        console.error(`\n${cambio.resumen}`);
+        for (;;) {
+            const r = (await preguntar("[Enter] aplicar   [s] saltar   [d] ver diff completo"))
+                .trim()
+                .toLowerCase();
+            if (r === "d") {
+                // El diff entero solo para quien lo pide: el objetivo de B7 no es
+                // volcar un diff, es que se vea que el fichero de uno se respeta.
+                console.error(`\n${diffCompleto(cambio.previo, cambio.siguiente)}\n`);
+                continue;
+            }
+            if (r === "s")
+                return false;
+            if (r === "" || r === "a")
+                return true;
+        }
+    };
+}
+/** Diff de líneas, sin dependencias: marca lo que sale y lo que entra. */
+function diffCompleto(previo, siguiente) {
+    const antes = (previo ?? "").split("\n");
+    const despues = siguiente.split("\n");
+    const vivas = new Set(despues);
+    const comunes = new Set(antes);
+    return [
+        ...antes.filter((l) => !vivas.has(l)).map((l) => `- ${l}`),
+        ...despues.filter((l) => !comunes.has(l)).map((l) => `+ ${l}`),
+    ].join("\n");
+}
 async function main() {
     const [command, arg] = process.argv.slice(2);
     switch (command) {
@@ -222,7 +282,11 @@ async function main() {
         case "sync": {
             const db = new Supabase();
             requireCredentials(db);
-            await syncContextFiles(db, arg ?? process.cwd());
+            const resto = process.argv.slice(3);
+            const dir = resto.find((a) => !a.startsWith("--")) ?? process.cwd();
+            await syncContextFiles(db, dir, {
+                confirmar: confirmadorDeEscritura(resto.includes("--yes")),
+            });
             return;
         }
         case "context": {
@@ -269,6 +333,55 @@ async function main() {
             await printImpact(new Supabase());
             return;
         }
+        case "silence": {
+            // Sin credenciales y sin red: el contador es local por diseño (ver
+            // tallyPath). Se lee del repo, no del servidor, y por eso contesta el
+            // mismo día en que se instala en vez de dentro de dos.
+            const dir = process.argv[3] ?? process.cwd();
+            console.log(informeDeSilencio(await silenciosAcumulados(dir)));
+            return;
+        }
+        case "scan": {
+            // Como `silence`: sin credenciales, sin red, sin escribir. Todo lo que
+            // dice sale del `git log` del directorio que le pasen — por eso se puede
+            // correr sobre el repo de otro sin pedirle nada a nadie, que es el punto
+            // entero de B2.
+            // El parseo vive en scan.ts para que se pueda probar sin construir el
+            // binario: ver `argumentosDeScan` y el porqué escrito allí.
+            const { dir, json, card, badge, off } = argumentosDeScan(process.argv.slice(3));
+            if (badge) {
+                // La única forma de `scan` que necesita cuenta y red. El cálculo es el
+                // mismo; lo que cambia es que además se publica para que el endpoint
+                // pueda servir la imagen.
+                const { apagarBadge, publicarBadge, LO_QUE_SE_PUBLICA } = await import("./badge.js");
+                const db = new Supabase();
+                const r = off
+                    ? await apagarBadge(db, dir)
+                    : await publicarBadge(db, dir, await informeDeRepo(dir));
+                if (!r.ok) {
+                    console.error(r.motivo);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (r.apagado) {
+                    console.error("✓ Badge apagado. La imagen deja de servirse y sus números se han\n" +
+                        "  borrado. Tu atlas no se ha tocado.");
+                    return;
+                }
+                console.log(r.snippet);
+                // QUÉ se ha hecho público, la primera vez y con todas las letras. Lo
+                // que se expone son cuatro números y nada más, pero eso lo tiene que
+                // decir el producto, no descubrirlo el usuario.
+                console.error(r.nuevo ? `\n${LO_QUE_SE_PUBLICA}\n` : "");
+                console.error("✓ Números publicados. Pega esa línea en tu README.\n" +
+                    "  El badge dice qué parte de tus ficheros concentra la mitad de los\n" +
+                    "  cambios — una propiedad de tu repo, no de cuánto llevas usando\n" +
+                    "  ChangeBook, así que significa lo mismo hoy que dentro de tres meses.");
+                return;
+            }
+            console.log(await correrScan(dir, { json, card }));
+            return;
+        }
         case "hook-impact": {
             const dir = process.argv[4] ?? process.cwd();
             if (arg === "install") {
@@ -307,7 +420,12 @@ async function main() {
             catch (error) {
                 console.error(error instanceof Error ? error.message : String(error));
             }
-            await syncContextFiles(db, dir);
+            // B7 también aquí, y aquí es donde más importa: `init` es la primera vez
+            // que el producto escribe en un fichero del usuario, y la confianza se
+            // gana o se pierde en ese momento.
+            await syncContextFiles(db, dir, {
+                confirmar: confirmadorDeEscritura(process.argv.includes("--yes")),
+            });
             // Ofrecer el push, NUNCA instalarlo en silencio: .claude/settings.json se
             // suele commitear y compartir, y meter un hook en el arranque de sesiones
             // ajenas sin permiso explícito no se hace. Se ofrece el comando; correrlo
@@ -325,6 +443,56 @@ async function main() {
                 console.error("\nOptional: before every edit, tell the agent who depends on the file " +
                     "it is about to touch:\n  changebook hook-impact install");
             }
+            // B8 · el historial pasado, ofrecido en el momento de instalar.
+            //
+            // El desfase de valor no se arregla solo con el informe local: el atlas
+            // sigue vacío hasta que haya commits ANALIZADOS. Importar el pasado lo
+            // llena de golpe — y por eso hasta hoy era una opción avanzada que nadie
+            // encontraba.
+            //
+            // PERO ESTO GASTA CRÉDITOS DEL USUARIO, así que la cifra va delante y en
+            // su unidad. `planDeImport` es el único sitio donde se decide cuántos
+            // commits entran, y `importHistory` usa esa misma función: la cifra que
+            // se confirma no puede separarse de la que se gasta.
+            //
+            // Sin terminal NO se importa y no se pregunta — un `init` dentro de un CI
+            // o un Dockerfile no tiene a nadie delante, y asumir el sí ahí convierte
+            // una instalación automatizada en un cargo que nadie autorizó.
+            const plan = planDeImport(await contarCommits(dir));
+            if (plan.aImportar > 0) {
+                if (!hayTerminal()) {
+                    console.error(`\nHay ${plan.aImportar} commits que se pueden importar para llenar el atlas ` +
+                        `de golpe (${plan.creditos} créditos). Sin terminal no se hace solo:\n` +
+                        `  changebook import`);
+                }
+                else if (await confirmar(`\n¿Importar los últimos ${plan.aImportar} commits para llenar el atlas ahora?\n` +
+                    `Cuesta ${plan.creditos} créditos de tu plan de este mes. [S/n]`)) {
+                    try {
+                        await importHistory(db, { dir, commits: plan.aImportar });
+                    }
+                    catch (error) {
+                        // Un import fallido no invalida la instalación: el MCP, los hooks y
+                        // el sync ya están puestos. Se dice y se sigue.
+                        console.error(`\nLa importación no pudo terminar: ${error instanceof Error ? error.message : String(error)}\nEl resto de la instalación está hecha. Reintenta con: changebook import`);
+                    }
+                }
+                else {
+                    console.error(`\nSin importar. Cuando quieras:  changebook import --commits ${plan.aImportar}`);
+                }
+            }
+            // B8 · «instalar es descubrir, no esperar». El producto tiene un desfase
+            // de valor estructural: instalas hoy y el atlas empieza a servir mañana,
+            // cuando haya commits analizados. Y el hook de impacto está diseñado para
+            // callarse, así que en la primera hora no se ve NADA — un producto que se
+            // instala en silencio y calla se desinstala en silencio.
+            //
+            // El informe de acoplamiento tapa ese hueco sin esperar a nada: sale
+            // entero del `git log` que ya está en el disco, no cuesta un crédito y no
+            // llama a ningún modelo. Va por stdout —no por stderr como el resto del
+            // progreso— porque es CONTENIDO, no traza: así se puede canalizar.
+            const informe = await informeParaInit(dir);
+            if (informe)
+                console.log(`\n${informe}`);
             console.error(`✓ Ready. Ask your agent about the atlas, or open ${atlasWebUrl()}`);
             return;
         }

package/dist/pregunta.js

@@ -0,0 +1,59 @@
+// `readline/promises`, no `readline` a secas: el `question` del segundo lleva
+// callback y devuelve `void`, así que `await` sobre él espera a nada y sigue de
+// largo. Compila, corre, y la pregunta se contesta sola.
+import { createInterface } from 'node:readline/promises';
+// ── Preguntar antes de gastar ────────────────────────────────────────────────
+//
+// El CLI no preguntaba nada hasta ahora, y hay un motivo para que la primera
+// pregunta sea justo esta: importar el historial GASTA CRÉDITOS del usuario.
+//
+// LA REGLA QUE GOBIERNA ESTE FICHERO: sin terminal no se gasta. Un `init` dentro
+// de un script, un CI o un Dockerfile no tiene a nadie delante a quien
+// preguntar, y en esa situación la respuesta segura no es «asumo que sí» — es no
+// hacerlo y decir cómo pedirlo explícitamente. Asumir el sí convierte un `init`
+// automatizado en un cargo recurrente que nadie autorizó.
+/** ¿Hay una persona delante? Las dos puntas, porque preguntar necesita las dos. */
+export function hayTerminal(entrada = process.stdin, salida = process.stderr) {
+    return Boolean(entrada.isTTY && salida.isTTY);
+}
+/**
+ * Interpreta la respuesta. Separado de la lectura para poder probarlo sin
+ * terminal: la parte que decide es esta, no la que lee bytes.
+ *
+ * Solo un «no» explícito declina. Enter acepta —la ficha de B8 pide que importar
+ * sea el DEFECTO— pero la cifra va delante, en la pregunta, no en la letra
+ * pequeña.
+ */
+export function esUnSi(respuesta) {
+    const r = respuesta.trim().toLowerCase();
+    if (r === '')
+        return true;
+    return r === 's' || r === 'si' || r === 'sí' || r === 'y' || r === 'yes';
+}
+/**
+ * Pregunta y espera. Sin terminal devuelve `false` SIN preguntar y sin bloquear:
+ * un proceso que se queda esperando una respuesta que nunca llega es peor que
+ * uno que no hace el trabajo.
+ */
+export async function confirmar(pregunta) {
+    if (!hayTerminal())
+        return false;
+    return esUnSi(await preguntar(pregunta));
+}
+/**
+ * Una respuesta cruda, para las preguntas de más de dos salidas (B7: aplicar,
+ * saltar, ver el diff). Sin terminal devuelve cadena vacía SIN bloquear — quien
+ * llame decide qué significa eso, que no es lo mismo en todas partes.
+ */
+export async function preguntar(pregunta) {
+    if (!hayTerminal())
+        return '';
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await rl.question(`${pregunta} `);
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=pregunta.js.map

package/dist/reglas.js

@@ -0,0 +1,299 @@
+/**
+ * B9 · Lo que ya rompió aquí se convierte en regla.
+ *
+ * LA DISCIPLINA, que es lo que separa esto de un linter: **solo entran reglas
+ * nacidas de un fallo REAL de este repo, con su hash**. Un catálogo de reglas
+ * genéricas convierte el producto en un linter, y los linters son gratis. Esto
+ * no envía una librería de reglas: envía el mecanismo que convierte cada
+ * cicatriz en una regla que caza el mismo patrón en cualquier fichero.
+ *
+ * POR QUÉ ESTAS TRES Y NO LAS DE LA FICHA. La ficha eligió tres fallos de la web
+ * (ruta huérfana, estado sucio antes de navegar fuera, test de contrato que
+ * nunca se pone rojo). Los tres son reales, pero para cazarlos en el repo de
+ * OTRO hay que entender su framework —qué es una ruta, qué es un manejador— o
+ * ejecutar su suite de tests. O sea que solo servirían a repos como éste.
+ *
+ * Las de aquí salen de fallos del 25/07 y del 02/08 y no necesitan entender
+ * nada: son sobre la BASE DE DATOS y el DESPLIEGUE, que funcionan igual para
+ * todo el mundo. Cada una se apaga sola si el repo no tiene esa forma
+ * (`aplica`), en vez de opinar sobre un proyecto que no la tiene.
+ *
+ * SE ESCRIBIERON TRES Y SE ENVÍAN DOS. La tercera se midió sobre este repo,
+ * salió con 6 hallazgos y los 6 falsos, y no se sirve — ver R2 más abajo, que se
+ * queda escrita como aviso a quien la reinvente. Medir antes de servir es el
+ * criterio 2 de la ficha, y es lo único que separa esto de un linter ruidoso.
+ *
+ * TODAS FALLAN CERRADAS HACIA EL SILENCIO. Ante la duda no hay hallazgo: un
+ * aviso falso en un pre-commit se paga con la desinstalación del hook, y eso
+ * cuesta más que el defecto que se dejó pasar.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ── Utilidades compartidas ──────────────────────────────────────────────────
+/** Quita comentarios de línea `--` y bloques de SQL. Igual que en los tests. */
+export function sqlSinComentarios(src) {
+    return src
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .split('\n')
+        .filter((l) => !l.trim().startsWith('--'))
+        .join('\n');
+}
+const esMigracion = (f) => f.endsWith('.sql') && /(^|\/)migrations\//.test(f);
+/**
+ * Quita los comentarios de un fichero, con la gramática de su extensión.
+ *
+ * POR QUÉ (invariante 13, y una tercera vez el mismo día). Una regla que lee
+ * fuente y afirma sobre él tiene que mirar el CÓDIGO, no la prosa. Medido: al
+ * arreglar uno de los hallazgos escribí un comentario explicando que la cascada
+ * ya no vivía en `resolve_agent_task`… y esa mención hizo que la regla siguiera
+ * avisando del mismo fichero. El comentario que explica un arreglo es
+ * exactamente lo que lo camufla.
+ *
+ * Extensión desconocida: se devuelve tal cual. Perder un comentario mal quitado
+ * es peor que dejarlo — el lado seguro aquí es el falso positivo ruidoso, no el
+ * silencio.
+ */
+export function sinComentariosPorExtension(rel, src) {
+    const ext = /\.([a-z0-9]+)$/i.exec(rel)?.[1]?.toLowerCase() ?? '';
+    const abre = {
+        ts: '//', tsx: '//', js: '//', jsx: '//', mjs: '//', cjs: '//',
+        sql: '--', yml: '#', yaml: '#', toml: '#', py: '#', rb: '#', sh: '#',
+    };
+    const marca = abre[ext];
+    if (!marca)
+        return src;
+    const conBloques = marca === '//' || marca === '--'
+        ? src.replace(/\/\*[\s\S]*?\*\//g, '')
+        : src;
+    return conBloques
+        .split('\n')
+        .filter((l) => !l.trim().startsWith(marca))
+        .join('\n');
+}
+// ── R1 · Un contrato mirando una versión muerta ─────────────────────────────
+/**
+ * `sql-version-vieja`
+ *
+ * DE DÓNDE SALE. `atlas_brief` está definida en tres migraciones y
+ * `admin_metrics` en CINCO: cada versión es un `create or replace` en un fichero
+ * nuevo, y la que manda es la última. Dos tests fijaban el fichero POR NOMBRE, o
+ * sea que vigilaban una versión que ya nadie ejecuta y seguían en verde con el
+ * defecto dentro. Peor: creyendo que ese fichero era LA definición, reaplicarlo
+ * a producción habría degradado la función dos versiones.
+ *
+ * QUÉ CAZA. Un fichero que NO es una migración y nombra el fichero de una
+ * migración que redefine una función SQL, existiendo otra posterior que la
+ * redefine también.
+ *
+ * POR QUÉ GENERALIZA. Solo mira nombres de fichero y `create or replace
+ * function`. No sabe nada de este proyecto ni de ningún framework.
+ *
+ * LO QUE MIDIÓ, sobre este repo (612 ficheros), y se publica con la regla como
+ * pide el criterio 2 de la ficha:
+ *
+ *   1ª pasada   9 hallazgos · 3 falsos (uno de un doc que NARRA historia, dos de
+ *               ficheros que citaban la migración por su tabla). Afinada con dos
+ *               condiciones: se saltan los `.md` y se exige que el fichero
+ *               NOMBRE la función.
+ *   2ª pasada   6 hallazgos, los 6 CIERTOS, leídos uno a uno. Uno de ellos era
+ *               de esa misma mañana: `atlas_precision` había cambiado y su test
+ *               seguía verificando la regla vieja.
+ *   arreglados  5 (el sexto se arregló de camino). Quedan 2.
+ *
+ * SU LÍMITE, dicho en vez de escondido: los 2 que quedan son ficheros que leen
+ * la migración vieja POR OTRA COSA —las columnas que creó, que las versiones
+ * posteriores no tocan— y que además nombran la función en otra aserción. Un
+ * texto no puede distinguir eso, y estrechar más la regla la dejaría ciega a
+ * los casos ciertos. Se prefiere que quien lo lea mire, a no avisar.
+ */
+export const SQL_VERSION_VIEJA = {
+    id: 'sql-version-vieja',
+    hash: 'dc075b6',
+    cicatriz: 'Dos tests afirmaban sobre una migración que ya no era la versión en vigor',
+    aplica: (repo) => repo.ficheros.some(esMigracion),
+    correr(repo) {
+        // función → migraciones que la definen, en orden de nombre (= de aplicación).
+        const porFuncion = new Map();
+        for (const f of repo.ficheros.filter(esMigracion).sort()) {
+            const sql = repo.leer(f);
+            if (!sql)
+                continue;
+            const limpio = sqlSinComentarios(sql);
+            for (const m of limpio.matchAll(/create\s+or\s+replace\s+function\s+(?:[a-z_]+\.)?([a-z0-9_]+)\s*\(/gi)) {
+                const fn = m[1].toLowerCase();
+                porFuncion.set(fn, [...(porFuncion.get(fn) ?? []), f]);
+            }
+        }
+        // Solo las redefinidas: una función con UNA definición no tiene versión
+        // vieja que citar, y avisar ahí sería ruido sobre el caso normal. Lo hace
+        // el `slice(0, -1)` —sobre una lista de uno da vacío— y no un guard aparte:
+        // el guard que había estuvo aquí hasta que una mutación lo quitó y NADA se
+        // puso rojo. Era código muerto con pinta de protección.
+        const caducadas = new Map(); // basename viejo → función
+        for (const [fn, ficheros] of porFuncion) {
+            for (const viejo of ficheros.slice(0, -1)) {
+                caducadas.set(path.basename(viejo), fn);
+            }
+        }
+        if (caducadas.size === 0)
+            return [];
+        const fuera = [];
+        for (const f of repo.ficheros) {
+            if (esMigracion(f))
+                continue; // una migración puede citar a otra: es su historia
+            // LA DOCUMENTACIÓN NARRA, no afirma. Un doc que cuenta lo que pasó el 12
+            // de julio TIENE que citar el fichero de aquel día; exigirle el último
+            // sería pedirle que reescriba la historia. Medido: era 1 de los 9
+            // hallazgos de la primera pasada, y el único de su clase.
+            if (/\.(md|mdx|txt)$/i.test(f))
+                continue;
+            const crudo = repo.leer(f);
+            if (!crudo)
+                continue;
+            const src = sinComentariosPorExtension(f, crudo);
+            for (const [viejo, fn] of caducadas) {
+                if (!src.includes(viejo))
+                    continue;
+                // Y CITAR NO ES AFIRMAR. Un test puede leer esa migración por la tabla
+                // que crea, por su trigger o por un grant, sin decir una palabra de la
+                // función redefinida. Sin esta condición se avisa de un fichero que no
+                // tiene nada que ver con lo que caducó — medido también en la primera
+                // pasada. Se exige que el fichero NOMBRE la función.
+                if (!src.includes(fn))
+                    continue;
+                fuera.push({
+                    regla: this.id,
+                    hash: this.hash,
+                    fichero: f,
+                    que: `cita la migración ${viejo}, que ya no es la versión en vigor de ` +
+                        `${fn}(). Lo que afirme sobre ella no vigila lo que corre en producción.`,
+                });
+            }
+        }
+        return fuera;
+    },
+};
+// ── R2 · MEDIDA Y DESCARTADA ────────────────────────────────────────────────
+//
+// La cicatriz es real y cara: `regression_alerts` tiene el `update` acotado POR
+// COLUMNA a propósito, el 25/07 se añadió `resolution` sin meterla en el grant y
+// los TRES caminos que la escribían empezaron a fallar con 42501 **en silencio**
+// (`atlas_resolve_alert` devolvía «cerré 0» como si no hubiera nada que cerrar).
+// Volvió a asomar el 02/08 con `resolution_by`.
+//
+// La regla obvia —«columna añadida a una tabla con grant por columna y ausente
+// de él»— SE MIDIÓ Y NO SIRVE: 6 hallazgos sobre este repo, **los 6 falsos**.
+// `evidence_symbol`, `evidence_scope`, `evidence_line`, `chars_served`,
+// `latency_ms` y `advice_hash` se escriben todas en el INSERT, y un grant de
+// UPDATE por columna no tiene nada que decir sobre ellas. La regla confunde
+// «existe la columna» con «alguien la actualiza», y esas dos cosas no se
+// distinguen mirando solo el SQL.
+//
+// Se deja escrito en vez de borrado para que nadie la reinvente creyendo que es
+// evidente: para que valiera habría que saber qué columnas viajan en un UPDATE
+// del cliente, y eso vive en el código, no en el esquema. Criterio 2 de la
+// ficha B9: por encima de ~15% de falsos positivos no se sirve. Aquí es 100%.
+// ── R3 · Una función desplegada sin declarar ────────────────────────────────
+/**
+ * `funcion-sin-declarar`
+ *
+ * DE DÓNDE SALE. El endpoint del badge se escribió, se desplegó y no fallaba
+ * nada… y devolvía 401 a todo el que mirara un README, porque sin bloque en
+ * `config.toml` una función hereda `verify_jwt = true`. Al poner el contrato
+ * salieron CINCO más sin declarar: ahí el valor por defecto era el correcto,
+ * pero la garantía era invisible.
+ *
+ * QUÉ CAZA. Un directorio de función sin su `[functions.<nombre>]`.
+ *
+ * POR QUÉ GENERALIZA (dentro de su forma). No sabe nada de este proyecto: se
+ * activa solo si el repo tiene `config.toml` y un directorio de funciones. Un
+ * repo sin eso no oye ni una palabra de esta regla.
+ */
+export const FUNCION_SIN_DECLARAR = {
+    id: 'funcion-sin-declarar',
+    hash: '4444c1b',
+    cicatriz: 'Una edge function sin bloque en config.toml: pública en el código y 401 para todo el mundo',
+    aplica: (repo) => repo.ficheros.some((f) => f.endsWith('supabase/config.toml')),
+    correr(repo) {
+        const config = repo.ficheros.find((f) => f.endsWith('supabase/config.toml'));
+        if (!config)
+            return [];
+        const toml = repo.leer(config);
+        // `null` es «no se pudo leer» y `''` es «está vacío», y NO son lo mismo: un
+        // config vacío no declara nada, así que todas las funciones están sin
+        // declarar. Con `if (!toml)` la regla se callaba justo en el repo donde más
+        // tendría que hablar — la misma confusión entre «no hay nada» y «no miré»
+        // que persigue todo este proyecto. Lo destapó una mutación.
+        if (toml === null)
+            return [];
+        const funciones = new Set();
+        for (const f of repo.ficheros) {
+            const m = /(?:^|\/)supabase\/functions\/([^/]+)\/index\.ts$/.exec(f);
+            // `_shared` no es una función: es la librería que todas importan.
+            if (m && !m[1].startsWith('_'))
+                funciones.add(m[1]);
+        }
+        return [...funciones]
+            .filter((fn) => !toml.includes(`[functions.${fn}]`))
+            .sort()
+            .map((fn) => ({
+            regla: this.id,
+            hash: this.hash,
+            fichero: `supabase/functions/${fn}/index.ts`,
+            que: `no tiene bloque [functions.${fn}] en config.toml. Hereda ` +
+                `verify_jwt = true: si es pública, devolverá 401 sin que falle nada.`,
+        }));
+    },
+};
+export const REGLAS = [SQL_VERSION_VIEJA, FUNCION_SIN_DECLARAR];
+/** Corre las reglas que apliquen. Puro sobre `Repo` para poder medirlo sin disco. */
+export function correrReglas(repo, reglas = REGLAS) {
+    const fuera = [];
+    for (const r of reglas) {
+        try {
+            if (!r.aplica(repo))
+                continue;
+            fuera.push(...r.correr(repo));
+        }
+        catch {
+            // Una regla que revienta se calla. Ninguna puede tumbar un commit.
+        }
+    }
+    return fuera;
+}
+/** Un `Repo` respaldado por el disco, con el contenido cacheado por fichero. */
+export function repoEnDisco(dir, ficheros) {
+    const cache = new Map();
+    return {
+        ficheros,
+        leer(rel) {
+            if (cache.has(rel))
+                return cache.get(rel) ?? null;
+            let texto = null;
+            try {
+                texto = fs.readFileSync(path.join(dir, rel), 'utf8');
+            }
+            catch {
+                texto = null;
+            }
+            cache.set(rel, texto);
+            return texto;
+        },
+    };
+}
+/** El texto para el pre-commit. Vacío cuando no hay nada — silencio por defecto. */
+export function informeDeReglas(hallazgos) {
+    if (hallazgos.length === 0)
+        return '';
+    const lineas = ['\n⚠ ChangeBook · patrones que ya rompieron aquí antes:'];
+    for (const h of hallazgos) {
+        lineas.push(`  ${h.fichero}`);
+        lineas.push(`    ${h.que}`);
+        // LA PROCEDENCIA VA EN EL AVISO, no en un documento. Sin el hash esto es una
+        // opinión; con él es «esto te pasó, y aquí está la vez que pasó».
+        lineas.push(`    Nació de: ${h.hash} · ${h.regla}`);
+    }
+    lineas.push('');
+    return lineas.join('\n');
+}
+//# sourceMappingURL=reglas.js.map