changebook 0.4.0 → 0.4.1

package/dist/analyze.js

@@ -6,7 +6,7 @@
  */
 import * as path from "node:path";
 import { atlasWebUrl } from "./browser.js";
-import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, } from "./git.js";
+import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, usableSummary, } from "./git.js";
 import { canonicalDiffHash } from "./canonical.js";
 import { optimizeTokensForAI, truncateAtFileBoundary } from "./optimize.js";
 export async function analyze(db, options = {}) {
@@ -15,10 +15,16 @@ export async function analyze(db, options = {}) {
     let rawDiff;
     let commitHash;
     let committedAt;
+    // El mensaje del commit como resumen: enruta al modelo pequeño en el servidor
+    // (~3 veces más barato). Este es el camino del hook post-commit, o sea el que
+    // dispara en CADA commit, así que es donde más veces se cobra la diferencia.
+    // Analizando cambios sin commitear no hay mensaje todavía: va sin resumen.
+    let agentSummary;
     if (options.commit) {
         const meta = await commitMeta(cwd, options.commit);
         commitHash = meta.hash;
         committedAt = meta.committedAt;
+        agentSummary = usableSummary(meta.message) ?? undefined;
         rawDiff = await commitDiff(cwd, meta.hash);
         if (!rawDiff.trim()) {
             console.error(`Commit ${meta.hash.slice(0, 8)} has no analyzable diff (merge?). Skipped.`);
@@ -53,6 +59,7 @@ export async function analyze(db, options = {}) {
         projectName,
         commitHash,
         committedAt,
+        agentSummary,
     });
     if (status !== 200 || body.error) {
         // The server's messages are user-facing (quota, waitlist…): pass through.
@@ -94,11 +101,22 @@ async function commitMeta(cwd, ref) {
         const { stdout } = await execFileAsync("git", 
         // --end-of-options so a user-supplied ref beginning with "-" is treated as
         // a revision, not as a git option.
-        ["log", "-1", "--pretty=format:%H|%cI", "--end-of-options", ref], { cwd, encoding: "utf8" });
-        const [hash, committedAt] = stdout.trim().split("|");
+        // %B (mensaje entero) va detrás de la fecha a propósito: es el único
+        // campo que puede llevar "|" y saltos de línea, así que se corta por los
+        // DOS primeros separadores y el resto se queda entero. Con -1 no hace
+        // falta -z: solo hay un registro.
+        ["log", "-1", "--pretty=format:%H|%cI|%B", "--end-of-options", ref], { cwd, encoding: "utf8" });
+        const raw = stdout.trim();
+        const firstPipe = raw.indexOf("|");
+        const secondPipe = raw.indexOf("|", firstPipe + 1);
+        const hash = firstPipe < 0 ? raw : raw.slice(0, firstPipe);
         if (!hash)
             throw new Error("empty git log output");
-        return { hash, committedAt };
+        return {
+            hash,
+            committedAt: secondPipe < 0 ? raw.slice(firstPipe + 1) : raw.slice(firstPipe + 1, secondPipe),
+            message: secondPipe < 0 ? "" : raw.slice(secondPipe + 1),
+        };
     }
     catch (error) {
         throw new Error(`Could not resolve commit "${ref}" in "${cwd}": ${gitErrorMessage(error)}`);

package/dist/git.js

@@ -11,6 +11,40 @@ export const GIT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 // Mirror of the extension's default changebook.maxDiffCharacters (the server
 // rejects anything above 60k anyway).
 export const MAX_DIFF_CHARACTERS = 25_000;
+// ── El mensaje de commit como resumen ────────────────────────────────────────
+// El mensaje, cuando dice algo, ES el resumen del cambio: lo escribió quien lo
+// hizo y explica la intención, que es la mitad cara del análisis y la única que
+// el servidor no puede reconstruir del diff. Mandarlo hace que el servidor
+// enrute al modelo pequeño: medido, $0,063 contra $0,021 = 3 veces menos.
+//
+// Vive aquí por lo mismo que commitDiff: lo usan los DOS subcomandos (`analyze`,
+// que es el hook post-commit, e `import`, que es la historia), y tenerlo en uno
+// solo es exactamente el fallo que dejó al otro pagando el modelo caro.
+//
+// Copia deliberada de la del servidor (_shared/github.ts) y de la de la
+// extensión (src/util/summary.ts): los tres artefactos se publican por separado
+// y tienen que ser autocontenidos, igual que canonicalDiffHash.
+// test/summaryParity.test.ts fija que no se separen — si lo hacen no falla
+// nada, solo cambia la factura.
+//
+// Los dos filtros: un mensaje pobre ("fix", "wip") NO se manda, porque el
+// modelo pequeño se APOYA en el resumen y alimentarlo con ruido daría un
+// análisis peor Y más barato; y el largo se recorta por línea entera, porque el
+// servidor RECHAZA los que se pasan y un 400 no encarecería el análisis: lo
+// dejaría sin hacer.
+const MIN_USEFUL_SUMMARY_CHARS = 40;
+const MAX_AGENT_SUMMARY_CHARS = 2_400;
+/** El mensaje si sirve como resumen, recortado por línea entera; si no, null. */
+export function usableSummary(message) {
+    const text = message.trim();
+    if (text.length < MIN_USEFUL_SUMMARY_CHARS)
+        return null;
+    if (text.length <= MAX_AGENT_SUMMARY_CHARS)
+        return text;
+    const cut = text.slice(0, MAX_AGENT_SUMMARY_CHARS);
+    const lastBreak = cut.lastIndexOf("\n");
+    return (lastBreak > MIN_USEFUL_SUMMARY_CHARS ? cut.slice(0, lastBreak) : cut).trim();
+}
 /** `git show <hash> -U0` — the unified diff of a single commit, no context. */
 export async function commitDiff(cwd, hash) {
     try {

package/dist/guard.js

@@ -175,15 +175,27 @@ async function logRun(dir, message) {
         // Best-effort only.
     }
 }
-function printFindings(findings, block) {
-    console.error(`\n⚠ ChangeBook: ${findings.length === 1 ? "an open alert" : `${findings.length} open alerts`} on what you're about to commit:\n`);
+/**
+ * El aviso que ve el humano, como texto.
+ *
+ * Se construye aparte de imprimirlo para poder MEDIRLO: es lo que el guardián
+ * sirve de verdad, y su longitud es lo que se registra como chars_served
+ * (QA 2026-07-19). Cadena vacía cuando no hay nada que avisar.
+ */
+export function findingsMessage(findings, block) {
+    if (findings.length === 0)
+        return "";
+    const lines = [
+        `\n⚠ ChangeBook: ${findings.length === 1 ? "an open alert" : `${findings.length} open alerts`} on what you're about to commit:\n`,
+    ];
     for (const f of findings) {
-        console.error(`  • ${f.module} — ${f.plain}`);
-        console.error(`    staged: ${f.staged.slice(0, 5).join(", ")}`);
+        lines.push(`  • ${f.module} — ${f.plain}`);
+        lines.push(`    staged: ${f.staged.slice(0, 5).join(", ")}`);
     }
-    console.error(block
+    lines.push(block
         ? "\nCommit blocked (CHANGEBOOK_GUARD=block). Review the alert in your atlas (changebook open) or bypass once with: git commit --no-verify\n"
         : "\nReview or dismiss the alert in your atlas: changebook open\n");
+    return lines.join("\n");
 }
 /**
  * Returns the process exit code. Everything that can go wrong resolves to 0
@@ -225,11 +237,21 @@ export async function runGuard(db, dir, env = process.env) {
         return 0;
     }
     const findings = guardFindings(staged, signals.alerts, signals.filesByModule);
+    const block = mode === "block";
+    const message = findingsMessage(findings, block);
     // La consulta del guardián también es una consulta del atlas (QA
     // 2026-07-18: el contador solo veía las tools MCP y el trabajo más
     // constante del atlas era invisible). Solo las frescas — un rebase servido
     // de caché no re-consulta nada. Best-effort y ACOTADO: jamás puede
     // convertir un commit rápido en uno lento.
+    //
+    // chars_served = el aviso que el humano acaba viendo, 0 cuando todo está
+    // limpio (QA 2026-07-19). Antes se registraba siempre 0 y el guardián, que es
+    // el consumidor MÁS frecuente del atlas, no se distinguía de una consulta que
+    // no encontró nada. Con esto "revisó" y "avisó" son dos cosas separables en el
+    // dato, sin inventar ninguna valoración: esos caracteres se sirvieron de
+    // verdad. Lo que el guardián evita de verdad, un error, no se mide en
+    // caracteres y no se intenta.
     if (!signals.fromCache && signals.projectId) {
         await Promise.race([
             db
@@ -237,6 +259,7 @@ export async function runGuard(db, dir, env = process.env) {
                 project_id: signals.projectId,
                 tool: "guard_precommit",
                 source: "guard",
+                chars_served: message.length,
             })
                 .catch(() => { }),
             new Promise((resolve) => {
@@ -247,8 +270,7 @@ export async function runGuard(db, dir, env = process.env) {
     await logRun(dir, `staged=${staged.length} openAlerts=${signals.alerts.length} findings=${findings.length}`);
     if (findings.length === 0)
         return 0;
-    const block = mode === "block";
-    printFindings(findings, block);
+    console.error(message);
     return block ? EXIT_BLOCK : 0;
 }
 //# sourceMappingURL=guard.js.map

package/dist/import.js

@@ -10,7 +10,7 @@
  */
 import * as path from "node:path";
 import { atlasWebUrl } from "./browser.js";
-import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, } from "./git.js";
+import { commitDiff, execFileAsync, GIT_MAX_BUFFER_BYTES, gitErrorMessage, MAX_DIFF_CHARACTERS, usableSummary, } from "./git.js";
 import { canonicalDiffHash } from "./canonical.js";
 import { optimizeTokensForAI } from "./optimize.js";
 // Under the server's MAX_BATCH_ITEMS (25) to leave headroom.
@@ -53,12 +53,16 @@ export async function importHistory(db, options = {}) {
             trivial += 1;
             continue;
         }
+        // El servidor decide con esto si enruta al modelo pequeño. Va opcional: un
+        // servidor antiguo lo ignora sin romperse.
+        const summary = usableSummary(commit.message);
         items.push({
             compressedDiff: compressed,
             rawDiffChars: diff.length,
             rawContentHash: canonicalDiffHash(diff),
             commitHash: commit.hash,
             committedAt: commit.date,
+            ...(summary ? { agentSummary: summary } : {}),
         });
     }
     if (items.length === 0) {
@@ -134,15 +138,34 @@ function sleep(ms) {
 // ── git helpers ───────────────────────────────────────────────────────────────
 async function listCommits(cwd, count) {
     try {
-        const { stdout } = await execFileAsync("git", ["log", "-n", String(count), "--no-merges", "--pretty=format:%H|%cI"], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
+        // -z separa los commits por NUL en vez de por salto de línea. Es
+        // obligatorio desde que se pide %B: el mensaje tiene saltos dentro, así que
+        // partir por "\n" mezclaría el cuerpo de un commit con el siguiente.
+        const { stdout } = await execFileAsync("git", [
+            "log",
+            "-n",
+            String(count),
+            "--no-merges",
+            "-z",
+            "--pretty=format:%H|%cI|%B",
+        ], { cwd, encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES });
         return stdout
-            .split("\n")
+            .split("\0")
             .filter(Boolean)
-            .map((line) => {
-            const [hash, date] = line.split("|");
-            return { hash, date };
+            .map((record) => {
+            // Solo los DOS primeros "|" son separadores: el hash y la fecha ISO no
+            // pueden contener uno, pero el mensaje sí, y hay que dejarlo entero.
+            const firstPipe = record.indexOf("|");
+            const secondPipe = record.indexOf("|", firstPipe + 1);
+            if (firstPipe < 0 || secondPipe < 0)
+                return null;
+            return {
+                hash: record.slice(0, firstPipe),
+                date: record.slice(firstPipe + 1, secondPipe),
+                message: record.slice(secondPipe + 1),
+            };
         })
-            .filter((c) => c.hash && c.date);
+            .filter((c) => c != null && !!c.hash && !!c.date);
     }
     catch (error) {
         const message = gitErrorMessage(error);

package/dist/sync.js

@@ -132,6 +132,12 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         "",
         "Si vas a trabajar un encargo pendiente del atlas, anuncia primero al usuario en 2-3 líneas qué vas a hacer y por qué, antes de tocar código.",
         "",
+        // QA de Raúl 2026-07-19: el atlas avisó de un riesgo real, el agente lo
+        // usó y siguió trabajando sin decir nada. Desde fuera, un guardián que
+        // trabaja callado y un producto que no hace nada son la misma cosa. El
+        // dueño paga esto: tiene que verlo ocurrir.
+        "Cuando el atlas te avise de un riesgo (alerta abierta, `atlas_file_context` o el guardián), DÍSELO al usuario en 1-2 líneas antes de seguir, aunque lo resuelvas tú: él no ve esos avisos.",
+        "",
         "Antes de tocar un archivo concreto, consulta `atlas_file_context` con sus rutas: te da su módulo, riesgo, alertas abiertas e historia por una llamada — más barato que releer el código y su git log.",
         "",
         // Frontera por proyecto (QA 2026-07-18): el atlas y la cola de encargos

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "mcpName": "io.github.raulbr90/changebook",
   "description": "ChangeBook for coding agents: MCP server (product memory for Claude Code/Codex) + CLI to sign in, analyze changes and sync the product map.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.raulbr90/changebook",
   "description": "Query your product's living memory: module map + analyzed change history. Read-only MCP tools.",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.0",
+      "version": "0.4.1",
       "transport": {
         "type": "stdio"
       }