weavatrix 0.3.14 → 1.1.0

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

@@ -1,300 +0,0 @@
-// Orchestrator for the internal graph builder: the two-pass parse loop, community bucketing, and the
-// graph.json writer. (Split from internal-builder.js — see its doc comment for the overall architecture;
-// the language registry / parser lifecycle / walk live in ./internal-builder.langs.js and the per-repo
-// resolvers in ./internal-builder.resolvers.js.)
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { extname, relative, dirname } from "node:path";
-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 { scanEmbeddedSql, resolveSqlReferences } from "./builder/lang-sql.js";
-import { assignDeterministicCommunities } from "./community.js";
-import { snapshotRepository } from "./incremental-refresh.js";
-import { EDGE_PROVENANCE_V, stampEdgeProvenance } from "./edge-provenance.js";
-import {runInternalGraphPass2} from './internal-builder.pass2.js'
-
-function physicalLineCount(text) {
-  if (!text.length) return 0;
-  let lines = 1;
-  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lines++;
-  return text.endsWith("\n") ? lines - 1 : lines;
-}
-
-// Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
-export async function buildInternalGraph(repoDir, opts = {}) {
-  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); }
-  const langs = await ensureParser(opts, wanted);
-  const qc = new Map();
-  const q = (grammar, src) => { const k = grammar + ":" + src; if (qc.has(k)) return qc.get(k); let x = null; try { x = new Query(langs[grammar], src); } catch { x = null; } qc.set(k, x); return x; };
-  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 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 symIdsByFileName = 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);
-      let idsByName = symIdsByFileName.get(file);
-      if (!idsByName) symIdsByFileName.set(file, (idsByName = new Map()));
-      const ids = idsByName.get(match[1]) || [];
-      ids.push(id);
-      idsByName.set(match[1], ids);
-      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 = [];
-  // SQL references (from .sql statements AND string literals in host-language code) collect during
-  // pass 1 and resolve after both passes, once every schema object the repo declares is indexed.
-  const sqlRefs = [];
-
-  const resolvers = buildResolvers(repoDir, fileSet);          // aliases, go.mod, java index, href, selectors
-  const { selectorIndex, htmlUsages } = resolvers;
-
-  // ---- pass 1: files + symbols + imports (dispatched to each language module) ----
-  // This runs on Electron's MAIN thread (the worker path hung web-tree-sitter's WASM in an Electron worker
-  // thread → the infinite "BUILDING GRAPH…"). Parsing is synchronous CPU, so we YIELD the event loop every
-  // few dozen files to keep the window responsive during a big-repo build, and SKIP giant/minified files
-  // (a multi-MB single-line bundle can wedge the tree-sitter parse).
-  let _parsed = 0;
-  for (const abs of files) {
-    const fileRel = rel(abs); const ext = extname(abs);
-    const fileNode = { id: fileRel, label: fileRel.split("/").pop(), file_type: "code", source_file: fileRel, source_location: "L1" };
-    if (isDataFile(fileRel) || isDocFile(fileRel)) {
-      addNode(fileNode); perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue;
-    }  // config/infra/docs file-only node
-    let code; try { code = readFileSync(abs, "utf8"); } catch { addNode(fileNode); continue; }
-    addNode({ ...fileNode, physical_loc: physicalLineCount(code) });
-    const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || (!langs[grammar] && !lang.textOnly)) continue;
-    // 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()); symIdsByFileName.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);
-    let tree = null;   // textOnly languages (SQL) scan `code` directly — no grammar, no parse
-    if (!lang.textOnly) {
-      const parser = new Parser(); parser.setLanguage(langs[grammar]);
-      try { tree = parser.parse(code); } catch { continue; }
-    }
-
-    const syms = []; const nameToId = new Map(); const nameToIds = new Map(); const moduleNameToId = new Map();
-    const addSym = (name, line, callable, extra) => {
-      if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) 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 selectionNode = extra && extra.selectionNode;
-      const endLine = sourceNode?.endPosition ? sourceNode.endPosition.row + 1 : 0;
-      let complexity = null;
-      if (callable && sourceNode) {
-        try { complexity = analyzeSyntaxComplexity(sourceNode, { family: lang.family, name }); }
-        catch { complexity = null; }
-      }
-      addNode({
-        id,
-        label: callable ? `${name}()` : name,
-        ...(callable ? { callable: true } : {}),
-        file_type: "code",
-        source_file: fileRel,
-        source_location: `L${line}`,
-        ...(endLine >= line ? { source_end: `L${endLine}` } : {}),
-        ...(sourceNode?.startPosition && sourceNode?.endPosition ? {
-          // web-tree-sitter Point columns are zero-based UTF-16 code-unit offsets. Keep the
-          // declaration body range as well as the identifier selection so LSP reference
-          // locations on a boundary line cannot be attributed to the wrong symbol.
-          source_range: {
-            start: {
-              line: sourceNode.startPosition.row,
-              character: sourceNode.startPosition.column,
-            },
-            end: {
-              line: sourceNode.endPosition.row,
-              character: sourceNode.endPosition.column,
-            },
-          },
-        } : {}),
-        ...(selectionNode?.startPosition && selectionNode?.endPosition ? {
-          // web-tree-sitter's JavaScript Point columns are already zero-based UTF-16 code-unit
-          // offsets, matching LSP positions exactly (including text before non-ASCII identifiers).
-          selection_start: {
-            line: selectionNode.startPosition.row,
-            character: selectionNode.startPosition.column,
-          },
-          selection_end: {
-            line: selectionNode.endPosition.row,
-            character: selectionNode.endPosition.column,
-          },
-        } : {}),
-        ...(complexity ? { complexity } : {}),
-        ...(extra && extra.exported ? { exported: true } : {}),
-        ...(extra && extra.testSurface ? { test_surface: true } : {}),
-        ...(extra && extra.decorated ? { decorated: true } : {}),
-        ...(extra && extra.symbolKind ? { symbol_kind: extra.symbolKind } : {}),
-        ...(extra && extra.symbolSpace ? { symbol_space: extra.symbolSpace } : {}),
-        ...(extra && extra.memberOf ? { member_of: extra.memberOf } : {}),
-        ...(extra && extra.visibility ? { visibility: extra.visibility } : {}),
-        ...(Number.isInteger(extra?.parameterCount) ? { parameter_count: extra.parameterCount } : {}),
-        ...(extra?.receiverType ? { receiver_type: extra.receiverType } : {}),
-        ...(extra?.returnType ? { return_type: extra.returnType } : {}),
-        ...(extra?.fieldTypes && Object.keys(extra.fieldTypes).length ? { field_types: extra.fieldTypes } : {})
-      });
-      links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
-      syms.push({
-        id,
-        name,
-        start: line,
-        end: endLine >= line ? endLine : 0,
-        ...(extra?.memberOf ? {memberOf: extra.memberOf} : {}),
-        ...(extra?.symbolKind ? {symbolKind: extra.symbolKind} : {}),
-        ...(extra?.symbolSpace ? {symbolSpace: extra.symbolSpace} : {}),
-        ...(Number.isInteger(extra?.parameterCount) ? {parameterCount: extra.parameterCount} : {}),
-      });
-      if (!nameToId.has(name)) nameToId.set(name, id);
-      const ids = nameToIds.get(name) || [];
-      ids.push(id);
-      nameToIds.set(name, ids);
-      if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
-      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({
-        source: fileRel,
-        target: tgt,
-        relation: meta.relation || "imports",
-        confidence: "EXTRACTED",
-        provenance: meta.provenance || "RESOLVED",
-        ...(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 } : {}), ...(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 } : {}), ...(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, ...(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 = 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, recordJsExport, fileSet, sqlRefs, ...resolvers }); }
-    catch (e) { /* one bad file never sinks the whole build */ void e; }
-    // string-literal SQL in host-language code → schema reference candidates (resolved post-pass-2)
-    if (!lang.textOnly && !lang.isWeb) try { scanEmbeddedSql(code, fileRel, sqlRefs); } catch { /* never sinks the build */ }
-
-    syms.sort((a, b) => a.start - b.start);
-    const eof = code.split("\n").length;
-    for (let i = 0; i < syms.length; i++) {
-      if (!syms[i].end || syms[i].end < syms[i].start) syms[i].end = i + 1 < syms.length ? syms[i + 1].start - 1 : eof;
-    }
-    perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId); symIdsByFileName.set(fileRel, nameToIds);
-    if (tree) tree.delete();
-  }
-
-  // ---- pass 2: scope-aware calls + inheritance (Go package = whole dir → same-dir symbols share scope;
-  // C# gets the same treatment: one folder ≈ one namespace by convention, and `using` names namespaces,
-  // not files, so the folder map is the only reliable cross-file resolver) ----
-  const {reExportOccurrences} = runInternalGraphPass2({
-    files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
-    symIdsByFileName, importedLocals, jsExports, resolvers,
-  });
-  // HTML class/id usage → the CSS file(s) defining that selector: file-level reference edges (deduped per pair).
-  const htmlRefSeen = new Set();
-  for (const u of htmlUsages) {
-    const defs = selectorIndex.get(u.label); if (!defs) continue;
-    for (const cssFile of defs) {
-      if (cssFile === u.htmlFile) continue;
-      const key = u.htmlFile + ">" + cssFile; if (htmlRefSeen.has(key)) continue; htmlRefSeen.add(key);
-      links.push({ source: u.htmlFile, target: cssFile, relation: "references", confidence: "INFERRED" });
-    }
-  }
-  // code/SQL → schema-object edges (tables/views/functions declared in .sql files)
-  try { resolveSqlReferences({ sqlRefs, links, nodeById, perFileSymbols }); } catch { /* never sinks the build */ }
-
-  // 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.
-  assignDeterministicCommunities(nodes);
-  stampEdgeProvenance(links);
-
-  // extImportsV: bump when the externalImports schema/coverage changes (v3 = Java/Rust 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: 3,
-    edgeTypesV: 2,
-    edgeProvenanceV: EDGE_PROVENANCE_V,
-    complexityV: 2,
-    physicalFileLocV: 1,
-    repoBoundaryV: 1,
-    barrelResolutionV: 1,
-    reExportOccurrencesV: 1,
-    symbolSpacesV: 1,
-    extractorSchemaV: 7,   // v7 = Solidity + SQL indexing (schema objects, embedded-SQL edges)
-    reExportOccurrences,
-    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");
-  return { ok: true, nodes: graph.nodes.length, links: graph.links.length, graphJson: outPath };
-}
-
-export const INTERNAL_BUILDER_LANGS = GRAMMARS;

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

