changebook 0.4.3 → 0.4.4

package/dist/sync.js

@@ -156,7 +156,10 @@ export function buildSection(rows, changes, alerts = [], projectName, pendingTas
         //   · anunciar antes de atacar un encargo
         //   · DECIR el riesgo al usuario (QA 2026-07-19: el guardian aviso, el
         //     agente lo uso y siguio callado; desde fuera eso es no hacer nada)
-        'Memoria del proyecto en ChangeBook. Oriéntate con UNA llamada a `atlas_project_brief`. Antes de tocar un archivo: `atlas_file_context` con su ruta. Tras cada commit: `atlas_record_change` con el diff, `commit_hash`, `committed_at` y un `summary` tuyo (abarata el análisis; reenviar lo ya registrado es gratis).',
+        //   · cargar las tools diferidas de UNA vez (benchmark 2026-07-20: 3 de 7
+        //     llamadas del agente CON atlas eran ToolSearch cargando esquemas de
+        //     uno en uno — cada una relee ~45k tokens de contexto)
+        'Memoria del proyecto en ChangeBook. Oriéntate con UNA llamada a `atlas_project_brief`. Antes de tocar un archivo: `atlas_file_context` con su ruta. Tras cada commit: `atlas_record_change` con el diff, `commit_hash`, `committed_at` y un `summary` tuyo (abarata el análisis; reenviar lo ya registrado es gratis). Tools diferidas: una sola llamada a ToolSearch con todas, nunca de una en una.',
         '',
         ...(projectName
             ? [

package/dist/tools.js

@@ -95,11 +95,37 @@ export function quotedInList(values) {
         .map((v) => `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`)
         .join(",");
 }
+export const FILES_CAP = 8;
+export function filesUnionByChange(rows, cap = FILES_CAP) {
+    const acc = new Map();
+    for (const r of rows) {
+        if (!Array.isArray(r.files))
+            continue;
+        let list = acc.get(r.changelog_id);
+        if (!list) {
+            list = [];
+            acc.set(r.changelog_id, list);
+        }
+        for (const f of r.files) {
+            if (typeof f === "string" && f.length > 0 && !list.includes(f)) {
+                list.push(f);
+            }
+        }
+    }
+    const out = new Map();
+    for (const [id, list] of acc) {
+        out.set(id, {
+            files: list.slice(0, cap),
+            more: Math.max(0, list.length - cap),
+        });
+    }
+    return out;
+}
 // Consultation metering (never billing): each successful read leaves a row in
 // atlas_reads so the web can show "your agent consulted the atlas N times".
 // Best-effort and non-blocking — metering must never break or slow a read.
 // user_id is filled server-side (column default auth.uid()).
-function recordRead(db, tool, projectFilter, charsServed) {
+function recordRead(db, tool, projectFilter, charsServed, latencyMs) {
     const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
     void db
         .insertRow("atlas_reads", {
@@ -107,6 +133,11 @@ function recordRead(db, tool, projectFilter, charsServed) {
         tool,
         source: "stdio",
         chars_served: charsServed,
+        // Latencia del handler (encargo 0dbbfbf4): nullable a propósito — es
+        // metering, jamás contrato, y un servidor viejo simplemente no la manda.
+        ...(latencyMs !== undefined
+            ? { latency_ms: Math.max(0, Math.min(Math.round(latencyMs), 600000)) }
+            : {}),
     })
         .catch(() => { });
 }
@@ -157,6 +188,76 @@ export async function derivaContraHead(dir, hash) {
 }
 // ── Registration ──────────────────────────────────────────────────────────────
 export function registerTools(server, db) {
+    // Espejo del hospedado (T3 del benchmark 2026-07-20): definiciones
+    // exportadas por archivo, sin grep. Usos y tests siguen fuera y se dice.
+    server.registerTool("atlas_symbol_lookup", {
+        title: "Where is this symbol defined?",
+        description: `Files where an exported symbol (function/class/const/interface/type/enum) is DEFINED, with its kind and the commit that last touched it. Mechanical index built from every ingested diff.
+
+Definitions only — usages and tests are not indexed; grep for those. Exact match first, substring fallback.
+
+Args:
+  - symbol (required): the identifier to look up.
+  - project (recommended): the repo you are working in (folder name or slug).
+
+Returns (structured): { symbol, exact_match, matches: [{ symbol, file, kind, commit }] }`,
+        inputSchema: {
+            symbol: z
+                .string()
+                .min(2)
+                .max(120)
+                .describe("Identifier to look up (exported definition)"),
+            project: z
+                .string()
+                .min(1)
+                .max(120)
+                .describe("Project to scope to (repo folder name or slug)"),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ symbol, project }) => {
+        try {
+            const t0 = Date.now();
+            const pf = await db.projectFilterFor(project);
+            const base = `symbol_index?select=symbol,file,kind,commit_hash&order=symbol.asc&limit=20` +
+                pf;
+            let matches = await db.rest(`${base}&symbol=eq.${encodeURIComponent(symbol)}`);
+            let exact = true;
+            if (matches.length === 0) {
+                exact = false;
+                matches = await db.rest(`${base}&symbol=ilike.${ilikePattern(symbol)}`);
+            }
+            const lines = [`# Symbol lookup: ${symbol}`, ""];
+            if (matches.length === 0) {
+                lines.push("Not in the index. It may be unexported, renamed, or defined before the index existed — fall back to grep and SAY you did, instead of guessing.");
+            }
+            for (const m of matches) {
+                lines.push(`- ${m.symbol} (${m.kind}) — ${m.file}${m.commit_hash ? ` · commit ${m.commit_hash.slice(0, 7)}` : ""}`);
+            }
+            if (matches.length > 0) {
+                lines.push("", "Definitions only — usages and tests are not indexed; grep for those.");
+            }
+            const salida = toolResult(lines.join("\n"), {
+                symbol,
+                exact_match: exact,
+                matches: matches.map((m) => ({
+                    symbol: m.symbol,
+                    file: m.file,
+                    kind: m.kind,
+                    commit: m.commit_hash?.slice(0, 7) ?? null,
+                })),
+            });
+            recordRead(db, "atlas_symbol_lookup", pf, servedCharsOf(salida), Date.now() - t0);
+            return salida;
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
     server.registerTool("atlas_recent_changes", {
         title: "Recent ChangeBook changes",
         description: `List the most recent analyzed code changes from the ChangeBook changelog (newest first).
@@ -169,7 +270,7 @@ Args:
   - search (optional): case-insensitive text filter over the business and technical summaries.
   - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project.
 
-Returns (structured): { count, offset, has_more, changes: [{ id, date, business_impact, diff_chars, modules: [{ module, risk }] }] }. Pass include_tech for summary_tech.
+Returns (structured): { count, offset, has_more, changes: [{ id, date, commit, business_impact, diff_chars, files, files_more, modules: [{ module, risk }] }] }. files is a capped union (files_more = paths cut). Pass include_tech for summary_tech.
 
 Don't use for per-module deep dives — use atlas_module_detail for that.`,
         inputSchema: {
@@ -191,8 +292,9 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
         },
     }, async ({ limit, offset, search, project, include_tech }) => {
         try {
+            const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
-            let query = `changelog?select=id,business_impact,summary_tech,created_at,diff_character_count` +
+            let query = `changelog?select=id,business_impact,summary_tech,created_at,diff_character_count,commit_hash` +
                 `&order=created_at.desc&limit=${limit}&offset=${offset}` +
                 pf;
             if (search) {
@@ -201,12 +303,14 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
             }
             const rows = await db.rest(query);
             const modulesByChange = new Map();
+            let filesByChange = new Map();
             if (rows.length > 0) {
                 const ids = rows.map((r) => r.id).join(",");
                 const mods = await db.rest(
-                // Only the module name and risk are used below; don't pull note/tech/
-                // excerpt/files (up to ~1.5k each) for every row of every change.
-                `change_module?select=changelog_id,module,risk&changelog_id=in.(${ids})`);
+                // note/tech/excerpt stay out (~1.5k each per row); `files` comes in
+                // deliberately (commit mirror, benchmark 2026-07-20) and is served
+                // as a capped union, never raw.
+                `change_module?select=changelog_id,module,risk,files&changelog_id=in.(${ids})`);
                 for (const m of mods) {
                     const list = modulesByChange.get(m.changelog_id);
                     if (list)
@@ -214,6 +318,7 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
                     else
                         modulesByChange.set(m.changelog_id, [m]);
                 }
+                filesByChange = filesUnionByChange(mods);
             }
             const changes = rows.map((r) => ({
                 id: r.id,
@@ -226,6 +331,9 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
                 // que casaron los resultados.
                 ...(include_tech || search ? { summary_tech: r.summary_tech ?? null } : {}),
                 diff_chars: r.diff_character_count ?? null,
+                commit: r.commit_hash?.slice(0, 7) ?? null,
+                files: filesByChange.get(r.id)?.files ?? [],
+                files_more: filesByChange.get(r.id)?.more ?? 0,
                 modules: (modulesByChange.get(r.id) ?? []).map((m) => ({
                     module: m.module,
                     risk: m.risk,
@@ -242,11 +350,13 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
                 const mods = c.modules
                     .map((m) => m.module + (m.risk ? ` [${m.risk}]` : ""))
                     .join(", ");
-                lines.push(`## ${c.date} — ${c.business_impact}`);
+                lines.push(`## ${c.date}${c.commit ? ` · ${c.commit}` : ""} — ${c.business_impact}`);
                 if ((include_tech || search) && c.summary_tech)
                     lines.push(`- Tech: ${c.summary_tech}`);
                 if (mods)
                     lines.push(`- Modules: ${mods}`);
+                if (c.files.length > 0)
+                    lines.push(`- Files: ${c.files.join(", ")}${c.files_more > 0 ? ` (+${c.files_more} more)` : ""}`);
                 lines.push("");
             }
             if (changes.length === 0) {
@@ -256,7 +366,7 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
             }
             const changesText = lines.join("\n");
             const salida = toolResult(changesText, output);
-            recordRead(db, "atlas_recent_changes", pf, servedCharsOf(salida));
+            recordRead(db, "atlas_recent_changes", pf, servedCharsOf(salida), Date.now() - t0);
             return salida;
         }
         catch (error) {
@@ -288,6 +398,7 @@ Returns (structured): { count, modules: [{ module, domain, risk, changes, last_c
         },
     }, async ({ domain, project }) => {
         try {
+            const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
             let query = 
             // The aggregation below uses only these columns; note/tech/excerpt
@@ -331,7 +442,7 @@ Returns (structured): { count, modules: [{ module, domain, risk, changes, last_c
             }
             const modulesText = lines.join("\n");
             const salida = toolResult(modulesText, output);
-            recordRead(db, "atlas_modules", pf, servedCharsOf(salida));
+            recordRead(db, "atlas_modules", pf, servedCharsOf(salida), Date.now() - t0);
             return salida;
         }
         catch (error) {
@@ -372,6 +483,7 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
         },
     }, async ({ module, limit, include_excerpts, full, project }) => {
         try {
+            const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
             const rows = await db.rest(`change_module?select=changelog_id,module,domain,category,risk,files,note,tech,excerpt,created_at` +
                 `&module=eq.${encodeURIComponent(module)}&order=created_at.desc&limit=${limit}` +
@@ -462,7 +574,7 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
                 lines.push(TEMPORAL_CONTRACT, "");
             const detailText = lines.join("\n");
             const salida = toolResult(detailText, output);
-            recordRead(db, "atlas_module_detail", pf, servedCharsOf(salida));
+            recordRead(db, "atlas_module_detail", pf, servedCharsOf(salida), Date.now() - t0);
             return salida;
         }
         catch (error) {
@@ -471,7 +583,7 @@ Returns (structured): { module, count, changes: [{ date, commit, risk, note, tec
     });
     server.registerTool("atlas_file_context", {
         title: "Context of the files you are about to edit",
-        description: `Everything the atlas knows about specific FILES: which module each belongs to, its risk, open regression alerts on those modules, and how often they changed recently.
+        description: `Everything the atlas knows about specific FILES: which module each belongs to, its risk, open regression alerts on those modules, how often they changed recently, and the CURRENT value of watched config constants (with the commit it comes from — no need to re-read the file for those).
 
 Call this BEFORE editing a file — one cheap call instead of re-reading the code and its git history.
 
@@ -479,7 +591,7 @@ Args:
   - files (required): 1-8 repo-relative paths.
   - project (recommended): the repo you are working in (folder name or slug). The atlas is per-project — always scope to your own project.
 
-Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_changed, last_note }], open_alerts }] }`,
+Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_changed, last_note }], open_alerts, watched_values: [{ name, value, commit }] }] }`,
         inputSchema: {
             files: z.array(z.string().min(1).max(300)).min(1).max(8)
                 .describe("Repo-relative paths you are about to edit"),
@@ -494,6 +606,7 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
         },
     }, async ({ files, project }) => {
         try {
+            const t0 = Date.now();
             const pf = await db.projectFilterFor(project);
             const paths = [...new Set(files.map(normalizeRepoPath).filter(Boolean))];
             const perFile = await Promise.all(paths.map(async (file) => {
@@ -522,10 +635,24 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
             const moduleNames = [
                 ...new Set(perFile.flatMap((f) => f.modules.map((m) => m.module))),
             ];
-            const alerts = moduleNames.length
-                ? await db.rest(`regression_alerts?select=module,plain,evidence_symbol,evidence_expect&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
+            const [alerts, watched] = await Promise.all([
+                moduleNames.length
+                    ? db.rest(`regression_alerts?select=module,plain,evidence_symbol,evidence_expect&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
+                        pf)
+                    : Promise.resolve([]),
+                // Constantes vigiladas (espejo del hospedado): el valor VIGENTE con
+                // su commit, extraído mecánicamente en cada ingesta — la cura del
+                // fallo de frescura del benchmark 2026-07-20. Best-effort: sin la
+                // tabla, el contexto sigue sirviéndose.
+                db
+                    .rest(`watched_values?select=file,name,value,commit_hash&file=in.(${encodeURIComponent(quotedInList(paths))})&order=name.asc&limit=40` +
                     pf)
-                : [];
+                    .catch(() => []),
+            ]);
+            const watchedByFile = new Map();
+            for (const w of watched) {
+                watchedByFile.set(w.file, [...(watchedByFile.get(w.file) ?? []), w]);
+            }
             // Refutación al servir (benchmark 2026-07-20): el mismo grep que el
             // guardián corre en el pre-commit, pero aquí, en la consulta que el
             // agente hace ANTES de editar — 4 de 7 alertas abiertas se caían con
@@ -576,13 +703,35 @@ Returns (structured): { files: [{ file, modules: [{ module, risk, changes, last_
                         lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
                     }
                 }
+                for (const w of watchedByFile.get(f.file) ?? []) {
+                    lines.push(`- Current value: ${w.name} = ${w.value}` +
+                        (w.commit_hash
+                            ? ` (as of commit ${w.commit_hash.slice(0, 7)})`
+                            : ""));
+                }
                 lines.push("");
             }
             if (!ancla)
                 lines.push(TEMPORAL_CONTRACT, "");
             const contextText = lines.join("\n");
-            const salida = toolResult(contextText, { files: perFile });
-            recordRead(db, "atlas_file_context", pf, servedCharsOf(salida));
+            // open_alerts entra en el structured desde el 2026-07-20: la
+            // descripción lo prometía y solo viajaba en el texto (bug cazado por
+            // el verificador adversarial del benchmark).
+            const salida = toolResult(contextText, {
+                files: perFile.map((f) => ({
+                    ...f,
+                    open_alerts: f.modules.flatMap((m) => (alertsByModule.get(m.module) ?? []).map((plain) => ({
+                        module: m.module,
+                        plain,
+                    }))),
+                    watched_values: (watchedByFile.get(f.file) ?? []).map((w) => ({
+                        name: w.name,
+                        value: w.value,
+                        commit: w.commit_hash?.slice(0, 7) ?? null,
+                    })),
+                })),
+            });
+            recordRead(db, "atlas_file_context", pf, servedCharsOf(salida), Date.now() - t0);
             return salida;
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "changebook",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "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.3",
+  "version": "0.4.4",
   "websiteUrl": "https://changebook.dev",
   "remotes": [
     {
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "changebook",
-      "version": "0.4.3",
+      "version": "0.4.4",
       "transport": {
         "type": "stdio"
       }