changebook 0.3.2 → 0.4.1

package/dist/import.js

@@ -10,7 +10,8 @@
  */
 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.
 const CHUNK_SIZE = 20;
@@ -52,11 +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) {
@@ -132,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/index.js

@@ -8,11 +8,15 @@
  * The CLI subcommands feed and connect that memory without the VS Code
  * extension: login, analyze, sync, init, open.
  */
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { analyze } from "./analyze.js";
 import { atlasWebUrl, openInBrowser } from "./browser.js";
 import { clearCredentials, credentialsPath } from "./credentials.js";
+import { runGuard } from "./guard.js";
 import { hookStatus, installHook, uninstallHook } from "./hook.js";
 import { importHistory } from "./import.js";
 import { registerAgents } from "./init.js";
@@ -20,6 +24,10 @@ import { login } from "./login.js";
 import { AUTH_HELP, Supabase } from "./supabase.js";
 import { syncContextFiles } from "./sync.js";
 import { registerTools } from "./tools.js";
+// Single source of truth for the reported version: package.json (dist is one
+// level below it). Avoids the hardcoded "0.2.0" drifting from the published
+// version (audit M5). test/mcpVersion.test.ts pins package.json ↔ server.json.
+const VERSION = JSON.parse(readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")).version;
 const HELP = `changebook — the ChangeBook product memory, from any terminal
 
 Usage:
@@ -31,14 +39,19 @@ Usage:
                           Backfill the last N commits (default 25) via the
                           Anthropic Batch API — 50% cheaper, non-interactive
   changebook hook install|uninstall|status [dir]
-                          Git post-commit hook: analyze every new commit automatically
+                          Git hooks: analyze every new commit (post-commit) and
+                          warn before committing to a module with an open alert
+                          (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 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)
 
 Environment: CHANGEBOOK_REFRESH_TOKEN / CHANGEBOOK_ACCESS_TOKEN override the stored
-session (CI/headless); CHANGEBOOK_PROJECT scopes queries to one project.`;
+session (CI/headless); CHANGEBOOK_PROJECT scopes queries to one project;
+CHANGEBOOK_GUARD=off|block tunes the pre-commit signal guard (default: warn).`;
 function requireCredentials(db) {
     if (!db.hasCredentials()) {
         console.error(AUTH_HELP);
@@ -48,7 +61,7 @@ function requireCredentials(db) {
 async function serve(db) {
     const server = new McpServer({
         name: "changebook-mcp-server",
-        version: "0.2.0",
+        version: VERSION,
     });
     registerTools(server, db);
     if (!db.hasCredentials()) {
@@ -104,11 +117,17 @@ async function main() {
         case "login":
             await login();
             return;
-        case "logout":
+        case "logout": {
+            // Revoke server-side first (best-effort), then forget the local file —
+            // otherwise the refresh token stays alive on the server after "logout".
+            const db = new Supabase();
+            if (db.hasCredentials())
+                await db.signOut();
             console.error(clearCredentials()
                 ? `✓ Session removed from ${credentialsPath()}`
                 : "No stored session.");
             return;
+        }
         case "analyze": {
             const db = new Supabase();
             requireCredentials(db);
@@ -121,6 +140,13 @@ async function main() {
             await importHistory(db, parseImportArgs(process.argv.slice(3)));
             return;
         }
+        case "guard": {
+            // No requireCredentials: a logged-out (or offline, or never-imported)
+            // repo must commit exactly as before — runGuard resolves every failure
+            // to exit 0 itself. The explicit exit also drops any fetch still racing
+            // the timeout, so the commit never waits on a dangling socket.
+            return process.exit(await runGuard(new Supabase(), arg ?? process.cwd()));
+        }
         case "hook": {
             const dir = process.argv[4] ?? process.cwd();
             if (arg === "install")

package/dist/supabase.js

@@ -6,6 +6,7 @@
  * refresh token when needed (refresh does not require a captcha).
  */
 import { loadCredentials, saveCredentials } from "./credentials.js";
+import { slugifyProject } from "./guard.js";
 // Public defaults — the anon key is the same public key the web app ships.
 const DEFAULT_URL = "https://oyosihxkecspjkiligga.supabase.co";
 const DEFAULT_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im95b3NpaHhrZWNzcGpraWxpZ2dhIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODMwMDYyNTUsImV4cCI6MjA5ODU4MjI1NX0.TU-UK1DToHmLHp9q7QEQ5eAa7V3sq3HtgCxPEa-DvDE";
@@ -70,6 +71,14 @@ export class Supabase {
         if (this.projectFilterCache !== undefined)
             return this.projectFilterCache;
         if (!this.projectEnv) {
+            // Sin proyecto explícito: si la cuenta tiene VARIOS proyectos, negar la
+            // mezcla — la frontera por proyecto que el MCP hospedado ya aplica
+            // (auditoría M3: el stdio devolvía "" = todos los proyectos y mezclaba
+            // historia/módulos/contexto). Con 0 o 1 proyecto no hay ambigüedad.
+            const some = await this.rest("projects?select=id&limit=2");
+            if (some.length > 1) {
+                throw new SupabaseError("Esta cuenta tiene varios proyectos. Define CHANGEBOOK_PROJECT (nombre o slug del repo) o pasa `project` en la tool para no mezclar sus datos.", 400);
+            }
             this.projectFilterCache = "";
             return this.projectFilterCache;
         }
@@ -84,6 +93,111 @@ export class Supabase {
         this.projectFilterCache = `&project_id=eq.${rows[0].id}`;
         return this.projectFilterCache;
     }
+    /**
+     * Per-call variant of projectFilter(): resolves an explicit project (tool
+     * argument — the repo the agent is working in) by server-side slug first,
+     * then exact name; falls back to the env-based filter when absent. The
+     * atlas is per-project, so tools pass what the agent gave them here.
+     */
+    async projectFilterFor(project) {
+        const wanted = project?.trim();
+        if (!wanted)
+            return this.projectFilter();
+        const slug = slugifyProject(wanted);
+        let rows = slug
+            ? await this.rest(`projects?select=id&slug=eq.${encodeURIComponent(slug)}&limit=1`)
+            : [];
+        if (rows.length === 0) {
+            rows = await this.rest(`projects?select=id&name=eq.${encodeURIComponent(wanted)}&limit=1`);
+        }
+        if (rows.length === 0) {
+            throw new SupabaseError(`No ChangeBook project named "${wanted}" (by slug or name).`, 404);
+        }
+        return `&project_id=eq.${rows[0].id}`;
+    }
+    /**
+     * POST one row via PostgREST as the signed-in user (RLS applies). Used for
+     * best-effort metering inserts — callers typically fire-and-forget it.
+     */
+    async insertRow(table, row) {
+        if (!this.hasCredentials())
+            throw new SupabaseError(AUTH_HELP, 401);
+        if (!this.accessToken)
+            await this.refresh();
+        let res = await this.insertOnce(table, row);
+        if (res.status === 401 && this.refreshToken) {
+            await this.refresh();
+            res = await this.insertOnce(table, row);
+        }
+        if (!res.ok) {
+            throw new SupabaseError(`Insert into ${table} failed (${res.status}): ${(await res.text()).slice(0, 200)}`, res.status);
+        }
+    }
+    /** POST /rest/v1/rpc/<fn> as the signed-in user (definer rules apply). */
+    async callRpc(fn, args) {
+        if (!this.hasCredentials())
+            throw new SupabaseError(AUTH_HELP, 401);
+        if (!this.accessToken)
+            await this.refresh();
+        let res = await this.rpcOnce(fn, args);
+        if (res.status === 401 && this.refreshToken) {
+            await this.refresh();
+            res = await this.rpcOnce(fn, args);
+        }
+        if (!res.ok) {
+            throw new SupabaseError(`RPC ${fn} failed (${res.status}): ${(await res.text()).slice(0, 200)}`, res.status);
+        }
+        return (await res.json());
+    }
+    rpcOnce(fn, args) {
+        return fetch(`${this.url}/rest/v1/rpc/${fn}`, {
+            method: "POST",
+            headers: {
+                apikey: this.anonKey,
+                Authorization: `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(args),
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    insertOnce(table, row) {
+        return fetch(`${this.url}/rest/v1/${table}`, {
+            method: "POST",
+            headers: {
+                apikey: this.anonKey,
+                Authorization: `Bearer ${this.accessToken}`,
+                "Content-Type": "application/json",
+                Prefer: "return=minimal",
+            },
+            body: JSON.stringify(row),
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    /**
+     * Revoke the session server-side (GoTrue /logout). Best-effort: the caller
+     * still clears the local file afterwards. The extension already does this;
+     * without it a `changebook logout` left the refresh token alive on the
+     * server (audit B4).
+     */
+    async signOut() {
+        if (!this.accessToken) {
+            try {
+                await this.refresh();
+            }
+            catch {
+                return; // no valid token to revoke
+            }
+        }
+        await fetch(`${this.url}/auth/v1/logout?scope=global`, {
+            method: "POST",
+            headers: {
+                apikey: this.anonKey,
+                Authorization: `Bearer ${this.accessToken}`,
+            },
+            signal: AbortSignal.timeout(10_000),
+        }).catch(() => { });
+    }
     /** GET a PostgREST path (e.g. "changelog?select=...") as the signed-in user. */
     async rest(pathWithQuery) {
         if (!this.hasCredentials())

package/dist/sync.js

@@ -12,6 +12,11 @@
  */
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+/** The project identity of the synced repo (same rule as analyze/guard). */
+function projectNameFor(targetDir) {
+    return (process.env.CHANGEBOOK_PROJECT?.trim() ||
+        path.basename(path.resolve(targetDir)));
+}
 const START = "<!-- changebook:start -->";
 const END = "<!-- changebook:end -->";
 // DB text (notes, alert bodies, business impact) is AI-written and gets embedded
@@ -26,10 +31,12 @@ const MAX_MODULES = 15;
 const MAX_CHANGES = 5;
 const MAX_COUPLINGS = 5;
 // El bloque entra en CADA sesión de agente del usuario, así que tiene un
-// presupuesto fijo (~500 tokens) y nunca crece sin control. Cuando no cabe
-// todo, se recorta por prioridad: regresiones > acoplamientos > hotspots >
-// módulos > últimos cambios.
-const SYNC_BUDGET_CHARS = 2_000;
+// presupuesto fijo (~750 tokens) y nunca crece sin control. Cuando no cabe
+// todo, se recorta por prioridad: regresiones > encargos > acoplamientos >
+// hotspots > módulos > últimos cambios. Subido de 2.000 a 3.000 el
+// 2026-07-18: la cabecera ganó las reglas de frontera/aviso/file-context y
+// con 2.000 expulsaba Módulos y Encargos enteros del mapa.
+const SYNC_BUDGET_CHARS = 3_000;
 // Co-change pair thresholds — same spirit as the web's signals: at least 3
 // shared analyses and a ≥60% rate before we call it a dependency.
 const MIN_PAIR_COUNT = 3;
@@ -38,9 +45,23 @@ const MIN_PAIR_RATE = 0.6;
 const ALERT_WINDOW_DAYS = 14;
 const MAX_ALERTS = 3;
 export async function syncContextFiles(db, targetDir) {
-    const projectFilter = await db.projectFilter();
+    const projectName = projectNameFor(targetDir);
+    // Frontera por proyecto también aquí (QA 2026-07-18): sin filtro, una
+    // cuenta con varios proyectos construiría el mapa de ESTE repo mezclando
+    // los datos de todos. Y si el proyecto aún no existe en el atlas, el mapa
+    // debe salir VACÍO — jamás el de otro proyecto.
+    let projectFilter;
+    let projectResolved = true;
+    try {
+        projectFilter = await db.projectFilterFor(projectName);
+    }
+    catch {
+        projectFilter = "&project_id=eq.00000000-0000-0000-0000-000000000000";
+        projectResolved = false;
+    }
+    const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
     const since = new Date(Date.now() - ALERT_WINDOW_DAYS * 24 * 3600 * 1000).toISOString();
-    const [moduleRows, changes, alerts] = await Promise.all([
+    const [moduleRows, changes, alerts, pendingTasks] = await Promise.all([
         db.rest("change_module?select=changelog_id,module,domain,risk,files,note,created_at&order=created_at.desc&limit=500" +
             projectFilter),
         db.rest(`changelog?select=business_impact,created_at&order=created_at.desc&limit=${MAX_CHANGES}` +
@@ -48,19 +69,47 @@ export async function syncContextFiles(db, targetDir) {
         // AI-detected regression warnings: best-effort — an error (older schema,
         // RLS hiccup) must not block the sync of the rest of the map.
         db
-            .rest(`regression_alerts?select=module,plain,created_at&created_at=gte.${since}&order=created_at.desc&limit=${MAX_ALERTS}` +
+            .rest(
+        // resolved_at=is.null: a dismissed/auto-resolved alert inside the
+        // window must not resurface in every agent session as urgent.
+        `regression_alerts?select=module,plain,created_at&created_at=gte.${since}&resolved_at=is.null&order=created_at.desc&limit=${MAX_ALERTS}` +
             projectFilter)
             .catch(() => []),
+        // Auto-remediación fase 2: los encargos pendientes entran en el bloque
+        // para que CUALQUIER sesión arranque sabiéndolos y se ofrezca a atacarlos
+        // (proponer, no ejecutar — la aprobación sigue siendo del humano).
+        // Best-effort como las alertas.
+        projectResolved && projectId
+            ? db
+                .callRpc("list_agent_tasks", {
+                p_project_id: projectId,
+            })
+                .then((rows) => rows.filter((r) => r.status === "pending"))
+                .catch(() => [])
+            : Promise.resolve([]),
     ]);
-    const section = buildSection(moduleRows, changes, alerts);
+    const section = buildSection(moduleRows, changes, alerts, projectName, pendingTasks);
     for (const name of ["CLAUDE.md", "AGENTS.md"]) {
         const file = path.join(targetDir, name);
         const updated = await upsertSection(file, section);
         console.error(`${updated} ${name}`);
     }
+    // El sync ES una consulta del atlas — la más apalancada: el mapa que
+    // destila entra en CADA sesión de agente vía CLAUDE.md/AGENTS.md sin
+    // pagar tool calls. Cuenta como lectura (best-effort).
+    if (projectResolved && projectId) {
+        await db
+            .insertRow("atlas_reads", {
+            project_id: projectId,
+            tool: "sync_context_files",
+            source: "sync",
+            chars_served: section.length,
+        })
+            .catch(() => { });
+    }
 }
 /** Exported for tests. */
-export function buildSection(rows, changes, alerts = []) {
+export function buildSection(rows, changes, alerts = [], projectName, pendingTasks = []) {
     // Newest-first rows: the first occurrence of a module is its latest state.
     const seen = new Map();
     for (const row of rows) {
@@ -79,8 +128,26 @@ export function buildSection(rows, changes, alerts = []) {
         // útiles ya van por entrada (regresiones, últimos cambios).
         "## Mapa del producto (ChangeBook · auto-generado)",
         "",
-        "Este proyecto tiene memoria en ChangeBook. Antes de explorar código a mano, orienta con las tools MCP: `atlas_modules` (mapa), `atlas_recent_changes` (historia), `atlas_module_detail` (detalle + diffs).",
+        "Este proyecto tiene memoria en ChangeBook. Al EMPEZAR la sesión, oriéntate con UNA sola llamada a la tool MCP `atlas_project_brief` (mapa + alertas + encargos pendientes + últimos cambios); para profundizar: `atlas_module_detail` (detalle + diffs).",
+        "",
+        "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
+        // son POR PROYECTO; sin este dato el agente recibiría los de otros.
+        ...(projectName
+            ? [
+                `El proyecto de ESTE repo es \`${sanitizeCell(projectName)}\`. El atlas es por proyecto: pasa SIEMPRE \`project: "${sanitizeCell(projectName)}"\` en las tools del atlas (mapa, historia, detalle, encargos y registro). Los encargos o datos de otros proyectos no pertenecen a esta sesión.`,
+                "",
+            ]
+            : []),
         // La instrucción de escritura vive AQUÍ y no en la doc de la tool: los
         // agentes obedecen lo que el workspace les dice, no lo que una tool
         // disponible insinúa (lección 2026-07-17: un agente con la tool conectada
@@ -124,14 +191,33 @@ export function buildSection(rows, changes, alerts = []) {
         return `- **${m.module}** está marcado crítico${note ? ` — ${note}` : ""}`;
     });
     const changeLines = changes.map((c) => `- ${c.created_at.slice(0, 10)} — ${sanitizeCell((c.business_impact ?? "").slice(0, 140))}`);
+    // Auto-remediación fase 2: la cola entra en cada sesión para que el agente
+    // se OFREZCA a atacarla — proponer con plan y esperar el OK del humano,
+    // nunca ejecutar por su cuenta. Títulos deduplicados (la cola real puede
+    // llevar la misma señal encolada varias veces).
+    const taskTitles = [
+        ...new Set(pendingTasks.map((t) => (t.title ?? "").trim()).filter(Boolean)),
+    ].slice(0, 3);
+    const taskLines = taskTitles.length > 0
+        ? [
+            `- Hay ${pendingTasks.length} encargo(s) pendientes en la cola de este proyecto. Al empezar, propón al usuario cuál atacarías y por qué, y espera su OK antes de tocar código. Cola viva: \`atlas_pending_tasks\`; cierra con \`atlas_complete_task\`.`,
+            ...taskTitles.map((t) => `- ${sanitizeCell(t.slice(0, 120))}`),
+        ]
+        : [];
     // El orden de renderizado (legibilidad) y la prioridad de presupuesto
     // (utilidad para el agente) son independientes: si no cabe todo, caen
     // primero los últimos cambios y los módulos, nunca las regresiones.
     const sections = [
-        { key: "modules", priority: 3, title: "### Módulos", lines: moduleLines },
+        { key: "modules", priority: 4, title: "### Módulos", lines: moduleLines },
         {
-            key: "couplings",
+            key: "tasks",
             priority: 1,
+            title: "### Encargos pendientes del dueño (proponte atacarlos)",
+            lines: taskLines,
+        },
+        {
+            key: "couplings",
+            priority: 2,
             title: "### Módulos que cambian juntos (si tocas uno, revisa el otro)",
             lines: couplingLines,
         },
@@ -143,13 +229,13 @@ export function buildSection(rows, changes, alerts = []) {
         },
         {
             key: "hotspots",
-            priority: 2,
+            priority: 3,
             title: "### Avisos abiertos (revisar antes de modificar)",
             lines: hotspotLines,
         },
         {
             key: "changes",
-            priority: 4,
+            priority: 5,
             title: "### Últimos cambios",
             lines: changeLines,
         },