weavatrix 0.3.13 → 1.0.0

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

@@ -1,295 +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, countLocalRefsOutsideOwnRange, 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);
-    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);
-      const refs = countLocalRefsOutsideOwnRange(txt, bareSymbolName(sorted[i].label), start, end);
-      if (refs > 0) symbolLocalRefs.set(sorted[i].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,154 +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;
-}
-
-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;
-}

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

@@ -1,65 +0,0 @@
-// Reading a built graph.json and summarizing it for the UI cards: named communities and degree
-// hotspots. Both read the graph file from disk and return [] on any failure.
-import { readFileSync } from "node:fs";
-import { communityTerritoryOf } from "../graph/community.js";
-import { isStructuralRelation } from "../graph/relations.js";
-
-// graph-builder labels communities "Community N" without an LLM. Derive a real name from each
-// community's dominant folder + sample files so the UI shows modules, not bare numbers.
-export function summarizeCommunities(graphJsonPath, max = 40) {
-  try {
-    const graph = JSON.parse(readFileSync(graphJsonPath, "utf8"));
-    const byCommunity = new Map();
-    for (const node of graph.nodes || []) {
-      if (node.file_type !== "code") continue;
-      const community = node.community;
-      if (community === undefined || community === null) continue;
-      if (!byCommunity.has(community)) byCommunity.set(community, { id: community, size: 0, dirs: new Map(), files: [] });
-      const entry = byCommunity.get(community);
-      entry.size += 1;
-      const parts = String(node.source_file || "").split(/[\\/]/).filter(Boolean);
-      const dir = communityTerritoryOf(node.source_file);
-      entry.dirs.set(dir, (entry.dirs.get(dir) || 0) + 1);
-      if (entry.files.length < 4) entry.files.push(parts[parts.length - 1] || node.source_file || "");
-    }
-    return [...byCommunity.values()]
-      .map((entry) => {
-        const dominant = [...entry.dirs.entries()].sort((left, right) => right[1] - left[1])[0];
-        return { id: entry.id, size: entry.size, name: dominant ? dominant[0] : "(mixed)", files: entry.files };
-      })
-      .sort((left, right) => right.size - left.size)
-      .slice(0, max);
-  } catch {
-    return [];
-  }
-}
-
-// Top nodes by total degree (in+out) — the "load-bearing" / refactor-candidate hotspots.
-export function summarizeHotspots(graphJsonPath, max = 15) {
-  try {
-    const graph = JSON.parse(readFileSync(graphJsonPath, "utf8"));
-    const nodes = graph.nodes || [];
-    const endpoint = (value) => (value && typeof value === "object" ? value.id : value);
-    const inDeg = new Map();
-    const outDeg = new Map();
-    for (const link of graph.links || []) {
-      if (isStructuralRelation(link.relation) || link.barrelProxy === true) continue;
-      const s = endpoint(link.source);
-      const t = endpoint(link.target);
-      outDeg.set(s, (outDeg.get(s) || 0) + 1);
-      inDeg.set(t, (inDeg.get(t) || 0) + 1);
-    }
-    return nodes
-      .filter((node) => node.file_type === "code")
-      .map((node) => {
-        const inbound = inDeg.get(node.id) || 0;
-        const outbound = outDeg.get(node.id) || 0;
-        return { label: node.label || node.norm_label || node.id, file: node.source_file || "", in: inbound, out: outbound, degree: inbound + outbound };
-      })
-      .filter((node) => node.degree > 0)
-      .sort((left, right) => right.degree - left.degree)
-      .slice(0, max);
-  } catch {
-    return [];
-  }
-}

package/src/analysis/health-capabilities.js

@@ -1,83 +0,0 @@
-// Honest Health capability coverage. `status` says whether a check actually ran for this repository;
-// `completeness` says whether its evidence can support a repository-wide conclusion.
-const capability = (status, completeness, detail, extra = {}) => ({ status, completeness, detail, ...extra });
-
-const sourceLanguages = (files) => {
-  const languages = new Set();
-  for (const file of files || []) {
-    if (/\.(?:[cm]?js|jsx|[cm]?ts|tsx)$/i.test(file)) languages.add("javascript/typescript");
-    else if (/\.py$/i.test(file)) languages.add("python");
-    else if (/\.go$/i.test(file)) languages.add("go");
-    else if (/\.java$/i.test(file)) languages.add("java");
-    else if (/\.rs$/i.test(file)) languages.add("rust");
-    else if (/\.cs$/i.test(file)) languages.add("csharp");
-  }
-  return languages;
-};
-
-const checkCapability = (check, supported, label) => {
-  if (!supported) return capability("NOT_SUPPORTED", "PARTIAL", `${label} is not supported for the discovered package ecosystem.`);
-  if (check?.status === "OK") return capability("CHECKED", "COMPLETE", check.detail || `${label} completed.`);
-  if (check?.status === "PARTIAL") return capability("NOT_CHECKED", "PARTIAL", check.detail || `${label} evidence is partial.`);
-  if (check?.status === "ERROR") return capability("NOT_CHECKED", "PARTIAL", check.detail || `${label} failed.`);
-  return capability("NOT_CHECKED", "PARTIAL", check?.detail || `${label} was not requested.`);
-};
-
-export function buildHealthCapabilityMatrix({
-  graphComplete,
-  dependencyStatus,
-  dependencyEcosystems = {},
-  checks = {},
-  sourceFiles = [],
-  correctnessCoverage = {},
-  measuredCoverageFiles = 0,
-} = {}) {
-  const languages = sourceLanguages(sourceFiles);
-  const ecosystemRows = Object.values(dependencyEcosystems).filter((item) => item?.present);
-  const supportedDependencyRows = ecosystemRows.filter((item) => item.status === "CHECKED");
-  const unsupportedDependencyRows = ecosystemRows.filter((item) => item.status === "NOT_SUPPORTED");
-  const noDependencyEvidence = ecosystemRows.length === 0;
-  const onlyUnsupportedDependencies = unsupportedDependencyRows.length > 0 && supportedDependencyRows.length === 0;
-  const advisorySupported = supportedDependencyRows.some((item) => ["npm", "go", "python", "rust", "maven", "gradle"].includes(item.ecosystem));
-  const onlyRustAdvisories = supportedDependencyRows.length > 0 && supportedDependencyRows.every((item) => item.ecosystem === "rust");
-  const malwareSupported = supportedDependencyRows.some((item) => ["npm", "go", "python"].includes(item.ecosystem));
-  const coverageSupported = [...languages].some((language) => ["javascript/typescript", "python", "go"].includes(language));
-  const runtimeFiles = Number(correctnessCoverage.runtimeCorrectnessFiles || 0);
-  const concurrencyFiles = Number(correctnessCoverage.concurrencyFiles || 0);
-
-  return {
-    capabilityMatrixV: 1,
-    structure: capability(
-      "CHECKED",
-      graphComplete ? "COMPLETE" : "PARTIAL",
-      graphComplete
-        ? "Graph cycles, orphans and configured boundaries were checked over the complete graph."
-        : "Structure checks ran, but the graph is scoped or excludes part of the repository.",
-    ),
-    dependencies: capability(
-      noDependencyEvidence ? "NOT_CHECKED" : onlyUnsupportedDependencies ? "NOT_SUPPORTED" : "CHECKED",
-      !noDependencyEvidence && dependencyStatus === "COMPLETE" ? "COMPLETE" : "PARTIAL",
-      noDependencyEvidence
-        ? "No dependency manifest was discovered, so manifest-to-import verification did not run."
-        : onlyUnsupportedDependencies
-        ? "Dependency manifests were detected, but every discovered build ecosystem lacks import-to-artifact verification."
-        : unsupportedDependencyRows.length
-          ? `Supported ecosystems were checked; ${unsupportedDependencyRows.map((item) => item.ecosystem).join(", ")} remains NOT_SUPPORTED.`
-          : "Discovered supported manifests were compared with indexed imports at their documented evidence level.",
-      { ecosystems: dependencyEcosystems },
-    ),
-    runtimeCorrectness: runtimeFiles
-      ? capability("CHECKED", "PARTIAL", `Checked ${runtimeFiles} product source file(s) for the bounded Go/Java/retry correctness patterns. This is not compiler or runtime proof.`, { checks: correctnessCoverage.checks || {} })
-      : capability("NOT_SUPPORTED", "PARTIAL", "No source file matched the currently supported bounded correctness patterns."),
-    concurrency: concurrencyFiles
-      ? capability("CHECKED", "PARTIAL", `Checked ${concurrencyFiles} Java source file(s) for direct InterruptedException restore/rethrow evidence. No race detector ran; race freedom is not claimed.`)
-      : capability("NOT_SUPPORTED", "PARTIAL", "No supported Java interruption check applied. No race detector ran; race freedom is not claimed."),
-    advisories: checkCapability(onlyRustAdvisories && checks.rustsec?.status === "OK" ? checks.rustsec : checks.osv, advisorySupported, onlyRustAdvisories ? "RustSec advisory matching" : "OSV advisory matching"),
-    malware: checkCapability(checks.malware, malwareSupported, "Installed-package malware scanning"),
-    coverage: measuredCoverageFiles > 0
-      ? capability("CHECKED", "COMPLETE", `Mapped an existing supported coverage report to ${measuredCoverageFiles} file(s).`)
-      : coverageSupported
-        ? capability("NOT_CHECKED", "PARTIAL", "No supported measured coverage report was found; static test reachability is not coverage.")
-        : capability("NOT_SUPPORTED", "PARTIAL", `No supported coverage format applies to the discovered language set${languages.size ? ` (${[...languages].join(", ")})` : ""}.`),
-  };
-}