weavatrix 0.1.2 → 0.1.4

package/src/graph/builder/lang-rust.js

@@ -1,10 +1,8 @@
 // Rust extractor. Symbols: fn (incl. impl methods) + struct/enum/trait/type/mod + const/static
 // (+ macro_rules!/union via optional queries). Calls: `foo()` / `x.foo()` / `path::foo()` (name only).
-// Heritage: `impl Trait for Type` resolves only when the impl block sits inside a tracked symbol
-// (e.g. a mod) — a top-level impl has no enclosing symbol to anchor the edge, so v1 usually skips it.
-// `use` paths map to files only through the crate's module tree, which needs Cargo layout resolution —
-// no import edges in v1; cross-file connectivity comes from the name-based calls pass plus the
-// same-folder scope (mod.rs convention).
+// File dependencies follow Rust's module tree: outlined `mod`, `use` trees, public re-exports, and anchored
+// `crate/self/super` paths resolve to repo-local .rs or */mod.rs files. External crates deliberately stay out
+// of this adapter; Cargo dependency analysis owns them.
 const SYMS_CORE = `
   (function_item name: (identifier) @method)
   (struct_item name: (type_identifier) @class)
@@ -20,6 +18,66 @@ const SYMS_OPTIONAL = [
   `(union_item name: (type_identifier) @class)`,
 ];
 
+const cleanSegment = (part) => String(part || "").trim().replace(/^r#/, "");
+const pathParts = (node) => String(node?.text || "").split("::").map(cleanSegment).filter(Boolean);
+const under = (node, type) => { for (let p = node?.parent; p; p = p.parent) if (p.type === type) return true; return false; };
+
+function pathAttribute(modNode) {
+  for (let prev = modNode?.previousNamedSibling; prev?.type === "attribute_item"; prev = prev.previousNamedSibling) {
+    const hashedRaw = prev.text.match(/\bpath\s*=\s*r(#+)"([^"]+)"\1/);
+    if (hashedRaw) return hashedRaw[2] || "";
+    const plain = prev.text.match(/\bpath\s*=\s*(?:r)?"([^"]+)"/);
+    if (plain) return plain[1] || "";
+  }
+  return "";
+}
+
+function inlineAncestors(node) {
+  const result = [];
+  for (let p = node?.parent; p; p = p.parent) {
+    if (p.type !== "declaration_list" || p.parent?.type !== "mod_item") continue;
+    const mod = p.parent;
+    const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
+    if (name) result.unshift({ name: cleanSegment(name), path: pathAttribute(mod) });
+  }
+  return result;
+}
+
+// Expand a Rust use tree into its leaf paths while retaining aliases. Examples:
+// `crate::api::{self, Client as C, types::*}` -> api, api::Client, api::types.
+function useLeaves(node, prefix = []) {
+  if (!node) return [];
+  if (node.type === "use_declaration") {
+    const body = node.namedChildren.find((child) => child.type !== "visibility_modifier");
+    return useLeaves(body, prefix);
+  }
+  if (node.type === "use_list") return node.namedChildren.flatMap((child) => useLeaves(child, prefix));
+  if (node.type === "scoped_use_list") {
+    const list = node.namedChildren.find((child) => child.type === "use_list");
+    const head = node.namedChildren.find((child) => child !== list);
+    return useLeaves(list, [...prefix, ...pathParts(head)]);
+  }
+  if (node.type === "use_as_clause") {
+    const named = node.namedChildren;
+    const alias = cleanSegment(named[named.length - 1]?.text);
+    return useLeaves(named[0], prefix).map((leaf) => ({ ...leaf, local: alias }));
+  }
+  if (node.type === "use_wildcard") {
+    return [{ segments: [...prefix, ...pathParts(node.namedChildren[0])], wildcard: true, local: null }];
+  }
+  if (node.type === "self") {
+    const local = [...prefix].reverse().find((part) => !["crate", "self", "super"].includes(part)) || null;
+    return [{ segments: prefix.length ? [...prefix] : ["self"], moduleSelf: true, local }];
+  }
+  if (["identifier", "scoped_identifier", "scoped_type_identifier", "crate", "super"].includes(node.type)) {
+    const own = pathParts(node);
+    const segments = [...prefix, ...own];
+    const local = [...own].reverse().find((part) => !["crate", "self", "super"].includes(part)) || null;
+    return [{ segments, local }];
+  }
+  return [];
+}
+
 export default {
   family: "rust",
   grammars: ["rust"],
@@ -35,11 +93,76 @@ export default {
   ],
 
   pass1(ctx) {
-    const { grammar, tree, caps, addSym } = ctx;
+    const { grammar, tree, fileRel, caps, addSym, addImportEdge, imports, resolveRustMod, resolveRustPath } = ctx;
     for (const src of [SYMS_CORE, ...SYMS_OPTIONAL]) {
       for (const cap of caps(grammar, src, tree.rootNode)) {
         addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
       }
     }
+
+    // File dependency edges are intentionally unique per source/target/relation. A qualified path can be
+    // nested in another qualified path and often repeats an existing `mod`/`use`; counting occurrences would
+    // inflate module coupling without adding structure.
+    const emitted = new Set();
+    const emit = (target, meta = {}) => {
+      if (!target || target === fileRel) return;
+      const relation = meta.relation || "imports";
+      const key = relation + ">" + target;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      // Rust `mod`/`use`/`pub use` relationships are resolved by the compiler. They describe real
+      // architectural coupling, but they are not runtime module loading and therefore must not create
+      // JavaScript-style initialization cycles or runtime boundary/blast-radius findings.
+      addImportEdge(target, { ...meta, relation, compileOnly: true });
+    };
+
+    // `mod foo;` loads foo.rs or foo/mod.rs. Inline `mod foo { ... }` stays in the current file, but any
+    // outlined modules declared inside it are captured separately with their inline ancestor path.
+    for (const cap of caps(grammar, `(mod_item) @mod`, tree.rootNode)) {
+      const mod = cap.node;
+      if (mod.namedChildren.some((child) => child.type === "declaration_list")) continue;
+      const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
+      if (!name) continue;
+      const target = resolveRustMod(fileRel, cleanSegment(name), {
+        inlineModules: inlineAncestors(mod),
+        explicitPath: pathAttribute(mod),
+      });
+      emit(target, { line: mod.startPosition.row + 1, specifier: `mod ${name}` });
+    }
+
+    // Imports/re-exports may be nested trees and aliases. Besides the file edge, retain direct item aliases
+    // so the existing pass-2 call resolver can connect `use crate::worker::run; run()` across folders.
+    for (const cap of caps(grammar, `(use_declaration) @use`, tree.rootNode)) {
+      const use = cap.node;
+      const relation = use.namedChildren.some((child) => child.type === "visibility_modifier") ? "re_exports" : "imports";
+      const ancestors = inlineAncestors(use);
+      for (const leaf of useLeaves(use)) {
+        const resolved = resolveRustPath(fileRel, leaf.segments, { inlineModules: ancestors, unqualified: true });
+        if (!resolved) continue;
+        emit(resolved.targetFile, { relation, line: use.startPosition.row + 1, specifier: use.text.replace(/;\s*$/, "") });
+        if (!leaf.wildcard && leaf.local && leaf.local !== "_") {
+          const imported = resolved.remaining.length ? cleanSegment(resolved.remaining.at(-1)) : "*";
+          imports.set(cleanSegment(leaf.local), { imported, targetFile: resolved.targetFile, rustModule: imported === "*" });
+        }
+      }
+    }
+
+    // Fully-qualified paths need no `use` declaration but still prove a dependency. Restrict this pass to
+    // explicit crate/self/super anchors so associated paths such as `Type::method` cannot be mistaken for a
+    // same-named module file. Inner prefixes are skipped; only the maximal path emits an edge.
+    for (const cap of caps(grammar, `[(scoped_identifier) (scoped_type_identifier)] @path`, tree.rootNode)) {
+      const node = cap.node;
+      if (under(node, "use_declaration")) continue;
+      if (["scoped_identifier", "scoped_type_identifier"].includes(node.parent?.type)) continue;
+      const segments = pathParts(node);
+      if (!["crate", "self", "super"].includes(segments[0])) continue;
+      const resolved = resolveRustPath(fileRel, segments, { inlineModules: inlineAncestors(node), unqualified: false });
+      if (!resolved) continue;
+      emit(resolved.targetFile, { line: node.startPosition.row + 1, specifier: node.text });
+      const finalName = cleanSegment(segments.at(-1));
+      if (resolved.remaining.length && finalName && !imports.has(finalName)) {
+        imports.set(finalName, { imported: finalName, targetFile: resolved.targetFile, rustQualified: true });
+      }
+    }
   },
 };

package/src/graph/community.js

@@ -0,0 +1,17 @@
+// Deterministic community territories. Most languages keep the historical top-two-folder bucket. Java
+// Maven/Gradle trees need package depth: otherwise every class under application/src becomes one giant blob.
+export function communityTerritoryOf(file) {
+  const normalized = String(file || "").replace(/\\/g, "/");
+  if (/\.java$/i.test(normalized)) {
+    const marker = /(?:^|\/)src\/(?:main|test)\/java\//.exec(normalized);
+    if (marker) {
+      const end = marker.index + marker[0].length;
+      const prefix = normalized.slice(0, end).replace(/\/$/, "");
+      const packageDirs = normalized.slice(end).split("/").filter(Boolean).slice(0, -1);
+      if (packageDirs.length) return `${prefix}/${packageDirs.slice(0, 5).join("/")}`;
+      return prefix;
+    }
+  }
+  const dirs = normalized.split("/").filter(Boolean).slice(0, -1);
+  return dirs.length ? dirs.slice(0, 2).join("/") : "(root)";
+}

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

@@ -8,6 +8,8 @@ import { specToPkg } from "./builder/spec-pkg.js";
 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";
 
 // Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
 export async function buildInternalGraph(repoDir, opts = {}) {
@@ -53,10 +55,11 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     const parser = new Parser(); parser.setLanguage(langs[grammar]);
     let tree; try { tree = parser.parse(code); } catch { continue; }
 
-    const syms = []; const nameToId = new Map();
+    const syms = []; const nameToId = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
       if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) return;
-      const id = `${fileRel}#${name}@${line}`; if (nodeIds.has(id)) return;
+      const suffix = /^:[A-Za-z0-9_-]+$/.test(extra?.idSuffix || "") ? extra.idSuffix : "";
+      const id = `${fileRel}#${name}@${line}${suffix}`; if (nodeIds.has(id)) return;
       const sourceNode = extra && extra.sourceNode;
       const endLine = sourceNode?.endPosition ? sourceNode.endPosition.row + 1 : 0;
       let complexity = null;
