weavatrix 0.1.2 → 0.1.4

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

@@ -1,5 +1,6 @@
 // Per-repo resolution context shared by the language modules: JS/TS path-aliases + relative imports, Python
-// dotted/relative modules, Go package dirs, Java class files, and web hrefs / the CSS selector index.
+// dotted/relative modules, Go package dirs, Rust crate/module paths, Java class files, and web hrefs /
+// the CSS selector index.
 // (Split from internal-builder.js — see its doc comment for the overall architecture.)
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -47,29 +48,204 @@ export function buildResolvers(repoDir, fileSet) {
     return cands.find((f) => f === full || f.endsWith("/" + full)) || cands[0] || null;
   };
 
-  // path aliases (tsconfig compilerOptions.paths + vite/webpack alias) — without these, @components/@/etc
-  // imports are missed and their targets look falsely DEAD.
-  const aliasList = [];
-  const addAlias = (a, t) => {
+  // Rust modules are files, but their paths are logical rather than simple source-relative imports:
+  // `foo.rs` owns children below `foo/`, while lib.rs/main.rs/mod.rs own siblings. Keep the resolver
+  // filesystem-only and crate-local: Cargo/external dependencies belong to dependency analysis, not to
+  // the internal module graph.
+  const cleanRustRel = (p) => String(p || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "").replace(/^\.$/, "");
+  const rustDir = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
+  const rustBase = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? p : p.slice(i + 1); };
+  const rustJoin = (...parts) => cleanRustRel(join(...parts.filter((x) => x != null && x !== "")));
+  const rustFiles = new Set([...fileSet].filter((fr) => fr.endsWith(".rs")));
+  const rustRoots = new Map();
+  for (const fr of rustFiles) {
+    const base = rustBase(fr);
+    if (base !== "lib.rs" && base !== "main.rs") continue;
+    const dir = rustDir(fr);
+    let root = rustRoots.get(dir);
+    if (!root) rustRoots.set(dir, (root = { base: dir, lib: null, main: null }));
+    root[base === "lib.rs" ? "lib" : "main"] = fr;
+  }
+  const rustRootList = [...rustRoots.values()].sort((a, b) => b.base.length - a.base.length);
+  const rustContext = (fromRel) => {
+    fromRel = cleanRustRel(fromRel);
+    const base = rustBase(fromRel);
+    const dir = rustDir(fromRel);
+    if (base === "lib.rs" || base === "main.rs") return { base: dir, rootFile: fromRel };
+
+    // Cargo treats direct files in these conventional folders as independent crate roots. This only
+    // affects paths originating in the root file itself; nested module ownership still comes from mod/use.
+    if (/^(?:bin|examples|tests|benches)$/.test(rustBase(dir))) return { base: dir, rootFile: fromRel };
+    for (const root of rustRootList) {
+      if (!root.base || fromRel.startsWith(root.base + "/")) return { base: root.base, rootFile: root.lib || root.main };
+    }
+    return { base: dir, rootFile: fromRel };
+  };
+  const rustModuleBase = (fromRel) => {
+    const ctx = rustContext(fromRel);
+    if (ctx.rootFile === cleanRustRel(fromRel)) return rustDir(fromRel);
+    const name = rustBase(fromRel);
+    if (name === "lib.rs" || name === "main.rs" || name === "mod.rs") return rustDir(fromRel);
+    return rustJoin(rustDir(fromRel), name.replace(/\.rs$/, ""));
+  };
+  const rustInlineBase = (fromRel, inlineModules = []) => {
+    let base = rustModuleBase(fromRel);
+    for (let i = 0; i < inlineModules.length; i++) {
+      const mod = inlineModules[i] || {};
+      if (mod.path) {
+        // Rust Reference: a path attribute on the first inline module is relative to the source file's
+        // directory; nested attributes are relative to their containing module's search directory.
+        const parent = i === 0 ? rustDir(fromRel) : base;
+        base = rustJoin(parent, mod.path);
+      } else base = rustJoin(base, mod.name);
+    }
+    return base;
+  };
+  const rustModuleFile = (moduleBase, ctx) => {
+    moduleBase = cleanRustRel(moduleBase);
+    if (moduleBase === cleanRustRel(ctx.base) && ctx.rootFile && rustFiles.has(ctx.rootFile)) return ctx.rootFile;
+    const flat = moduleBase + ".rs";
+    if (rustFiles.has(flat)) return flat;
+    const legacy = rustJoin(moduleBase, "mod.rs");
+    return rustFiles.has(legacy) ? legacy : null;
+  };
+  const resolveRustMod = (fromRel, name, { inlineModules = [], explicitPath = "" } = {}) => {
+    fromRel = cleanRustRel(fromRel);
+    if (explicitPath) {
+      const parent = inlineModules.length ? rustInlineBase(fromRel, inlineModules) : rustDir(fromRel);
+      const target = rustJoin(parent, explicitPath);
+      return rustFiles.has(target) ? target : null;
+    }
+    const targetBase = rustJoin(rustInlineBase(fromRel, inlineModules), String(name || "").replace(/^r#/, ""));
+    return rustModuleFile(targetBase, rustContext(fromRel));
+  };
+  const resolveRustPath = (fromRel, rawSegments, { inlineModules = [], unqualified = true } = {}) => {
+    fromRel = cleanRustRel(fromRel);
+    const segments = (Array.isArray(rawSegments) ? rawSegments : String(rawSegments || "").split("::"))
+      .map((s) => String(s).trim().replace(/^r#/, "")).filter(Boolean);
+    if (!segments.length) return null;
+    const ctx = rustContext(fromRel);
+    const current = rustInlineBase(fromRel, inlineModules);
+    let rest = [...segments];
+    const starts = [];
+    let anchored = false;
+    if (rest[0] === "crate") { anchored = true; rest.shift(); starts.push(ctx.base); }
+    else if (rest[0] === "self") { anchored = true; rest.shift(); starts.push(current); }
+    else if (rest[0] === "super") {
+      anchored = true;
+      let base = current;
+      while (rest[0] === "super") { rest.shift(); base = rustDir(base); }
+      if (ctx.base && base !== ctx.base && !base.startsWith(ctx.base + "/")) return null;
+      starts.push(base);
+    } else if (unqualified) {
+      // Rust 2018 resolves a bare use path from the crate root/external prelude. Prefer an internal root
+      // module, then allow a lexically-local module for qualified expressions in nested modules.
+      starts.push(ctx.base);
+      if (current !== ctx.base) starts.push(current);
+    } else return null;
+
+    for (const start of starts) {
+      const min = anchored ? 0 : 1; // never reinterpret an unresolved external `serde::X` as the crate root
+      for (let used = rest.length; used >= min; used--) {
+        const target = rustModuleFile(rustJoin(start, ...rest.slice(0, used)), ctx);
+        if (target) return { targetFile: target, consumed: segments.length - rest.length + used, remaining: rest.slice(used), anchored };
+      }
+    }
+    return null;
+  };
+
+  // Path aliases (tsconfig compilerOptions.paths + vite/webpack alias) are scoped to their config folder.
+  // Without nearest-config resolution, a monorepo's root `@/*` can hijack the same alias in web/.
+  const aliasContexts = new Map();
+  const cleanRel = (p) => String(p || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "").replace(/^\.$/, "");
+  const contextFor = (dir) => {
+    dir = cleanRel(dir);
+    let ctx = aliasContexts.get(dir);
+    if (!ctx) aliasContexts.set(dir, (ctx = { dir, aliases: [], baseUrls: [] }));
+    return ctx;
+  };
+  const addAlias = (ctx, a, t) => {
     a = String(a).replace(/\/\*$/, "").replace(/\/$/, "");
-    t = String(t).replace(/\/\*$/, "").replace(/^\.\//, "").replace(/\/$/, "");
-    if (a && t && !aliasList.some((x) => x.alias === a)) aliasList.push({ alias: a, target: t });
+    t = cleanRel(String(t)).replace(/\/\*$/, "");
+    if (a && t && !ctx.aliases.some((x) => x.alias === a)) ctx.aliases.push({ alias: a, target: t });
+  };
+  const parseJsonc = (raw) => {
+    // Regex comment stripping corrupts perfectly valid path strings such as `"@/*"` followed later by
+    // `"**/*.ts"`. Strip comments/trailing commas only while outside JSON strings.
+    raw = String(raw).replace(/^\uFEFF/, "");
+    let clean = ""; let inString = false; let escaped = false;
+    for (let i = 0; i < raw.length; i++) {
+      const ch = raw[i], next = raw[i + 1];
+      if (inString) {
+        clean += ch;
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') { inString = true; clean += ch; continue; }
+      if (ch === "/" && next === "/") { while (i < raw.length && raw[i] !== "\n") i++; clean += "\n"; continue; }
+      if (ch === "/" && next === "*") {
+        i += 2;
+        while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) { if (raw[i] === "\n") clean += "\n"; i++; }
+        i++;
+        continue;
+      }
+      clean += ch;
+    }
+    let withoutTrailing = ""; inString = false; escaped = false;
+    for (let i = 0; i < clean.length; i++) {
+      const ch = clean[i];
+      if (inString) {
+        withoutTrailing += ch;
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        continue;
+      }
+      if (ch === '"') { inString = true; withoutTrailing += ch; continue; }
+      if (ch === ",") {
+        let j = i + 1; while (/\s/.test(clean[j] || "")) j++;
+        if (clean[j] === "}" || clean[j] === "]") continue;
+      }
+      withoutTrailing += ch;
+    }
+    return JSON.parse(withoutTrailing);
   };
-  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"]) {
+  const configRank = (fr) => /(^|\/)tsconfig\.json$/i.test(fr) ? 0 : /(^|\/)jsconfig\.json$/i.test(fr) ? 1 : 2;
+  const configFiles = [...fileSet]
+    .filter((fr) => /(^|\/)(?:tsconfig(?:\.[^/]+)?|jsconfig)\.json$/i.test(fr))
+    .sort((a, b) => dirname(a).localeCompare(dirname(b)) || configRank(a) - configRank(b) || a.localeCompare(b));
+  for (const cfg of configFiles) {
     try {
-      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);
-      for (const [k, v] of Object.entries(paths)) { const t = Array.isArray(v) ? v[0] : v; if (t) addAlias(k, (baseUrl && !String(t).startsWith("./") ? baseUrl + "/" : "") + t); }
+      const tj = parseJsonc(readLocal(cfg)); const co = tj.compilerOptions || {}; const paths = co.paths || {};
+      const cfgDir = cleanRel(dirname(cfg)); const ctx = contextFor(cfgDir);
+      const baseRoot = cleanRel(join(cfgDir || ".", String(co.baseUrl || ".")));
+      if (co.baseUrl != null && !ctx.baseUrls.includes(baseRoot)) ctx.baseUrls.push(baseRoot);
+      for (const [k, v] of Object.entries(paths)) {
+        const t = Array.isArray(v) ? v[0] : v;
+        if (t) addAlias(ctx, k, join(baseRoot || ".", String(t)));
+      }
     } catch { /* no/invalid tsconfig */ }
   }
-  for (const vc of ["vite.config.ts", "vite.config.js", "vite.config.mjs", "webpack.config.js"]) {
-    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 */ }
+  for (const vc of [...fileSet].filter((fr) => /(^|\/)(?:vite\.config\.(?:ts|js|mjs)|webpack\.config\.js)$/.test(fr))) {
+    try {
+      const cfgDir = cleanRel(dirname(vc)); const ctx = contextFor(cfgDir); const src = readLocal(vc);
+      for (const m of src.matchAll(/['"`]([^'"`]+)['"`]\s*:\s*path\.resolve\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g)) addAlias(ctx, m[1], join(cfgDir || ".", m[2]));
+    } catch { /* no/invalid 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; };
+  for (const ctx of aliasContexts.values()) ctx.aliases.sort((a, b) => b.alias.length - a.alias.length);
+  const contextsForFile = (fromRel) => [...aliasContexts.values()]
+    .filter((ctx) => !ctx.dir || fromRel === ctx.dir || fromRel.startsWith(ctx.dir + "/"))
+    .sort((a, b) => b.dir.length - a.dir.length);
+  const resolveAlias = (fromRel, spec) => {
+    if (spec === undefined) { spec = fromRel; fromRel = ""; }
+    for (const ctx of contextsForFile(fromRel)) for (const { alias, target } of ctx.aliases) {
+      if (spec === alias) return target;
+      if (spec.startsWith(alias + "/")) return target + spec.slice(alias.length);
+    }
+    return null;
+  };
 
   const JS_EXTS = ["", ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs", ".json", "/index.js", "/index.ts", "/index.jsx", "/index.tsx"];
   const resolveJsImport = (fromRel, spec) => {
@@ -77,10 +253,10 @@ export function buildResolvers(repoDir, fileSet) {
     let base;
     if (spec.startsWith(".")) base = join(dirname(fromRel), spec).replace(/\\/g, "/").replace(/^\.\//, "");
     else {
-      base = resolveAlias(spec);
+      base = resolveAlias(fromRel, spec);
       if (base == null) {
         // baseUrl-rooted internal import ("components/Button" with baseUrl:"src") — try before calling it an npm package
-        for (const b of jsBaseUrls) {
+        for (const ctx of contextsForFile(fromRel)) for (const b of ctx.baseUrls) {
           const root = (b ? b + "/" : "") + spec;
           for (const e of JS_EXTS) { const cand = (root + e).replace(/\/+/g, "/"); if (fileSet.has(cand)) return cand; }
         }
@@ -119,5 +295,5 @@ export function buildResolvers(repoDir, fileSet) {
     return fileSet.has(cand) ? cand : null;
   };
 
-  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goRequires };
+  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goRequires };
 }

package/src/graph/relations.js

@@ -0,0 +1,4 @@
+// Ownership/nesting edges are useful for navigation, but are not evidence of code usage.
+const STRUCTURAL_RELATIONS = new Set(["contains", "method"]);
+
+export const isStructuralRelation = (relation) => STRUCTURAL_RELATIONS.has(String(relation || ""));

package/src/mcp/catalog.mjs

@@ -23,7 +23,7 @@ function buildTools({tg, ti, th, ta}) {
         {cap: 'graph', name: 'get_node', description: 'Get full details for a specific node by label or ID.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID to look up'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNode(g, a, ctx)},
         {cap: 'graph', name: 'get_neighbors', description: 'Get all direct neighbors of a node with edge details (1 hop, call sites deduped). For transitive impact use get_dependents; for the impact of your current branch changes use change_impact.', inputSchema: {type: 'object', properties: {label: {type: 'string'}, relation_filter: {type: 'string', description: 'Optional: filter by relation type'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNeighbors(g, a, ctx)},
         {cap: 'graph', name: 'query_graph', description: 'Explore the graph around a concept (BFS/DFS). Returns a focused, ranked subgraph — the closest, most-connected nodes near the matched seeds, with edges among them — not the full flood; states how many nodes were reached vs shown.', inputSchema: {type: 'object', properties: {question: {type: 'string', description: 'Natural language question or keyword search'}, mode: {type: 'string', enum: ['bfs', 'dfs'], default: 'bfs'}, depth: {type: 'integer', default: 3}, context_filter: {type: 'array', items: {type: 'string'}}, token_budget: {type: 'integer', description: 'Higher budget shows more nodes/edges', default: 2000}}, required: ['question']}, run: (g, a) => tg.tQueryGraph(g, a)},
-        {cap: 'graph', name: 'god_nodes', description: 'Return the most connected nodes - the core abstractions of the knowledge graph.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', default: 10}}}, run: (g, a) => tg.tGodNodes(g, a)},
+        {cap: 'graph', name: 'god_nodes', description: 'Rank connectivity hubs by unique call/import/reference neighbors, with class/method ownership reported separately from runtime connectivity. Repeated call sites do not inflate the rank.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', default: 10}}}, run: (g, a) => tg.tGodNodes(g, a)},
         {cap: 'graph', name: 'shortest_path', description: 'Find the shortest path between two concepts in the knowledge graph.', inputSchema: {type: 'object', properties: {source: {type: 'string'}, target: {type: 'string'}, max_hops: {type: 'integer', default: 8}}, required: ['source', 'target']}, run: (g, a) => tg.tShortestPath(g, a)},
         {cap: 'graph', name: 'get_dependents', description: 'Transitive blast-radius of ONE node: everything that calls/imports/inherits it, directly or through intermediaries (reverse edges, ranked by proximity then connectivity). For a symbol, also follows importers of its containing file. Use before refactoring; get_neighbors shows only 1 hop, change_impact covers your whole current diff at once.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID'}, depth: {type: 'integer', description: 'Max reverse hops, default 3', default: 3}, max_nodes: {type: 'integer', description: 'Max dependents to list, default 40', default: 40}}, required: ['label']}, run: (g, a) => ti.tGetDependents(g, a)},
         {cap: 'graph', name: 'change_impact', description: 'Blast radius of a change: by default diffs branch commits + staged/unstaged/untracked work against a base ref (auto merge-base with origin/main|master), OR takes an explicit `files` list (e.g. a PR\'s changed files — assesses a NOT-checked-out PR). Maps changed files/symbols onto the graph and lists everything depending on them (reverse edges, ranked by proximity + connectivity) with test coverage attached — untested hotspots called out. Run before opening or reviewing a PR; drill down with get_dependents, coverage detail via coverage_map.', inputSchema: {type: 'object', properties: {base: {type: 'string', description: 'Base ref, e.g. origin/main or HEAD~1 (default: first existing of origin/HEAD, origin/main, origin/master, main, master)'}, files: {type: 'array', items: {type: 'string'}, description: 'Explicit repo-relative changed-file list — skips the local git diff; use for PRs that are not checked out'}, depth: {type: 'integer', description: 'Max reverse hops, default 2'}, max_nodes: {type: 'integer', description: 'Max impacted nodes to list, default 40'}}}, run: (g, a, ctx) => ti.tChangeImpact(g, a, ctx)},
@@ -34,14 +34,14 @@ function buildTools({tg, ti, th, ta}) {
         {cap: 'health', name: 'run_audit', description: 'Full internal health audit of the repo: dead code (unused files/exports), dependency health (missing/undeclared and unused npm/Go/Python deps), structure (import cycles, orphan files, boundary-rule violations), and offline supply-chain checks (known OSV vulnerabilities, typosquats, lockfile drift). Filter by category/severity. Malware heuristics are opt-in (slow).', inputSchema: {type: 'object', properties: {category: {type: 'string', enum: ['unused', 'structure', 'vulnerability', 'malware'], description: 'Only findings of this category'}, min_severity: {type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'], description: 'Minimum severity to include'}, max_findings: {type: 'integer', description: 'Max findings to list, default 30'}, include_malware_scan: {type: 'boolean', description: 'Also grep installed packages for malware heuristics (slow)', default: false}}}, run: (g, a, ctx) => th.tRunAudit(g, a, ctx)},
         {cap: 'health', name: 'coverage_map', description: 'Map an existing test-coverage report (istanbul/lcov/coverage.py/Go cover.out — read offline, never runs tests) onto the code graph: per-module coverage plus refactor-risk hotspots — well-connected symbols with low coverage, ranked by degree × uncovered. Pair with get_dependents: many dependents + low coverage ⇒ write tests before changing.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max risk hotspots to list, default 15'}, path: {type: 'string', description: 'Optional repo-relative path prefix filter, e.g. src/query'}}}, run: (g, a, ctx) => th.tCoverageMap(g, a, ctx)},
         {cap: 'graph', name: 'list_communities', description: 'List graph communities named by their dominant folder (largest first) with sample files — a readable module overview; feed the list position into get_community.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max communities to list, default 20'}}}, run: (g, a, ctx) => th.tListCommunities(g, a, ctx)},
-        {cap: 'graph', name: 'module_map', description: 'Folder-level architecture map: modules with file/symbol counts plus the strongest module→module dependency edges. Fast orientation before diving into files.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
-        {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: 'graph', name: 'module_map', description: 'Folder-level architecture map with file/symbol counts and strongest module dependencies, separating runtime, TypeScript type-only and language compile-only coupling.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
+        {cap: 'source', name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web …): method, path, handler, and file:line.', 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: '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: 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)},
+        {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 never read for sync. Rebuild graphs created before 0.1.4 once to add edge metadata v2.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tSyncGraph(g, a, ctx)},
     ]
 }
 

package/src/mcp/graph-context.mjs

@@ -6,8 +6,8 @@ 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'
+import {isStructuralRelation} from '../graph/relations.js'
 
 // ---- graph load + indexes -----------------------------------------------------------------------
 export function loadGraph(path) {
@@ -33,22 +33,35 @@ export function loadGraph(path) {
         if (!e || e.source == null || e.target == null) continue
         const s = String(e.source)
         const t = String(e.target)
-        push(out, s, {id: t, relation: e.relation, confidence: e.confidence})
-        push(inn, t, {id: s, relation: e.relation, confidence: e.confidence})
+        const metadata = {
+            relation: e.relation,
+            confidence: e.confidence,
+            ...(e.typeOnly === true ? {typeOnly: true} : {}),
+            ...(e.compileOnly === true ? {compileOnly: true} : {}),
+            ...(Number.isInteger(e.line) ? {line: e.line} : {}),
+            ...(typeof e.specifier === 'string' ? {specifier: e.specifier} : {}),
+        }
+        push(out, s, {id: t, ...metadata})
+        push(inn, t, {id: s, ...metadata})
+    }
+    return {
+        nodes, links, byId, byLabel, out, inn,
+        repoBoundaryV: Number(raw.repoBoundaryV) || 0,
+        edgeTypesV: Number(raw.edgeTypesV) || 0,
     }
-    return {nodes, links, byId, byLabel, out, inn, repoBoundaryV: Number(raw.repoBoundaryV) || 0}
 }
 
 export const isSymbol = (id) => String(id).includes('#')
-export const degreeOf = (g, id) => (g.out.get(id)?.length || 0) + (g.inn.get(id)?.length || 0)
 export const labelOf = (g, id) => {
     const n = g.byId.get(String(id))
     return n ? String(n.label ?? n.id) : String(id)
 }
 
-// "connectivity" degree ignores structural `contains` (parent→symbol nesting) so god_nodes surfaces real
-// call/import/reference hubs, not just files that hold many symbols.
-export const connList = (list) => (list || []).filter((e) => e.relation !== 'contains')
+// Connectivity ignores structural file/symbol and class/method ownership, so runtime/compile-time
+// dependency ranks never treat nesting as a call or import.
+export const connList = (list) => (list || []).filter((e) => !isStructuralRelation(e.relation))
+export const degreeOf = (g, id) => connList(g.out.get(id)).length + connList(g.inn.get(id)).length
+export const uniqueConnCount = (list) => new Set(connList(list).map((e) => String(e.id))).size
 
 // Resolve a user-supplied "label" to a node: exact id → exact label → ci label → substring (best degree).
 // Returns {node, matches, alternates} so callers can disclose ambiguity instead of silently picking one.
@@ -191,89 +204,4 @@ export function rawGraph(ctx) {
     return rawGraphCache.data
 }
 
-// ---- graph diff ----------------------------------------------------------------------------------
-// One previous state is enough (4-13 MB per repo — cheap): rebuild_graph snapshots the outgoing
-// graph.json as graph.prev.json and reports the structural delta inline, at the exact moment the fix
-// is being verified. graph_diff re-queries the same pair later. Raw node/edge dumps would be noise —
-// the signal is aggregated: module-dependency drift, cycle count changes, newly orphaned symbols.
-export const prevGraphPathFor = (graphPath) => String(graphPath).replace(/\.json$/, '.prev.json')
-export const edgeEndpoint = (v) => String(v && typeof v === 'object' ? v.id : v)
-export const fileOfId = (id) => { const s = String(id); const h = s.indexOf('#'); return h < 0 ? s : s.slice(0, h) }
-const folderOfFile = (file) => {
-    const dirs = String(file || '').split(/[\\/]/).filter(Boolean).slice(0, -1)
-    return dirs.length ? dirs.slice(0, 2).join('/') : '(root)'
-}
-
-// Works on anything with {nodes, links}: the raw graph.json shape and the loadGraph struct alike.
-export function diffGraphs(oldG, newG) {
-    const nodeIds = (graph) => new Set((graph.nodes || []).map((n) => String(n.id)))
-    const oldNodes = nodeIds(oldG)
-    const newNodes = nodeIds(newG)
-
-    const edgeKey = (l) => `${edgeEndpoint(l.source)}|${l.relation || ''}|${edgeEndpoint(l.target)}`
-    const edgeSet = (graph) => new Set((graph.links || []).map(edgeKey))
-    const oldEdges = edgeSet(oldG)
-    const newEdges = edgeSet(newG)
-
-    const moduleEdges = (graph) => {
-        const set = new Set()
-        for (const l of graph.links || []) {
-            if (l.relation === 'contains') continue
-            const a = folderOfFile(fileOfId(edgeEndpoint(l.source)))
-            const b = folderOfFile(fileOfId(edgeEndpoint(l.target)))
-            if (a !== b) set.add(`${a} → ${b}`)
-        }
-        return set
-    }
-    const oldMods = moduleEdges(oldG)
-    const newMods = moduleEdges(newG)
-
-    const incoming = (graph) => {
-        const m = new Map()
-        for (const l of graph.links || []) {
-            if (l.relation === 'contains') continue
-            const t = edgeEndpoint(l.target)
-            m.set(t, (m.get(t) || 0) + 1)
-        }
-        return m
-    }
-    const oldIn = incoming(oldG)
-    const newIn = incoming(newG)
-
-    const cycles = (graph) => { try { return findSccs(buildFileImportGraph(graph).adj).length } catch { return null } }
-
-    return {
-        nodes: {
-            added: [...newNodes].filter((id) => !oldNodes.has(id)),
-            removed: [...oldNodes].filter((id) => !newNodes.has(id))
-        },
-        edges: {
-            added: [...newEdges].filter((k) => !oldEdges.has(k)).length,
-            removed: [...oldEdges].filter((k) => !newEdges.has(k)).length
-        },
-        moduleEdges: {
-            added: [...newMods].filter((k) => !oldMods.has(k)),
-            removed: [...oldMods].filter((k) => !newMods.has(k))
-        },
-        // survived the rebuild but lost every caller/importer — likely made dead by the change
-        orphaned: [...oldIn.keys()].filter((id) => newNodes.has(id) && !newIn.has(id)),
-        cycles: {before: cycles(oldG), after: cycles(newG)}
-    }
-}
-
-export function formatGraphDiff(d) {
-    if (!d.nodes.added.length && !d.nodes.removed.length && !d.edges.added && !d.edges.removed) {
-        return 'No structural change between the two graph states.'
-    }
-    const cap = (list, n) => list.slice(0, n).map((x) => `  ${x}`).concat(list.length > n ? [`  … +${list.length - n} more`] : [])
-    const lines = [`Structural delta: nodes +${d.nodes.added.length}/−${d.nodes.removed.length}, edges +${d.edges.added}/−${d.edges.removed}.`]
-    if (d.cycles.before != null && d.cycles.after != null && d.cycles.before !== d.cycles.after) {
-        lines.push(`Import cycles: ${d.cycles.before} → ${d.cycles.after}${d.cycles.after < d.cycles.before ? '  (cycle broken — fix confirmed)' : '  (NEW cycle introduced — see run_audit)'}`)
-    }
-    if (d.moduleEdges.added.length) lines.push('NEW module dependencies (architecture drift — review):', ...cap(d.moduleEdges.added, 12))
-    if (d.moduleEdges.removed.length) lines.push('Removed module dependencies (decoupling confirmed):', ...cap(d.moduleEdges.removed, 12))
-    if (d.orphaned.length) lines.push('Symbols that lost their last caller/importer (now dead?):', ...cap(d.orphaned, 10))
-    if (d.nodes.added.length) lines.push('Added nodes:', ...cap(d.nodes.added, 12))
-    if (d.nodes.removed.length) lines.push('Removed nodes:', ...cap(d.nodes.removed, 12))
-    return lines.join('\n')
-}
+export {prevGraphPathFor, edgeEndpoint, fileOfId, diffGraphs, formatGraphDiff} from './graph-diff.mjs'

package/src/mcp/graph-diff.mjs

@@ -0,0 +1,163 @@
+// Structural graph delta helpers split from graph-context so the process-lifetime graph indexes stay small.
+import {buildFileImportGraph, findSccs} from '../analysis/dep-rules.js'
+import {folderModuleOf} from '../analysis/graph-analysis.aggregate.js'
+import {isStructuralRelation} from '../graph/relations.js'
+
+// ---- graph diff ----------------------------------------------------------------------------------
+// One previous state is enough (4-13 MB per repo — cheap): rebuild_graph snapshots the outgoing
+// graph.json as graph.prev.json and reports the structural delta inline, at the exact moment the fix
+// is being verified. graph_diff re-queries the same pair later. Raw node/edge dumps would be noise —
+// the signal is aggregated: module-dependency drift, cycle count changes, newly orphaned symbols.
+export const prevGraphPathFor = (graphPath) => String(graphPath).replace(/\.json$/, '.prev.json')
+export const edgeEndpoint = (v) => String(v && typeof v === 'object' ? v.id : v)
+export const fileOfId = (id) => { const s = String(id); const h = s.indexOf('#'); return h < 0 ? s : s.slice(0, h) }
+const folderOfFile = folderModuleOf
+
+// Works on anything with {nodes, links}: the raw graph.json shape and the loadGraph struct alike.
+export function diffGraphs(oldG, newG) {
+    const oldEdgeTypesV = Number(oldG.edgeTypesV) || 0
+    const newEdgeTypesV = Number(newG.edgeTypesV) || 0
+    const schemaMigration = oldEdgeTypesV !== newEdgeTypesV
+    const nodeIds = (graph) => new Set((graph.nodes || []).map((n) => String(n.id)))
+    const oldNodes = nodeIds(oldG)
+    const newNodes = nodeIds(newG)
+
+    const edgeClass = (l) => l.typeOnly === true ? 'type' : l.compileOnly === true ? 'compile' : 'runtime'
+    const edgeKey = (l) => `${edgeEndpoint(l.source)}|${l.relation || ''}|${schemaMigration ? 'untyped' : edgeClass(l)}|${edgeEndpoint(l.target)}`
+    const edgeSet = (graph) => new Set((graph.links || []).map(edgeKey))
+    const oldEdges = edgeSet(oldG)
+    const newEdges = edgeSet(newG)
+
+    const moduleEdges = (graph, classification) => {
+        const set = new Set()
+        for (const l of graph.links || []) {
+            if (isStructuralRelation(l.relation)) continue
+            if (edgeClass(l) !== classification) continue
+            const a = folderOfFile(fileOfId(edgeEndpoint(l.source)))
+            const b = folderOfFile(fileOfId(edgeEndpoint(l.target)))
+            if (a !== b) set.add(`${a} → ${b}`)
+        }
+        return set
+    }
+    // A parser/schema upgrade can discover edges that the old graph could not represent (Rust use/mod in
+    // edgeTypesV2). Do not call that architecture drift: establish a fresh classification baseline.
+    const oldMods = schemaMigration ? new Set() : moduleEdges(oldG, 'runtime')
+    const newMods = schemaMigration ? new Set() : moduleEdges(newG, 'runtime')
+    const oldTypeMods = schemaMigration ? new Set() : moduleEdges(oldG, 'type')
+    const newTypeMods = schemaMigration ? new Set() : moduleEdges(newG, 'type')
+    const oldCompileMods = schemaMigration ? new Set() : moduleEdges(oldG, 'compile')
+    const newCompileMods = schemaMigration ? new Set() : moduleEdges(newG, 'compile')
+
+    const incoming = (graph) => {
+        const m = new Map()
+        for (const l of graph.links || []) {
+            if (isStructuralRelation(l.relation)) continue
+            const t = edgeEndpoint(l.target)
+            m.set(t, (m.get(t) || 0) + 1)
+        }
+        return m
+    }
+    const oldIn = incoming(oldG)
+    const newIn = incoming(newG)
+
+    const cycles = (graph, includeTypeOnly) => {
+        try {
+            const sccs = findSccs(buildFileImportGraph(graph, {includeTypeOnly}).adj)
+                .map((members) => members.map(String).sort())
+                .sort((a, b) => b.length - a.length || a.join('\n').localeCompare(b.join('\n')))
+            return {
+                count: sccs.length,
+                largest: sccs[0]?.length || 0,
+                groups: sccs,
+            }
+        } catch {
+            return null
+        }
+    }
+    const cycleDelta = (before, after) => {
+        if (!before || !after) return null
+        const key = (group) => group.join('|')
+        const beforeKeys = new Set(before.groups.map(key))
+        const afterKeys = new Set(after.groups.map(key))
+        const overlap = (a, b) => {
+            const bSet = new Set(b)
+            return a.reduce((n, member) => n + (bSet.has(member) ? 1 : 0), 0)
+        }
+        const unmatchedBefore = before.groups.filter((group) => !afterKeys.has(key(group)))
+        const unmatchedAfter = after.groups.filter((group) => !beforeKeys.has(key(group)))
+        const changed = unmatchedAfter.filter((group) => unmatchedBefore.some((old) => overlap(group, old) >= 2))
+        const introduced = unmatchedAfter.filter((group) => !unmatchedBefore.some((old) => overlap(group, old) >= 2))
+        const resolved = unmatchedBefore.filter((group) => !unmatchedAfter.some((next) => overlap(group, next) >= 2))
+        return {
+            before: before.count,
+            after: after.count,
+            largestBefore: before.largest,
+            largestAfter: after.largest,
+            introduced: introduced.map(key),
+            resolved: resolved.map(key),
+            membershipChanged: changed.length,
+        }
+    }
+
+    return {
+        schemaMigration: schemaMigration ? {from: oldEdgeTypesV, to: newEdgeTypesV} : null,
+        nodes: {
+            added: [...newNodes].filter((id) => !oldNodes.has(id)),
+            removed: [...oldNodes].filter((id) => !newNodes.has(id))
+        },
+        edges: {
+            added: [...newEdges].filter((k) => !oldEdges.has(k)).length,
+            removed: [...oldEdges].filter((k) => !newEdges.has(k)).length
+        },
+        moduleEdges: {
+            added: [...newMods].filter((k) => !oldMods.has(k)),
+            removed: [...oldMods].filter((k) => !newMods.has(k)),
+            typeAdded: [...newTypeMods].filter((k) => !oldTypeMods.has(k)),
+            typeRemoved: [...oldTypeMods].filter((k) => !newTypeMods.has(k)),
+            compileAdded: [...newCompileMods].filter((k) => !oldCompileMods.has(k)),
+            compileRemoved: [...oldCompileMods].filter((k) => !newCompileMods.has(k)),
+        },
+        // survived the rebuild but lost every caller/importer — likely made dead by the change
+        orphaned: [...oldIn.keys()].filter((id) => newNodes.has(id) && !newIn.has(id)),
+        cycles: {
+            runtime: schemaMigration ? null : cycleDelta(cycles(oldG, false), cycles(newG, false)),
+            // Backward-compatible field name: since edgeTypesV 2 this includes typeOnly and compileOnly.
+            typeInclusive: schemaMigration ? null : cycleDelta(cycles(oldG, true), cycles(newG, true)),
+        }
+    }
+}
+
+export function formatGraphDiff(d) {
+    if (!d.nodes.added.length && !d.nodes.removed.length && !d.edges.added && !d.edges.removed) {
+        return d.schemaMigration
+            ? `Graph edge schema upgraded v${d.schemaMigration.from} → v${d.schemaMigration.to}; compile-time baseline established. Runtime/compile-time cycle and module classifications are intentionally not compared on this rebuild.`
+            : 'No structural change between the two graph states.'
+    }
+    const cap = (list, n) => list.slice(0, n).map((x) => `  ${x}`).concat(list.length > n ? [`  … +${list.length - n} more`] : [])
+    const lines = [`Structural delta: nodes +${d.nodes.added.length}/−${d.nodes.removed.length}, edges +${d.edges.added}/−${d.edges.removed}.`]
+    if (d.schemaMigration) lines.push(`Graph edge schema upgraded v${d.schemaMigration.from} → v${d.schemaMigration.to}; runtime/compile-time cycle and module classifications are intentionally not compared until the next rebuild.`)
+    const runtime = d.cycles?.runtime
+    if (runtime && (runtime.before !== runtime.after || runtime.largestBefore !== runtime.largestAfter || runtime.introduced.length || runtime.resolved.length || runtime.membershipChanged)) {
+        const changes = []
+        if (runtime.introduced.length) changes.push(`${runtime.introduced.length} genuinely new runtime SCC(s) — review`)
+        if (runtime.resolved.length) changes.push(`${runtime.resolved.length} runtime SCC(s) resolved`)
+        if (runtime.membershipChanged) changes.push(`${runtime.membershipChanged} SCC membership change(s)`)
+        const verdict = changes.length ? `; ${changes.join('; ')}` : ''
+        lines.push(`Runtime import cycles: count ${runtime.before} → ${runtime.after}, largest SCC ${runtime.largestBefore} → ${runtime.largestAfter}${verdict}.`)
+    }
+    const all = d.cycles?.typeInclusive
+    if (all && (all.before !== all.after || all.largestBefore !== all.largestAfter) &&
+        (!runtime || all.before !== runtime.before || all.after !== runtime.after || all.largestBefore !== runtime.largestBefore || all.largestAfter !== runtime.largestAfter)) {
+        lines.push(`Compile-time-inclusive dependency SCCs: count ${all.before} → ${all.after}, largest ${all.largestBefore} → ${all.largestAfter} (compile-time coupling, not necessarily a runtime cycle).`)
+    }
+    if (d.moduleEdges.added.length) lines.push('NEW module dependencies (architecture drift — review):', ...cap(d.moduleEdges.added, 12))
+    if (d.moduleEdges.removed.length) lines.push('Removed module dependencies (decoupling confirmed):', ...cap(d.moduleEdges.removed, 12))
+    if (d.moduleEdges.typeAdded.length) lines.push('New type-only module dependencies (compile-time coupling):', ...cap(d.moduleEdges.typeAdded, 12))
+    if (d.moduleEdges.typeRemoved.length) lines.push('Removed type-only module dependencies:', ...cap(d.moduleEdges.typeRemoved, 12))
+    if (d.moduleEdges.compileAdded.length) lines.push('New compile-only module dependencies (compile-time coupling):', ...cap(d.moduleEdges.compileAdded, 12))
+    if (d.moduleEdges.compileRemoved.length) lines.push('Removed compile-only module dependencies:', ...cap(d.moduleEdges.compileRemoved, 12))
+    if (d.orphaned.length) lines.push('Symbols that lost their last caller/importer (now dead?):', ...cap(d.orphaned, 10))
+    if (d.nodes.added.length) lines.push('Added nodes:', ...cap(d.nodes.added, 12))
+    if (d.nodes.removed.length) lines.push('Removed nodes:', ...cap(d.nodes.removed, 12))
+    return lines.join('\n')
+}