weavatrix 0.3.14 → 1.0.0

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

@@ -1,163 +0,0 @@
-import {readFileSync} from 'node:fs'
-import {extname} from 'node:path'
-import {Parser, EXT_LANG, FAMILY, LANGS} from './internal-builder.langs.js'
-import {addJavaReferences} from './internal-builder.java.js'
-import {resolveJsBarrels} from './internal-builder.barrels.js'
-import {createPass2Resolution} from './builder/pass2-resolution.js'
-import {createGoReceiverResolution} from './builder/go-receiver-resolution.js'
-
-export function runInternalGraphPass2({
-    files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
-    symIdsByFileName, importedLocals, jsExports, resolvers,
-}) {
-    const resolution = createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName})
-    const {dirSymbols, resolveNamedSymbol, resolveCall, resolveJavaType, resolveRustMethod} = resolution
-    const {resolveRustPath, resolveRustCratePath} = resolvers || {}
-    const {resolveNamespaceMember, reExportOccurrences} = resolveJsBarrels({
-        jsExports, importedLocals, links,
-        resolveSymbol: (file, name, typeOnly) => resolveNamedSymbol(file, name, typeOnly ? 'type' : 'value'),
-    })
-    const enclosing = (file, line) => {
-        let best = null
-        for (const symbol of perFileSymbols.get(file) || []) {
-            if (line < symbol.start || line > symbol.end) continue
-            if (!best || symbol.start > best.start || (symbol.start === best.start && symbol.end < best.end)) best = symbol
-        }
-        return best
-    }
-    const goReceivers = createGoReceiverResolution({resolution, nodeById, importedLocals})
-    for (const absolute of files) {
-        const file = rel(absolute), grammar = EXT_LANG[extname(absolute)]
-        if (!grammar) continue
-        const lang = LANGS[FAMILY[grammar]]
-        if (!lang || lang.isWeb || !langs[grammar]) continue
-        let code
-        try { code = readFileSync(absolute, 'utf8') } catch { continue }
-        const parser = new Parser()
-        parser.setLanguage(langs[grammar])
-        let tree
-        try { tree = parser.parse(code) } catch { continue }
-        if (!lang.customCalls) for (const capture of caps(grammar, lang.calls, tree.rootNode)) {
-            const caller = enclosing(file, capture.node.startPosition.row + 1)
-            if (!caller) continue
-            const target = resolveCall(capture.node.text, file)
-            if (target && target !== caller.id) links.push({source: caller.id, target, relation: 'calls', confidence: 'INFERRED', line: capture.node.startPosition.row + 1})
-        }
-        if (typeof lang.pass2 === 'function') try {
-            lang.pass2({
-                grammar, tree, fileRel: file, code, caps, field, enclosing, links, nodeById,
-                perFileSymbols, symByFileName, symIdsByFileName, importedLocals, resolveCall, resolveJavaType,
-                dirSymbols, resolveNamedSymbol, resolveRustMethod, resolveRustPath, resolveRustCratePath,
-            })
-        } catch { /* one language-specific resolver never sinks the graph */ }
-        if (lang.selectorCall) for (const capture of caps(grammar, lang.selectorCall, tree.rootNode)) {
-            const selector = capture.node, operand = field(selector, 'operand'), member = field(selector, 'field')
-            if (!operand || !member) continue
-            const caller = enclosing(file, selector.startPosition.row + 1)
-            if (!caller) continue
-            const bindings = goReceivers.receiverBindings(selector, file)
-            const imported = operand.type === 'identifier' && !bindings.has(operand.text)
-                ? importedLocals.get(file)?.get(operand.text) : null
-            let target = imported?.targetDir ? dirSymbols.get(imported.targetDir)?.get(member.text) : null
-            let resolved = !!target
-            if (!target) {
-                let receiver = null
-                if (operand.type === 'identifier') receiver = bindings.get(operand.text) || null
-                else if (operand.type === 'selector_expression') {
-                    const base = field(operand, 'operand')
-                    const baseType = base?.type === 'identifier' ? bindings.get(base.text) : null
-                    receiver = goReceivers.fieldType(baseType, field(operand, 'field')?.text)
-                }
-                target = goReceivers.exactMethod(receiver, member.text)
-                resolved = !!target
-                if (!target && !receiver) target = goReceivers.uniqueMethod(goReceivers.dirOf(file), member.text)
-            }
-            if (target && target !== caller.id) links.push({
-                source: caller.id, target, relation: 'calls', confidence: 'INFERRED',
-                ...(resolved ? {provenance: 'RESOLVED'} : {}), line: selector.startPosition.row + 1,
-            })
-        }
-        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 capture of caps(grammar, query, tree.rootNode)) {
-                const owner = enclosing(file, capture.node.startPosition.row + 1)
-                if (!owner) continue
-                const target = FAMILY[grammar] === 'java' ? resolveJavaType(capture.node.text, file) : resolveCall(capture.node.text, file)
-                if (target && target !== owner.id) links.push({source: owner.id, target, relation, confidence: 'INFERRED'})
-            }
-        }
-        if (FAMILY[grammar] === 'js') addJavaScriptReferences({
-            grammar, tree, file, caps, field, importedLocals, resolveNamespaceMember,
-            resolveNamedSymbol, enclosing, links,
-        })
-        if (FAMILY[grammar] === 'go') addGoReferences({
-            grammar, tree, file, caps, field, importedLocals, dirSymbols, enclosing, links,
-        })
-        if (FAMILY[grammar] === 'java') addJavaReferences({grammar, tree, fileRel: file, caps, resolveJavaType, enclosing, links})
-        tree.delete()
-    }
-    return {reExportOccurrences}
-}
-
-function addJavaScriptReferences({grammar, tree, file, caps, field, importedLocals, resolveNamespaceMember, resolveNamedSymbol, enclosing, links}) {
-    for (const capture of caps(grammar, `(call_expression function: (member_expression) @memberCall)`, tree.rootNode)) {
-        const object = field(capture.node, 'object'), property = field(capture.node, 'property')
-        if (!object || object.type !== 'identifier' || !property) continue
-        const imported = importedLocals.get(file)?.get(object.text)
-        if (!imported || !['*', 'default'].includes(imported.imported) || imported.typeOnly) continue
-        const origin = resolveNamespaceMember(file, imported, property.text, 'call')
-        if (origin.status !== 'resolved') continue
-        const target = resolveNamedSymbol(origin.origin.file, origin.origin.name, 'value')
-        const caller = enclosing(file, capture.node.startPosition.row + 1)
-        if (target && caller && target !== caller.id) links.push({source: caller.id, target, relation: 'calls', confidence: 'INFERRED', line: capture.node.startPosition.row + 1})
-    }
-    for (const capture of caps(grammar, `[(jsx_opening_element name: (_) @jsx) (jsx_self_closing_element name: (_) @jsx)]`, tree.rootNode)) {
-        const parts = capture.node.text.split('.'), localName = parts[0]
-        if (parts.length === 1 && !/^[A-Z_$]/.test(localName)) continue
-        const imported = importedLocals.get(file)?.get(localName)
-        if (!imported?.targetFile || imported.typeOnly) continue
-        let targetFile = imported.originFile || imported.targetFile
-        let importedName = imported.originName || imported.imported
-        if (imported.imported === '*' && parts.length > 1) {
-            const origin = resolveNamespaceMember(file, imported, parts.at(-1), 'jsx')
-            if (origin.status === 'resolved') { targetFile = origin.origin.file; importedName = origin.origin.name }
-        }
-        const target = resolveNamedSymbol(targetFile, importedName, 'value') || resolveNamedSymbol(targetFile, localName, 'value')
-        if (!target) continue
-        const owner = enclosing(file, capture.node.startPosition.row + 1)
-        links.push({source: owner?.id || file, target, relation: 'references', confidence: 'INFERRED', usage: 'jsx', line: capture.node.startPosition.row + 1})
-    }
-    if (grammar === 'javascript') return
-    for (const capture of caps(grammar, `(type_identifier) @typeRef`, tree.rootNode)) {
-        const name = capture.node.text, imported = importedLocals.get(file)?.get(name)
-        const targetFile = imported?.originFile || imported?.targetFile || file
-        const targetName = imported?.originName || imported?.imported || name
-        const target = resolveNamedSymbol(targetFile, targetName, 'type')
-        if (!target || String(target).startsWith(`${file}#${name}@${capture.node.startPosition.row + 1}`)) continue
-        const source = enclosing(file, capture.node.startPosition.row + 1)?.id || file
-        if (source !== target) links.push({source, target, relation: 'references', confidence: 'EXTRACTED', provenance: 'RESOLVED', typeOnly: true, line: capture.node.startPosition.row + 1, usage: 'type'})
-    }
-}
-
-function addGoReferences({grammar, tree, file, caps, field, importedLocals, dirSymbols, enclosing, links}) {
-    const seen = new Set()
-    const emit = (source, target) => {
-        const key = `${source}>${target}`
-        if (!target || target === source || seen.has(key)) return
-        seen.add(key); links.push({source, target, relation: 'references', confidence: 'INFERRED'})
-    }
-    const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : '', symbols = dirSymbols.get(dir)
-    for (const capture of caps(grammar, `[(identifier) (type_identifier)] @id`, tree.rootNode)) {
-        const target = symbols?.get(capture.node.text)
-        if (!target || target.slice(0, target.indexOf('#')) === file) continue
-        emit(enclosing(file, capture.node.startPosition.row + 1)?.id || file, target)
-    }
-    for (const capture of caps(grammar, `(selector_expression) @sel`, tree.rootNode)) {
-        const selector = capture.node, operand = field(selector, 'operand'), member = field(selector, 'field')
-        if (!operand || operand.type !== 'identifier' || !member) continue
-        const imported = importedLocals.get(file)?.get(operand.text)
-        const target = imported?.targetDir && dirSymbols.get(imported.targetDir)?.get(member.text)
-        if (target) emit(enclosing(file, selector.startPosition.row + 1)?.id || file, target)
-    }
-}

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

