weavatrix 0.1.3 → 0.2.0

package/src/analysis/graph-analysis.aggregate.js

@@ -6,6 +6,8 @@ import { join } from "node:path";
 import { normalizeRepoParts, readCoverageForRepo, pctFromCounts } from "./coverage-reports.js";
 import { bareSymbolName, countLocalRefsOutsideOwnRange, computeSymbolExternalRefs } from "./graph-analysis.refs.js";
 import { createRepoBoundary } from "../repo-path.js";
+import { edgeList, folderModuleOf } from "./graph-analysis.edges.js";
+export { folderModuleOf } from "./graph-analysis.edges.js";
 
 // Aggregate a built graph.json into the file- and module-level view the UI needs:
 //   - graph-builder nodes are FILES *and* their symbols (functions/methods), linked file→symbol by the
@@ -13,7 +15,6 @@ import { createRepoBoundary } from "../repo-path.js";
 //   - Each file is assigned to ONE module via its file-node's community (symbols may cluster apart,
 //     but the file itself belongs where its file-node sits) → exact, non-overlapping file counts.
 //   - Real edges (everything except "contains") roll up to file→file and module→module relations.
-// Module names match summarizeCommunities (dominant first-two-path-parts), so they line up with cards.
 export function analyzeGraph(graphJsonPath, repoRoot) {
   let graph;
   try {
@@ -40,15 +41,11 @@ export function aggregateGraph(graph, repoRoot) {
   // MODULE = the file's own top FOLDER (its "territory"), up to 2 path levels — NOT a dependency
   // cluster. e.g. src/widget/foo.js → "src/widget"; benchmarks/cleanup.py → "benchmarks" (so all
   // benchmarks files are one module); a top-level file like index.js → "(root)".
-  const folderOf = (file) => {
-    const dirs = String(file || "").split(/[\\/]/).filter(Boolean).slice(0, -1);
-    return dirs.length ? dirs.slice(0, 2).join("/") : "(root)";
-  };
   // In a merged (cross-repo) graph every node carries a `repo`; qualify file & module identity by it
   // so same-named folders/files in different repos never merge. Single-repo graphs have no `repo`,
   // so identity stays the bare path (unchanged behavior).
   const fileIdOf = (node) => (node.repo ? `${node.repo}::${node.source_file}` : node.source_file);
-  const moduleOfNode = (node) => (node.repo ? `${node.repo}/` : "") + folderOf(node.source_file);
+  const moduleOfNode = (node) => (node.repo ? `${node.repo}/` : "") + folderModuleOf(node.source_file);
 
   // file → module (folder) + symbols + display path, all keyed by repo-qualified file id
   const fileModule = new Map();
@@ -102,45 +99,41 @@ export function aggregateGraph(graph, repoRoot) {
   const moduleEdges = new Map();
   const typeOnlyFileEdges = new Map();
   const typeOnlyModuleEdges = new Map();
+  const compileOnlyFileEdges = new Map();
+  const compileOnlyModuleEdges = new Map();
+  const compileTimeFileEdges = new Map();
+  const compileTimeModuleEdges = new Map();
+  const addFileEdge = (map, key, link) => {
+    let edge = map.get(key);
+    if (!edge) map.set(key, (edge = { count: 0, rels: {} }));
+    edge.count++;
+    if (link.relation) edge.rels[link.relation] = (edge.rels[link.relation] || 0) + 1;
+  };
   for (const link of links) {
-    if (link.relation === "contains") continue;
+    if (link.relation === "contains" || link.barrelProxy === true) continue;
     const fromFile = id2file.get(endpoint(link.source));
     const toFile = id2file.get(endpoint(link.target));
     if (fromFile && toFile && fromFile !== toFile) {
       const key = `${fromFile} ${toFile}`;
-      const targetFileEdges = link.typeOnly === true ? typeOnlyFileEdges : fileEdges;
-      let fe = targetFileEdges.get(key);
-      if (!fe) targetFileEdges.set(key, (fe = { count: 0, rels: {} }));
-      fe.count++;
-      if (link.relation) fe.rels[link.relation] = (fe.rels[link.relation] || 0) + 1;
+      const compileTime = link.typeOnly === true || link.compileOnly === true;
+      const targetFileEdges = link.typeOnly === true ? typeOnlyFileEdges : link.compileOnly === true ? compileOnlyFileEdges : fileEdges;
+      addFileEdge(targetFileEdges, key, link);
+      if (compileTime) addFileEdge(compileTimeFileEdges, key, link);
       const fromMod = fileModule.get(fromFile);
       const toMod = fileModule.get(toFile);
       if (fromMod && toMod && fromMod !== toMod) {
         const mkey = `${fromMod} ${toMod}`;
-        const targetModuleEdges = link.typeOnly === true ? typeOnlyModuleEdges : moduleEdges;
+        const targetModuleEdges = link.typeOnly === true ? typeOnlyModuleEdges : link.compileOnly === true ? compileOnlyModuleEdges : moduleEdges;
         targetModuleEdges.set(mkey, (targetModuleEdges.get(mkey) || 0) + 1);
+        if (compileTime) compileTimeModuleEdges.set(mkey, (compileTimeModuleEdges.get(mkey) || 0) + 1);
       }
     }
   }
-  const split = (key) => {
-    const i = key.indexOf(" ");
-    return [key.slice(0, i), key.slice(i + 1)];
-  };
-  const edgeList = (map) =>
-    [...map.entries()]
-      .map(([key, v]) => {
-        const [from, to] = split(key);
-        if (typeof v === "number") return { from, to, count: v }; // moduleEdges (no relation breakdown)
-        const dom = Object.entries(v.rels).sort((a, b) => b[1] - a[1])[0];
-        return { from, to, count: v.count, relation: dom ? dom[0] : null };
-      })
-      .sort((a, b) => b.count - a.count);
-
   // symbol-level (function/method) call graph: edges between symbol nodes (calls/method), each symbol
   // tagged with its file's module so the Symbols view can still cluster into module regions.
   const symEdges = new Map();
   for (const link of links) {
-    if (link.relation === "contains") continue;
+    if (link.relation === "contains" || link.barrelProxy === true) continue;
     const s = endpoint(link.source);
     const t = endpoint(link.target);
     if (s === t || !symbolIds.has(s) || !symbolIds.has(t)) continue;
@@ -268,8 +261,12 @@ export function aggregateGraph(graph, repoRoot) {
       .sort((a, b) => b.fileCount - a.fileCount),
     moduleEdges: edgeList(moduleEdges),
     typeOnlyModuleEdges: edgeList(typeOnlyModuleEdges),
+    compileOnlyModuleEdges: edgeList(compileOnlyModuleEdges),
+    compileTimeModuleEdges: edgeList(compileTimeModuleEdges),
     fileEdges: edgeList(fileEdges),
     typeOnlyFileEdges: edgeList(typeOnlyFileEdges),
+    compileOnlyFileEdges: edgeList(compileOnlyFileEdges),
+    compileTimeFileEdges: edgeList(compileTimeFileEdges),
     symbols,
     symbolEdges,
     symbolRefs: [...new Set([...symbolLocalRefs.keys(), ...symbolExternalRefs.keys()])].map((id) => {
@@ -283,8 +280,12 @@ export function aggregateGraph(graph, repoRoot) {
       nodes: nodes.filter((n) => n.file_type === "code").length,
       fileEdges: fileEdges.size,
       typeOnlyFileEdges: typeOnlyFileEdges.size,
+      compileOnlyFileEdges: compileOnlyFileEdges.size,
+      compileTimeFileEdges: compileTimeFileEdges.size,
       moduleEdges: moduleEdges.size,
       typeOnlyModuleEdges: typeOnlyModuleEdges.size,
+      compileOnlyModuleEdges: compileOnlyModuleEdges.size,
+      compileTimeModuleEdges: compileTimeModuleEdges.size,
       symbols: symbols.length,
       symbolEdges: symbolEdges.length
     }

package/src/analysis/graph-analysis.edges.js

@@ -0,0 +1,24 @@
+import { communityTerritoryOf } from "../graph/community.js";
+
+// Stable folder territories used by module_map. Nested package source roots keep the first directory below
+// `src`; otherwise a monorepo's entire crate/app would collapse into one module with no visible dependencies.
+export function folderModuleOf(file) {
+  if (/\.java$/i.test(String(file || ""))) return communityTerritoryOf(file);
+  const dirs = String(file || "").split(/[\\/]/).filter(Boolean).slice(0, -1);
+  if (!dirs.length) return "(root)";
+  const sourceRoot = dirs.lastIndexOf("src");
+  if (sourceRoot >= 0 && dirs.length > sourceRoot + 1) return dirs.slice(0, sourceRoot + 2).join("/");
+  return dirs.slice(0, 2).join("/");
+}
+
+export function edgeList(map) {
+  return [...map.entries()]
+    .map(([key, value]) => {
+      const splitAt = key.indexOf(" ");
+      const from = key.slice(0, splitAt), to = key.slice(splitAt + 1);
+      if (typeof value === "number") return { from, to, count: value };
+      const dominant = Object.entries(value.rels).sort((a, b) => b[1] - a[1])[0];
+      return { from, to, count: value.count, relation: dominant ? dominant[0] : null };
+    })
+    .sort((a, b) => b.count - a.count);
+}

package/src/analysis/graph-analysis.js

@@ -4,4 +4,4 @@
 // Facade: implementation lives in graph-analysis.summaries.js and graph-analysis.aggregate.js
 // (with internal helpers in graph-analysis.refs.js).
 export { summarizeCommunities, summarizeHotspots } from "./graph-analysis.summaries.js";
-export { analyzeGraph, aggregateGraph } from "./graph-analysis.aggregate.js";
+export { analyzeGraph, aggregateGraph, folderModuleOf } from "./graph-analysis.aggregate.js";

package/src/analysis/graph-analysis.summaries.js

@@ -1,6 +1,8 @@
 // Reading a built graph.json and summarizing it for the UI cards: named communities and degree
 // hotspots. Both read the graph file from disk and return [] on any failure.
 import { readFileSync } from "node:fs";
+import { communityTerritoryOf } from "../graph/community.js";
+import { isStructuralRelation } from "../graph/relations.js";
 
 // graph-builder labels communities "Community N" without an LLM. Derive a real name from each
 // community's dominant folder + sample files so the UI shows modules, not bare numbers.
@@ -16,7 +18,7 @@ export function summarizeCommunities(graphJsonPath, max = 40) {
       const entry = byCommunity.get(community);
       entry.size += 1;
       const parts = String(node.source_file || "").split(/[\\/]/).filter(Boolean);
-      const dir = parts.length > 1 ? parts.slice(0, 2).join("/") : "(root)";
+      const dir = communityTerritoryOf(node.source_file);
       entry.dirs.set(dir, (entry.dirs.get(dir) || 0) + 1);
       if (entry.files.length < 4) entry.files.push(parts[parts.length - 1] || node.source_file || "");
     }
@@ -41,6 +43,7 @@ export function summarizeHotspots(graphJsonPath, max = 15) {
     const inDeg = new Map();
     const outDeg = new Map();
     for (const link of graph.links || []) {
+      if (isStructuralRelation(link.relation) || link.barrelProxy === true) continue;
       const s = endpoint(link.source);
       const t = endpoint(link.target);
       outDeg.set(s, (outDeg.get(s) || 0) + 1);