weavatrix 0.1.4 → 0.2.0

package/src/graph/incremental-refresh.js

@@ -0,0 +1,232 @@
+// Conservative incremental graph refresh. This module never writes graph.json: it either returns the
+// untouched complete graph, a fully rebuilt graph, or a complete merge of a bounded scoped parse into
+// the previous graph. Callers own serialization/locking.
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { extname, relative } from "node:path";
+import { walk } from "./internal-builder.langs.js";
+import { createRepoBoundary } from "../repo-path.js";
+import { assignDeterministicCommunities } from "./community.js";
+
+const JS_EXT = new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
+const CONFIG_RISK = /(^|\/)(package(?:-lock)?\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|tsconfig(?:\.[^/]*)?\.json|jsconfig(?:\.[^/]*)?\.json|go\.(?:mod|sum)|Cargo\.(?:toml|lock)|pom\.xml|build\.gradle(?:\.kts)?|vite\.config\.[^/]+|webpack\.config\.[^/]+|babel\.config\.[^/]+)$/i;
+const CONTROL_FILES = [".gitignore", ".weavatrixignore", ".weavatrix.json"];
+const MAX_CONTROL_BYTES = 1_000_000;
+
+const norm = (value) => String(value || "").replace(/\\/g, "/").replace(/^\.\//, "");
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const endpoint = (value) => String(value && typeof value === "object" ? value.id : value);
+const fileOfEndpoint = (value, nodesById) => {
+  const id = endpoint(value);
+  const source = nodesById.get(id)?.source_file;
+  if (source) return norm(source);
+  const marker = id.indexOf("#");
+  return norm(marker < 0 ? id : id.slice(0, marker));
+};
+
+// We only need to know whether a module's public surface changed, not understand its implementation.
+// The full tree-sitter pass remains authoritative; this signature is deliberately conservative and
+// whitespace-insensitive. Any changed export statement forces a full rebuild.
+export function jsExportSignature(text, file = "") {
+  if (!JS_EXT.has(extname(file))) return "";
+  const source = String(text || "");
+  const exports = [];
+  const pattern = /\bexport\s+(?:declare\s+)?(?:type\s+)?(?:\*\s+(?:as\s+[A-Za-z_$][\w$]*\s+)?from\s*["'][^"']+["']|\{[\s\S]*?\}(?:\s+from\s*["'][^"']+["'])?|default\s+(?:(?:async\s+)?function\s*\*?|class)?\s*[A-Za-z_$]?[\w$]*|(?:async\s+)?function\s*\*?\s+[A-Za-z_$][\w$]*|class\s+[A-Za-z_$][\w$]*|(?:const|let|var|interface|type|enum)\s+[A-Za-z_$][\w$]*)/g;
+  for (const match of source.matchAll(pattern)) exports.push(match[0].replace(/\s+/g, " ").trim());
+  // The general matcher intentionally stops before implementation bodies. Preserve every binding name
+  // in multi-declarator exports (`export const a = 1, b = 2`) so adding/removing one cannot slip through.
+  for (const match of source.matchAll(/\bexport\s+(?:declare\s+)?(?:const|let|var)\s+([^;\n]+)/g)) {
+    const names = [];
+    for (const part of match[1].split(",")) {
+      const declared = part.trim().match(/^([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=/);
+      if (declared) names.push(declared[1]);
+    }
+    exports.push(`bindings:${names.join(",")}`);
+  }
+  return hash(exports.join("\n"));
+}
+
+export function snapshotRepository(repoDir, files = walk(repoDir)) {
+  const root = String(repoDir);
+  const fileHashes = {};
+  const fileExportSignatures = {};
+  const relativeFiles = [];
+  for (const abs of files) {
+    const rel = norm(relative(root, abs));
+    let body;
+    try { body = readFileSync(abs); } catch { continue; }
+    relativeFiles.push(rel);
+    fileHashes[rel] = hash(body);
+    if (JS_EXT.has(extname(rel))) fileExportSignatures[rel] = jsExportSignature(body.toString("utf8"), rel);
+  }
+  relativeFiles.sort();
+  const controlHashes = {};
+  const boundary = createRepoBoundary(root);
+  for (const rel of CONTROL_FILES) {
+    const resolved = boundary.resolve(rel);
+    if (!resolved.ok) {
+      controlHashes[rel] = resolved.reason === "not-found" ? null : `UNREADABLE:${resolved.reason}`;
+      continue;
+    }
+    try {
+      const stats = statSync(resolved.path);
+      controlHashes[rel] = stats.isFile() && stats.size <= MAX_CONTROL_BYTES
+        ? hash(readFileSync(resolved.path))
+        : stats.isFile() ? "UNREADABLE:oversized" : "UNREADABLE:not-file";
+    } catch {
+      controlHashes[rel] = "UNREADABLE:unreadable";
+    }
+  }
+  const revision = hash([
+    ...relativeFiles.map((file) => `${file}:${fileHashes[file]}`),
+    ...Object.keys(controlHashes).sort().map((file) => `${file}:${controlHashes[file] ?? "missing"}`),
+  ].join("\n"));
+  return { files, relativeFiles, fileHashes, fileExportSignatures, controlHashes, revision };
+}
+
+function sameRecord(left, right) {
+  const a = left && typeof left === "object" ? left : {};
+  const b = right && typeof right === "object" ? right : {};
+  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) if (a[key] !== b[key]) return false;
+  return true;
+}
+
+function changedPaths(previous, current) {
+  const keys = new Set([...Object.keys(previous || {}), ...Object.keys(current || {})]);
+  return [...keys].filter((file) => previous?.[file] !== current?.[file]).sort();
+}
+
+function isBarrelFile(graph, file) {
+  const nodesById = new Map((graph.nodes || []).map((node) => [String(node.id), node]));
+  return (graph.links || []).some((link) => {
+    const sourceFile = fileOfEndpoint(link.source, nodesById);
+    return sourceFile === file && (link.relation === "re_exports" || link.barrelProxy === true);
+  });
+}
+
+function reverseImporters(graph, changed) {
+  const changedSet = new Set(changed);
+  const nodesById = new Map((graph.nodes || []).map((node) => [String(node.id), node]));
+  const result = new Set();
+  for (const link of graph.links || []) {
+    const targetFile = fileOfEndpoint(link.target, nodesById);
+    if (!changedSet.has(targetFile)) continue;
+    const sourceFile = fileOfEndpoint(link.source, nodesById);
+    if (sourceFile && sourceFile !== targetFile) result.add(sourceFile);
+  }
+  return result;
+}
+
+function mergeScopedGraph(base, scoped, affected, snapshot) {
+  const affectedSet = new Set(affected);
+  const baseNodes = Array.isArray(base.nodes) ? base.nodes : [];
+  const scopedNodes = Array.isArray(scoped.nodes) ? scoped.nodes : [];
+  const baseNodesById = new Map(baseNodes.map((node) => [String(node.id), node]));
+  const nodeFile = (node) => norm(node?.source_file || fileOfEndpoint(node?.id, baseNodesById));
+  const nodes = [...baseNodes.filter((node) => !affectedSet.has(nodeFile(node))), ...scopedNodes];
+  assignDeterministicCommunities(nodes);
+  const nodesById = new Map(nodes.map((node) => [String(node.id), node]));
+  if (nodesById.size !== nodes.length) throw new Error("incremental merge produced duplicate node ids");
+
+  const baseLinkKept = (link) => {
+    const sourceFile = fileOfEndpoint(link.source, baseNodesById);
+    // A scoped rebuild owns every outgoing edge of an affected source. Incoming edges from an
+    // unaffected source still describe that source and must survive (A -> B -> changed C reparses
+    // B+C, but A -> B is not regenerated by the scoped builder). The node-id filter below safely
+    // removes an incoming edge when its affected target symbol no longer exists.
+    return !affectedSet.has(sourceFile);
+  };
+  // Base and scoped links are disjoint by source file: every scoped source was removed above. Keep
+  // repeated call/reference occurrences intact because occurrence hotspots intentionally use them.
+  const links = [...(base.links || []).filter(baseLinkKept), ...(scoped.links || [])]
+    .filter((link) => nodesById.has(endpoint(link.source)) && nodesById.has(endpoint(link.target)));
+
+  const externalImports = [
+    ...(base.externalImports || []).filter((record) => !affectedSet.has(norm(record?.file))),
+    ...(scoped.externalImports || []),
+  ];
+  const fileNodes = new Set(nodes.filter((node) => !String(node.id).includes("#")).map((node) => norm(node.source_file || node.id)));
+  if (fileNodes.size !== snapshot.relativeFiles.length || snapshot.relativeFiles.some((file) => !fileNodes.has(file))) {
+    throw new Error("incremental merge did not preserve the complete file universe");
+  }
+
+  const merged = {
+    ...base,
+    nodes,
+    links,
+    externalImports,
+    jsExportRecords: scoped.jsExportRecords || base.jsExportRecords || {},
+    fileHashes: snapshot.fileHashes,
+    fileExportSignatures: snapshot.fileExportSignatures,
+    controlHashes: snapshot.controlHashes,
+    graphRevision: snapshot.revision,
+  };
+  for (const key of ["extImportsV", "edgeTypesV", "complexityV", "repoBoundaryV", "barrelResolutionV", "extractorSchemaV"]) {
+    merged[key] = Math.max(Number(base[key]) || 0, Number(scoped[key]) || 0);
+  }
+  return merged;
+}
+
+export async function refreshGraphIncrementally(repoDir, existingGraph, {
+  buildGraph,
+  maxChangedFiles = 24,
+  maxParsedFiles = 80,
+  builderOptions = {},
+} = {}) {
+  const builder = buildGraph || (await import("./internal-builder.js")).buildInternalGraph;
+  const snapshot = snapshotRepository(repoDir);
+  const full = async (reason, changedFiles = []) => {
+    const graph = await builder(repoDir, builderOptions);
+    return { graph, kind: "full", changedFiles, reason, revision: graph.graphRevision || snapshot.revision, parsedFiles: snapshot.relativeFiles };
+  };
+
+  if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
+    || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
+    || Number(existingGraph.extractorSchemaV) < 1) {
+    return full("incremental-baseline-unavailable");
+  }
+  if (!sameRecord(existingGraph.controlHashes, snapshot.controlHashes)) return full("ignore-or-control-config-changed");
+
+  const oldFiles = Object.keys(existingGraph.fileHashes).sort();
+  if (oldFiles.length !== snapshot.relativeFiles.length || oldFiles.some((file, index) => file !== snapshot.relativeFiles[index])) {
+    const changedFiles = changedPaths(existingGraph.fileHashes, snapshot.fileHashes);
+    return full("file-universe-changed", changedFiles);
+  }
+  const changedFiles = changedPaths(existingGraph.fileHashes, snapshot.fileHashes);
+  if (!changedFiles.length) {
+    return { graph: existingGraph, kind: "none", changedFiles: [], reason: "content-unchanged", revision: snapshot.revision, parsedFiles: [] };
+  }
+  if (changedFiles.length > maxChangedFiles) return full("changed-set-too-large", changedFiles);
+  if (changedFiles.some((file) => CONFIG_RISK.test(file))) return full("config-manifest-or-alias-changed", changedFiles);
+  if (changedFiles.some((file) => !JS_EXT.has(extname(file)))) return full("language-requires-full-context", changedFiles);
+  for (const file of changedFiles) {
+    if (isBarrelFile(existingGraph, file)) return full(`barrel-file-changed:${file}`, changedFiles);
+    if (existingGraph.fileExportSignatures[file] !== snapshot.fileExportSignatures[file]) {
+      return full(`export-surface-changed:${file}`, changedFiles);
+    }
+  }
+
+  const importers = reverseImporters(existingGraph, changedFiles);
+  const affected = [...new Set([...changedFiles, ...importers])].filter((file) => snapshot.fileHashes[file]).sort();
+  if (affected.length > maxParsedFiles) return full("reverse-importer-set-too-large", changedFiles);
+  try {
+    const scoped = await builder(repoDir, {
+      ...builderOptions,
+      includeFiles: affected,
+      baseGraph: existingGraph,
+    });
+    if (scoped.incrementalScope !== true) return full("builder-did-not-honor-incremental-scope", changedFiles);
+    const graph = mergeScopedGraph(existingGraph, scoped, affected, snapshot);
+    return {
+      graph,
+      kind: "incremental",
+      changedFiles,
+      reason: importers.size ? "changed-files-and-reverse-importers" : "changed-files-only",
+      revision: snapshot.revision,
+      parsedFiles: affected,
+    };
+  } catch {
+    return full("incremental-merge-safety-fallback", changedFiles);
+  }
+}

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

@@ -0,0 +1,169 @@
+// TypeScript/JavaScript barrel transparency. The parser keeps physical import/re-export edges for
+// execution-order and cycle analysis; this post-pass resolves public export names to their declaring
+// files, marks the physical facade hops as proxies, and adds direct semantic importer -> origin edges.
+// Resolution follows ESM rules that matter for a static graph: explicit exports shadow `export *`,
+// `default` never flows through a star, cycles terminate, and conflicting star origins stay ambiguous.
+
+const resolved = (file, name, typeOnly = false) => ({ status: "resolved", origin: { file, name, typeOnly } });
+const MISSING = Object.freeze({ status: "missing" });
+const AMBIGUOUS = Object.freeze({ status: "ambiguous" });
+
+function mergeCandidates(candidates) {
+  if (candidates.some((candidate) => candidate.status === "ambiguous")) return AMBIGUOUS;
+  const origins = new Map();
+  for (const candidate of candidates) {
+    if (candidate.status !== "resolved") continue;
+    const key = `${candidate.origin.file}\0${candidate.origin.name}`;
+    const current = origins.get(key);
+    if (!current) origins.set(key, { ...candidate.origin });
+    else current.typeOnly = current.typeOnly && candidate.origin.typeOnly;
+  }
+  if (!origins.size) return MISSING;
+  if (origins.size > 1) return AMBIGUOUS;
+  return { status: "resolved", origin: [...origins.values()][0] };
+}
+
+function withTypeOnly(result, typeOnly) {
+  if (result.status !== "resolved" || !typeOnly) return result;
+  return resolved(result.origin.file, result.origin.name, true);
+}
+
+export function resolveJsBarrels({ jsExports, importedLocals, links }) {
+  const tables = new Map();
+  for (const [file, records] of jsExports) {
+    const table = { explicit: new Map(), stars: [] };
+    for (const record of records || []) {
+      if (record.kind === "star") {
+        table.stars.push(record);
+        continue;
+      }
+      if (!record.exported) continue;
+      const list = table.explicit.get(record.exported) || [];
+      list.push(record);
+      table.explicit.set(record.exported, list);
+    }
+    tables.set(file, table);
+  }
+
+  const cache = new Map();
+  const resolveExport = (file, name, trail = new Set()) => {
+    const key = `${file}\0${name}`;
+    const rootResolution = trail.size === 0;
+    if (cache.has(key)) return cache.get(key);
+    if (trail.has(key)) return MISSING;
+    const table = tables.get(file);
+    if (!table) return MISSING;
+    const nextTrail = new Set(trail);
+    nextTrail.add(key);
+
+    const explicit = table.explicit.get(name) || [];
+    if (explicit.length) {
+      const candidates = explicit.map((record) => {
+        if (record.kind === "named") {
+          return withTypeOnly(resolveExport(record.targetFile, record.imported, nextTrail), record.typeOnly);
+        }
+        if (record.kind === "namespace") return resolved(record.targetFile, "*", record.typeOnly);
+        const local = record.local || name;
+        const binding = importedLocals.get(file)?.get(local);
+        if (binding?.targetFile && binding.imported && binding.imported !== "*") {
+          return withTypeOnly(resolveExport(binding.targetFile, binding.imported, nextTrail), record.typeOnly || binding.typeOnly);
+        }
+        // Type/interface declarations are intentionally not symbol nodes yet, but their declaring file is
+        // still the correct semantic origin for file/module dependency analysis.
+        return resolved(file, local, record.typeOnly);
+      });
+      const result = mergeCandidates(candidates);
+      if (rootResolution) cache.set(key, result);
+      return result;
+    }
+
+    if (name === "default") {
+      if (rootResolution) cache.set(key, MISSING);
+      return MISSING;
+    }
+    const candidates = table.stars.map((star) => withTypeOnly(resolveExport(star.targetFile, name, nextTrail), star.typeOnly));
+    const result = mergeCandidates(candidates);
+    if (rootResolution) cache.set(key, result);
+    return result;
+  };
+
+  // Every internal re-export is a physical facade hop. It remains in the graph for runtime cycle truth,
+  // but semantic consumers ignore it in favor of importer -> declaration edges below.
+  for (const link of links) {
+    if (link.relation !== "re_exports") continue;
+    const records = jsExports.get(String(link.source)) || [];
+    if (records.some((record) => record.targetFile === String(link.target))) link.barrelProxy = true;
+  }
+
+  const semanticEdges = new Map();
+  const addSemanticEdge = (source, imp, origin, usage = null, force = false) => {
+    if (!origin?.file || (!force && origin.file === imp.targetFile)) return;
+    const key = `${source}\0${origin.file}\0${imp.line || 0}`;
+    const effectiveTypeOnly = imp.typeOnly === true || origin.typeOnly === true;
+    const current = semanticEdges.get(key);
+    if (current) {
+      if (!effectiveTypeOnly) delete current.typeOnly;
+      return;
+    }
+    semanticEdges.set(key, {
+      source,
+      target: origin.file,
+      relation: "imports",
+      confidence: "EXTRACTED",
+      semanticOrigin: true,
+      viaBarrel: imp.targetFile,
+      ...(effectiveTypeOnly ? { typeOnly: true } : {}),
+      ...(imp.line ? { line: imp.line } : {}),
+      ...(imp.specifier ? { specifier: imp.specifier } : {}),
+      ...(usage ? { usage } : {}),
+    });
+  };
+
+  const proxiedImportGroups = new Set();
+  for (const [source, imports] of importedLocals) {
+    for (const imp of imports.values()) {
+      if (!imp?.targetFile || imp.imported === "*") continue;
+      const result = resolveExport(imp.targetFile, imp.imported);
+      if (result.status !== "resolved") continue;
+      imp.originFile = result.origin.file;
+      imp.originName = result.origin.name;
+      imp.originTypeOnly = result.origin.typeOnly === true;
+      if (result.origin.file === imp.targetFile) continue;
+      proxiedImportGroups.add(`${source}\0${imp.targetFile}\0${imp.line || 0}`);
+      for (const link of links) {
+        if (String(link.source) === source && String(link.target) === imp.targetFile && link.relation === "imports"
+          && (!imp.line || !link.line || link.line === imp.line)) link.barrelProxy = true;
+      }
+      addSemanticEdge(source, imp, result.origin);
+    }
+  }
+  // One import statement can mix a barrel-local export with re-exported bindings. Once its physical
+  // file edge becomes a proxy, preserve the local binding as its own semantic edge to the barrel file.
+  for (const [source, imports] of importedLocals) for (const imp of imports.values()) {
+    if (!imp?.originFile || imp.originFile !== imp.targetFile) continue;
+    if (!proxiedImportGroups.has(`${source}\0${imp.targetFile}\0${imp.line || 0}`)) continue;
+    addSemanticEdge(source, imp, { file: imp.originFile, name: imp.originName, typeOnly: imp.originTypeOnly }, null, true);
+  }
+  links.push(...semanticEdges.values());
+
+  // Namespace member usage is only knowable in pass 2 (`ui.Button`, `ui.run`). Expose a bounded helper
+  // that uses the same cache and emits the corresponding semantic file edge exactly once.
+  const resolveNamespaceMember = (source, imp, member, usage = null) => {
+    if (!imp?.targetFile || imp.imported !== "*") return MISSING;
+    const result = resolveExport(imp.targetFile, member);
+    if (result.status !== "resolved") return result;
+    if (result.origin.file !== imp.targetFile) {
+      for (const link of links) {
+        if (String(link.source) === source && String(link.target) === imp.targetFile && link.relation === "imports"
+          && (!imp.line || !link.line || link.line === imp.line)) link.barrelProxy = true;
+      }
+      addSemanticEdge(source, imp, result.origin, usage);
+      // addSemanticEdge may have created a new entry after the initial push.
+      const edge = semanticEdges.get(`${source}\0${result.origin.file}\0${imp.line || 0}`);
+      if (edge && !links.includes(edge)) links.push(edge);
+    }
+    return result;
+  };
+
+  return { resolveExport, resolveNamespaceMember };
+}

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

@@ -9,11 +9,19 @@ import { analyzeSyntaxComplexity } from "../analysis/source-complexity.js";
 import { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk } from "./internal-builder.langs.js";
 import { buildResolvers } from "./internal-builder.resolvers.js";
 import { addJavaReferences } from "./internal-builder.java.js";
-import { communityTerritoryOf } from "./community.js";
+import { assignDeterministicCommunities } from "./community.js";
+import { resolveJsBarrels } from "./internal-builder.barrels.js";
+import { snapshotRepository } from "./incremental-refresh.js";
 
 // Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
 export async function buildInternalGraph(repoDir, opts = {}) {
-  const files = walk(repoDir);
+  const rel = (p) => relative(repoDir, p).replace(/\\/g, "/");
+  const allFiles = walk(repoDir);
+  const snapshot = snapshotRepository(repoDir, allFiles);
+  const requestedFiles = Array.isArray(opts.includeFiles)
+    ? new Set(opts.includeFiles.map((file) => String(file).replace(/\\/g, "/").replace(/^\.\//, "")))
+    : null;
+  const files = requestedFiles ? allFiles.filter((file) => requestedFiles.has(rel(file))) : allFiles;
   // Lazy grammar loading: compile only the WASMs for languages this repo actually contains.
   const wanted = new Set();
   for (const f of files) { const g = EXT_LANG[extname(f)]; if (g) wanted.add(g); }
@@ -23,13 +31,31 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   const caps = (grammar, src, root) => { const query = src && q(grammar, src); return query ? query.captures(root) : []; };
   const field = (n, f) => (n && n.childForFieldName ? n.childForFieldName(f) : null);
 
-  const rel = (p) => relative(repoDir, p).replace(/\\/g, "/");
-  const fileSet = new Set(files.map(rel));
+  const fileSet = new Set(allFiles.map(rel));
   const nodes = []; const links = []; const nodeIds = new Set(); const nodeById = new Map();
   const addNode = (n) => { if (!nodeIds.has(n.id)) { nodeIds.add(n.id); nodes.push(n); nodeById.set(n.id, n); } };
   const perFileSymbols = new Map();
   const symByFileName = new Map();
   const importedLocals = new Map();
+  const jsExports = new Map();
+  if (requestedFiles && opts.baseGraph?.jsExportRecords) {
+    for (const [file, records] of Object.entries(opts.baseGraph.jsExportRecords)) {
+      if (!requestedFiles.has(file) && Array.isArray(records)) jsExports.set(file, records.map((record) => ({ ...record })));
+    }
+  }
+  if (requestedFiles && Array.isArray(opts.baseGraph?.nodes)) {
+    for (const node of opts.baseGraph.nodes) {
+      const id = String(node?.id || "");
+      const file = String(node?.source_file || (id.includes("#") ? id.slice(0, id.indexOf("#")) : id)).replace(/\\/g, "/");
+      if (!id.includes("#") || requestedFiles.has(file) || !fileSet.has(file)) continue;
+      const match = id.match(/#([A-Za-z_$][\w$]*)@\d+/);
+      if (!match) continue;
+      let names = symByFileName.get(file);
+      if (!names) symByFileName.set(file, (names = new Map()));
+      if (!names.has(match[1])) names.set(match[1], id);
+      nodeById.set(id, node);
+    }
+  }
   // Bare-package imports (axios, node:fs, @scope/x) — the graph can't resolve them to a repo file, but
   // dependency analysis NEEDS them (unused/missing deps). Additive top-level array; nodes/links untouched.
   const externalImports = [];
@@ -52,6 +78,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     // giant / generated / minified file → keep the file NODE but don't parse symbols (avoids a wedged parse)
     if (code.length > MAX_PARSE_BYTES) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); continue; }
     if ((++_parsed % 24) === 0) await new Promise((r) => setImmediate(r)); // breathe: let the UI paint between chunks
+    if (typeof opts.onParseFile === "function") opts.onParseFile(fileRel);
     const parser = new Parser(); parser.setLanguage(langs[grammar]);
     let tree; try { tree = parser.parse(code); } catch { continue; }
 
@@ -88,6 +115,12 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       return id;
     };
     const imports = new Map(); importedLocals.set(fileRel, imports);
+    const recordJsExport = (record) => {
+      if (!record) return;
+      const records = jsExports.get(fileRel) || [];
+      records.push(record);
+      jsExports.set(fileRel, records);
+    };
     const addImportEdge = (tgt, meta = {}) => {
       if (!tgt || tgt === fileRel) return;
       links.push({
@@ -117,7 +150,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     // Post-hoc export flag (export {a}, export default X, CJS module.exports) — declarations are flagged at addSym time.
     const markExported = (name) => { const id = moduleNameToId.get(name); const n = id && nodeById.get(id); if (n) n.exported = true; };
 
-    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, fileSet, ...resolvers }); }
+    try { lang.pass1({ grammar, tree, fileRel, code, caps, field, addSym, addNode, links, nodeIds, syms, nameToId, imports, addImportEdge, addExternalImport, markExported, recordJsExport, fileSet, ...resolvers }); }
     catch (e) { /* one bad file never sinks the whole build */ void e; }
 
     syms.sort((a, b) => a.start - b.start);
@@ -140,6 +173,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     let dm = goDirSymbols.get(d); if (!dm) goDirSymbols.set(d, (dm = new Map()));
     for (const [n, id] of m) if (!dm.has(n)) dm.set(n, id);
   }
+  const { resolveNamespaceMember } = resolveJsBarrels({ jsExports, importedLocals, links });
   // Exact source ranges can overlap (a named function nested inside another function). Attribute a call
   // to the innermost matching symbol, not whichever outer declaration happened to be added first.
   const enclosing = (fileRel, line) => {
@@ -154,7 +188,11 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     const local = symByFileName.get(fileRel); if (local && local.has(name)) return local.get(name);
     if (sharesDirScope(fileRel)) { const d = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : ""; const dm = goDirSymbols.get(d); if (dm && dm.has(name)) return dm.get(name); }
     const imp = importedLocals.get(fileRel) && importedLocals.get(fileRel).get(name);
-    if (imp && imp.targetFile) { const tf = symByFileName.get(imp.targetFile); if (tf && tf.has(imp.imported)) return tf.get(imp.imported); }
+    if (imp && imp.targetFile) {
+      const targetFile = imp.originFile || imp.targetFile;
+      const importedName = imp.originName || imp.imported;
+      const tf = symByFileName.get(targetFile); if (tf && tf.has(importedName)) return tf.get(importedName);
+    }
     return null;
   };
   const javaTypeKinds = new Set(["class", "interface", "enum", "record", "annotation"]);
@@ -203,6 +241,18 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     // JSX is a real symbol use even though it is not a call_expression. Resolve imported components to their
     // declaration so component fan-in and unused-export checks do not claim `<SettingsView />` is unreferenced.
     if (FAMILY[grammar] === "js") {
+      // Namespace calls (`ui.run()`) need the member name before an export-star facade can be resolved.
+      for (const cap of caps(grammar, `(call_expression function: (member_expression) @memberCall)`, tree.rootNode)) {
+        const object = field(cap.node, "object"), property = field(cap.node, "property");
+        if (!object || object.type !== "identifier" || !property) continue;
+        const imp = importedLocals.get(fileRel)?.get(object.text);
+        if (!imp || imp.imported !== "*" || imp.typeOnly) continue;
+        const origin = resolveNamespaceMember(fileRel, imp, property.text, "call");
+        if (origin.status !== "resolved") continue;
+        const target = symByFileName.get(origin.origin.file)?.get(origin.origin.name);
+        const caller = enclosing(fileRel, cap.node.startPosition.row + 1);
+        if (target && caller && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
+      }
       for (const cap of caps(grammar, `[
         (jsx_opening_element name: (_) @jsx)
         (jsx_self_closing_element name: (_) @jsx)
@@ -213,9 +263,14 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         if (parts.length === 1 && !/^[A-Z_$]/.test(localName)) continue; // undotted lowercase tags are platform/intrinsic elements
         const imp = importedLocals.get(fileRel)?.get(localName);
         if (!imp || !imp.targetFile || imp.typeOnly) continue;
-        const targetSymbols = symByFileName.get(imp.targetFile);
+        let targetFile = imp.originFile || imp.targetFile;
+        let importedName = imp.originName || imp.imported;
+        if (imp.imported === "*" && parts.length > 1) {
+          const origin = resolveNamespaceMember(fileRel, imp, parts[parts.length - 1], "jsx");
+          if (origin.status === "resolved") { targetFile = origin.origin.file; importedName = origin.origin.name; }
+        }
+        const targetSymbols = symByFileName.get(targetFile);
         if (!targetSymbols) continue;
-        const importedName = imp.imported === "*" && parts.length > 1 ? parts[parts.length - 1] : imp.imported;
         const target = targetSymbols.get(importedName) || targetSymbols.get(localName);
         if (!target) continue;
         const owner = enclosing(fileRel, cap.node.startPosition.row + 1);
@@ -261,18 +316,34 @@ export async function buildInternalGraph(repoDir, opts = {}) {
 
   // community = folder bucket (top 2 path parts) — deterministic, mirrors the folder-based module grouping the
   // app already uses (graph-builder-analysis.js). Populates Modules/community cards without a heavy clustering pass.
-  const commOf = new Map(); let commSeq = 0;
-  for (const n of nodes) { const territory = communityTerritoryOf(n.source_file); if (!commOf.has(territory)) commOf.set(territory, commSeq++); n.community = commOf.get(territory); }
+  assignDeterministicCommunities(nodes);
 
   // extImportsV: bump when the externalImports schema/coverage changes (v2 = go/python ecosystems) —
   // deps-engine rebuilds in memory when a saved graph is older than this.
   // edgeTypesV 2 adds language-neutral compile-only edges (currently Rust mod/use/re-export) on top
   // of v1's TypeScript typeOnly classification.
-  return { nodes, links, externalImports, extImportsV: 2, edgeTypesV: 2, complexityV: 1, repoBoundaryV: 1 };
+  return {
+    nodes,
+    links,
+    externalImports,
+    extImportsV: 2,
+    edgeTypesV: 2,
+    complexityV: 1,
+    repoBoundaryV: 1,
+    barrelResolutionV: 1,
+    extractorSchemaV: 1,
+    jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
+    fileHashes: snapshot.fileHashes,
+    fileExportSignatures: snapshot.fileExportSignatures,
+    controlHashes: snapshot.controlHashes,
+    graphRevision: snapshot.revision,
+    ...(requestedFiles ? { incrementalScope: true } : {}),
+  };
 }
 
 // Build + write graph.json to outPath (creating the dir). Returns { ok, nodes, links, graphJson }.
 export async function writeInternalGraph(repoDir, outPath, opts = {}) {
+  if (Array.isArray(opts.includeFiles)) throw new Error("refusing to write a scoped incremental graph as a complete graph");
   const graph = await buildInternalGraph(repoDir, opts);
   mkdirSync(dirname(outPath), { recursive: true });
   writeFileSync(outPath, JSON.stringify(graph), "utf8");

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

@@ -9,6 +9,7 @@ import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { isPathInside } from "../repo-path.js";
 import { childProcessEnv } from "../child-env.js";
+import { filterWeavatrixIgnored } from "../path-ignore.js";
 import LANG_JS from "./builder/lang-js.js";
 import LANG_PY from "./builder/lang-python.js";
 import LANG_GO from "./builder/lang-go.js";
@@ -132,7 +133,7 @@ function gitFileUniverse(dir) {
 }
 
 function walk(dir) {
-  return gitFileUniverse(dir) ?? walkFallback(dir);
+  return filterWeavatrixIgnored(dir, gitFileUniverse(dir) ?? walkFallback(dir));
 }
 
 export { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk };

package/src/graph/layout.js

@@ -2,9 +2,11 @@
 // pure filter/analysis helpers so callers get everything from one import:
 //   graph-filter.js   — pure graph filters (test-mode, path-scope)
 //   graph-analysis.js — parse graph.json → file/module/symbol view, hotspots, communities
-import { readdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { repoBaseName } from "../scan/discover.js";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import process from "node:process";
+import { readdirSync, realpathSync } from "node:fs";
 
 export * from "./graph-filter.js";
 export * from "../analysis/graph-analysis.js";
@@ -12,14 +14,28 @@ export * from "../analysis/graph-analysis.js";
 // Graphs live in a `weavatrix-graphs/` folder NEXT to the repo (inside the repo's parent folder),
 // never inside the repo itself — the graph is derived data, not source. One folder per repo holds
 // graph.json plus graph.prev.json (saved by rebuild_graph for graph_diff).
+export function graphHomeDir() {
+  return resolve(process.env.WEAVATRIX_GRAPH_HOME || join(homedir(), ".weavatrix", "graphs"));
+}
+
+export function graphStorageKey(repoPath) {
+  let absolute;
+  try { absolute = realpathSync.native(repoPath); }
+  catch { absolute = resolve(repoPath); }
+  const normalized = process.platform === "win32" ? absolute.toLowerCase() : absolute;
+  const slug = (basename(absolute) || "repo").replace(/[^A-Za-z0-9_.-]/g, "_");
+  const digest = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  return `${slug}-${digest}`;
+}
+
 export function graphOutDirForRepo(repoPath) {
-  return join(dirname(repoPath), "weavatrix-graphs", repoBaseName(repoPath));
+  return join(graphHomeDir(), graphStorageKey(repoPath));
 }
 
 // A separate dir for a single module's scoped graph, so it never clobbers the repo's graph.
 export function graphOutDirForModule(repoPath, moduleName) {
   const safe = String(moduleName).replace(/[^A-Za-z0-9_.-]/g, "_");
-  return join(dirname(repoPath), "weavatrix-graphs", repoBaseName(repoPath), "modules", safe);
+  return join(graphOutDirForRepo(repoPath), "modules", safe);
 }
 
 // Top-level source folders of a repo (for path-scoped builds).