@@ -73,28 +76,46 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         ...(endLine >= line ? { source_end: `L${endLine}` } : {}),
         ...(complexity ? { complexity } : {}),
         ...(extra && extra.exported ? { exported: true } : {}),
-        ...(extra && extra.decorated ? { decorated: true } : {})
+        ...(extra && extra.decorated ? { decorated: true } : {}),
+        ...(extra && extra.symbolKind ? { symbol_kind: extra.symbolKind } : {}),
+        ...(extra && extra.memberOf ? { member_of: extra.memberOf } : {}),
+        ...(extra && extra.visibility ? { visibility: extra.visibility } : {})
       });
       links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
-      syms.push({ id, name, start: line, end: endLine >= line ? endLine : 0 }); if (!nameToId.has(name)) nameToId.set(name, id);
+      syms.push({ id, name, start: line, end: endLine >= line ? endLine : 0 });
+      if (!nameToId.has(name)) nameToId.set(name, id);
+      if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
+      return id;
     };
     const imports = new Map(); importedLocals.set(fileRel, imports);
-    const addImportEdge = (tgt) => { if (tgt && tgt !== fileRel) links.push({ source: fileRel, target: tgt, relation: "imports", confidence: "EXTRACTED" }); };
+    const addImportEdge = (tgt, meta = {}) => {
+      if (!tgt || tgt === fileRel) return;
+      links.push({
+        source: fileRel,
+        target: tgt,
+        relation: meta.relation || "imports",
+        confidence: "EXTRACTED",
+        ...(typeof meta.typeOnly === "boolean" ? { typeOnly: meta.typeOnly } : {}),
+        ...(meta.compileOnly === true ? { compileOnly: true } : {}),
+        ...(meta.line ? { line: meta.line } : {}),
+        ...(meta.specifier ? { specifier: meta.specifier } : {}),
+      });
+    };
     // rec: {spec, kind, line} bare-pkg import · {dynamic:true, spec?, target?} dynamic import marker
     // (target = internally-resolved dynamic import; suppresses false "unused file" in dep analysis) ·
     // {unresolved:true, spec} broken local import (relative or alias path that resolves to no file).
     const addExternalImport = (rec) => {
       if (!rec) return;
-      if (rec.dynamic) { externalImports.push({ file: fileRel, spec: rec.spec || null, kind: rec.kind || "dynamic", dynamic: true, line: rec.line || 0, ...(rec.target ? { target: rec.target } : {}) }); return; }
-      if (rec.unresolved) { externalImports.push({ file: fileRel, spec: rec.spec, kind: rec.kind || "esm", unresolved: true, line: rec.line || 0 }); return; }
+      if (rec.dynamic) { externalImports.push({ file: fileRel, spec: rec.spec || null, kind: rec.kind || "dynamic", dynamic: true, line: rec.line || 0, ...(rec.target ? { target: rec.target } : {}), ...(rec.typeOnly ? { typeOnly: true } : {}) }); return; }
+      if (rec.unresolved) { externalImports.push({ file: fileRel, spec: rec.spec, kind: rec.kind || "esm", unresolved: true, line: rec.line || 0, ...(rec.typeOnly ? { typeOnly: true } : {}) }); return; }
       // non-npm extractors (go/python) classify their own specs and pass pkg/builtin/ecosystem precomputed
-      if (rec.pkg) { externalImports.push({ file: fileRel, spec: rec.spec, pkg: rec.pkg, builtin: !!rec.builtin, kind: rec.kind || "import", line: rec.line || 0, ...(rec.ecosystem ? { ecosystem: rec.ecosystem } : {}) }); return; }
+      if (rec.pkg) { externalImports.push({ file: fileRel, spec: rec.spec, pkg: rec.pkg, builtin: !!rec.builtin, kind: rec.kind || "import", line: rec.line || 0, ...(rec.ecosystem ? { ecosystem: rec.ecosystem } : {}), ...(rec.typeOnly ? { typeOnly: true } : {}) }); return; }
       const r = specToPkg(rec.spec);
       if (!r) return;
-      externalImports.push({ file: fileRel, spec: rec.spec, pkg: r.pkg, builtin: !!r.builtin, kind: rec.kind || "esm", line: rec.line || 0 });
+      externalImports.push({ file: fileRel, spec: rec.spec, pkg: r.pkg, builtin: !!r.builtin, kind: rec.kind || "esm", line: rec.line || 0, ...(rec.typeOnly ? { typeOnly: true } : {}) });
     };
     // Post-hoc export flag (export {a}, export default X, CJS module.exports) — declarations are flagged at addSym time.
-    const markExported = (name) => { const id = nameToId.get(name); const n = id && nodeById.get(id); if (n) n.exported = true; };
+    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 }); }
     catch (e) { /* one bad file never sinks the whole build */ void e; }
@@ -136,6 +157,17 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     if (imp && imp.targetFile) { const tf = symByFileName.get(imp.targetFile); if (tf && tf.has(imp.imported)) return tf.get(imp.imported); }
     return null;
   };
+  const javaTypeKinds = new Set(["class", "interface", "enum", "record", "annotation"]);
+  const resolveJavaType = (name, fileRel) => {
+    const imp = importedLocals.get(fileRel)?.get(name);
+    if (imp?.targetFile) {
+      const symbols = symByFileName.get(imp.targetFile);
+      const target = symbols?.get(imp.imported) || symbols?.get(name);
+      if (target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind)) return target;
+    }
+    const target = symByFileName.get(fileRel)?.get(name);
+    return target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind) ? target : null;
+  };
   for (const abs of files) {
     const fileRel = rel(abs); const grammar = EXT_LANG[extname(abs)]; if (!grammar) continue;
     const lang = LANGS[FAMILY[grammar]]; if (!lang || lang.isWeb || !langs[grammar]) continue;
@@ -159,10 +191,36 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       const target = dm && dm.get(fld.text);
       if (target && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
     }
-    for (const heritageSrc of lang.heritage || []) for (const cap of caps(grammar, heritageSrc, tree.rootNode)) {
-      const cls = enclosing(fileRel, cap.node.startPosition.row + 1); if (!cls) continue;
-      const target = resolveCall(cap.node.text, fileRel);
-      if (target && target !== cls.id) links.push({ source: cls.id, target, relation: "inherits", confidence: "INFERRED" });
+    for (const heritageSpec of lang.heritage || []) {
+      const query = typeof heritageSpec === "string" ? heritageSpec : heritageSpec.query;
+      const relation = typeof heritageSpec === "string" ? "inherits" : (heritageSpec.relation || "inherits");
+      for (const cap of caps(grammar, query, tree.rootNode)) {
+        const cls = enclosing(fileRel, cap.node.startPosition.row + 1); if (!cls) continue;
+        const target = FAMILY[grammar] === "java" ? resolveJavaType(cap.node.text, fileRel) : resolveCall(cap.node.text, fileRel);
+        if (target && target !== cls.id) links.push({ source: cls.id, target, relation, confidence: "INFERRED" });
+      }
+    }
+    // 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") {
+      for (const cap of caps(grammar, `[
+        (jsx_opening_element name: (_) @jsx)
+        (jsx_self_closing_element name: (_) @jsx)
+      ]`, tree.rootNode)) {
+        const jsxName = cap.node.text;
+        const parts = jsxName.split(".");
+        const localName = parts[0];
+        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);
+        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);
+        links.push({ source: owner?.id || fileRel, target, relation: "references", confidence: "INFERRED", usage: "jsx", line: cap.node.startPosition.row + 1 });
+      }
     }
     // Go value references: a top-level const/var/type/func used BY NAME (bare `X`, or cross-package `pkg.X`) in
     // another file/scope → a `references` edge, so used-but-never-called symbols (message-type consts, etc.) are