@@ -1,33 +0,0 @@
-// 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.js

@@ -1,12 +0,0 @@
-// Built-in, dependency-free code-graph builder: parses a repo with web-tree-sitter (WASM grammars,
-// no Python/native tooling) and emits graph.json ({nodes: files+symbols, links:
-// contains/imports/calls/inherits}) for the analysis pipeline.
-//
-// ARCHITECTURE: this file is a slim FACADE so external import paths stay unchanged. The orchestrator
-// (file walk dispatch, the two-pass loop, community, graph.json writer) lives in ./internal-builder.build.js;
-// the language registry, web-tree-sitter parser lifecycle, and the cycle-safe file walk live in
-// ./internal-builder.langs.js; the per-repo resolvers (JS/TS aliases, go.mod, java index, href, CSS
-// selector index) live in ./internal-builder.resolvers.js. Each language lives in its OWN module under
-// ./builder/lang-*.js and declares its grammars, file extensions, tree-sitter queries, and a pass1(ctx)
-// extractor. To add/fix a language, edit only its module (or add one to LANG_MODULES).
-export { buildInternalGraph, writeInternalGraph, INTERNAL_BUILDER_LANGS } from "./internal-builder.build.js";

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

@@ -1,157 +0,0 @@
-// Language registry, parser lifecycle (web-tree-sitter init + grammar loading), and the cycle-safe
-// repo file walk for the internal graph builder (split from internal-builder.js — see its doc comment).
-//
-// Loaded via createRequire: web-tree-sitter's ESM build throws on fs/promises in pure-ESM Node, but its CJS
-// 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 { createRequire } from "node:module";
-import { isPathInside } from "../repo-path.js";
-import { runGit } from "../git-exec.js";
-import { filterWeavatrixIgnored } from "../path-ignore.js";
-import {trustedGrammarWasm, trustedRuntimeWasm} from './parser-artifact-boundary.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";
-import LANG_JAVA from "./builder/lang-java.js";
-import LANG_CSHARP from "./builder/lang-csharp.js";
-import LANG_RUST from "./builder/lang-rust.js";
-import LANG_SOLIDITY from "./builder/lang-solidity.js";
-import LANG_SQL from "./builder/lang-sql.js";
-import LANG_HTML from "./builder/lang-html.js";
-import LANG_CSS from "./builder/lang-css.js";
-
-const require = createRequire(import.meta.url);
-const { Parser, Language, Query } = require("web-tree-sitter");
-
-const WTS_DIR = dirname(require.resolve("web-tree-sitter"));
-const NODE_MODULES = dirname(WTS_DIR);
-const DEFAULT_WASM_DIR = join(NODE_MODULES, "tree-sitter-wasms", "out");
-
-// ---- language registry (derived from the per-language modules) ----
-const LANG_MODULES = [LANG_JS, LANG_PY, LANG_GO, LANG_JAVA, LANG_CSHARP, LANG_RUST, LANG_SOLIDITY, LANG_SQL, LANG_HTML, LANG_CSS];
-const LANGS = {};                 // family -> module
-const EXT_LANG = {};              // ext -> grammar
-const FAMILY = {};                // grammar -> family
-const GRAMMARS_SET = new Set();
-for (const L of LANG_MODULES) {
-  LANGS[L.family] = L;
-  for (const g of L.grammars) GRAMMARS_SET.add(g);
-  for (const [ext, g] of Object.entries(L.exts)) { EXT_LANG[ext] = g; FAMILY[g] = L.family; }
-}
-const GRAMMARS = [...GRAMMARS_SET];
-
-// non-code files graph-builder also indexes as nodes (config/data/scripts) — added as file-only nodes (no symbols),
-// so file counts + import targets (e.g. import cfg from "./x.json") match graph-builder.
-const DATA_EXT = new Set([".json", ".sh", ".ps1", ".yaml", ".yml"]);   // config/data/scripts + k8s/skaffold/CI yaml
-const INFRA_NAME = /(^|[\\/])(Dockerfile|Containerfile)(\.[\w.-]+)?$|\.dockerfile$/i;   // Dockerfile[.prod], *.dockerfile (no ext)
-const isDataFile = (p) => DATA_EXT.has(extname(p)) || INFRA_NAME.test(String(p));
-// Docs/prose (README, CLAUDE.md, AGENTS.md, docs/*.md, …) are indexed as file-only nodes so the GUI board can
-// render them as NEUTRAL pillars (never dead-code scored) and wire the agent-instruction ones UP to the
-// Claude Code / Codex node. AGENT_DOTFILE lets a few AI-agent instruction dotfiles past the dotfile skip below.
-const DOC_EXT = new Set([".md", ".mdx", ".markdown", ".mdown", ".mkd", ".mkdn", ".rst", ".adoc", ".asciidoc"]);
-const AGENT_DOTFILE = /^\.(cursorrules|windsurfrules|clinerules)$/i;
-const RUNTIME_EVIDENCE = /^\.weavatrix\/(?:reports\/)?transport-runtime\.json$/i;
-const isDocFile = (p) => DOC_EXT.has(extname(p)) || AGENT_DOTFILE.test(String(p).split(/[\\/]/).pop() || "");
-const SKIP = new Set(["node_modules", ".git", "dist", "build", "coverage", "vendor", "weavatrix-graphs", "weavatrix-graphs", ".next", "out", "__pycache__", ".venv", "venv", "env", ".tox", "site-packages", ".mypy_cache", ".pytest_cache"]);
-const MAX_PARSE_BYTES = 1_500_000;   // skip parsing files above this (minified bundles / generated blobs wedge tree-sitter)
-
-let _ready = null;
-const _langs = {};
-// `wanted` (a Set of grammar names) makes loading LAZY: only grammars for extensions actually present
-// in the repo get compiled. The heavy WASMs (rust ~3MB, c_sharp ~4MB) cost seconds to compile — a tax
-// a JS-only repo must never pay. Omit `wanted` to load everything (old behavior).
-async function ensureParser(opts = {}, wanted = null) {
-  if (opts.runtimeWasm != null || opts.wasmDir != null) {
-    throw new Error('custom parser artifacts are not supported; Weavatrix loads only pinned package-owned WASM')
-  }
-  if (!_ready) {
-    const runtimeWasm = trustedRuntimeWasm(WTS_DIR)
-    _ready = Parser.init({ locateFile: () => runtimeWasm });
-  }
-  await _ready;
-  const list = wanted ? GRAMMARS.filter((g) => wanted.has(g)) : GRAMMARS;
-  for (const g of list) if (!_langs[g]) {
-    const grammarWasm = trustedGrammarWasm(DEFAULT_WASM_DIR, g)
-    try { _langs[g] = await Language.load(grammarWasm); } catch { _langs[g] = null; }
-  }
-  return _langs;
-}
-
-// 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 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;
-  if (!isPathInside(rootReal, real)) return acc;
-  if (seen.has(real)) return acc;
-  seen.add(real);
-  let entries;
-  try { entries = readdirSync(dir); } catch { return acc; }
-  for (const name of entries) {
-    if (SKIP.has(name)) continue;
-    // dotfiles/dot-dirs are skipped EXCEPT a few AI-agent instruction dotfiles (.cursorrules etc.); dot-DIRS
-    // never match AGENT_DOTFILE, so we still never recurse into them (.git/.github/.cursor stay out).
-    if (name.startsWith(".") && !AGENT_DOTFILE.test(name)) continue;
-    const full = join(dir, name);
-    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()) 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); }
-  }
-  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) {
-  const lsFiles = runGit(dir, ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
-    stdio: ["ignore", "pipe", "ignore"], timeout: 15_000, maxBuffer: 64 * 1024 * 1024,
-  });
-  if (lsFiles.status !== 0 || lsFiles.error) return null;
-  const raw = lsFiles.stdout;
-
-  // `git -C <dir>` also succeeds when <dir> is merely nested under some parent repository. If that
-  // nested directory is ignored by the parent, `ls-files` is empty even though <dir> can be a valid
-  // standalone repository root selected by the user (or a repository staged by a test/tool). In
-  // that one ambiguous case, fall back to the boundary-safe walker. Preserve an empty universe for
-  // an actual Git root so ignored files do not leak back into its graph.
-  if (!raw) {
-    const top = runGit(dir, ["rev-parse", "--show-toplevel"], {
-      stdio: ["ignore", "pipe", "ignore"], timeout: 15_000, maxBuffer: 1024 * 1024,
-    });
-    if (top.status !== 0 || top.error) return null;
-    if (realpathSync.native(String(top.stdout).trim()) !== realpathSync.native(dir)) return null;
-  }
-
-  let rootReal;
-  try { rootReal = realpathSync.native(dir); } catch { return null; }
-  const files = [];
-  for (const rel of raw.split("\0")) {
-    if (!rel) continue;
-    if (RUNTIME_EVIDENCE.test(rel.replace(/\\/g, "/"))) continue; // runtime output must not change the source revision it attests
-    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 filterWeavatrixIgnored(dir, gitFileUniverse(dir) ?? walkFallback(dir));
-}
-
-export { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk };