changebook 0.6.0 → 0.7.1

package/dist/guard.js

@@ -17,7 +17,11 @@ import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { execFileAsync, gitPath, projectNameFor } from "./git.js";
 import { feedWarningFor } from "./feed.js";
+import { VENTANA_DIAS, acierto, estaSilenciado, } from "./aciertos.js";
+import { avisoDeHookMudoPara } from "./hookMudo.js";
+import { correrReglas, informeDeReglas, repoEnDisco, } from "./reglas.js";
 import { avisoDeRamaPara } from "./rama.js";
+import { aliasesFor, canonicalizeModuleRows, expandModuleNames, } from "./aliasDeModulo.js";
 /** Exit code that asks the pre-commit hook to abort the commit. */
 export const EXIT_BLOCK = 3;
 // A commit should never feel slow because of us: whatever the network hasn't
@@ -462,6 +466,38 @@ function grepDelRepo(dir, simbolo, modo) {
  * siempre.
  */
 const GUARD_CACHE_V = 1;
+/**
+ * Los hallazgos de B9 que tocan lo que se va a commitear.
+ *
+ * Las reglas necesitan ver el repo ENTERO —para saber qué función SQL se
+ * redefinió, hay que leer todas las migraciones— pero solo se HABLA de los
+ * ficheros del commit. Sin ese recorte, un repo con seis hallazgos viejos
+ * saluda con seis avisos en cada commit hasta que alguien desinstala el hook.
+ */
+/**
+ * B6 · la línea de reconocimiento, si hay alguna que dar.
+ *
+ * Consulta propia y acotada: las alertas CERRADAS de los últimos días, que la
+ * consulta grande no trae (pide `resolved_at=is.null` a propósito). Trae pocas
+ * filas y va con `.catch` por fuera — si falla, no se dice nada y ya está.
+ */
+export async function aciertoReciente(db, dir, projectId) {
+    if (estaSilenciado())
+        return "";
+    const desde = new Date(Date.now() - VENTANA_DIAS * 86_400_000).toISOString();
+    const filas = await db.rest(`regression_alerts?select=id,module,plain,resolution,resolution_by,resolved_at` +
+        `&project_id=eq.${projectId}&resolution=eq.fixed&resolved_at=gte.${desde}` +
+        `&order=resolved_at.desc&limit=5`);
+    return acierto(filas, dir);
+}
+export async function reglasSobreLoStaged(dir) {
+    const staged = new Set(await stagedFiles(dir));
+    if (staged.size === 0)
+        return [];
+    const { stdout } = await execFileAsync("git", ["ls-files"], { cwd: dir });
+    const todos = stdout.split("\n").filter(Boolean);
+    return correrReglas(repoEnDisco(dir, todos)).filter((h) => staged.has(h.fichero));
+}
 export async function stagedFiles(dir) {
     // -z: NUL-separated, and crucially git does NOT octal-quote non-ASCII paths
     // (default quotepath would emit "m\303\263dulo.ts", which never matches the
@@ -519,23 +555,37 @@ async function fetchSignals(db, dir, env) {
     let filesByModule = new Map();
     const projectId = projects[0]?.id ?? null;
     if (projectId) {
-        alerts = await db.rest(
-        // `evidence_scope` NO es opcional aquí, por mucho que el tipo lo sea: sin
-        // él, `alcanceDelRepo` devuelve "sin_declarar" para TODA alerta y la
-        // refutación de `avisoRefutado` no descarta nada nunca. El campo se
-        // escribe en la base desde el 2026-07-26 y ningún cliente lo pedía; el
-        // comentario de `avisoRefutado` decía que esa rama "disparó 0 veces en
-        // producción", y disparó cero porque el dato no llegaba, no porque el gate
-        // fuera barato. Lo vigila `test/alcanceLlegaAlCliente.test.ts`, que lee
-        // ESTA línea: un test de comportamiento no lo caza, porque los stubs
-        // inyectan el campo a mano.
-        `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`);
+        // Los alias van en PARALELO con las alertas, no después: este camino corre
+        // en cada pre-commit y una ronda de red más se paga en cada commit del día.
+        const [alertasCrudas, { aliases, hermanas }] = await Promise.all([
+            db.rest(
+            // `evidence_scope` NO es opcional aquí, por mucho que el tipo lo sea: sin
+            // él, `alcanceDelRepo` devuelve "sin_declarar" para TODA alerta y la
+            // refutación de `avisoRefutado` no descarta nada nunca. El campo se
+            // escribe en la base desde el 2026-07-26 y ningún cliente lo pedía; el
+            // comentario de `avisoRefutado` decía que esa rama "disparó 0 veces en
+            // producción", y disparó cero porque el dato no llegaba, no porque el gate
+            // fuera barato. Lo vigila `test/alcanceLlegaAlCliente.test.ts`, que lee
+            // ESTA línea: un test de comportamiento no lo caza, porque los stubs
+            // inyectan el campo a mano.
+            `regression_alerts?select=id,module,plain,created_at,evidence_symbol,evidence_expect,evidence_scope,evidence_line,files&project_id=eq.${projectId}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}`),
+            aliasesFor(db, projectId),
+        ]);
+        alerts = canonicalizeModuleRows(alertasCrudas, aliases);
         const modules = [
             ...new Set(alerts.map((a) => (a.module ?? "").trim()).filter(Boolean)),
         ];
         if (modules.length > 0) {
-            const rows = await db.rest(`change_module?select=module,files,created_at&project_id=eq.${projectId}&module=in.(${encodeURIComponent(pgInList(modules))})&order=created_at.desc&limit=200`);
-            filesByModule = moduleFilesUnion(rows);
+            // EXPANDIR ANTES DE CONSULTAR. El filtro va al servidor por nombre y en la
+            // base siguen las etiquetas viejas, así que preguntar solo por el canónico
+            // devolvería un trozo de los ficheros del módulo — y el guardián se
+            // callaría ante una alerta abierta por un fichero que sí es suyo, que es
+            // exactamente el fallo que `moduleFilesUnion` documenta del 2026-07-18.
+            const rows = await db.rest(`change_module?select=module,files,created_at&project_id=eq.${projectId}&module=in.(${encodeURIComponent(pgInList(expandModuleNames(modules, hermanas)))})&order=created_at.desc&limit=200`);
+            // Y canonicalizar DESPUÉS: la unión tiene que agrupar los ficheros de las
+            // dos etiquetas bajo una sola clave, o el aviso buscaría por un nombre que
+            // no está en el mapa.
+            filesByModule = moduleFilesUnion(canonicalizeModuleRows(rows, aliases));
         }
     }
     if (cacheFile) {
@@ -687,6 +737,27 @@ export async function runGuard(db, dir, env = process.env) {
     const pulse = await feedWarningFor(dir);
     if (pulse)
         console.error(pulse);
+    // Y el pulso del OTRO hook (C6). Son dos silencios distintos y hasta hoy solo
+    // se vigilaba uno: `feedWarningFor` dice si el atlas deja de alimentarse;
+    // esto dice si el aviso PREVIO A EDITAR dejó de darse. Un hook de retención
+    // pasiva desinstalado se ve igual que un repo tranquilo, así que sin esto la
+    // única señal de que se rompió es que el usuario deje de usar el producto.
+    // Offline y de un `stat`, como el de arriba: no puede frenar un commit.
+    const mudo = await avisoDeHookMudoPara(dir);
+    if (mudo)
+        console.error(mudo);
+    // B9 · los patrones que ya rompieron aquí. Offline y sin cuenta, como los dos
+    // de arriba: son hechos del repo, no del atlas.
+    //
+    // ACOTADO A LO QUE SE VA A COMMITEAR, y esa decisión es lo que lo hace
+    // usable: medidas sobre este repo, las reglas encuentran seis cosas ciertas
+    // pero VIEJAS. Avisar de las seis en cada commit sería ruido desde el primer
+    // día, y un pre-commit ruidoso se desinstala. Se habla solo de los ficheros
+    // que el commit toca; el resto sale en el informe, no aquí.
+    const hallazgos = await reglasSobreLoStaged(dir).catch(() => []);
+    const informe = informeDeReglas(hallazgos);
+    if (informe)
+        console.error(informe);
     // ANTES del corte por credenciales a proposito: que tu rama vaya a revertir el
     // trabajo de otro es un hecho de git, no del atlas. Quien no tenga sesion —o
     // no tenga cuenta— tambien merece enterarse. Ver rama.ts para el porque de la
@@ -724,6 +795,18 @@ export async function runGuard(db, dir, env = process.env) {
         await logRun(dir, `timeout after ${GUARD_TIMEOUT_MS}ms — passing`);
         return 0;
     }
+    // B6 · cuando el aviso acierta, se dice. Va DESPUÉS de tener señales —así
+    // reusa el project_id que ya se resolvió— y es best-effort entero: una línea
+    // de reconocimiento no puede costar un commit. Se dice una vez por alerta.
+    //
+    // Es lo único que este producto dice cuando algo va BIEN. Sin ello solo habla
+    // de riesgos, y un producto que solo trae malas noticias se lee como una
+    // molestia hasta que se desinstala.
+    if (signals.projectId) {
+        const linea = await aciertoReciente(db, dir, signals.projectId).catch(() => "");
+        if (linea)
+            console.error(linea);
+    }
     // Presupuesto de greps para decidir A QUIEN se avisa. `contarEnRepo` y
     // `ficherosEnRepo` son execFileSync, o sea que BLOQUEAN el bucle de eventos y
     // el techo de GUARD_TIMEOUT_MS no puede desalojarlos — un Promise.race no gana

package/dist/hookMudo.js

@@ -0,0 +1,172 @@
+import * as fs from 'node:fs';
+import { settingsHookInstalled } from './context.js';
+import { gitPath } from './git.js';
+import { IMPACT_HOOK } from './impact.js';
+/**
+ * C6 · Un hook que se rompe deja de romperse en silencio.
+ *
+ * POR QUÉ, y es el fallo de toda esta categoría de producto: `hook-impact` es de
+ * RETENCIÓN PASIVA. Una vez instalado, el usuario no tiene que acordarse de
+ * nada, y por eso **un hook desinstalado se ve exactamente igual que un repo
+ * tranquilo**: los dos son silencio. Es la invariante 17 del repo, y este
+ * fichero es su caso más caro — el que le pasa a los usuarios y no al dueño, que
+ * desinstalan sin saber por qué dejó de servirles.
+ *
+ * SE MIDEN DOS COSAS INDEPENDIENTES, y esa es toda la gracia:
+ *
+ *   `declarado`    ¿sigue el hook en `.claude/settings.json`?
+ *   `ultimaSenal`  ¿cuándo dejó rastro por última vez?
+ *
+ * Cruzarlas separa cuatro situaciones que un solo dato confunde:
+ *
+ *   declarado + fresco   → sano. SILENCIO ABSOLUTO.
+ *   declarado + rancio   → está puesto y no corre. Lo más difícil de ver solo.
+ *   sin declarar + hubo  → alguien lo quitó. El caso de la ficha.
+ *   sin declarar + nunca → no se instaló jamás. NO es una rotura, y avisar aquí
+ *                          convertiría este canal en publicidad. Se calla.
+ *
+ * La última línea es la que decide si esto sirve: un aviso que también sale
+ * cuando no pasa nada es ruido, y el ruido enseña a ignorar el canal — que es
+ * justo lo que hace que el hook se desinstale.
+ */
+/** El rastro se considera vivo si es de los últimos 14 días (ficha C6). */
+export const DIAS_SIN_SENAL = 14;
+/** Cada cuánto se repite un aviso que sigue vigente. */
+const DIAS_ENTRE_AVISOS = 30;
+/**
+ * Los cuatro estados. Pura a propósito: la tabla de verdad es lo que hay que
+ * poder probar, y leer ficheros dentro la haría dependiente del disco.
+ */
+export function estadoDelHook(h) {
+    const dias = h.ultimaSenal === null
+        ? Infinity
+        : (h.ahora - h.ultimaSenal) / 86_400_000;
+    if (h.declarado)
+        return dias <= DIAS_SIN_SENAL ? 'sano' : 'declarado-mudo';
+    // Sin declarar: lo que distingue «lo quitaron» de «nunca lo hubo» es que
+    // exista rastro, no cuánto de viejo sea. Un repo con el hook retirado hace
+    // seis meses sigue siendo un repo al que le quitaron el hook.
+    return h.ultimaSenal === null ? 'nunca' : 'retirado';
+}
+/**
+ * El texto. Cadena vacía cuando no hay nada que decir — un hook sano tiene que
+ * callar del todo, igual que `feedWarning`.
+ */
+export function avisoDeHookMudo(estado, opts = {}) {
+    const { audience = 'human', dias } = opts;
+    if (estado === 'sano' || estado === 'nunca')
+        return '';
+    const cuanto = typeof dias === 'number' && Number.isFinite(dias)
+        ? ` (último rastro hace ${Math.floor(dias)} días)`
+        : '';
+    if (estado === 'retirado') {
+        const que = `El hook de ChangeBook que avisa ANTES de editar ya no está en .claude/settings.json${cuanto}.`;
+        return audience === 'agent'
+            ? [
+                '⚠ ChangeBook: el aviso previo a editar está retirado en este repo.',
+                `${que} Vas a editar sin saber quién depende de cada fichero: dilo antes de dar por bueno un cambio grande.`,
+                'Si el dueño lo quiere de vuelta: `changebook hook-impact install`.',
+            ].join('\n')
+            : [
+                '\n⚠ ChangeBook: el aviso previo a editar está retirado.',
+                `  ${que}`,
+                '  Si lo quitaste a propósito, ignora esto — no se repetirá.',
+                '  Para volver a ponerlo: changebook hook-impact install\n',
+            ].join('\n');
+    }
+    // declarado-mudo: lo más difícil de ver solo, porque el fichero DICE que está.
+    const que = `Está declarado en .claude/settings.json pero no ha dejado rastro${cuanto}.`;
+    return audience === 'agent'
+        ? [
+            '⚠ ChangeBook: el aviso previo a editar está puesto pero no corre.',
+            `${que} O sea que lleva ese tiempo sin decirte quién depende de lo que tocas — no lo tomes como que no había nada que decir.`,
+            'Díselo al dueño; se comprueba con `changebook hook-impact status`.',
+        ].join('\n')
+        : [
+            '\n⚠ ChangeBook: el aviso previo a editar está puesto pero no corre.',
+            `  ${que}`,
+            '  No es lo mismo que "no había nada que avisar": lleva ese tiempo mudo.',
+            '  Compruébalo con: changebook hook-impact status\n',
+        ].join('\n');
+}
+/**
+ * Leer y escribir la marca. Locales y no importados de `impact.ts`: sus
+ * `leerJson`/`escribirJson` son privados de aquel módulo, y exportarlos solo
+ * para esto ensancharía su superficie pública por comodidad.
+ */
+function leerMarca(file) {
+    if (!file)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function escribirMarca(file, marca) {
+    if (!file)
+        return;
+    try {
+        fs.writeFileSync(file, JSON.stringify(marca));
+    }
+    catch {
+        // Sin sitio donde anotar, el aviso se repetirá. Es el lado seguro.
+    }
+}
+async function marcaPath(dir) {
+    return gitPath(dir, 'changebook-hook-mudo.json').catch(() => null);
+}
+/** El rastro del hook: la marca de tiempo del acumulado de silencios. */
+async function ultimaSenal(dir) {
+    const file = await gitPath(dir, 'changebook-impact-silencio.json').catch(() => null);
+    if (!file)
+        return null;
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null; // No existe: nunca dejó rastro.
+    }
+}
+/**
+ * El aviso para un directorio, y la marca para no repetirlo.
+ *
+ * SE AVISA UNA VEZ POR EPISODIO, no una vez y nunca más: si el estado cambia
+ * —se retiró y luego se quedó mudo, o volvió a romperse tras arreglarse— eso es
+ * un suceso nuevo y merece decirse. Y si el mismo estado sigue vigente 30 días
+ * después, se repite: callar para siempre convierte «no molestar» en «no
+ * enterarse», que es el fallo que este fichero existe para arreglar.
+ *
+ * Best-effort de principio a fin: esto corre dentro del pre-commit y del arranque
+ * de sesión, y ninguno de los dos puede caerse porque no se pueda leer un JSON.
+ */
+export async function avisoDeHookMudoPara(dir, opts = {}) {
+    try {
+        const ahora = Date.now();
+        const senal = await ultimaSenal(dir);
+        const estado = estadoDelHook({
+            declarado: settingsHookInstalled(dir, IMPACT_HOOK),
+            ultimaSenal: senal,
+            ahora,
+        });
+        if (estado === 'sano' || estado === 'nunca')
+            return '';
+        const file = await marcaPath(dir);
+        const previa = leerMarca(file);
+        if (previa?.estado === estado &&
+            ahora - previa.en < DIAS_ENTRE_AVISOS * 86_400_000) {
+            return '';
+        }
+        escribirMarca(file, { estado, en: ahora });
+        return avisoDeHookMudo(estado, {
+            ...opts,
+            dias: senal === null ? null : (ahora - senal) / 86_400_000,
+        });
+    }
+    catch {
+        // Un aviso que no se puede calcular no puede romper el commit.
+        return '';
+    }
+}
+//# sourceMappingURL=hookMudo.js.map