@@ -184,6 +242,9 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         const caller = enclosing(fileRel, sel.startPosition.row + 1); emitRef(caller ? caller.id : fileRel, target);
       }
     }
+    if (FAMILY[grammar] === "java") {
+      addJavaReferences({ grammar, tree, fileRel, caps, resolveJavaType, enclosing, links });
+    }
     tree.delete();
   }
 
@@ -200,13 +261,14 @@ 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 folderOf = (f) => { const d = String(f || "").split("/").filter(Boolean).slice(0, -1); return d.length ? d.slice(0, 2).join("/") : "(root)"; };
   const commOf = new Map(); let commSeq = 0;
-  for (const n of nodes) { const fo = folderOf(n.source_file); if (!commOf.has(fo)) commOf.set(fo, commSeq++); n.community = commOf.get(fo); }
+  for (const n of nodes) { const territory = communityTerritoryOf(n.source_file); if (!commOf.has(territory)) commOf.set(territory, commSeq++); n.community = commOf.get(territory); }
 
   // 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.
-  return { nodes, links, externalImports, extImportsV: 2, complexityV: 1, repoBoundaryV: 1 };
+  // 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 };
 }
 
 // Build + write graph.json to outPath (creating the dir). Returns { ok, nodes, links, graphJson }.

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

