weavatrix 0.1.3 → 0.1.4

package/src/mcp/tools-graph.mjs

@@ -7,16 +7,20 @@ import {
     graphStaleness, fileStalenessNote,
 } from './graph-context.mjs'
 
+const compileKind = (edge) => edge?.typeOnly === true ? 'type-only' : edge?.compileOnly === true ? 'compile-only' : null
+
 export function tGraphStats(g, ctx) {
     const files = g.nodes.filter((n) => !isSymbol(n.id)).length
     const symbols = g.nodes.length - files
     const relCount = {}
     const confCount = {}
     let typeOnlyEdges = 0
+    let compileOnlyEdges = 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++
+        if (e.compileOnly === true) compileOnlyEdges++
     }
     const comm = new Map()
     for (const n of g.nodes) {
@@ -35,7 +39,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+)`,
+        g.edgeTypesV ? `- Typed-edge metadata: v${g.edgeTypesV} (${typeOnlyEdges} type-only, ${compileOnlyEdges} compile-only edges)` : `- Typed-edge metadata: unavailable (rebuild_graph required)`,
         `- Relations: ${fmt(relCount)}`,
         Object.keys(confCount).length ? `- Confidence: ${fmt(confCount)}` : null,
         `- Communities: ${comm.size} (top by size: ${topComm.map(([c, n]) => `#${c}=${n}`).join(', ')})`,
@@ -57,7 +61,7 @@ export function tGetNode(g, {label} = {}, ctx) {
     const sample = (list, dir) =>
         list
             .slice(0, 12)
-            .map((e) => `  ${dir === 'out' ? '→' : '←'} ${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]`)
+            .map((e) => `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]`)
             .join('\n') || '  (none)'
     return [
         note,
@@ -80,10 +84,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.typeOnly === true ? 'type' : 'runtime'}|${e.id}`
+        const key = `${e.relation || 'rel'}|${compileKind(e) || 'runtime'}|${e.id}`
         const cur = grouped.get(key)
         if (cur) cur.count += 1
-        else grouped.set(key, {id: e.id, relation: e.relation, typeOnly: e.typeOnly === true, count: 1})
+        else grouped.set(key, {id: e.id, relation: e.relation, typeOnly: e.typeOnly === true, compileOnly: e.compileOnly === true, count: 1})
     }
     return [...grouped.values()]
 }
@@ -102,7 +106,7 @@ export function tGetNeighbors(g, {label, relation_filter} = {}, ctx) {
     const outs = dedupeEdges(outsRaw)
     const ins = dedupeEdges(insRaw)
     const line = (e, dir) =>
-        `  ${dir === 'out' ? '→' : '←'} ${e.typeOnly ? 'type-only ' : ''}${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]${e.count > 1 ? `  (${e.count} sites)` : ''}`
+        `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${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)`,
@@ -114,55 +118,8 @@ export function tGetNeighbors(g, {label, relation_filter} = {}, ctx) {
     ].filter(Boolean).join('\n')
 }
 