@@ -1,286 +0,0 @@
-// Per-repo resolution context shared by the language modules: JS/TS path-aliases + relative imports, Python
-// dotted/relative modules, Go package dirs, Rust crate/module paths, Java class files, and web hrefs /
-// the CSS selector index.
-// (Split from internal-builder.js — see its doc comment for the overall architecture.)
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { parseGoMod } from "../analysis/manifests.js";
-import { parseCargoToml, cargoName } from "../analysis/cargo-manifests.js";
-import { createRepoBoundary } from "../repo-path.js";
-import { listRepoFiles } from "../analysis/internal-audit/repo-files.js";
-import { createRustResolvers } from "./resolvers/rust.js";
-
-export function buildResolvers(repoDir, fileSet) {
-  const boundary = createRepoBoundary(repoDir);
-  const readLocal = (relativePath) => {
-    const resolved = boundary.resolve(relativePath);
-    if (!resolved.ok) throw new Error("resolver input is outside the repository");
-    return readFileSync(resolved.path, "utf8");
-  };
-  // Go package = directory (resolved via go.mod module prefix); Java class = file (basename index).
-  // go.mod requires also feed goSpecToPkg so external Go imports map to their declared module.
-  let goModule = "";
-  let goRequires = [];
-  const goModules = [];
-  for (const manifest of listRepoFiles(repoDir).filter((file) => /(^|\/)go\.mod$/i.test(file))) {
-    try {
-      const gomod = parseGoMod(readLocal(manifest));
-      if (!gomod.module) continue;
-      const root = manifest.includes("/") ? manifest.slice(0, manifest.lastIndexOf("/")) : "";
-      goModules.push({ root, module: gomod.module, requires: gomod.requires.map((item) => item.path) });
-    } catch { /* unreadable module */ }
-  }
-  goModules.sort((left, right) => right.module.length - left.module.length);
-  goModule = goModules.find((item) => !item.root)?.module || goModules[0]?.module || "";
-  goRequires = [...new Set(goModules.flatMap((item) => item.requires))];
-  const dirFiles = new Map();
-  const filesByBase = new Map();
-  for (const fr of fileSet) {
-    const base = fr.split("/").pop();
-    (filesByBase.get(base) || filesByBase.set(base, []).get(base)).push(fr);
-    if (fr.endsWith(".go")) { const d = fr.includes("/") ? fr.slice(0, fr.lastIndexOf("/")) : ""; (dirFiles.get(d) || dirFiles.set(d, []).get(d)).push(fr); }
-  }
-  const resolveGoImport = (importPath) => {
-    for (const own of goModules) {
-      if (importPath !== own.module && !importPath.startsWith(own.module + "/")) continue;
-      const subpath = importPath === own.module ? "" : importPath.slice(own.module.length + 1);
-      const d = [own.root, subpath].filter(Boolean).join("/");
-      if (dirFiles.has(d)) return d;
-    }
-    // a module DECLARED in go.mod is external by definition — never let the suffix fallback hijack it
-    // into a same-named internal dir (pkg/errors/ vs github.com/pkg/errors → false "unused module")
-    if (goRequires.some((r) => importPath === r || importPath.startsWith(r + "/"))) return null;
-    const segs = importPath.split("/");
-    for (const n of [Math.min(2, segs.length), 1]) { const suf = segs.slice(-n).join("/"); for (const d of dirFiles.keys()) if (d === suf || d.endsWith("/" + suf)) return d; }
-    return null;
-  };
-  const resolveJavaImport = (parts) => {
-    const full = parts.join("/") + ".java", base = parts[parts.length - 1] + ".java";
-    const cands = filesByBase.get(base) || [];
-    return cands.find((f) => f === full || f.endsWith("/" + full)) || cands[0] || null;
-  };
-
-  const { resolveRustMod, resolveRustPath } = createRustResolvers(fileSet);
-
-  // Workspace crate map: normalized package name → its crate source root file (lib.rs/main.rs). A path or
-  // `use` that starts with a sibling crate's name (`use radiochron::wlan`) then resolves INTO that crate's
-  // files instead of being logged as an external crates.io dependency — so cross-crate imports and calls
-  // become real graph edges rather than a false "unused dependency" plus missing coupling.
-  // Cargo.toml (like go.mod) is a manifest, not a parsed source file, so it is read via listRepoFiles
-  // rather than the source fileSet. The crate root .rs it points at IS in fileSet (it is parsed).
-  const rustCrates = new Map();
-  const ambiguousCrates = new Set();
-  for (const manifest of listRepoFiles(repoDir).filter((file) => /(^|\/)Cargo\.toml$/i.test(file))) {
-    let parsed;
-    try { parsed = parseCargoToml(readLocal(manifest)); } catch { continue; }
-    if (!parsed.packageName) continue;
-    const dir = manifest.includes("/") ? manifest.slice(0, manifest.lastIndexOf("/")) : "";
-    const rootFile = ["src/lib.rs", "src/main.rs", "lib.rs", "main.rs"]
-      .map((candidate) => [dir, candidate].filter(Boolean).join("/"))
-      .find((path) => fileSet.has(path));
-    if (!rootFile) continue;
-    const key = cargoName(parsed.packageName);
-    // A repo can hold two crates with the same package name (independent workspaces, vendored copies).
-    // Cross-crate resolution has no way to pick the right one from a bare `name::path`, so treat the name
-    // as ambiguous and resolve nothing for it — better a missing edge than a confident wrong one.
-    if (rustCrates.has(key) && rustCrates.get(key) !== rootFile) ambiguousCrates.add(key);
-    else rustCrates.set(key, rootFile);
-  }
-  // Resolve `<crate>::<segments...>` against the named sibling crate's root, reusing the crate-anchored
-  // module resolver. Returns {targetFile, remaining} or null when the head is not an unambiguous workspace crate.
-  const resolveRustCratePath = (crateName, segments = []) => {
-    const key = cargoName(crateName);
-    if (ambiguousCrates.has(key)) return null;
-    const rootFile = rustCrates.get(key);
-    if (!rootFile) return null;
-    return resolveRustPath(rootFile, ["crate", ...segments], { unqualified: false });
-  };
-
-  // Path aliases (tsconfig compilerOptions.paths + vite/webpack alias) are scoped to their config folder.
-  // Without nearest-config resolution, a monorepo's root `@/*` can hijack the same alias in web/.
-  const aliasContexts = new Map();
-  const cleanRel = (p) => String(p || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "").replace(/^\.$/, "");
-  const contextFor = (dir) => {
-    dir = cleanRel(dir);
-    let ctx = aliasContexts.get(dir);
-    if (!ctx) aliasContexts.set(dir, (ctx = { dir, aliases: [], baseUrls: [] }));
-    return ctx;
-  };
-  const addAlias = (ctx, a, t) => {
-    a = String(a).replace(/\/\*$/, "").replace(/\/$/, "");
-    t = cleanRel(String(t)).replace(/\/\*$/, "");
-    if (a && t && !ctx.aliases.some((x) => x.alias === a)) ctx.aliases.push({ alias: a, target: t });
-  };
-  const parseJsonc = (raw) => {
-    // Regex comment stripping corrupts perfectly valid path strings such as `"@/*"` followed later by
-    // `"**/*.ts"`. Strip comments/trailing commas only while outside JSON strings.
-    raw = String(raw).replace(/^\uFEFF/, "");
-    let clean = ""; let inString = false; let escaped = false;
-    for (let i = 0; i < raw.length; i++) {
-      const ch = raw[i], next = raw[i + 1];
-      if (inString) {
-        clean += ch;
-        if (escaped) escaped = false;
-        else if (ch === "\\") escaped = true;
-        else if (ch === '"') inString = false;
-        continue;
-      }
-      if (ch === '"') { inString = true; clean += ch; continue; }
-      if (ch === "/" && next === "/") { while (i < raw.length && raw[i] !== "\n") i++; clean += "\n"; continue; }
-      if (ch === "/" && next === "*") {
-        i += 2;
-        while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) { if (raw[i] === "\n") clean += "\n"; i++; }
-        i++;
-        continue;
-      }
-      clean += ch;
-    }
-    let withoutTrailing = ""; inString = false; escaped = false;
-    for (let i = 0; i < clean.length; i++) {
-      const ch = clean[i];
-      if (inString) {
-        withoutTrailing += ch;
-        if (escaped) escaped = false;
-        else if (ch === "\\") escaped = true;
-        else if (ch === '"') inString = false;
-        continue;
-      }
-      if (ch === '"') { inString = true; withoutTrailing += ch; continue; }
-      if (ch === ",") {
-        let j = i + 1; while (/\s/.test(clean[j] || "")) j++;
-        if (clean[j] === "}" || clean[j] === "]") continue;
-      }
-      withoutTrailing += ch;
-    }
-    return JSON.parse(withoutTrailing);
-  };
-  const configRank = (fr) => /(^|\/)tsconfig\.json$/i.test(fr) ? 0 : /(^|\/)jsconfig\.json$/i.test(fr) ? 1 : 2;
-  const configFiles = [...fileSet]
-    .filter((fr) => /(^|\/)(?:tsconfig(?:\.[^/]+)?|jsconfig)\.json$/i.test(fr))
-    .sort((a, b) => dirname(a).localeCompare(dirname(b)) || configRank(a) - configRank(b) || a.localeCompare(b));
-  for (const cfg of configFiles) {
-    try {
-      const tj = parseJsonc(readLocal(cfg)); const co = tj.compilerOptions || {}; const paths = co.paths || {};
-      const cfgDir = cleanRel(dirname(cfg)); const ctx = contextFor(cfgDir);
-      const baseRoot = cleanRel(join(cfgDir || ".", String(co.baseUrl || ".")));
-      if (co.baseUrl != null && !ctx.baseUrls.includes(baseRoot)) ctx.baseUrls.push(baseRoot);
-      for (const [k, v] of Object.entries(paths)) {
-        const t = Array.isArray(v) ? v[0] : v;
-        if (t) addAlias(ctx, k, join(baseRoot || ".", String(t)));
-      }
-    } catch { /* no/invalid tsconfig */ }
-  }
-  for (const vc of [...fileSet].filter((fr) => /(^|\/)(?:vite\.config\.(?:ts|js|mjs)|webpack\.config\.js)$/.test(fr))) {
-    try {
-      const cfgDir = cleanRel(dirname(vc)); const ctx = contextFor(cfgDir); const src = readLocal(vc);
-      for (const m of src.matchAll(/['"`]([^'"`]+)['"`]\s*:\s*path\.resolve\([^,]+,\s*['"`]([^'"`]+)['"`]\s*\)/g)) addAlias(ctx, m[1], join(cfgDir || ".", m[2]));
-    } catch { /* no/invalid bundler config */ }
-  }
-  for (const ctx of aliasContexts.values()) ctx.aliases.sort((a, b) => b.alias.length - a.alias.length);
-  const contextsForFile = (fromRel) => [...aliasContexts.values()]
-    .filter((ctx) => !ctx.dir || fromRel === ctx.dir || fromRel.startsWith(ctx.dir + "/"))
-    .sort((a, b) => b.dir.length - a.dir.length);
-  const resolveAlias = (fromRel, spec) => {
-    if (spec === undefined) { spec = fromRel; fromRel = ""; }
-    for (const ctx of contextsForFile(fromRel)) for (const { alias, target } of ctx.aliases) {
-      if (spec === alias) return target;
-      if (spec.startsWith(alias + "/")) return target + spec.slice(alias.length);
-    }
-    return null;
-  };
-
-  const JS_EXTS = ["", ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs", ".json", "/index.js", "/index.ts", "/index.jsx", "/index.tsx"];
-  const resolveJsBase = (base) => {
-    for (const extension of JS_EXTS) {
-      const candidate = (base + extension).replace(/\/+/g, "/");
-      if (fileSet.has(candidate)) return candidate;
-    }
-    // TypeScript NodeNext source commonly imports the emitted extension (`./http.js`) while the
-    // repository contains `http.ts`/`http.tsx`. Exact runtime files win above; a source counterpart
-    // is accepted only when unique so same-basename ambiguity is never guessed.
-    const sourceCandidates = [];
-    if (/\.js$/i.test(base)) sourceCandidates.push(base.replace(/\.js$/i, ".ts"), base.replace(/\.js$/i, ".tsx"));
-    else if (/\.jsx$/i.test(base)) sourceCandidates.push(base.replace(/\.jsx$/i, ".tsx"));
-    const existing = [...new Set(sourceCandidates.map((candidate) => candidate.replace(/\/+/g, "/")))]
-      .filter((candidate) => fileSet.has(candidate));
-    return existing.length === 1 ? existing[0] : null;
-  };
-  const resolveJsImport = (fromRel, spec) => {
-    if (!spec) return null;
-    let base;
-    if (spec.startsWith(".")) base = join(dirname(fromRel), spec).replace(/\\/g, "/").replace(/^\.\//, "");
-    else {
-      base = resolveAlias(fromRel, spec);
-      if (base == null) {
-        // baseUrl-rooted internal import ("components/Button" with baseUrl:"src") — try before calling it an npm package
-        for (const ctx of contextsForFile(fromRel)) for (const b of ctx.baseUrls) {
-          const root = (b ? b + "/" : "") + spec;
-          const resolved = resolveJsBase(root);
-          if (resolved) return resolved;
-        }
-        return null;   // genuinely bare → npm package (stays unresolved here)
-      }
-    }
-    return resolveJsBase(base);
-  };
-
-  const resolvePyPath = (baseDir, parts) => {
-    const p = [baseDir, ...parts].filter(Boolean).join("/").replace(/\/+/g, "/").replace(/^\.\//, "");
-    // src-layout: absolute imports of the repo's own package live under src/ (PEP 517 convention)
-    const cands = baseDir ? [p + ".py", p + "/__init__.py"] : [p + ".py", p + "/__init__.py", "src/" + p + ".py", "src/" + p + "/__init__.py"];
-    for (const cand of cands) if (fileSet.has(cand)) return cand;
-    return null;
-  };
-  const pyBaseDir = (fromRel, dots) => { let d = dots > 0 ? dirname(fromRel) : ""; for (let i = 1; i < dots; i++) d = dirname(d); return d === "." ? "" : d; };
-  // top-level dirs holding .py files (incl. under src/) — PEP 420 namespace packages have no __init__.py,
-  // so an absolute import of one resolves to no FILE; knowing the dir exists stops a false "external dep".
-  const pyTopDirs = new Set();
-  for (const fr of fileSet) {
-    if (!fr.endsWith(".py") || !fr.includes("/")) continue;
-    const seg = fr.split("/");
-    pyTopDirs.add(seg[0]);
-    if (seg[0] === "src" && seg.length > 2) pyTopDirs.add(seg[1]);
-  }
-
-  // Solidity: relative imports, Foundry remappings (remappings.txt beats foundry.toml, longest prefix
-  // wins), then root-anchored specs (`src/X.sol` — forge resolves those against the project root).
-  // Nested remapping files are intentionally not scoped per-package: one remapping table per repo is the
-  // overwhelmingly common layout, and a wrong guess here would fabricate cross-package edges.
-  const solRemappings = [];
-  const addRemapping = (entry) => {
-    const m = /^\s*([^=\s]+)\s*=\s*(\S+)\s*$/.exec(String(entry || ""));
-    if (m && !solRemappings.some((r) => r.prefix === m[1])) solRemappings.push({ prefix: m[1], target: cleanRel(m[2]) });
-  };
-  // neither file has an indexed extension, so probe the filesystem directly rather than fileSet
-  try { for (const line of readLocal("remappings.txt").split(/\r?\n/)) addRemapping(line); } catch { /* absent/unreadable */ }
-  try {
-    const toml = readLocal("foundry.toml");
-    for (const m of toml.matchAll(/remappings\s*=\s*\[([^\]]*)\]/g)) for (const s of m[1].matchAll(/["']([^"']+)["']/g)) addRemapping(s[1]);
-  } catch { /* absent/unreadable */ }
-  solRemappings.sort((a, b) => b.prefix.length - a.prefix.length);
-  const resolveSolidityImport = (fromRel, spec) => {
-    if (!spec || !spec.endsWith(".sol")) return null;
-    if (spec.startsWith(".")) {
-      const candidate = cleanRel(join(dirname(fromRel), spec));
-      return fileSet.has(candidate) ? candidate : null;
-    }
-    for (const { prefix, target } of solRemappings) {
-      if (spec !== prefix && !spec.startsWith(prefix)) continue;
-      const candidate = cleanRel(target + "/" + spec.slice(prefix.length)).replace(/\/+/g, "/");
-      if (fileSet.has(candidate)) return candidate;
-    }
-    return fileSet.has(spec) ? spec : null;
-  };
-
-  const selectorIndex = new Map();
-  const htmlUsages = [];
-  const resolveHref = (fromRel, href) => {
-    if (!href) return null;
-    const h = href.split(/[?#]/)[0].replace(/^\.\//, "");
-    if (/^(https?:)?\/\//.test(h) || h.startsWith("data:") || h.startsWith("#") || h.startsWith("mailto:")) return null;
-    const cand = h.startsWith("/") ? h.slice(1) : join(dirname(fromRel), h).replace(/\\/g, "/").replace(/^\.\//, "");
-    return fileSet.has(cand) ? cand : null;
-  };
-
-  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveRustCratePath, resolveJavaImport, resolveSolidityImport, resolveHref, selectorIndex, htmlUsages, goModule, goModules, goRequires };
-}

package/src/graph/layout.js

@@ -1,51 +0,0 @@
-// Graph paths + analysis re-exports. This module owns the on-disk graph locations and re-exports the
-// 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 { 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";
-
-// 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(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(graphOutDirForRepo(repoPath), "modules", safe);
-}
-
-// Top-level source folders of a repo (for path-scoped builds).
-export function repoTopFolders(repoPath) {
-  try {
-    return readdirSync(repoPath, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !["node_modules", "weavatrix-graphs", "dist", "build", "coverage", "vendor"].includes(entry.name))
-      .map((entry) => entry.name)
-      .sort((left, right) => left.localeCompare(right));
-  } catch {
-    return [];
-  }
-}

package/src/graph/node-id.js

@@ -1,7 +0,0 @@
-export const graphEndpointId = (value) => String(value && typeof value === "object" ? value.id : value);
-
-export const fileOfId = (value) => {
-  const id = String(value || "");
-  const hash = id.indexOf("#");
-  return hash < 0 ? id : id.slice(0, hash);
-};

package/src/graph/parser-artifact-boundary.js

@@ -1,55 +0,0 @@
-import {createHash} from 'node:crypto'
-import {readFileSync, realpathSync, statSync} from 'node:fs'
-import {join} from 'node:path'
-import {isPathInside} from '../repo-path.js'
-
-// Exact SHA-256 allowlist for the parser artifacts shipped by the package-pinned
-// web-tree-sitter@0.25.10 and tree-sitter-wasms@0.1.13 dependencies. npm integrity
-// protects installation; this second boundary detects replacement or redirection
-// before Emscripten compiles a runtime or dynamic language module.
-const RUNTIME_SHA256 = 'f38dcc4b43b818f9a0785bc1c6d5611a75ac4cdd428ff3f02757c34ca4e46d7f'
-const GRAMMAR_SHA256 = Object.freeze({
-  javascript: '63812b9e275d26851264734868d27a1656bd44a2ef6eb3e85e6b03728c595ab5',
-  typescript: '8515404dceed38e1ed86aa34b09fcf3379fff1b4ff9dd3967bcd6d1eb5ac3d8f',
-  tsx: '6aa3b2c70e76f5d48eafef1093e9c4de383e13f2fdde2f4e9b98a378f6a8f1b6',
-  python: '9056d0fb0c337810d019fae350e8167786119da98f0f282aceae7ab89ee8253b',
-  go: '9963ca89b616eaf04b08a43bc1fb0f07b85395bec313330851f1f1ead2f755b6',
-  java: '637aac4415fb39a211a4f4292d63c66b5ce9c32fa2cd35464af4f681d91b9a1f',
-  c_sharp: '6266a7e32d68a3459104d994dc848df15d5672b0ea8e86d327274b694f8e6991',
-  rust: '4409921a70d0aa5bec7d1d7ce809a557a8ee1cf6ace901e3ac6a76e62cfea903',
-  solidity: '160745e470f234cae903a9ba445d19e758d0b02e1197401fc765976c6254d2b6',
-  html: '11b3405c1543fb012f5ed7f8ee73125076dce8b168301e1e787e4c717da6b456',
-  css: '5fc615467b1b98420ed7517e5bf9e1f88468132dd903d842dfb13714f6a1cb0c',
-})
-
-export function verifyParserArtifact({file, root, sha256, label = 'parser artifact'}) {
-  let rootReal, fileReal
-  try {
-    rootReal = realpathSync.native(root)
-    fileReal = realpathSync.native(file)
-  } catch {
-    throw new Error(`${label} is missing or cannot be resolved`)
-  }
-  if (!isPathInside(rootReal, fileReal) || !statSync(fileReal).isFile()) {
-    throw new Error(`${label} resolves outside its pinned package directory`)
-  }
-  const actual = createHash('sha256').update(readFileSync(fileReal)).digest('hex')
-  if (actual !== sha256) throw new Error(`${label} failed the pinned SHA-256 integrity check`)
-  return fileReal
-}
-
-export function trustedRuntimeWasm(wtsDir) {
-  return verifyParserArtifact({
-    file: join(wtsDir, 'tree-sitter.wasm'), root: wtsDir,
-    sha256: RUNTIME_SHA256, label: 'web-tree-sitter runtime',
-  })
-}
-
-export function trustedGrammarWasm(wasmDir, grammar) {
-  const sha256 = GRAMMAR_SHA256[grammar]
-  if (!sha256) throw new Error(`unsupported tree-sitter grammar: ${grammar}`)
-  return verifyParserArtifact({
-    file: join(wasmDir, `tree-sitter-${grammar}.wasm`), root: wasmDir,
-    sha256, label: `tree-sitter ${grammar} grammar`,
-  })
-}

package/src/graph/relations.js

@@ -1,4 +0,0 @@
-// Ownership/nesting edges are useful for navigation, but are not evidence of code usage.
-const STRUCTURAL_RELATIONS = new Set(["contains", "method"]);
-
-export const isStructuralRelation = (relation) => STRUCTURAL_RELATIONS.has(String(relation || ""));