weavatrix 0.1.2 → 0.1.3

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

@@ -47,29 +47,98 @@ 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) => {
+  // 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 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 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 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 +146,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; }
         }

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, excluding structural containment. Repeated call sites are reported separately and 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)},
@@ -41,7 +41,7 @@ function buildTools({tg, ti, th, ta}) {
         {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.3 once to add typed-edge metadata.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tSyncGraph(g, a, ctx)},
     ]
 }
 

package/src/mcp/graph-context.mjs

@@ -33,10 +33,21 @@ 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} : {}),
+            ...(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('#')
@@ -49,6 +60,7 @@ export const labelOf = (g, 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')
+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.
@@ -206,27 +218,43 @@ const folderOfFile = (file) => {
 
 // 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 edgeKey = (l) => `${edgeEndpoint(l.source)}|${l.relation || ''}|${edgeEndpoint(l.target)}`
+    const edgeKey = (l) => `${edgeEndpoint(l.source)}|${l.relation || ''}|${schemaMigration ? 'untyped' : l.typeOnly === true ? 'type' : 'runtime'}|${edgeEndpoint(l.target)}`
     const edgeSet = (graph) => new Set((graph.links || []).map(edgeKey))
     const oldEdges = edgeSet(oldG)
     const newEdges = edgeSet(newG)
 
-    const moduleEdges = (graph) => {
+    const moduleEdges = (graph, typeOnly) => {
         const set = new Set()
         for (const l of graph.links || []) {
             if (l.relation === 'contains') continue
+            if ((l.typeOnly === true) !== typeOnly) 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 combinedModuleEdges = (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 = schemaMigration ? combinedModuleEdges(oldG) : moduleEdges(oldG, false)
+    const newMods = schemaMigration ? combinedModuleEdges(newG) : moduleEdges(newG, false)
+    const oldTypeMods = schemaMigration ? new Set() : moduleEdges(oldG, true)
+    const newTypeMods = schemaMigration ? new Set() : moduleEdges(newG, true)
 
     const incoming = (graph) => {
         const m = new Map()
@@ -240,9 +268,47 @@ export function diffGraphs(oldG, newG) {
     const oldIn = incoming(oldG)
     const newIn = incoming(newG)
 
-    const cycles = (graph) => { try { return findSccs(buildFileImportGraph(graph).adj).length } catch { return null } }
+    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))
@@ -253,25 +319,46 @@ export function diffGraphs(oldG, newG) {
         },
         moduleEdges: {
             added: [...newMods].filter((k) => !oldMods.has(k)),
-            removed: [...oldMods].filter((k) => !newMods.has(k))
+            removed: [...oldMods].filter((k) => !newMods.has(k)),
+            typeAdded: [...newTypeMods].filter((k) => !oldTypeMods.has(k)),
+            typeRemoved: [...oldTypeMods].filter((k) => !newTypeMods.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)}
+        cycles: {
+            runtime: schemaMigration ? null : cycleDelta(cycles(oldG, false), cycles(newG, false)),
+            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 'No structural change between the two graph states.'
+        return d.schemaMigration
+            ? `Graph edge schema upgraded v${d.schemaMigration.from} → v${d.schemaMigration.to}; typed baseline established. Runtime/type 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.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.schemaMigration) lines.push(`Graph edge schema upgraded v${d.schemaMigration.from} → v${d.schemaMigration.to}; runtime/type 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(`Type-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.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))

package/src/mcp/sync-payload.mjs

@@ -63,6 +63,10 @@ function sanitizeLink(value) {
     const out = {source, target};
     setIf(out, 'relation', metadataString(value.relation, 32));
     setIf(out, 'confidence', metadataString(value.confidence, 32));
+    if (value.typeOnly === true) out.typeOnly = true;
+    const line = finiteNumber(value.line);
+    if (line !== undefined && Number.isInteger(line) && line >= 0) out.line = line;
+    setIf(out, 'specifier', metadataString(value.specifier));
     return out;
 }
 
@@ -85,14 +89,18 @@ export function createSyncPayload(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw) || raw.repoBoundaryV !== 1) {
         throw new Error('graph predates repository-boundary hardening');
     }
+    if (!Number.isInteger(raw.edgeTypesV) || raw.edgeTypesV < 1) {
+        throw new Error('graph predates typed import edges');
+    }
     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,
+        syncPayloadV: 2,
         repoBoundaryV: 1,
+        edgeTypesV: 1,
         extImportsV: Number.isInteger(raw.extImportsV) ? raw.extImportsV : 0,
         complexityV: Number.isInteger(raw.complexityV) ? raw.complexityV : 0,
         nodes,

package/src/mcp/tools-actions.mjs

@@ -16,7 +16,7 @@ export async function tRebuildGraph(g, args, ctx) {
     // snapshot the outgoing state: bytes → graph.prev.json (for graph_diff later), struct → inline delta
     let prevBytes = null
     try { prevBytes = readFileSync(ctx.graphPath) } catch { /* first build — nothing to diff against */ }
-    const before = g?.nodes ? {nodes: g.nodes, links: g.links} : null
+    const before = g?.nodes ? {nodes: g.nodes, links: g.links, edgeTypesV: g.edgeTypesV || 0} : null
     const res = await buildGraphForRepo(ctx.repoRoot, {mode, scope: args.scope || ''})
     if (!res || !res.ok) return `Graph rebuild failed: ${(res && res.error) || 'unknown error'}`
     if (prevBytes) { try { writeFileSync(prevGraphPathFor(ctx.graphPath), prevBytes) } catch { /* snapshot is best-effort */ } }
@@ -41,8 +41,21 @@ export async function tOpenRepo(g, args, ctx) {
     if (!existsSync(join(repoPath, '.git'))) return `Not a Git repository: ${requestedPath}`
     const graphPath = join(graphOutDirForRepo(repoPath), 'graph.json')
     let built = false
-    if (!existsSync(graphPath)) {
-        if (args.build === false) return `No graph yet for ${repoPath} (expected at ${graphPath}). Re-call without build:false to build one — large repos can take minutes.`
+    let upgrade = false
+    if (existsSync(graphPath)) {
+        try {
+            const saved = JSON.parse(readFileSync(graphPath, 'utf8'))
+            upgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 1
+        } catch {
+            upgrade = true
+        }
+    }
+    if (!existsSync(graphPath) || upgrade) {
+        if (args.build === false) {
+            return upgrade
+                ? `The existing graph for ${repoPath} predates typed import edges. Re-call without build:false to upgrade it before switching.`
+                : `No graph yet for ${repoPath} (expected at ${graphPath}). Re-call without build:false to build one — large repos can take minutes.`
+        }
         const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : 'full'
         const res = await buildGraphForRepo(repoPath, {mode, scope: ''})
         if (!res || !res.ok) return `Graph build failed for ${repoPath}: ${(res && res.error) || 'unknown error'}`
@@ -58,7 +71,8 @@ export async function tOpenRepo(g, args, ctx) {
         ctx.reload()
         return `Failed to load ${graphPath} — still targeting the previous repo (${prev.repoRoot || 'none'}).`
     }
-    return `Opened ${repoPath}${built ? ' (graph built fresh)' : ''}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`
+    const buildNote = built ? (upgrade ? ' (graph upgraded to typed import edges)' : ' (graph built fresh)') : ''
+    return `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`
 }
 
 // Sibling repos that already have a built graph in the central weavatrix-graphs folder — open_repo candidates.
@@ -99,7 +113,7 @@ export async function tRefreshAdvisories(g, args, ctx) {
     if (res.ok === false) return `Advisory refresh failed: ${res.error}`
     const meta = storeMeta()
     return [
-        `Advisory store refreshed from OSV.dev: ${res.queried} package versions queried, ${res.vulnerable} with known advisories (${res.fetched} advisory records fetched).`,
+        `Advisory store ${res.status === 'PARTIAL' ? 'partially refreshed' : 'refreshed'} from OSV.dev: ${res.queriedOk ?? res.queried}/${res.queried} package versions queried successfully, ${res.vulnerable} with known advisories (${res.fetched} advisory records fetched).`,
         res.unsupported ? `${res.unsupported} packages skipped (ecosystem not OSV-queryable — npm/PyPI/Go only).` : null,
         res.errors?.length ? `Partial: ${res.errors.length} request error(s), first: ${res.errors[0]}` : null,
         `Store: ${DEFAULT_STORE} (${meta.advisoryCount} advisories, fetched ${meta.fetchedAt}). run_audit now reflects it — offline.`,
@@ -118,8 +132,8 @@ export async function tSyncGraph(g, args, ctx) {
     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.'
+    try { payload = createSyncPayload(raw) } catch (e) {
+        return `Cannot sync: ${e.message}. Run rebuild_graph once before sync_graph.`
     }
     const body = JSON.stringify(payload)
     const repoName = String(ctx.repoRoot || '').replace(/[\\/]+$/, '').split(/[\\/]/).pop() || 'repo'
@@ -128,6 +142,7 @@ export async function tSyncGraph(g, args, ctx) {
             method: 'POST',
             headers: {
                 'content-type': 'application/json',
+                'x-weavatrix-payload-version': String(payload.syncPayloadV),
                 'x-weavatrix-repo': repoName,
                 ...(process.env.WEAVATRIX_SYNC_TOKEN ? {authorization: `Bearer ${process.env.WEAVATRIX_SYNC_TOKEN}`} : {}),
             },

package/src/mcp/tools-graph.mjs

@@ -12,9 +12,11 @@ export function tGraphStats(g, ctx) {
     const symbols = g.nodes.length - files
     const relCount = {}
     const confCount = {}
+    let typeOnlyEdges = 0
     for (const e of g.links) {
         relCount[e.relation ?? '?'] = (relCount[e.relation ?? '?'] || 0) + 1
         if (e.confidence != null) confCount[e.confidence] = (confCount[e.confidence] || 0) + 1
+        if (e.typeOnly === true) typeOnlyEdges++
     }
     const comm = new Map()
     for (const n of g.nodes) {
@@ -33,6 +35,7 @@ export function tGraphStats(g, ctx) {
         ctx?.repoRoot ? `- Repo: ${ctx.repoRoot}` : null,
         `- Nodes: ${g.nodes.length} (${files} files, ${symbols} symbols)`,
         `- Edges: ${g.links.length}`,
+        g.edgeTypesV ? `- Typed-edge metadata: v${g.edgeTypesV} (${typeOnlyEdges} type-only edges)` : `- Typed-edge metadata: unavailable (rebuild_graph with Weavatrix 0.1.3+)`,
         `- Relations: ${fmt(relCount)}`,
         Object.keys(confCount).length ? `- Confidence: ${fmt(confCount)}` : null,
         `- Communities: ${comm.size} (top by size: ${topComm.map(([c, n]) => `#${c}=${n}`).join(', ')})`,
@@ -77,10 +80,10 @@ export function tGetNode(g, {label} = {}, ctx) {
 function dedupeEdges(list) {
     const grouped = new Map()
     for (const e of list) {
-        const key = `${e.relation || 'rel'}|${e.id}`
+        const key = `${e.relation || 'rel'}|${e.typeOnly === true ? 'type' : 'runtime'}|${e.id}`
         const cur = grouped.get(key)
         if (cur) cur.count += 1
-        else grouped.set(key, {id: e.id, relation: e.relation, count: 1})
+        else grouped.set(key, {id: e.id, relation: e.relation, typeOnly: e.typeOnly === true, count: 1})
     }
     return [...grouped.values()]
 }
@@ -99,7 +102,7 @@ export function tGetNeighbors(g, {label, relation_filter} = {}, ctx) {
     const outs = dedupeEdges(outsRaw)
     const ins = dedupeEdges(insRaw)
     const line = (e, dir) =>
-        `  ${dir === 'out' ? '→' : '←'} ${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]${e.count > 1 ? `  (${e.count} sites)` : ''}`
+        `  ${dir === 'out' ? '→' : '←'} ${e.typeOnly ? 'type-only ' : ''}${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]${e.count > 1 ? `  (${e.count} sites)` : ''}`
     return [
         note,
         `Neighbors of ${n.label ?? id}${rf ? ` (relation=${rf})` : ''}: ${outs.length + ins.length} unique (${outsRaw.length + insRaw.length} edges)`,
@@ -113,21 +116,52 @@ export function tGetNeighbors(g, {label, relation_filter} = {}, ctx) {
 
 export function tGodNodes(g, {top_n = 10} = {}) {
     const n = Math.max(1, Math.min(100, Number(top_n) || 10))
-    const ranked = g.nodes
+    const scored = g.nodes
         .map((node) => {
-            const o = connList(g.out.get(String(node.id))).length
-            const i = connList(g.inn.get(String(node.id))).length
-            return {node, deg: o + i, out: o, in: i}
+            const outs = connList(g.out.get(String(node.id)))
+            const ins = connList(g.inn.get(String(node.id)))
+            const outIds = new Set(outs.map((e) => String(e.id)))
+            const inIds = new Set(ins.map((e) => String(e.id)))
+            const allIds = new Set([...outIds, ...inIds])
+            const runtimeIds = new Set([...outs, ...ins].filter((e) => e.typeOnly !== true).map((e) => String(e.id)))
+            const compileOnlyIds = new Set([...outs, ...ins].filter((e) => e.typeOnly === true).map((e) => String(e.id)))
+            for (const id of runtimeIds) compileOnlyIds.delete(id)
+            const occurrences = outs.length + ins.length
+            return {
+                node,
+                deg: allIds.size,
+                runtime: runtimeIds.size,
+                compileOnly: compileOnlyIds.size,
+                out: outIds.size,
+                in: inIds.size,
+                occurrences,
+            }
         })
-        .sort((a, b) => b.deg - a.deg)
-        .slice(0, n)
+        .filter((entry) => entry.deg > 0)
+        .sort((a, b) => b.runtime - a.runtime || b.deg - a.deg || b.occurrences - a.occurrences)
+    const ranked = scored.slice(0, n)
+    const rankedIds = new Set(ranked.map((entry) => String(entry.node.id)))
+    // Unique neighbors measure coupling, but a large component repeatedly calling the same helper (for
+    // example i18n) can still be a valuable complexity hotspot. Preserve that second lens explicitly
+    // instead of letting repeated sites inflate the coupling rank.
+    const occurrenceHotspots = scored
+        .filter((entry) => !rankedIds.has(String(entry.node.id)))
+        .filter((entry) => entry.occurrences >= 20 && entry.occurrences - entry.deg >= 10)
+        .sort((a, b) => (b.occurrences - b.deg) - (a.occurrences - a.deg) || b.occurrences - a.occurrences)
+        .slice(0, Math.min(5, n))
     return [
-        `Top ${n} most-connected nodes (call/import/reference edges, excluding structural containment):`,
+        `Top ${ranked.length} connectivity hubs (ranked by unique runtime call/import/reference neighbors; structural containment excluded):`,
         ...ranked.map(
             (r, i) =>
-                `${String(i + 1).padStart(2)}. ${r.node.label ?? r.node.id}  (${r.deg} edges: out ${r.out}, in ${r.in})  [${r.node.id}]`
+                `${String(i + 1).padStart(2)}. ${r.node.label ?? r.node.id}  (${r.deg} unique: ${r.runtime} runtime, ${r.compileOnly} compile-only; out ${r.out}, in ${r.in}; ${r.occurrences} edge occurrence${r.occurrences === 1 ? '' : 's'})  [${r.node.id}]`
+        ),
+        `Repeated call sites affect the occurrence count, not the connectivity rank; compile-only neighbors are secondary to runtime coupling.`,
+        occurrenceHotspots.length ? `` : null,
+        occurrenceHotspots.length ? `High occurrence hotspots outside the connectivity rank (repeated call/reference sites; complexity signal, not broader coupling):` : null,
+        ...occurrenceHotspots.map((r) =>
+            `  ${r.node.label ?? r.node.id}  (${r.occurrences} occurrences across ${r.deg} unique neighbors; ${r.occurrences - r.deg} repeats)  [${r.node.id}]`
         ),
-    ].join('\n')
+    ].filter((line) => line != null).join('\n')
 }
 
 export function tGetCommunity(g, {community_id} = {}) {