-export function tGodNodes(g, {top_n = 10} = {}) {
-    const n = Math.max(1, Math.min(100, Number(top_n) || 10))
-    const scored = g.nodes
-        .map((node) => {
-            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,
-            }
-        })
-        .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 ${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} 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}]`
-        ),
-    ].filter((line) => line != null).join('\n')
-}
+export {tGodNodes} from './tools-graph-hubs.mjs'
+
 
 export function tGetCommunity(g, {community_id} = {}) {
     const groups = new Map()

package/src/mcp/tools-health.mjs

@@ -113,7 +113,7 @@ export async function tRunAudit(g, args, ctx) {
     return [
         `Internal audit of ${audit.repo} (${audit.scanned.files} files, ${audit.scanned.symbols} symbols, ${audit.scanned.externalImports} external imports; malware scan: ${audit.scanned.malwareScanMode}).`,
         `Severity: critical ${sev.critical}, high ${sev.high}, medium ${sev.medium}, low ${sev.low}, info ${sev.info}. Categories: unused ${bycat.unused}, structure ${bycat.structure}, vulnerability ${bycat.vulnerability}, malware ${bycat.malware}.`,
-        `Structure: ${audit.structureReport?.runtimeCycles ?? audit.structureReport?.cycles ?? 0} runtime cycle(s), ${audit.structureReport?.typeCouplings ?? 0} type-induced coupling group(s), ${audit.structureReport?.orphans ?? 0} orphan(s); import edges: ${audit.structureReport?.runtimeImportEdges ?? audit.structureReport?.importEdges ?? 0} runtime + ${audit.structureReport?.typeOnlyImportEdges ?? 0} type-only. Dead: ${audit.deadReport.deadFiles} file(s), ${audit.deadReport.unusedExports} unused export(s).`,
+        `Structure: ${audit.structureReport?.runtimeCycles ?? audit.structureReport?.cycles ?? 0} runtime cycle(s), ${audit.structureReport?.compileTimeCouplings ?? audit.structureReport?.typeCouplings ?? 0} compile-time coupling group(s), ${audit.structureReport?.orphans ?? 0} orphan(s); import edges: ${audit.structureReport?.runtimeImportEdges ?? audit.structureReport?.importEdges ?? 0} runtime + ${audit.structureReport?.typeOnlyImportEdges ?? 0} type-only + ${audit.structureReport?.compileOnlyImportEdges ?? 0} compile-only. Dead: ${audit.deadReport.deadFiles} file(s), ${audit.deadReport.unusedExports} unused export(s).`,
         `Checks: ${check('OSV', audit.checks?.osv)}; ${check('malware', audit.checks?.malware)}. A NOT_CHECKED/PARTIAL/ERROR check is incomplete or unknown, never a clean zero.`,
         ``,
         `Showing ${shown.length} of ${filtered.length} finding(s)${cat ? ` in category "${cat}"` : ''}${args.min_severity ? ` at ≥${args.min_severity}` : ''}:`,
@@ -140,16 +140,28 @@ export function tModuleMap(g, args, ctx) {
     const topN = Math.max(1, Math.min(60, Number(args.top_n) || 25))
     const mods = agg.modules.slice(0, topN)
     const edges = agg.moduleEdges.slice(0, Math.min(50, topN * 2))
-    const typeEdges = (agg.typeOnlyModuleEdges || []).slice(0, Math.min(50, topN * 2))
+    const compileEdges = new Map()
+    const collectCompileEdges = (list, kind) => {
+        for (const edge of list || []) {
+            const key = `${edge.from}\0${edge.to}`
+            const current = compileEdges.get(key) || {from: edge.from, to: edge.to, count: 0, typeOnly: 0, compileOnly: 0}
+            current.count += edge.count
+            current[kind] += edge.count
+            compileEdges.set(key, current)
+        }
+    }
+    collectCompileEdges(agg.typeOnlyModuleEdges, 'typeOnly')
+    collectCompileEdges(agg.compileOnlyModuleEdges, 'compileOnly')
+    const compiled = [...compileEdges.values()].sort((a, b) => b.count - a.count).slice(0, Math.min(50, topN * 2))
     return [
-        `Module map: ${agg.totals.files} files in ${agg.modules.length} folder-modules, ${agg.totals.moduleEdges} runtime module dependencies and ${agg.totals.typeOnlyModuleEdges || 0} type-only dependencies. Top ${mods.length}:`,
+        `Module map: ${agg.totals.files} files in ${agg.modules.length} folder-modules, ${agg.totals.moduleEdges} runtime module dependencies and ${agg.totals.compileTimeModuleEdges || 0} compile-time dependencies (${agg.totals.typeOnlyModuleEdges || 0} type-only, ${agg.totals.compileOnlyModuleEdges || 0} compile-only). Top ${mods.length}:`,
         ...mods.map((m) => `  ${m.name} — ${m.fileCount} files, ${m.symbolCount} symbols`),
         ``,
         `Strongest runtime module dependencies:`,
         ...edges.map((e) => `  ${e.from} → ${e.to}  (${e.count})`),
-        typeEdges.length ? `` : null,
-        typeEdges.length ? `Type-only module dependencies (compile-time contracts, not runtime coupling):` : null,
-        ...typeEdges.map((e) => `  ${e.from} → ${e.to}  (${e.count})`),
+        compiled.length ? `` : null,
+        compiled.length ? `Compile-time module dependencies (not runtime coupling):` : null,
+        ...compiled.map((e) => `  ${e.from} → ${e.to}  (${e.count}; ${e.typeOnly} type-only, ${e.compileOnly} compile-only)`),
     ].filter((line) => line != null).join('\n')
 }
 

package/src/mcp/tools-impact.mjs

@@ -9,6 +9,7 @@ import {
     rawGraph, prevGraphPathFor, edgeEndpoint, diffGraphs, formatGraphDiff,
 } from './graph-context.mjs'
 import {readCoverageForRepo} from '../analysis/coverage-reports.js'
+import {isStructuralRelation} from '../graph/relations.js'
 
 function reverseReach(g, seeds, maxDepth) {
     const states = new Map([...seeds].map((id) => [String(id), {
@@ -19,9 +20,9 @@ function reverseReach(g, seeds, maxDepth) {
         const current = frontier[cursor]
         if (current.depth >= maxDepth) continue
         for (const e of g.inn.get(current.id) || []) {
-            if (e.relation === 'contains') continue
+            if (isStructuralRelation(e.relation)) continue
             const id = String(e.id)
-            const compileOnly = current.compileOnly || e.typeOnly === true
+            const compileOnly = current.compileOnly || e.typeOnly === true || e.compileOnly === true
             const depth = current.depth + 1
             const entry = states.get(id) || {
                 runtimeDepth: null, runtimeRelation: null, compileDepth: null, compileRelation: null,
@@ -74,12 +75,14 @@ export function tGetDependents(g, {label, depth = 3, max_nodes = 40} = {}) {
     const ranked = [...reached.entries()]
         .filter(([nid]) => !seeds.has(nid))
         .map(([nid, entry]) => ({id: nid, d: entry.depth, entry, deg: degreeOf(g, nid)}))
-        .sort((a, b) => a.d - b.d || b.deg - a.deg)
+        .sort((a, b) => a.d - b.d || Number(a.entry.compileOnly) - Number(b.entry.compileOnly) || b.deg - a.deg)
     if (!ranked.length) return [note, `No dependents found for ${n.label ?? id} within depth ${maxDepth} — nothing in the graph calls, imports, or inherits it.`].filter(Boolean).join('\n')
     const shown = ranked.slice(0, cap)
+    const runtimeCount = ranked.filter((entry) => !entry.entry.compileOnly).length
+    const compileCount = ranked.length - runtimeCount
     return [
         note,
-        `Dependents of ${n.label ?? id} (reverse calls/imports/inherits, depth ≤${maxDepth}): ${ranked.length} found, showing ${shown.length} by proximity + connectivity.`,
+        `Dependents of ${n.label ?? id} (reverse calls/imports/inherits, depth ≤${maxDepth}): ${ranked.length} found (${runtimeCount} runtime, ${compileCount} compile-time-only), showing ${shown.length} by proximity + connectivity.`,
         containingFile ? `Includes importers of its containing file ${labelOf(g, containingFile)}.` : null,
         ...shown.map((r) => `  [d${r.d} ${impactKind(r.entry)}] ${r.entry.relation || 'rel'}  ${labelOf(g, r.id)}  (deg ${r.deg})  [${r.id}]`),
     ].filter(Boolean).join('\n')
@@ -174,7 +177,7 @@ export function tChangeImpact(g, args, ctx) {
     const impacted = [...reached.entries()]
         .filter(([nid]) => !seeds.has(nid) && !changedSet.has(fileOfNode(nid)))
         .map(([nid, entry]) => ({id: nid, d: entry.depth, entry, deg: degreeOf(g, nid), file: fileOfNode(nid)}))
-        .sort((a, b) => a.d - b.d || b.deg - a.deg)
+        .sort((a, b) => a.d - b.d || Number(a.entry.compileOnly) - Number(b.entry.compileOnly) || b.deg - a.deg)
 
     // coverage overlay from EXISTING reports (fractions 0..1) — see coverage_map for details
     const knownFiles = (rawGraph(ctx).nodes || []).filter((n) => !String(n.id).includes('#') && n.source_file).map((n) => n.source_file)
@@ -184,11 +187,13 @@ export function tChangeImpact(g, args, ctx) {
     const hasCoverage = coverage.size > 0
 
     const shown = impacted.slice(0, cap)
+    const runtimeImpacted = impacted.filter((entry) => !entry.entry.compileOnly).length
+    const compileImpacted = impacted.length - runtimeImpacted
     const untestedHotspots = shown.filter((n) => { const c = covOf(n.file); return c != null && c < 0.5 && n.deg >= 5 })
     return [
         `Change impact ${sourceLabel}: ${changed.length} changed file(s) → ${seeds.size} graph seed(s) incl. their symbols${unmapped.length ? `; ${unmapped.length} file(s) not in the graph (new/non-code — rebuild_graph refreshes)` : ''}.`,
         impacted.length
-            ? `${impacted.length} impacted node(s) within ${maxDepth} reverse hop(s), showing ${shown.length}:`
+            ? `${impacted.length} impacted node(s) within ${maxDepth} reverse hop(s) (${runtimeImpacted} runtime, ${compileImpacted} compile-time-only), showing ${shown.length}:`
             : `Nothing else in the graph depends on the changed code within ${maxDepth} hop(s).`,
         hasCoverage ? `Coverage: existing report mapped where available.` : `Coverage: unavailable (no supported report found); per-node coverage labels omitted.`,
         ...shown.map((n) => `  [d${n.d} ${impactKind(n.entry)}] ${n.entry.relation || 'rel'}  ${labelOf(g, n.id)}  (deg ${n.deg}${hasCoverage ? `, ${pctStr(covOf(n.file))}` : ''})  [${n.id}]`),

package/src/mcp-server.mjs

@@ -131,8 +131,8 @@ async function main() {
             if (!graph && tool.cap !== 'build' && tool.cap !== 'retarget') return reply(id, {content: [{type: 'text', text: `Graph unavailable: ${graphError}`}], isError: true})
             try {
                 let text = String(await tool.run(graph, params?.arguments || {}, ctx))
-                if (graph && graph.edgeTypesV < 1 && (tool.cap === 'graph' || tool.cap === 'health')) {
-                    text += '\n\nWarning: this saved graph predates typed import edges, so type-only imports cannot be separated from runtime dependencies. Call rebuild_graph once before acting on cycle, boundary, dependency, or blast-radius findings.'
+                if (graph && graph.edgeTypesV < 2 && (tool.cap === 'graph' || tool.cap === 'health')) {
+                    text += '\n\nWarning: this saved graph predates compile-only edge metadata (edge schema v2), so Rust module/use dependencies may be absent or misclassified. Call rebuild_graph once before acting on cycle, boundary, dependency, or blast-radius findings.'
                 }
                 // Graph answers silently reflect a point-in-time build — surface staleness on every graph tool.
                 if (tool.cap === 'graph') {