changebook 0.3.2 → 0.4.1

package/dist/tools.js

@@ -55,6 +55,36 @@ function previewExcerpt(excerpt) {
 function day(iso) {
     return iso.slice(0, 10);
 }
+// Pre-edit lookup helpers (mirror of the hosted scope.ts — the npm package
+// must stay self-contained, so these three stay tiny and duplicated).
+// Exported so test/mcpParity.test.ts can pin them equal to the hosted copies:
+// drift would break atlas_file_context on stdio silently (audit M7).
+export function normalizeRepoPath(path) {
+    return path.trim().replace(/^\.\//, "").replace(/^\/+/, "");
+}
+export function fileContainsFilter(path) {
+    return `files=cs.${encodeURIComponent(JSON.stringify([path]))}`;
+}
+export function quotedInList(values) {
+    return values
+        .map((v) => `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`)
+        .join(",");
+}
+// 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) {
+    const projectId = /project_id=eq\.([0-9a-f-]+)/.exec(projectFilter)?.[1] ?? null;
+    void db
+        .insertRow("atlas_reads", {
+        project_id: projectId,
+        tool,
+        source: "stdio",
+        chars_served: charsServed,
+    })
+        .catch(() => { });
+}
 /** PostgREST `or=(...ilike...)` needs the pattern URL-encoded once. */
 function ilikePattern(search) {
     return encodeURIComponent(`*${search.replace(/[%*,()]/g, " ").trim()}*`);
@@ -71,6 +101,7 @@ Args:
   - limit (1-50, default 10): entries to return.
   - offset (default 0): pagination offset.
   - 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, summary_tech, diff_chars, modules: [{ module, risk }] }] }
 
@@ -82,6 +113,8 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
                 .describe("Pagination offset"),
             search: z.string().min(2).max(120).optional()
                 .describe("Case-insensitive filter over summaries"),
+            project: z.string().min(1).max(120).optional()
+                .describe("Project to scope to (repo folder name or slug)"),
         },
         annotations: {
             readOnlyHint: true,
@@ -89,11 +122,12 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
             idempotentHint: true,
             openWorldHint: true,
         },
