weavatrix 0.1.0 → 0.1.2

package/src/analysis/internal-audit.run.js

@@ -15,21 +15,24 @@ import { matchAdvisories } from "../security/match.js";
 import { scanMalware } from "../security/malware-heuristics.js";
 import { classifyTyposquat } from "../security/typosquat.js";
 import {
-  readText, readJson, collectSourceTexts, collectConfigTexts, workspacePkgNames,
+  readJson, readRepoText, readRepoJson, collectSourceTexts, collectConfigTexts, workspacePkgNames,
   collectPyManifest, TEST_FILE_RE,
 } from "./internal-audit.collect.js";
 import { entryFiles, computeReachability } from "./internal-audit.reach.js";
+import { createRepoBoundary } from "../repo-path.js";
 
 // Run the internal audit. graph is optional (loaded from the repo's central graph.json when absent);
 // advisoryStorePath overrides the default ~/.weavatrix/advisories.json (tests use a scratch path).
 // async because the malware sweep shells out to ripgrep.
 export async function runInternalAudit(repoPath, { graph, advisoryStorePath, skipMalwareScan = false, malwareExclusions = {}, rgPath = "" } = {}) {
   if (!existsSync(repoPath)) return { ok: false, error: "Repo path not found" };
+  const boundary = createRepoBoundary(repoPath);
+  if (!boundary.root) return { ok: false, error: "Repository path is unreadable" };
   if (!graph) {
     graph = readJson(join(graphOutDirForRepo(repoPath), "graph.json"));
     if (!graph) return { ok: false, error: "Build the graph first (no graph.json)" };
   }
-  const pkg = readJson(join(repoPath, "package.json")) || {};
+  const pkg = readRepoJson(boundary, "package.json") || {};
   const externalImports = graph.externalImports || [];
   const dynamicTargets = new Set(externalImports.filter((e) => e.dynamic && e.target).map((e) => e.target));
 
@@ -43,13 +46,13 @@ export async function runInternalAudit(repoPath, { graph, advisoryStorePath, ski
   const configTexts = collectConfigTexts(repoPath);
   const dep = computeDepFindings({ externalImports, pkg, workspacePkgNames: workspacePkgNames(repoPath, pkg), configTexts });
   // non-npm ecosystems: Go (go.mod) + Python (requirements/pyproject/Pipfile) — same findings shape
-  const goModText = readText(join(repoPath, "go.mod"));
+  const goModText = readRepoText(boundary, "go.mod");
   const goDep = computeGoDepFindings({ externalImports, goMod: goModText != null ? parseGoMod(goModText) : null });
   const pyDep = computePyDepFindings({ externalImports, pyManifest: collectPyManifest(repoPath), configTexts });
 
   // structure: cycles / orphans / boundary rules. Rules come from the repo's optional .weavatrix-deps.json
   // (the depcruise-config analogue); no bundled default rules — cycles+orphans are always on.
-  const rules = readJson(join(repoPath, ".weavatrix-deps.json")) || {};
+  const rules = readRepoJson(boundary, ".weavatrix-deps.json") || {};
   const externalImportFiles = new Set(externalImports.filter((e) => e.pkg && !e.builtin).map((e) => e.file));
   const structure = computeStructureFindings(graph, { rules, entrySet: entries, externalImportFiles });
 
@@ -175,7 +178,7 @@ export async function runInternalAudit(repoPath, { graph, advisoryStorePath, ski
       symbols: dead.stats.symbols,
       manifestDeps: dep.declared.size + goDep.declared.size + pyDep.declared.size,
       externalImports: externalImports.length,
-      nodeModulesPresent: existsSync(join(repoPath, "node_modules")),
+      nodeModulesPresent: boundary.resolve("node_modules").ok,
       installedPackages: installedCount,
       advisoryDbDate,
       malwareScanMode: malwareScan?.scanMode || "skipped",

package/src/build-graph.js

@@ -9,6 +9,7 @@
 import { existsSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { Worker } from "node:worker_threads";
+import { childProcessEnv } from "./child-env.js";
 import { graphOutDirForRepo, repoTopFolders, summarizeCommunities, summarizeHotspots, filterGraphForMode, filterGraphByScope } from "./graph/layout.js";
 
 // The worker path deadlocks web-tree-sitter's WASM in Electron's worker threads (fine in plain Node) — off
@@ -25,7 +26,7 @@ function buildGraphInWorker(payload) {
   return new Promise((resolve, reject) => {
     let worker;
     try {
-      worker = new Worker(new URL("./graph/build-worker.js", import.meta.url), { workerData: payload });
+      worker = new Worker(new URL("./graph/build-worker.js", import.meta.url), { workerData: payload, env: childProcessEnv() });
     } catch (e) {
       reject(Object.assign(e, { workerStartFailed: true }));
       return;

package/src/child-env.js

@@ -0,0 +1,7 @@
+// Child processes and worker threads do not need the hosted-sync bearer token.
+// Keep it in the MCP process so only sync_graph can attach it to an HTTP request.
+export function childProcessEnv(overrides = {}) {
+  const env = { ...process.env, ...overrides };
+  delete env.WEAVATRIX_SYNC_TOKEN;
+  return env;
+}

package/src/graph/internal-builder.build.js

@@ -11,13 +11,16 @@ import { buildResolvers } from "./internal-builder.resolvers.js";
 
 // Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
 export async function buildInternalGraph(repoDir, opts = {}) {
-  const langs = await ensureParser(opts);
+  const files = walk(repoDir);
+  // Lazy grammar loading: compile only the WASMs for languages this repo actually contains.
+  const wanted = new Set();
+  for (const f of files) { const g = EXT_LANG[extname(f)]; if (g) wanted.add(g); }
+  const langs = await ensureParser(opts, wanted);
   const qc = new Map();
   const q = (grammar, src) => { const k = grammar + ":" + src; if (qc.has(k)) return qc.get(k); let x = null; try { x = new Query(langs[grammar], src); } catch { x = null; } qc.set(k, x); return x; };
   const caps = (grammar, src, root) => { const query = src && q(grammar, src); return query ? query.captures(root) : []; };
   const field = (n, f) => (n && n.childForFieldName ? n.childForFieldName(f) : null);
 
-  const files = walk(repoDir);
   const rel = (p) => relative(repoDir, p).replace(/\\/g, "/");
   const fileSet = new Set(files.map(rel));
   const nodes = []; const links = []; const nodeIds = new Set(); const nodeById = new Map();
@@ -203,7 +206,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
 
   // extImportsV: bump when the externalImports schema/coverage changes (v2 = go/python ecosystems) —
   // deps-engine rebuilds in memory when a saved graph is older than this.
-  return { nodes, links, externalImports, extImportsV: 2, complexityV: 1 };
+  return { nodes, links, externalImports, extImportsV: 2, complexityV: 1, repoBoundaryV: 1 };
 }
 
 // Build + write graph.json to outPath (creating the dir). Returns { ok, nodes, links, graphJson }.

package/src/graph/internal-builder.langs.js

@@ -6,6 +6,7 @@
 import { readdirSync, statSync, realpathSync } from "node:fs";
 import { join, extname, dirname } from "node:path";
 import { createRequire } from "node:module";
+import { isPathInside } from "../repo-path.js";
 import LANG_JS from "./builder/lang-js.js";
 import LANG_PY from "./builder/lang-python.js";
 import LANG_GO from "./builder/lang-go.js";
@@ -52,20 +53,26 @@ const MAX_PARSE_BYTES = 1_500_000;   // skip parsing files above this (minified
 
 let _ready = null;
 const _langs = {};
-async function ensureParser(opts = {}) {
+// `wanted` (a Set of grammar names) makes loading LAZY: only grammars for extensions actually present
+// in the repo get compiled. The heavy WASMs (rust ~3MB, c_sharp ~4MB) cost seconds to compile — a tax
+// a JS-only repo must never pay. Omit `wanted` to load everything (old behavior).
+async function ensureParser(opts = {}, wanted = null) {
   if (!_ready) _ready = Parser.init({ locateFile: () => opts.runtimeWasm || DEFAULT_RUNTIME_WASM });
   await _ready;
   const wasmDir = opts.wasmDir || DEFAULT_WASM_DIR;
-  for (const g of GRAMMARS) if (!_langs[g]) { try { _langs[g] = await Language.load(join(wasmDir, `tree-sitter-${g}.wasm`)); } catch { _langs[g] = null; } }
+  const list = wanted ? GRAMMARS.filter((g) => wanted.has(g)) : GRAMMARS;
+  for (const g of list) if (!_langs[g]) { try { _langs[g] = await Language.load(join(wasmDir, `tree-sitter-${g}.wasm`)); } catch { _langs[g] = null; } }
   return _langs;
 }
 
 // Cycle-safe directory walk. statSync FOLLOWS symlinks/junctions, so a link pointing at an ancestor would
 // otherwise recurse forever (a/b/link/b/link/…). We dedupe by REAL path (a visited dir is never re-entered)
 // and cap depth as a backstop, so a symlink loop can't wedge the build.
-function walk(dir, acc = [], seen = new Set(), depth = 0) {
+function walk(dir, acc = [], seen = new Set(), depth = 0, rootReal = null) {
   if (depth > 40) return acc;
-  let real; try { real = realpathSync.native(dir); } catch { real = dir; }
+  let real; try { real = realpathSync.native(dir); } catch { return acc; }
+  if (rootReal == null) rootReal = real;
+  if (!isPathInside(rootReal, real)) return acc;
   if (seen.has(real)) return acc;
   seen.add(real);
   let entries;
@@ -76,9 +83,13 @@ function walk(dir, acc = [], seen = new Set(), depth = 0) {
     // never match AGENT_DOTFILE, so we still never recurse into them (.git/.github/.cursor stay out).
     if (name.startsWith(".") && !AGENT_DOTFILE.test(name)) continue;
     const full = join(dir, name);
+    let entryReal; try { entryReal = realpathSync.native(full); } catch { continue; }
+    if (!isPathInside(rootReal, entryReal)) continue;
     let st; try { st = statSync(full); } catch { continue; }
-    if (st.isDirectory()) walk(full, acc, seen, depth + 1);
-    else { const e = extname(name); if ((EXT_LANG[e] && _langs[EXT_LANG[e]]) || isDataFile(name) || isDocFile(name)) acc.push(full); }
+    if (st.isDirectory()) walk(full, acc, seen, depth + 1, rootReal);
+    // include by KNOWN extension, not by loaded grammar — grammars now load lazily AFTER the walk
+    // (the parse passes skip files whose grammar failed to load, so the guarantee is unchanged)
+    else { const e = extname(name); if (EXT_LANG[e] || isDataFile(name) || isDocFile(name)) acc.push(full); }
   }
   return acc;
 }

package/src/graph/internal-builder.resolvers.js

@@ -4,14 +4,21 @@
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { parseGoMod } from "../analysis/manifests.js";
+import { createRepoBoundary } from "../repo-path.js";
 
 export function buildResolvers(repoDir, fileSet) {
+  const boundary = createRepoBoundary(repoDir);
+  const readLocal = (relativePath) => {
+    const resolved = boundary.resolve(relativePath);
+    if (!resolved.ok) throw new Error("resolver input is outside the repository");
+    return readFileSync(resolved.path, "utf8");
+  };
   // Go package = directory (resolved via go.mod module prefix); Java class = file (basename index).
   // go.mod requires also feed goSpecToPkg so external Go imports map to their declared module.
   let goModule = "";
   let goRequires = [];
   try {
-    const gomod = parseGoMod(readFileSync(join(repoDir, "go.mod"), "utf8"));
+    const gomod = parseGoMod(readLocal("go.mod"));
     goModule = gomod.module;
     goRequires = gomod.requires.map((r) => r.path);
   } catch { /* no go.mod */ }
@@ -51,7 +58,7 @@ export function buildResolvers(repoDir, fileSet) {
   const jsBaseUrls = []; // tsconfig/jsconfig baseUrl roots — bare "components/Button" may be baseUrl-rooted, not an npm package
   for (const cfg of ["tsconfig.json", "tsconfig.app.json", "tsconfig.base.json", "jsconfig.json"]) {
     try {
-      const raw = readFileSync(join(repoDir, cfg), "utf8").replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+      const raw = readLocal(cfg).replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
       const tj = JSON.parse(raw); const co = tj.compilerOptions || {}; const paths = co.paths || {};
       const baseUrl = String(co.baseUrl || ".").replace(/^\.\/?/, "").replace(/\/$/, "");
       if (co.baseUrl != null && !jsBaseUrls.includes(baseUrl)) jsBaseUrls.push(baseUrl);
@@ -59,7 +66,7 @@ export function buildResolvers(repoDir, fileSet) {
     } catch { /* no/invalid tsconfig */ }
   }
   for (const vc of ["vite.config.ts", "vite.config.js", "vite.config.mjs", "webpack.config.js"]) {
-    try { const src = readFileSync(join(repoDir, vc), "utf8"); for (const m of src.matchAll(/['"`]([^'"`]+)['"`]\s*:\s*path\.resolve\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g)) addAlias(m[1], m[2]); } catch { /* no bundler config */ }
+    try { const src = readLocal(vc); for (const m of src.matchAll(/['"`]([^'"`]+)['"`]\s*:\s*path\.resolve\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g)) addAlias(m[1], m[2]); } catch { /* no bundler config */ }
   }
   aliasList.sort((a, b) => b.alias.length - a.alias.length);
   const resolveAlias = (spec) => { for (const { alias, target } of aliasList) { if (spec === alias) return target; if (spec.startsWith(alias + "/")) return target + spec.slice(alias.length); } return null; };

package/src/mcp/catalog.mjs

@@ -11,6 +11,7 @@ import {readSource, searchCode} from '../mcp-source-tools.mjs'
 
 const SELF_DIR = dirname(fileURLToPath(import.meta.url))
 const resolveRg = createRgResolver(SELF_DIR)
+export const DEFAULT_CAPS = Object.freeze(['graph', 'search', 'source', 'health', 'build', 'retarget'])
 
 // The files whose mtime the stdio shell watches for hot reload — keep in sync with the imports in
 // loadHotApi below (catalog.mjs itself is last: a change here re-derives the whole table).
@@ -37,16 +38,16 @@ function buildTools({tg, ti, th, ta}) {
         {cap: 'source', name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux …): method, path, handler, and file:line, deduped across code and OpenAPI docs.', inputSchema: {type: 'object', properties: {max_results: {type: 'integer', description: 'Max endpoints to list, default 100'}}}, run: (g, a, ctx) => th.tListEndpoints(g, a, ctx)},
         {cap: 'build', name: 'rebuild_graph', description: "Rebuild this repo's code graph from current source (weavatrix's own web-tree-sitter builder), reload it in-memory, and report the STRUCTURAL DELTA vs the previous state — new/removed module dependencies, cycle changes, newly orphaned symbols. The prior state is saved as graph.prev.json for graph_diff. Call after significant edits.", inputSchema: {type: 'object', properties: {mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], default: 'full'}, scope: {type: 'string', description: 'optional path prefix to limit the graph'}}}, run: (g, a, ctx) => ta.tRebuildGraph(g, a, ctx)},
         {cap: 'graph', name: 'graph_diff', description: 'Structural diff of the last rebuild: previous graph state (graph.prev.json, saved by rebuild_graph) vs current — architecture drift (new module dependencies), broken or introduced import cycles, symbols that lost their last caller. The semantic complement to the textual git diff for validating a refactor.', inputSchema: {type: 'object', properties: {path: {type: 'string', description: 'Optional node-id/path prefix to scope the diff, e.g. src/query'}}}, run: (g, a, ctx) => ti.tGraphDiff(g, a, ctx)},
-        {cap: 'build', name: 'open_repo', description: 'Retarget this server at another local repository: loads its graph from the central weavatrix-graphs layout next to the repo, building it first when missing (large repos can take minutes; pass build:false to probe without building). Afterwards every tool answers for the new repo.', inputSchema: {type: 'object', properties: {path: {type: 'string', description: 'Absolute path to the repository folder'}, build: {type: 'boolean', description: 'Build the graph when missing (default true)', default: true}, mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], default: 'full'}}, required: ['path']}, run: (g, a, ctx) => ta.tOpenRepo(g, a, ctx)},
-        {cap: 'graph', name: 'list_known_repos', description: 'List sibling repositories that already have a built graph in the central weavatrix-graphs folder next to the current repo — ready targets for open_repo.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tListKnownRepos(g, a, ctx)},
+        {cap: 'retarget', name: 'open_repo', description: 'OFFLINE RETARGET: switch this server to another local Git repository, building its graph when missing. This explicit tool call changes the active repository boundary; pass build:false to probe without building. Omit the retarget capability at registration to pin one repository.', inputSchema: {type: 'object', properties: {path: {type: 'string', description: 'Absolute path to a Git working tree'}, build: {type: 'boolean', description: 'Build the graph when missing (default true)', default: true}, mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], default: 'full'}}, required: ['path']}, run: (g, a, ctx) => ta.tOpenRepo(g, a, ctx)},
+        {cap: 'retarget', name: 'list_known_repos', description: 'OFFLINE RETARGET: list sibling repositories with existing graphs that can be selected through open_repo.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tListKnownRepos(g, a, ctx)},
         {cap: 'online', name: 'refresh_advisories', description: "ONLINE, explicit opt-in: refresh the local OSV advisory store for this repo's lockfile-pinned packages (npm/PyPI/Go). Sends package names + versions to OSV.dev — never automatic, never source code. Afterwards run_audit reads the refreshed store fully offline (~/.weavatrix/advisories.json).", inputSchema: {type: 'object', properties: {timeout_ms: {type: 'integer', description: 'Per-request timeout, default 20000'}}}, run: (g, a, ctx) => ta.tRefreshAdvisories(g, a, ctx)},
-        {cap: 'online', name: 'sync_graph', description: 'ONLINE, explicit opt-in, off until configured: push the current graph.json to your weavatrix site or self-hosted endpoint (env WEAVATRIX_SYNC_URL, optional WEAVATRIX_SYNC_TOKEN bearer auth) for a hosted graph view. Payload is the graph only — file paths, symbol names, edges — never file contents.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tSyncGraph(g, a, ctx)},
+        {cap: 'online', name: 'sync_graph', description: 'ONLINE, explicit opt-in, off until configured: send a versioned allowlist of graph metadata to an endpoint you configure (env WEAVATRIX_SYNC_URL, optional WEAVATRIX_SYNC_TOKEN bearer auth). Unknown graph fields are discarded and source file bodies are not read for sync. Graphs built before 0.1.2 must be rebuilt once before syncing.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tSyncGraph(g, a, ctx)},
     ]
 }
 
 // Import the tool modules (cache-busted when version > 0), build the catalog, apply the caps filter.
-// capsArg semantics: undefined/null = no per-repo config → ALL tools; a present string (even '') is an
-// explicit selection → expose exactly those groups, so "select nothing" really exposes nothing.
+// capsArg semantics: undefined/null = offline defaults (including explicit-call repo retargeting); a
+// present string (even '') is an explicit selection, so "select nothing" really exposes nothing.
 export async function loadHotApi(version, capsArg) {
     const v = version ? `?v=${version}` : ''
     const [tg, ti, th, ta] = await Promise.all([
@@ -56,8 +57,9 @@ export async function loadHotApi(version, capsArg) {
         import(new URL(`./tools-actions.mjs${v}`, import.meta.url).href),
     ])
     const all = buildTools({tg, ti, th, ta})
-    const caps = capsArg == null ? null : new Set(String(capsArg).split(',').map((s) => s.trim()).filter(Boolean))
-    const tools = caps ? all.filter((t) => caps.has(t.cap)) : all
+    const selected = capsArg == null ? DEFAULT_CAPS : String(capsArg).split(',').map((s) => s.trim()).filter(Boolean)
+    const caps = new Set(selected)
+    const tools = all.filter((t) => caps.has(t.cap))
     return {
         tools,
         byName: new Map(tools.map((t) => [t.name, t])),

package/src/mcp/graph-context.mjs

@@ -5,7 +5,9 @@
 import {readFileSync, statSync} from 'node:fs'
 import {join} from 'node:path'
 import {spawnSync} from 'node:child_process'
+import {childProcessEnv} from '../child-env.js'
 import {buildFileImportGraph, findSccs} from '../analysis/dep-rules.js'
+import {resolveRepoPath} from '../repo-path.js'
 
 // ---- graph load + indexes -----------------------------------------------------------------------
 export function loadGraph(path) {
@@ -34,7 +36,7 @@ export function loadGraph(path) {
         push(out, s, {id: t, relation: e.relation, confidence: e.confidence})
         push(inn, t, {id: s, relation: e.relation, confidence: e.confidence})
     }
-    return {nodes, links, byId, byLabel, out, inn}
+    return {nodes, links, byId, byLabel, out, inn, repoBoundaryV: Number(raw.repoBoundaryV) || 0}
 }
 
 export const isSymbol = (id) => String(id).includes('#')
@@ -123,13 +125,13 @@ export function graphStaleness(ctx) {
     try { info.builtAt = statSync(ctx.graphPath).mtime } catch { /* no graph file — nothing to report */ }
     if (ctx.repoRoot && info.builtAt) {
         try {
-            const head = spawnSync('git', ['-C', ctx.repoRoot, 'log', '-1', '--format=%cI'], {encoding: 'utf8', timeout: 4000})
+            const head = spawnSync('git', ['-C', ctx.repoRoot, 'log', '-1', '--format=%cI'], {encoding: 'utf8', timeout: 4000, env: childProcessEnv()})
             const iso = (head.stdout || '').trim()
             if (head.status === 0 && iso) {
                 info.headAt = new Date(iso)
                 if (info.headAt > info.builtAt) {
                     info.stale = true
-                    const cnt = spawnSync('git', ['-C', ctx.repoRoot, 'rev-list', '--count', `--since=${info.builtAt.toISOString()}`, 'HEAD'], {encoding: 'utf8', timeout: 4000})
+                    const cnt = spawnSync('git', ['-C', ctx.repoRoot, 'rev-list', '--count', `--since=${info.builtAt.toISOString()}`, 'HEAD'], {encoding: 'utf8', timeout: 4000, env: childProcessEnv()})
                     if (cnt.status === 0) info.behind = Number(cnt.stdout.trim()) || null
                 }
             }
@@ -138,7 +140,7 @@ export function graphStaleness(ctx) {
         // they edit, then re-query). Count dirty files actually TOUCHED after the build — a dirty file
         // older than the graph was already part of it.
         try {
-            const st = spawnSync('git', ['-C', ctx.repoRoot, 'status', '--porcelain'], {encoding: 'utf8', timeout: 4000})
+            const st = spawnSync('git', ['-C', ctx.repoRoot, 'status', '--porcelain'], {encoding: 'utf8', timeout: 4000, env: childProcessEnv()})
             if (st.status === 0) {
                 let newer = 0
                 for (const ln of String(st.stdout || '').split(/\r?\n/).filter(Boolean).slice(0, 200)) {
@@ -170,7 +172,8 @@ export function fileStalenessNote(ctx, sourceFile) {
     const s = graphStaleness(ctx)
     if (!s.builtAt) return null
     try {
-        if (statSync(join(ctx.repoRoot, String(sourceFile))).mtime > s.builtAt) {
+        const resolved = resolveRepoPath(ctx.repoRoot, String(sourceFile))
+        if (resolved.ok && statSync(resolved.path).mtime > s.builtAt) {
             return `Note: ${sourceFile} changed after the graph was built — line numbers above may have drifted (rebuild_graph refreshes them).`
         }
     } catch { /* file gone — the read tools will surface that themselves */ }

package/src/mcp/sync-payload.mjs

@@ -0,0 +1,102 @@
+// Versioned, explicit wire schema for sync_graph. Never forward graph.json wholesale: it is a local
+// cache file and may contain future fields or attacker-injected data that are not safe to upload.
+
+const CONTROL_CHARS = /[\u0000-\u001f\u007f]/;
+
+function metadataString(value, max = 4096) {
+    return typeof value === 'string' && value.length > 0 && value.length <= max && !CONTROL_CHARS.test(value)
+        ? value
+        : undefined;
+}
+
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function setIf(out, key, value) {
+    if (value !== undefined) out[key] = value;
+}
+
+const COMPLEXITY_NUMBERS = [
+    'startLine', 'endLine', 'loc', 'params', 'objectFields', 'branches', 'cyclomatic',
+    'loops', 'maxLoopDepth', 'returns', 'awaits', 'callCount', 'externalCalls',
+    'asyncBoundaries', 'allocations', 'objectLiterals', 'spreadCopies', 'sorts',
+    'linearOps', 'timeRank', 'timeScore', 'memoryRank', 'memoryScore',
+];
+
+function sanitizeComplexity(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+    const out = {};
+    for (const key of COMPLEXITY_NUMBERS) setIf(out, key, finiteNumber(value[key]));
+    if (typeof value.recursion === 'boolean') out.recursion = value.recursion;
+    for (const key of ['family', 'scope', 'complexityScope', 'confidence']) {
+        setIf(out, key, metadataString(value[key], 32));
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+
+function sanitizeNode(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const id = metadataString(value.id);
+    if (!id) return null;
+    const out = {id};
+    setIf(out, 'label', metadataString(value.label, 1024));
+    setIf(out, 'file_type', metadataString(value.file_type, 32));
+    setIf(out, 'source_file', metadataString(value.source_file));
+    const sourceLocation = metadataString(value.source_location, 32);
+    const sourceEnd = metadataString(value.source_end, 32);
+    if (sourceLocation && /^L\d+$/.test(sourceLocation)) out.source_location = sourceLocation;
+    if (sourceEnd && /^L\d+$/.test(sourceEnd)) out.source_end = sourceEnd;
+    const community = finiteNumber(value.community);
+    if (community !== undefined && Number.isInteger(community) && community >= 0) out.community = community;
+    if (typeof value.exported === 'boolean') out.exported = value.exported;
+    if (typeof value.decorated === 'boolean') out.decorated = value.decorated;
+    setIf(out, 'complexity', sanitizeComplexity(value.complexity));
+    return out;
+}
+
+function sanitizeLink(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const source = metadataString(value.source);
+    const target = metadataString(value.target);
+    if (!source || !target) return null;
+    const out = {source, target};
+    setIf(out, 'relation', metadataString(value.relation, 32));
+    setIf(out, 'confidence', metadataString(value.confidence, 32));
+    return out;
+}
+
+function sanitizeExternalImport(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const file = metadataString(value.file);
+    if (!file) return null;
+    const out = {file};
+    for (const key of ['spec', 'target']) setIf(out, key, metadataString(value[key]));
+    for (const key of ['pkg', 'kind', 'ecosystem']) setIf(out, key, metadataString(value[key], 256));
+    const line = finiteNumber(value.line);
+    if (line !== undefined && Number.isInteger(line) && line >= 0) out.line = line;
+    for (const key of ['builtin', 'dynamic', 'unresolved']) {
+        if (typeof value[key] === 'boolean') out[key] = value[key];
+    }
+    return out;
+}
+
+export function createSyncPayload(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw) || raw.repoBoundaryV !== 1) {
+        throw new Error('graph predates repository-boundary hardening');
+    }
+    const nodes = Array.isArray(raw.nodes) ? raw.nodes.map(sanitizeNode).filter(Boolean) : [];
+    const links = Array.isArray(raw.links) ? raw.links.map(sanitizeLink).filter(Boolean) : [];
+    const externalImports = Array.isArray(raw.externalImports)
+        ? raw.externalImports.map(sanitizeExternalImport).filter(Boolean)
+        : [];
+    return {
+        syncPayloadV: 1,
+        repoBoundaryV: 1,
+        extImportsV: Number.isInteger(raw.extImportsV) ? raw.extImportsV : 0,
+        complexityV: Number.isInteger(raw.complexityV) ? raw.complexityV : 0,
+        nodes,
+        links,
+        externalImports,
+    };
+}

package/src/mcp/tools-actions.mjs

@@ -1,13 +1,14 @@
-// Action tools: rebuild the graph, retarget the server at another repo, list sibling repos with
-// built graphs — plus the 'online' capability group (the ONLY tools that ever touch the network).
+// Action tools: rebuild the graph, the explicit 'retarget' group, and the explicit 'online' group
+// (the ONLY tools that ever touch the network).
 // Hot-reloadable (re-imported by catalog.mjs on change).
-import {readFileSync, writeFileSync, existsSync, readdirSync, statSync} from 'node:fs'
-import {join, dirname} from 'node:path'
+import {readFileSync, writeFileSync, existsSync, readdirSync, statSync, realpathSync} from 'node:fs'
+import {join, dirname, isAbsolute} from 'node:path'
 import {prevGraphPathFor, diffGraphs, formatGraphDiff} from './graph-context.mjs'
 import {buildGraphForRepo} from '../build-graph.js'
 import {graphOutDirForRepo} from '../graph/layout.js'
 import {refreshAdvisories, storeMeta, DEFAULT_STORE} from '../security/advisory-store.js'
 import {collectInstalled} from '../security/installed.js'
+import {createSyncPayload} from './sync-payload.mjs'
 
 export async function tRebuildGraph(g, args, ctx) {
     if (!ctx.repoRoot) return 'Rebuild needs the repo root (not provided to this server).'
@@ -31,9 +32,13 @@ export async function tRebuildGraph(g, args, ctx) {
 // repo. Loads <parent>/weavatrix-graphs/<name>/graph.json (the central layout graphs
 // always live in), building it first when missing. On a failed load the previous repo stays active.
 export async function tOpenRepo(g, args, ctx) {
-    const repoPath = String(args.path || '').trim().replace(/[\\/]+$/, '')
-    if (!repoPath) return 'Provide "path" — an absolute path to a local repository folder.'
-    if (!existsSync(repoPath)) return `Path not found: ${repoPath}`
+    const requestedPath = String(args.path || '').trim()
+    if (!requestedPath) return 'Provide "path" — an absolute path to a local repository folder.'
+    if (!isAbsolute(requestedPath)) return 'open_repo requires an absolute repository path.'
+    let repoPath
+    try { repoPath = realpathSync.native(requestedPath) } catch { return `Path not found: ${requestedPath}` }
+    try { if (!statSync(repoPath).isDirectory()) return `Not a directory: ${requestedPath}` } catch { return `Path not found: ${requestedPath}` }
+    if (!existsSync(join(repoPath, '.git'))) return `Not a Git repository: ${requestedPath}`
     const graphPath = join(graphOutDirForRepo(repoPath), 'graph.json')
     let built = false
     if (!existsSync(graphPath)) {
@@ -101,9 +106,8 @@ export async function tRefreshAdvisories(g, args, ctx) {
     ].filter(Boolean).join('\n')
 }
 
-// Push the current graph.json to a user-configured endpoint (the weavatrix site's hosted graph view,
-// or any self-hosted collector). Off until WEAVATRIX_SYNC_URL is set. The payload is the graph only —
-// file paths, symbol names, and edges — never file contents.
+// Push the current graph.json to a user-configured endpoint. Off until WEAVATRIX_SYNC_URL is set.
+// The payload is graph metadata (paths, symbols/ranges, imports, edges, metrics), never file contents.
 export async function tSyncGraph(g, args, ctx) {
     const url = process.env.WEAVATRIX_SYNC_URL
     if (!url) {
@@ -111,8 +115,13 @@ export async function tSyncGraph(g, args, ctx) {
             + ' (and WEAVATRIX_SYNC_TOKEN for bearer auth) in the MCP registration env, then call again.'
     }
     if (!g) return 'No graph loaded — build one first (open_repo / rebuild_graph).'
-    let body
-    try { body = readFileSync(ctx.graphPath, 'utf8') } catch (e) { return `Cannot read ${ctx.graphPath}: ${e.message}` }
+    let raw
+    try { raw = JSON.parse(readFileSync(ctx.graphPath, 'utf8')) } catch (e) { return `Cannot read ${ctx.graphPath}: ${e.message}` }
+    let payload
+    try { payload = createSyncPayload(raw) } catch {
+        return 'This graph predates repository-boundary hardening. Run rebuild_graph once before sync_graph.'
+    }
+    const body = JSON.stringify(payload)
     const repoName = String(ctx.repoRoot || '').replace(/[\\/]+$/, '').split(/[\\/]/).pop() || 'repo'
     try {
         const res = await fetch(url, {
@@ -125,7 +134,7 @@ export async function tSyncGraph(g, args, ctx) {
             body,
         })
         if (!res.ok) return `Sync endpoint answered HTTP ${res.status} — graph NOT accepted.`
-        return `Graph for ${repoName} (${g.nodes.length} nodes / ${g.links.length} edges, ${Math.round(body.length / 1024)} KB) pushed to ${url}.`
+        return `Graph for ${repoName} (${payload.nodes.length} nodes / ${payload.links.length} edges, ${Math.round(Buffer.byteLength(body) / 1024)} KB) pushed to ${url}.`
     } catch (e) {
         return `Sync failed: ${e.message} — the graph stays local.`
     }

package/src/mcp/tools-impact.mjs

@@ -3,6 +3,7 @@
 // Hot-reloadable (re-imported by catalog.mjs on change).
 import {readFileSync} from 'node:fs'
 import {spawnSync} from 'node:child_process'
+import {childProcessEnv} from '../child-env.js'
 import {
     isSymbol, degreeOf, labelOf, resolveNodeInfo, ambiguityNote,
     rawGraph, prevGraphPathFor, edgeEndpoint, diffGraphs, formatGraphDiff,
@@ -81,7 +82,7 @@ export function tGraphDiff(g, args, ctx) {
 
 // ---- change impact -------------------------------------------------------------------------------
 function gitLines(repoRoot, args) {
-    const res = spawnSync('git', ['-C', repoRoot, ...args], {encoding: 'utf8', timeout: 8000})
+    const res = spawnSync('git', ['-C', repoRoot, ...args], {encoding: 'utf8', timeout: 8000, env: childProcessEnv()})
     if (res.status !== 0) return null
     return String(res.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)
 }
@@ -89,7 +90,7 @@ function gitLines(repoRoot, args) {
 function resolveImpactBase(repoRoot, requested) {
     const candidates = requested ? [requested] : ['origin/HEAD', 'origin/main', 'origin/master', 'main', 'master']
     for (const ref of candidates) {
-        const ok = spawnSync('git', ['-C', repoRoot, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {encoding: 'utf8', timeout: 8000})
+        const ok = spawnSync('git', ['-C', repoRoot, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {encoding: 'utf8', timeout: 8000, env: childProcessEnv()})
         if (ok.status === 0) return ref
     }
     return null

package/src/mcp-rg.mjs

@@ -1,6 +1,7 @@
 import { readdirSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { spawnSync } from 'node:child_process'
+import { childProcessEnv } from './child-env.js'
 import { createRequire } from 'node:module'
 import process from 'node:process'
 
@@ -42,7 +43,7 @@ export function createRgResolver(selfDir) {
         } catch { /* optional packaged ripgrep path */ }
         for (const c of editorRgCandidates()) if (existsSync(c)) return (rgPath = c)
         try {
-            const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {encoding: 'utf8'})
+            const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {encoding: 'utf8', env: childProcessEnv()})
             const p = probe.status === 0 ? probe.stdout.split(/\r?\n/)[0].trim() : ''
             if (p && existsSync(p)) return (rgPath = p)
         } catch { /* optional PATH probe */ }