@@ -0,0 +1,33 @@
+// Resolve Java type usages only when they land on declarations that exist in the graph. Synthetic nodes for
+// String/List/annotations inflate metrics without adding navigation value, so unresolved/external types vanish.
+export function addJavaReferences({ grammar, tree, fileRel, caps, resolveJavaType, enclosing, links }) {
+  const refSeen = new Set();
+  const isHeritage = (node) => {
+    let current = node?.parent;
+    for (let hops = 0; current && hops < 8; hops++, current = current.parent) {
+      if (["superclass", "super_interfaces", "extends_interfaces"].includes(current.type)) return true;
+      if (["class_declaration", "interface_declaration", "enum_declaration", "record_declaration"].includes(current.type)) return false;
+    }
+    return false;
+  };
+  const emitTypeRef = (name, node) => {
+    if (!name || isHeritage(node)) return;
+    const target = resolveJavaType(name, fileRel);
+    if (!target) return;
+    const owner = enclosing(fileRel, node.startPosition.row + 1);
+    const source = owner?.id || fileRel;
+    if (source === target) return;
+    const key = `${source}>${target}`;
+    if (refSeen.has(key)) return;
+    refSeen.add(key);
+    links.push({ source, target, relation: "references", confidence: "INFERRED", usage: "type", line: node.startPosition.row + 1 });
+  };
+  for (const cap of caps(grammar, `(type_identifier) @type`, tree.rootNode)) {
+    // A qualified type is handled once by its outer scoped_type_identifier. Inner package segments could
+    // otherwise bind to unrelated same-named project types.
+    if (cap.node.parent?.type !== "scoped_type_identifier") emitTypeRef(cap.node.text, cap.node);
+  }
+  for (const cap of caps(grammar, `(scoped_type_identifier) @type`, tree.rootNode)) {
+    if (cap.node.parent?.type !== "scoped_type_identifier") emitTypeRef(cap.node.text.split(".").pop(), cap.node);
+  }
+}

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

