weavatrix 0.3.14 → 1.0.0

package/src/analysis/git-ref-graph.js

@@ -1,76 +0,0 @@
-// Build a source graph for an immutable Git commit without mutating the user's worktree.
-// The commit is first resolved to a full object id, then exported into a private temporary
-// directory. No hooks are run and no branch/worktree metadata is changed.
-import {mkdtempSync, mkdirSync, rmSync} from 'node:fs'
-import {join} from 'node:path'
-import {tmpdir} from 'node:os'
-import {runGit} from '../git-exec.js'
-import {runCommandSync} from '../process.js'
-import {buildInternalGraph} from '../graph/internal-builder.js'
-import {filterGraphForMode} from '../graph/graph-filter.js'
-
-const SAFE_REF = /^(?!-)[A-Za-z0-9][A-Za-z0-9._\/@{}+~^-]{0,199}$/
-
-function git(repoRoot, args, timeout = 15_000) {
-    return runGit(repoRoot, args, {timeout, maxBuffer: 4 * 1024 * 1024})
-}
-
-export function resolveGitCommit(repoRoot, requestedRef) {
-    const ref = String(requestedRef || '').trim()
-    if (!SAFE_REF.test(ref)) return {ok: false, error: 'base_ref contains unsupported characters'}
-    const result = git(repoRoot, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
-    const commit = String(result.stdout || '').trim()
-    if (result.status !== 0 || !/^[a-f0-9]{40,64}$/i.test(commit)) {
-        return {ok: false, error: `could not resolve Git ref "${ref}" to a commit`}
-    }
-    return {ok: true, ref, commit}
-}
-
-export async function withGitRefCheckout(repoRoot, requestedRef, operation) {
-    const resolved = resolveGitCommit(repoRoot, requestedRef)
-    if (!resolved.ok) return resolved
-    const temp = mkdtempSync(join(tmpdir(), 'weavatrix-git-ref-'))
-    const checkout = join(temp, 'repo')
-    const archive = join(temp, 'source.tar')
-    mkdirSync(checkout, {recursive: true})
-    try {
-        const archived = git(repoRoot, ['archive', '--format=tar', `--output=${archive}`, resolved.commit], 60_000)
-        if (archived.status !== 0) {
-            return {ok: false, error: `git archive failed for ${resolved.ref}: ${String(archived.stderr || '').trim() || 'unknown error'}`}
-        }
-        const extracted = runCommandSync('tar', ['-xf', archive, '-C', checkout], {timeout: 60_000, maxBuffer: 4 * 1024 * 1024})
-        if (extracted.status !== 0) {
-            return {ok: false, error: `temporary Git archive extraction failed: ${String(extracted.stderr || '').trim() || 'tar unavailable'}`}
-        }
-        // A normal build asks Git for tracked + non-ignored files. A plain archive has no .git
-        // directory, so the fallback walker deliberately skips tracked dot paths such as
-        // .github/workflows. Recreate only an index over the immutable archive (no commit, hooks or
-        // checkout) so live and baseline graphs use the same file-universe semantics.
-        const initialized = git(checkout, ['init', '--quiet'])
-        if (initialized.status !== 0) {
-            return {ok: false, error: `temporary Git index initialization failed: ${String(initialized.stderr || '').trim() || 'unknown error'}`}
-        }
-        const indexed = git(checkout, ['add', '--all', '--force'], 60_000)
-        if (indexed.status !== 0) {
-            return {ok: false, error: `temporary Git index population failed: ${String(indexed.stderr || '').trim() || 'unknown error'}`}
-        }
-        const value = await operation(checkout, resolved)
-        return {ok: true, ref: resolved.ref, commit: resolved.commit, value}
-    } catch (error) {
-        return {ok: false, error: error instanceof Error ? error.message : String(error)}
-    } finally {
-        rmSync(temp, {recursive: true, force: true})
-    }
-}
-
-export async function buildGraphAtGitRef(repoRoot, requestedRef, {mode = 'full'} = {}) {
-    const buildMode = ['full', 'no-tests', 'tests-only'].includes(mode) ? mode : 'full'
-    const result = await withGitRefCheckout(repoRoot, requestedRef, async (checkout) => {
-        const fullGraph = await buildInternalGraph(checkout)
-        return {
-            ...filterGraphForMode(fullGraph, buildMode, {repoRoot: checkout}),
-            graphBuildMode: buildMode,
-        }
-    })
-    return result.ok ? {...result, graph: result.value} : result
-}

package/src/analysis/go-dependency-evidence.js

@@ -1,62 +0,0 @@
-import { createRepoBoundary } from "../repo-path.js";
-import { computeGoDepFindings } from "./dep-check-ecosystems.js";
-import { listRepoFiles, readRepoText } from "./internal-audit.collect.js";
-import { parseGoMod } from "./manifests.js";
-import { makeFinding } from "./findings.js";
-import { dependencyScopeOwnsFile, dependencyScopeRoot } from "./dependency/scoped-dependencies.js";
-
-export function collectGoDependencyEvidence(repoRoot, { files = listRepoFiles(repoRoot), externalImports = [], nonRuntimeRoots = [] } = {}) {
-  const boundary = createRepoBoundary(repoRoot);
-  const manifests = files.filter((file) => /(^|\/)go\.mod$/i.test(file));
-  const scopes = manifests.map((file) => ({ file, root: dependencyScopeRoot(file), parsed: parseGoMod(readRepoText(boundary, file)) }))
-    .sort((left, right) => right.root.length - left.root.length || left.root.localeCompare(right.root));
-  const importsByScope = new Map(scopes.map((scope) => [scope, []]));
-  for (const entry of externalImports) {
-    if (entry.ecosystem !== "Go") continue;
-    const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, entry.file));
-    if (owner) importsByScope.get(owner).push(entry);
-  }
-  const findings = [], declared = new Set(), issues = [];
-  if (!scopes.length) {
-    const missing = new Map();
-    for (const entry of externalImports.filter((item) => item.ecosystem === "Go" && item.pkg && !item.builtin && !item.unresolved)) {
-      if (!missing.has(entry.pkg)) missing.set(entry.pkg, entry);
-    }
-    for (const [name, entry] of missing) findings.push(makeFinding({
-      category: "unused", rule: "missing-dep", severity: "low", confidence: "high",
-      title: `Go import without a module manifest: ${name}`,
-      reason: "An indexed external Go import exists, but no go.mod was discovered.",
-      detail: `"${entry.spec || name}" is imported by ${entry.file}, but no go.mod exists in the repository.`,
-      package: name, file: entry.file, line: entry.line || 0, source: "internal",
-      verification: { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "ACTION_REQUIRED", manifestDeclaration: { status: "NOT_PRESENT" }, indexedSourceImports: { status: "FOUND", count: 1, files: [entry.file] }, mapping: "Go module prefix" },
-      fixHint: "initialize or restore the owning Go module manifest",
-    }));
-  }
-  for (const scope of scopes) {
-    if (!scope.parsed.module) issues.push(`${scope.file}: module directive is missing or unreadable`);
-    const result = computeGoDepFindings({ externalImports: importsByScope.get(scope), goMod: scope.parsed, nonRuntimeRoots });
-    findings.push(...result.findings.map((finding) => ({
-      ...finding,
-      manifest: scope.file,
-      verification: finding.rule === "missing-dep"
-        ? { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "ACTION_REQUIRED", manifestDeclaration: { status: "NOT_FOUND", file: scope.file }, indexedSourceImports: { status: "FOUND", count: finding.evidence?.length || 1, files: (finding.evidence || []).map((item) => item.file) }, mapping: "longest go.mod module prefix" }
-        : { evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE", decision: "REVIEW_REQUIRED", manifestDeclaration: { status: "FOUND", file: scope.file }, indexedSourceImports: { status: "ZERO_FOUND", completeness: "COMPLETE_FOR_GRAPH_SCOPE", count: 0, files: [] }, mapping: "longest go.mod module prefix" },
-    })));
-    for (const name of result.declared) declared.add(`${scope.root || "."}:${name}`);
-  }
-  const present = manifests.length > 0;
-  return {
-    present,
-    status: present ? "CHECKED" : "NOT_PRESENT",
-    completeness: present ? (issues.length ? "PARTIAL" : "COMPLETE") : "NOT_APPLICABLE",
-    manifests,
-    declared,
-    findings,
-    reasons: issues,
-    reason: !present
-      ? "No go.mod was discovered."
-      : issues.length
-        ? `Go imports and requirements were checked across ${manifests.length} module(s), but ${issues.length} module descriptor(s) were incomplete.`
-        : `Every discovered go.mod scope (${manifests.length}) was compared with indexed Go imports, including direct/indirect requirements and replace directives.`,
-  };
-}

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

@@ -1,296 +0,0 @@
-// Aggregating a built graph.json into the file/module/symbol rollup the UI needs. `aggregateGraph`
-// is pure over the parsed graph (covered by tests) apart from optional repoRoot file reads;
-// `analyzeGraph` reads the graph file from disk first.
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { normalizeRepoParts, readCoverageForRepo, pctFromCounts } from "./coverage-reports.js";
-import { bareSymbolName, computeLocalSymbolRefs, computeSymbolExternalRefs } from "./graph-analysis.refs.js";
-import { createRepoBoundary } from "../repo-path.js";
-import { edgeList, folderModuleOf } from "./graph-analysis.edges.js";
-export { folderModuleOf } from "./graph-analysis.edges.js";
-
-// Aggregate a built graph.json into the file- and module-level view the UI needs:
-//   - graph-builder nodes are FILES *and* their symbols (functions/methods), linked file→symbol by the
-//     "contains" relation. So a community's raw node count (what the cards show) is NOT a file count.
-//   - Each file is assigned to ONE module via its file-node's community (symbols may cluster apart,
-//     but the file itself belongs where its file-node sits) → exact, non-overlapping file counts.
-//   - Real edges (everything except "contains") roll up to file→file and module→module relations.
-export function analyzeGraph(graphJsonPath, repoRoot) {
-  let graph;
-  try {
-    graph = JSON.parse(readFileSync(graphJsonPath, "utf8"));
-  } catch {
-    return null;
-  }
-  return aggregateGraph(graph, repoRoot);
-}
-
-// Pure aggregation over an already-parsed graph object — split out of analyzeGraph so it can be
-// unit-tested without a graph.json on disk. Touches the filesystem only when repoRoot is provided
-// (to read each source file's line count for the size colouring).
-export function aggregateGraph(graph, repoRoot) {
-  const nodes = graph.nodes || [];
-  const links = graph.links || [];
-  const endpoint = (value) => (value && typeof value === "object" ? value.id : value);
-
-  // symbol nodes = targets of a "contains" edge (a file "contains" its functions/methods)
-  const symbolIds = new Set();
-  for (const link of links) if (link.relation === "contains") symbolIds.add(endpoint(link.target));
-
-  // community → dominant folder name (over all code nodes — same rule as summarizeCommunities)
-  // MODULE = the file's own top FOLDER (its "territory"), up to 2 path levels — NOT a dependency
-  // cluster. e.g. src/widget/foo.js → "src/widget"; benchmarks/cleanup.py → "benchmarks" (so all
-  // benchmarks files are one module); a top-level file like index.js → "(root)".
-  // In a merged (cross-repo) graph every node carries a `repo`; qualify file & module identity by it
-  // so same-named folders/files in different repos never merge. Single-repo graphs have no `repo`,
-  // so identity stays the bare path (unchanged behavior).
-  const fileIdOf = (node) => (node.repo ? `${node.repo}::${node.source_file}` : node.source_file);
-  const moduleOfNode = (node) => (node.repo ? `${node.repo}/` : "") + folderModuleOf(node.source_file);
-
-  // file → module (folder) + symbols + display path, all keyed by repo-qualified file id
-  const fileModule = new Map();
-  const fileSymbols = new Map();
-  const filePath = new Map();
-  const moduleRepo = new Map();
-  for (const node of nodes) {
-    if (node.file_type !== "code" || !node.source_file) continue;
-    const fid = fileIdOf(node);
-    if (symbolIds.has(node.id)) {
-      const list = fileSymbols.get(fid) || [];
-      list.push({
-        id: node.id,
-        label: node.label || node.norm_label || node.id,
-        line: String(node.source_location || "").replace(/^L/, ""),
-        endLine: String(node.source_end || "").replace(/^L/, ""),
-        ...(node.complexity ? { complexity: node.complexity } : {}),
-        ...(node.decorated ? { decorated: true } : {}),
-        ...(node.symbol_kind ? {symbolKind: node.symbol_kind} : {}),
-        ...(node.symbol_space ? {symbolSpace: node.symbol_space} : {})
-      });
-      fileSymbols.set(fid, list);
-    }
-    if (!fileModule.has(fid)) {
-      const mod = moduleOfNode(node);
-      fileModule.set(fid, mod);
-      filePath.set(fid, node.source_file);
-      if (node.repo) moduleRepo.set(mod, node.repo);
-    }
-  }
-
-  // raw node count per module (files + their symbols), for the honest "X files · Y nodes"
-  const moduleNodeCount = new Map();
-  for (const node of nodes) {
-    if (node.file_type !== "code" || !node.source_file) continue;
-    const name = moduleOfNode(node);
-    moduleNodeCount.set(name, (moduleNodeCount.get(name) || 0) + 1);
-  }
-
-  // modules: folder → its files (+ symbol breakdown). `repo` is set for cross-repo graphs.
-  const modules = new Map();
-  for (const [fid, name] of fileModule) {
-    const mod = modules.get(name) || { name, repo: moduleRepo.get(name) || null, files: [] };
-    const symbols = fileSymbols.get(fid) || [];
-    mod.files.push({ file: fid, path: filePath.get(fid) || fid, symbolCount: symbols.length, symbols: symbols.slice(0, 300) });
-    modules.set(name, mod);
-  }
-
-  // file→file and module→module edges (skip "contains"; map endpoints by repo-qualified file / module)
-  const id2file = new Map();
-  for (const node of nodes) if (node.source_file) id2file.set(node.id, fileIdOf(node));
-  const fileEdges = new Map(); // key → { count, rels:{relation→n} } so we can emit the DOMINANT relation (call/import/inherit)
-  const moduleEdges = new Map();
-  const typeOnlyFileEdges = new Map();
-  const typeOnlyModuleEdges = new Map();
-  const compileOnlyFileEdges = new Map();
-  const compileOnlyModuleEdges = new Map();
-  const compileTimeFileEdges = new Map();
-  const compileTimeModuleEdges = new Map();
-  const addFileEdge = (map, key, link) => {
-    let edge = map.get(key);
-    if (!edge) map.set(key, (edge = { count: 0, rels: {} }));
-    edge.count++;
-    if (link.relation) edge.rels[link.relation] = (edge.rels[link.relation] || 0) + 1;
-  };
-  for (const link of links) {
-    if (link.relation === "contains" || link.barrelProxy === true) continue;
-    const fromFile = id2file.get(endpoint(link.source));
-    const toFile = id2file.get(endpoint(link.target));
-    if (fromFile && toFile && fromFile !== toFile) {
-      const key = `${fromFile} ${toFile}`;
-      const compileTime = link.typeOnly === true || link.compileOnly === true;
-      const targetFileEdges = link.typeOnly === true ? typeOnlyFileEdges : link.compileOnly === true ? compileOnlyFileEdges : fileEdges;
-      addFileEdge(targetFileEdges, key, link);
-      if (compileTime) addFileEdge(compileTimeFileEdges, key, link);
-      const fromMod = fileModule.get(fromFile);
-      const toMod = fileModule.get(toFile);
-      if (fromMod && toMod && fromMod !== toMod) {
-        const mkey = `${fromMod} ${toMod}`;
-        const targetModuleEdges = link.typeOnly === true ? typeOnlyModuleEdges : link.compileOnly === true ? compileOnlyModuleEdges : moduleEdges;
-        targetModuleEdges.set(mkey, (targetModuleEdges.get(mkey) || 0) + 1);
-        if (compileTime) compileTimeModuleEdges.set(mkey, (compileTimeModuleEdges.get(mkey) || 0) + 1);
-      }
-    }
-  }
-  // symbol-level (function/method) call graph: edges between symbol nodes (calls/method), each symbol
-  // tagged with its file's module so the Symbols view can still cluster into module regions.
-  const symEdges = new Map();
-  for (const link of links) {
-    if (link.relation === "contains" || link.barrelProxy === true) continue;
-    const s = endpoint(link.source);
-    const t = endpoint(link.target);
-    if (s === t || !symbolIds.has(s) || !symbolIds.has(t)) continue;
-    const key = `${s}\t${t}`;
-    symEdges.set(key, (symEdges.get(key) || 0) + 1);
-  }
-  const connectedSyms = new Set();
-  for (const key of symEdges.keys()) {
-    const tab = key.indexOf("\t");
-    connectedSyms.add(key.slice(0, tab));
-    connectedSyms.add(key.slice(tab + 1));
-  }
-  const symbols = [];
-  for (const node of nodes) {
-    if (!symbolIds.has(node.id) || !connectedSyms.has(node.id)) continue;
-    const fid = fileIdOf(node);
-    symbols.push({
-      id: node.id,
-      label: node.label || node.norm_label || node.id,
-      file: node.source_file || "",
-      module: fileModule.get(fid) || moduleOfNode(node),
-      line: String(node.source_location || "").replace(/^L/, ""),
-      endLine: String(node.source_end || "").replace(/^L/, ""),
-      ...(node.complexity ? { complexity: node.complexity } : {})
-    });
-  }
-  const symbolEdges = [...symEdges.entries()]
-    .map(([key, count]) => {
-      const tab = key.indexOf("\t");
-      return { from: key.slice(0, tab), to: key.slice(tab + 1), count };
-    })
-    .sort((a, b) => b.count - a.count);
-
-  // lines of code per folder (best-effort — needs the repo on disk; absent for merged combos) so the
-  // UI can color folders blue→red by size.
-  let folderLoc = null;
-  const fileLoc = new Map();
-  const fileText = new Map();
-  if (repoRoot) {
-    const boundary = createRepoBoundary(repoRoot);
-    folderLoc = {};
-    for (const [sourceFile, mod] of fileModule) {
-      let loc = 0;
-      try {
-        const resolved = boundary.resolve(sourceFile);
-        if (!resolved.ok) throw new Error("source path is outside the repository");
-        const txt = readFileSync(resolved.path, "utf8");
-        loc = txt ? txt.split("\n").length : 0;
-        fileText.set(sourceFile, txt || "");
-      } catch {
-        /* file may be gone — skip */
-      }
-      fileLoc.set(sourceFile, loc);
-      folderLoc[mod] = (folderLoc[mod] || 0) + loc;
-    }
-  }
-  const coverageByFile = repoRoot ? readCoverageForRepo(repoRoot, [...filePath.values()]) : new Map();
-  const coverageForFile = (fid) => coverageByFile.get(normalizeRepoParts(filePath.get(fid) || fid)) || null;
-  const coverageForRange = (fid, startLine, endLine) => {
-    const cov = coverageForFile(fid);
-    if (!cov) return null;
-    if (!(cov.lines instanceof Map) || !cov.lines.size || !Number.isFinite(startLine) || !Number.isFinite(endLine)) return cov.pct ?? null;
-    let total = 0;
-    let covered = 0;
-    for (let line = Math.max(1, startLine); line <= Math.max(startLine, endLine); line++) {
-      if (!cov.lines.has(line)) continue;
-      total++;
-      if (Number(cov.lines.get(line)) > 0) covered++;
-    }
-    return total ? pctFromCounts(covered, total) : cov.pct ?? null;
-  };
-
-  const symbolExternalRefs = computeSymbolExternalRefs(filePath, fileSymbols, fileText);
-
-  // Prefer the exact AST end line emitted by the internal builder. Older graph.json files only carry a
-  // start line, so keep the historical next-declaration/EOF approximation as a compatibility fallback.
-  const symbolLoc = new Map();
-  const symbolCoverage = new Map();
-  // Source-level refs catch local value/constants usage that graph-builder's call edges can miss.
-  const symbolLocalRefs = new Map();
-  for (const [fid, list] of fileSymbols) {
-    const total = fileLoc.get(fid) || 0;
-    const txt = fileText.get(fid) || "";
-    const sorted = list
-      .map((s) => ({ id: s.id, label: s.label, start: parseInt(s.line, 10), end: parseInt(s.endLine, 10), ref: s }))
-      .filter((s) => Number.isFinite(s.start) && s.start > 0)
-      .sort((a, b) => a.start - b.start);
-    const ranges = [];
-    for (let i = 0; i < sorted.length; i++) {
-      const start = sorted[i].start;
-      const next = i + 1 < sorted.length ? sorted[i + 1].start : total > start ? total + 1 : start + 1;
-      const exactEnd = Number.isFinite(sorted[i].end) && sorted[i].end >= start ? sorted[i].end : 0;
-      const end = exactEnd || Math.max(start, next - 1);
-      const loc = Math.max(1, end - start + 1);
-      symbolLoc.set(sorted[i].id, loc);
-      sorted[i].ref.loc = loc;
-      sorted[i].ref.endLine = end;
-      const cov = coverageForRange(fid, start, end);
-      if (cov != null) symbolCoverage.set(sorted[i].id, cov);
-      ranges.push({id: sorted[i].id, name: bareSymbolName(sorted[i].label), startLine: start, endLine: end});
-    }
-    for (const [id, refs] of computeLocalSymbolRefs(txt, ranges)) symbolLocalRefs.set(id, refs);
-  }
-  for (const s of symbols) {
-    const fid = id2file.get(s.id);
-    s.loc = symbolLoc.get(s.id) || 0;
-    s.coverage = symbolCoverage.get(s.id) ?? coverageForFile(fid)?.pct ?? null;
-  }
-
-  return {
-    complexityV: Number(graph.complexityV) || 0,
-    modules: [...modules.values()]
-      .map((mod) => ({
-        name: mod.name,
-        repo: mod.repo || null,
-        fileCount: mod.files.length,
-        nodeCount: moduleNodeCount.get(mod.name) || 0,
-        symbolCount: mod.files.reduce((sum, f) => sum + f.symbolCount, 0),
-        files: mod.files
-          .map((f) => {
-            const cov = coverageForFile(f.file);
-            return { ...f, loc: fileLoc.get(f.file) || 0, coverage: cov?.pct ?? null, coverageSource: cov?.source || "" };
-          })
-          .sort((a, b) => b.symbolCount - a.symbolCount)
-      }))
-      .sort((a, b) => b.fileCount - a.fileCount),
-    moduleEdges: edgeList(moduleEdges),
-    typeOnlyModuleEdges: edgeList(typeOnlyModuleEdges),
-    compileOnlyModuleEdges: edgeList(compileOnlyModuleEdges),
-    compileTimeModuleEdges: edgeList(compileTimeModuleEdges),
-    fileEdges: edgeList(fileEdges),
-    typeOnlyFileEdges: edgeList(typeOnlyFileEdges),
-    compileOnlyFileEdges: edgeList(compileOnlyFileEdges),
-    compileTimeFileEdges: edgeList(compileTimeFileEdges),
-    symbols,
-    symbolEdges,
-    symbolRefs: [...new Set([...symbolLocalRefs.keys(), ...symbolExternalRefs.keys()])].map((id) => {
-      const sourceRefs = symbolLocalRefs.get(id) || 0;
-      const externalRefs = symbolExternalRefs.get(id) || 0;
-      return { id, localRefs: sourceRefs + externalRefs, sourceRefs, externalRefs };
-    }),
-    folderLoc,
-    totals: {
-      files: fileModule.size,
-      nodes: nodes.filter((n) => n.file_type === "code").length,
-      fileEdges: fileEdges.size,
-      typeOnlyFileEdges: typeOnlyFileEdges.size,
-      compileOnlyFileEdges: compileOnlyFileEdges.size,
-      compileTimeFileEdges: compileTimeFileEdges.size,
-      moduleEdges: moduleEdges.size,
-      typeOnlyModuleEdges: typeOnlyModuleEdges.size,
-      compileOnlyModuleEdges: compileOnlyModuleEdges.size,
-      compileTimeModuleEdges: compileTimeModuleEdges.size,
-      symbols: symbols.length,
-      symbolEdges: symbolEdges.length
-    }
-  };
-}

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

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

package/src/analysis/graph-analysis.js

@@ -1,7 +0,0 @@
-// Reading a built graph.json and aggregating it into the views the UI needs: named communities,
-// degree hotspots, and the file/module/symbol rollup. `aggregateGraph` is pure (covered by tests);
-// the rest read the graph file from disk.
-// Facade: implementation lives in graph-analysis.summaries.js and graph-analysis.aggregate.js
-// (with internal helpers in graph-analysis.refs.js).
-export { summarizeCommunities, summarizeHotspots } from "./graph-analysis.summaries.js";
-export { analyzeGraph, aggregateGraph, folderModuleOf } from "./graph-analysis.aggregate.js";

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

@@ -1,202 +0,0 @@
-// Internal helpers for graph-analysis: identifier reference counting inside source text,
-// relative-import candidate resolution, and the import-driven external-reference scan that feeds
-// aggregateGraph's symbolRefs output. Not part of the public graph-analysis facade.
-import { normRepoPath, normalizeRepoParts, dirOfRepoPath } from "./coverage-reports.js";
-
-const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-export const bareSymbolName = (label) => String(label || "").replace(/\s*\(.*$/, "").trim();
-const isIdentifierName = (name) => /^[A-Za-z_$][\w$]*$/.test(name);
-
-function countIdentifierInLine(line, name) {
-  const re = new RegExp(`(^|[^A-Za-z0-9_$])${escapeRegExp(name)}(?![A-Za-z0-9_$])`, "g");
-  let count = 0;
-  while (re.exec(line)) count++;
-  return count;
-}
-
-function countIdentifierInText(text, name) {
-  if (!text || !isIdentifierName(name)) return 0;
-  return String(text).split(/\r?\n/).reduce((sum, line) => sum + countIdentifierInLine(line, name), 0);
-}
-
-function countMemberAccess(text, objectName, memberName) {
-  if (!text || !isIdentifierName(objectName) || !isIdentifierName(memberName)) return 0;
-  const re = new RegExp(`(^|[^A-Za-z0-9_$])${escapeRegExp(objectName)}\\s*\\.\\s*${escapeRegExp(memberName)}(?![A-Za-z0-9_$])`, "g");
-  let count = 0;
-  while (re.exec(String(text))) count++;
-  return count;
-}
-
-export function countLocalRefsOutsideOwnRange(text, name, startLine, endLine) {
-  if (!text || !isIdentifierName(name)) return 0;
-  const start = Number.isFinite(startLine) && startLine > 0 ? startLine : 0;
-  const end = Number.isFinite(endLine) && endLine >= start ? endLine : start;
-  let refs = 0;
-  const lines = String(text).split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const lineNo = i + 1;
-    if (start && lineNo >= start && lineNo <= end) continue;
-    refs += countIdentifierInLine(lines[i], name);
-  }
-  return refs;
-}
-
-const lowerBound = (values, target) => {
-  let low = 0, high = values.length;
-  while (low < high) {
-    const middle = (low + high) >>> 1;
-    if (values[middle] < target) low = middle + 1;
-    else high = middle;
-  }
-  return low;
-};
-
-// Count every wanted identifier in a file once, then subtract occurrences inside each declaration
-// with binary searches over occurrence line numbers. The former per-symbol full-file scan became
-// quadratic on large vendored files (thousands of symbols over tens of thousands of lines).
-export function computeLocalSymbolRefs(text, symbols) {
-  const candidates = (symbols || []).map((symbol) => ({
-    id: symbol.id,
-    name: bareSymbolName(symbol.name ?? symbol.label),
-    start: Number(symbol.startLine ?? symbol.start),
-    end: Number(symbol.endLine ?? symbol.end),
-  })).filter((symbol) => symbol.id && isIdentifierName(symbol.name));
-  if (!text || !candidates.length) return new Map();
-  const wanted = new Set(candidates.map((symbol) => symbol.name));
-  const occurrenceLines = new Map();
-  const identifier = /[A-Za-z_$][\w$]*/g;
-  const lines = String(text).split(/\r?\n/);
-  for (let index = 0; index < lines.length; index++) {
-    identifier.lastIndex = 0;
-    let match;
-    while ((match = identifier.exec(lines[index]))) {
-      const name = match[0];
-      if (!wanted.has(name)) continue;
-      const positions = occurrenceLines.get(name) || [];
-      positions.push(index + 1);
-      occurrenceLines.set(name, positions);
-    }
-  }
-  const refs = new Map();
-  for (const symbol of candidates) {
-    const positions = occurrenceLines.get(symbol.name) || [];
-    const start = Number.isFinite(symbol.start) && symbol.start > 0 ? symbol.start : 0;
-    const end = Number.isFinite(symbol.end) && symbol.end >= start ? symbol.end : start;
-    const inside = start ? lowerBound(positions, end + 1) - lowerBound(positions, start) : 0;
-    const outside = Math.max(0, positions.length - inside);
-    if (outside > 0) refs.set(symbol.id, outside);
-  }
-  return refs;
-}
-
-function importCandidates(fromFile, spec) {
-  const raw = String(spec || "");
-  if (!raw.startsWith(".")) return [];
-  const base = normalizeRepoParts(`${dirOfRepoPath(fromFile)}/${raw}`);
-  return [
-    base,
-    `${base}.js`,
-    `${base}.ts`,
-    `${base}.jsx`,
-    `${base}.tsx`,
-    `${base}.mjs`,
-    `${base}.cjs`,
-    `${base}/index.js`,
-    `${base}/index.ts`,
-    `${base}/index.jsx`,
-    `${base}/index.tsx`
-  ];
-}
-
-function stripModuleStatements(text) {
-  return String(text || "")
-    .replace(/\bimport\s+[\s\S]*?\s+from\s*['"][^'"]+['"]\s*;?/g, "")
-    .replace(/\bexport\s+(?:type\s+)?\{[\s\S]*?\}\s+from\s*['"][^'"]+['"]\s*;?/g, "")
-    .replace(/\b(?:const|let|var)\s+\{[\s\S]*?\}\s*=\s*require\(\s*['"][^'"]+['"]\s*\)\s*;?/g, "");
-}
-
-function parseNamedSpecifiers(raw) {
-  return String(raw || "")
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => {
-      const typeOnly = /^type\s+/.test(part);
-      const clean = part.replace(/^type\s+/, "").trim();
-      const m = clean.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
-      return m ? { imported: m[1], local: m[2] || m[1], typeOnly } : null;
-    })
-    .filter(Boolean);
-}
-
-// Import-driven external references: scan each file's import/export/require statements and count how
-// often the imported names are used in the importer, attributing counts to the target file's symbol
-// ids. Moved whole out of aggregateGraph; parameters are its `filePath` (fid → repo path),
-// `fileSymbols` (fid → symbol list) and `fileText` (fid → source text) maps.
-export function computeSymbolExternalRefs(filePath, fileSymbols, fileText) {
-  const fidByPath = new Map();
-  for (const [fid, p] of filePath) fidByPath.set(normRepoPath(p), fid);
-  const symbolIdsByFileAndName = new Map();
-  for (const [fid, list] of fileSymbols) {
-    const byName = symbolIdsByFileAndName.get(fid) || new Map();
-    for (const sym of list || []) {
-      const name = bareSymbolName(sym.label);
-      if (!isIdentifierName(name)) continue;
-      const ids = byName.get(name) || [];
-      ids.push({id: sym.id, space: sym.symbolSpace || "value"});
-      byName.set(name, ids);
-    }
-    symbolIdsByFileAndName.set(fid, byName);
-  }
-
-  const symbolExternalRefs = new Map();
-  const addExternalRefs = (targetFid, importedName, refs, typeOnly = false) => {
-    if (!targetFid || refs <= 0 || !isIdentifierName(importedName)) return;
-    const ids = symbolIdsByFileAndName.get(targetFid)?.get(importedName) || [];
-    for (const entry of ids) {
-      const matches = entry.space === "both" || (typeOnly ? entry.space === "type" : entry.space !== "type");
-      if (matches) symbolExternalRefs.set(entry.id, (symbolExternalRefs.get(entry.id) || 0) + refs);
-    }
-  };
-  const resolveImportedFid = (fromPath, spec) => {
-    for (const candidate of importCandidates(fromPath, spec)) {
-      const fid = fidByPath.get(candidate);
-      if (fid) return fid;
-    }
-    return "";
-  };
-  for (const [importerFid, txt] of fileText) {
-    const importerPath = filePath.get(importerFid) || importerFid;
-    const scrubbed = stripModuleStatements(txt);
-    const seenStatements = [
-      ...String(txt).matchAll(/\bimport\s+([\s\S]*?)\s+from\s*['"]([^'"]+)['"]\s*;?/g)
-    ];
-    for (const m of seenStatements) {
-      const targetFid = resolveImportedFid(importerPath, m[2]);
-      if (!targetFid) continue;
-      const named = String(m[1] || "").match(/\{([\s\S]*?)\}/);
-      if (named) {
-        const statementTypeOnly = /^\s*type\b/.test(String(m[1] || ""));
-        for (const spec of parseNamedSpecifiers(named[1])) addExternalRefs(targetFid, spec.imported, countIdentifierInText(scrubbed, spec.local), statementTypeOnly || spec.typeOnly);
-      }
-      const ns = String(m[1] || "").match(/\*\s+as\s+([A-Za-z_$][\w$]*)/);
-      if (ns) {
-        const byName = symbolIdsByFileAndName.get(targetFid) || new Map();
-        const statementTypeOnly = /^\s*type\b/.test(String(m[1] || ""));
-        for (const name of byName.keys()) addExternalRefs(targetFid, name, countMemberAccess(scrubbed, ns[1], name), statementTypeOnly);
-      }
-    }
-    for (const m of String(txt).matchAll(/\bexport\s+(type\s+)?\{([\s\S]*?)\}\s+from\s*['"]([^'"]+)['"]\s*;?/g)) {
-      const targetFid = resolveImportedFid(importerPath, m[3]);
-      if (!targetFid) continue;
-      const statementTypeOnly = Boolean(m[1]);
-      for (const spec of parseNamedSpecifiers(m[2])) addExternalRefs(targetFid, spec.imported, 1, statementTypeOnly || spec.typeOnly);
-    }
-    for (const m of String(txt).matchAll(/\b(?:const|let|var)\s+\{([\s\S]*?)\}\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)\s*;?/g)) {
-      const targetFid = resolveImportedFid(importerPath, m[2]);
-      if (!targetFid) continue;
-      for (const spec of parseNamedSpecifiers(m[1])) addExternalRefs(targetFid, spec.imported, countIdentifierInText(scrubbed, spec.local));
-    }
-  }
-  return symbolExternalRefs;
-}