-    }, async ({ limit, offset, search }) => {
+    }, async ({ limit, offset, search, project }) => {
         try {
+            const pf = await db.projectFilterFor(project);
             let query = `changelog?select=id,business_impact,summary_tech,created_at,diff_character_count` +
                 `&order=created_at.desc&limit=${limit}&offset=${offset}` +
-                (await db.projectFilter());
+                pf;
             if (search) {
                 const p = ilikePattern(search);
                 query += `&or=(business_impact.ilike.${p},summary_tech.ilike.${p})`;
@@ -148,7 +182,9 @@ Don't use for per-module deep dives — use atlas_module_detail for that.`,
                     ? `No changes match "${search}". Try a broader search or omit it.`
                     : "No analyzed changes yet. Analyze a diff from the ChangeBook extension first.");
             }
-            return toolResult(lines.join("\n"), output);
+            const changesText = lines.join("\n");
+            recordRead(db, "atlas_recent_changes", pf, changesText.length);
+            return toolResult(changesText, output);
         }
         catch (error) {
             return errorResult(error);
@@ -162,11 +198,14 @@ For each module: domain, category, latest risk level, number of analyzed changes
 
 Args:
   - domain (optional): filter by domain (e.g. "billing").
+  - 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, modules: [{ module, domain, category, risk, changes, last_changed, files }] }`,
         inputSchema: {
             domain: z.string().min(1).max(80).optional()
                 .describe("Only modules in this domain"),
+            project: z.string().min(1).max(120).optional()
+                .describe("Project to scope to (repo folder name or slug)"),
         },
         annotations: {
             readOnlyHint: true,
@@ -174,14 +213,15 @@ Returns (structured): { count, modules: [{ module, domain, category, risk, chang
             idempotentHint: true,
             openWorldHint: true,
         },
-    }, async ({ domain }) => {
+    }, async ({ domain, project }) => {
         try {
+            const pf = await db.projectFilterFor(project);
             let query = 
             // The aggregation below uses only these columns; note/tech/excerpt
             // (up to ~1.5k each × 1000 rows) would move 1-2 MB per call for nothing.
             `change_module?select=module,domain,category,risk,files,created_at` +
                 `&order=created_at.desc&limit=1000` +
-                (await db.projectFilter());
+                pf;
             if (domain)
                 query += `&domain=eq.${encodeURIComponent(domain)}`;
             const rows = await db.rest(query);
@@ -219,7 +259,9 @@ Returns (structured): { count, modules: [{ module, domain, category, risk, chang
                     ? `No modules in domain "${domain}". Call atlas_modules without a domain to see all.`
                     : "No modules yet. Analyze a diff from the ChangeBook extension first.");
             }
-            return toolResult(lines.join("\n"), output);
+            const modulesText = lines.join("\n");
+            recordRead(db, "atlas_modules", pf, modulesText.length);
+            return toolResult(modulesText, output);
         }
         catch (error) {
             return errorResult(error);
@@ -236,6 +278,7 @@ Args:
   - limit (1-20, default 5): number of recent changes to include.
   - include_excerpts (default true): include diff excerpts (short previews unless full is set).
   - full (default false): return the diff excerpts verbatim instead of the token-saving previews. Only pass it when you actually need the code lines.
+  - 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): { module, count, changes: [{ date, risk, note, tech, files, business_impact, excerpt, excerpt_truncated }] }`,
         inputSchema: {
@@ -247,6 +290,8 @@ Returns (structured): { module, count, changes: [{ date, risk, note, tech, files
                 .describe("Include diff excerpts (previews unless full)"),
             full: z.boolean().default(false)
                 .describe("Verbatim excerpts instead of short previews"),
+            project: z.string().min(1).max(120).optional()
+                .describe("Project to scope to (repo folder name or slug)"),
         },
         annotations: {
             readOnlyHint: true,
@@ -254,11 +299,12 @@ Returns (structured): { module, count, changes: [{ date, risk, note, tech, files
             idempotentHint: true,
             openWorldHint: true,
         },
-    }, async ({ module, limit, include_excerpts, full }) => {
+    }, async ({ module, limit, include_excerpts, full, project }) => {
         try {
+            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}` +
-                (await db.projectFilter()));
+                pf);
             if (rows.length === 0) {
                 return {
                     content: [
@@ -328,7 +374,98 @@ Returns (structured): { module, count, changes: [{ date, risk, note, tech, files
                 }
                 lines.push("");
             }
-            return toolResult(lines.join("\n"), output);
+            const detailText = lines.join("\n");
+            recordRead(db, "atlas_module_detail", pf, detailText.length);
+            return toolResult(detailText, output);
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+    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.
+
+Call this BEFORE editing a file — one cheap call instead of re-reading the code and its git history.
+
+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 }] }`,
+        inputSchema: {
+            files: z.array(z.string().min(1).max(300)).min(1).max(8)
+                .describe("Repo-relative paths you are about to edit"),
+            project: z.string().min(1).max(120).optional()
+                .describe("Project to scope to (repo folder name or slug)"),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ files, project }) => {
+        try {
+            const pf = await db.projectFilterFor(project);
+            const paths = [...new Set(files.map(normalizeRepoPath).filter(Boolean))];
+            const perFile = await Promise.all(paths.map(async (file) => {
+                const rows = await db.rest(`change_module?select=module,risk,note,created_at&${fileContainsFilter(file)}&order=created_at.desc&limit=20` +
+                    pf);
+                const byModule = new Map();
+                for (const row of rows) {
+                    const name = (row.module ?? "").trim();
+                    if (!name)
+                        continue;
+                    const existing = byModule.get(name);
+                    if (existing)
+                        existing.changes += 1;
+                    else {
+                        byModule.set(name, {
+                            module: name,
+                            risk: row.risk,
+                            changes: 1,
+                            last_changed: day(row.created_at),
+                            last_note: row.note,
+                        });
+                    }
+                }
+                return { file, modules: [...byModule.values()] };
+            }));
+            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&resolved_at=is.null&module=in.(${encodeURIComponent(quotedInList(moduleNames))})&order=created_at.desc&limit=10` +
+                    pf)
+                : [];
+            const alertsByModule = new Map();
+            for (const a of alerts) {
+                const m = (a.module ?? "").trim();
+                if (!m || !a.plain)
+                    continue;
+                alertsByModule.set(m, [...(alertsByModule.get(m) ?? []), a.plain]);
+            }
+            const lines = [`# File context (${paths.length} file(s))`, ""];
+            for (const f of perFile) {
+                lines.push(`## ${f.file}`);
+                if (f.modules.length === 0) {
+                    lines.push("No atlas history for this file yet (new or never analyzed).");
+                }
+                for (const m of f.modules) {
+                    lines.push(`- Module **${m.module}** — ${m.changes} change(s), last ${m.last_changed}` +
+                        (m.risk ? `, risk: ${m.risk}` : ""));
+                    if (m.last_note)
+                        lines.push(`  - Latest note: ${m.last_note}`);
+                    for (const plain of alertsByModule.get(m.module) ?? []) {
+                        lines.push(`  - ⚠ OPEN ALERT: ${plain}`);
+                    }
+                }
+                lines.push("");
+            }
+            const contextText = lines.join("\n");
+            recordRead(db, "atlas_file_context", pf, contextText.length);
+            return toolResult(contextText, { files: perFile });
         }
         catch (error) {
             return errorResult(error);

package/package.json

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