@@ -5,8 +5,10 @@
 // build works — and Electron main runs Node, so this needs no external runtime.
 import { readdirSync, statSync, realpathSync } from "node:fs";
 import { join, extname, dirname } from "node:path";
+import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { isPathInside } from "../repo-path.js";
+import { childProcessEnv } from "../child-env.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";
@@ -68,7 +70,7 @@ async function ensureParser(opts = {}, wanted = null) {
 // Cycle-safe directory walk. statSync FOLLOWS symlinks/junctions, so a link pointing at an ancestor would
 // otherwise recurse forever (a/b/link/b/link/…). We dedupe by REAL path (a visited dir is never re-entered)
 // and cap depth as a backstop, so a symlink loop can't wedge the build.
-function walk(dir, acc = [], seen = new Set(), depth = 0, rootReal = null) {
+function walkFallback(dir, acc = [], seen = new Set(), depth = 0, rootReal = null) {
   if (depth > 40) return acc;
   let real; try { real = realpathSync.native(dir); } catch { return acc; }
   if (rootReal == null) rootReal = real;
@@ -86,7 +88,7 @@ function walk(dir, acc = [], seen = new Set(), depth = 0, rootReal = null) {
     let entryReal; try { entryReal = realpathSync.native(full); } catch { continue; }
     if (!isPathInside(rootReal, entryReal)) continue;
     let st; try { st = statSync(full); } catch { continue; }
-    if (st.isDirectory()) walk(full, acc, seen, depth + 1, rootReal);
+    if (st.isDirectory()) walkFallback(full, acc, seen, depth + 1, rootReal);
     // include by KNOWN extension, not by loaded grammar — grammars now load lazily AFTER the walk
     // (the parse passes skip files whose grammar failed to load, so the guarantee is unchanged)
     else { const e = extname(name); if (EXT_LANG[e] || isDataFile(name) || isDocFile(name)) acc.push(full); }
@@ -94,4 +96,43 @@ function walk(dir, acc = [], seen = new Set(), depth = 0, rootReal = null) {
   return acc;
 }
 
+// Git already owns the repository's file-universe rules. Asking it for tracked files plus untracked,
+// non-ignored files prevents generated outputs (Electron release/, custom cache dirs, ignored agent files,
+// etc.) from contaminating graph/duplicate/audit results while still indexing new source before it is staged.
+// A repository may be opened without Git (or Git may be unavailable), so failure is deliberately a signal to
+// use the boundary-safe walker above rather than a build failure.
+function gitFileUniverse(dir) {
+  let raw;
+  try {
+    raw = execFileSync("git", ["-C", dir, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+      encoding: "utf8",
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 15_000,
+      maxBuffer: 64 * 1024 * 1024,
+      env: childProcessEnv(),
+    });
+  } catch { return null; }
+
+  let rootReal;
+  try { rootReal = realpathSync.native(dir); } catch { return null; }
+  const files = [];
+  for (const rel of raw.split("\0")) {
+    if (!rel) continue;
+    const full = join(dir, rel);
+    let real; try { real = realpathSync.native(full); } catch { continue; } // deleted index entry
+    if (!isPathInside(rootReal, real)) continue; // tracked symlink/junction escaping the repo
+    let st; try { st = statSync(full); } catch { continue; }
+    if (!st.isFile()) continue; // includes neither submodule dirs nor directory-like junctions
+    const name = rel.split(/[\\/]/).pop() || "";
+    const ext = extname(name);
+    if (EXT_LANG[ext] || isDataFile(name) || isDocFile(name)) files.push(full);
+  }
+  return files;
+}
+
+function walk(dir) {
+  return gitFileUniverse(dir) ?? walkFallback(dir);
+}
+
 export { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk };