weavatrix 0.1.0

package/src/analysis/source-complexity.report.js

@@ -0,0 +1,76 @@
+// Rank, score, label, and evidence builders for the source-complexity report.
+
+function timeScore(rank) {
+  return [0.2, 0.4, 0.65, 0.95, 1.3, 1.7][Math.max(0, Math.min(5, rank))] || 0.2;
+}
+
+function memoryScore(rank) {
+  return [0.15, 0.35, 0.85, 1.05, 1.4, 1.7][Math.max(0, Math.min(5, rank))] || 0.15;
+}
+
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+
+function deriveTimeRank(stats) {
+  if (stats.maxLoopDepth >= 3) return 5;
+  if (stats.maxLoopDepth === 2 || (stats.sorts && stats.maxSortLoopDepth > 0)) return 4;
+  if (stats.sorts) return 3;
+  if (stats.loops || stats.linearOps || stats.spreadCopies) return 2;
+  return 0;
+}
+
+function timeLabelForRank(stats, rank) {
+  if (stats.recursion) return "recursive local work — bound unknown";
+  if (rank >= 5) return "O(n^3+) local — deeply nested iteration";
+  if (rank === 4 && stats.sorts && stats.maxSortLoopDepth > 0) return "O(n^2 log n) local — sort inside iteration";
+  if (rank === 4) return "O(n^2) local — nested iteration";
+  if (rank === 3) return "O(n log n) local — sort";
+  if (rank === 2 && stats.spreadCopies) return `O(n) local — ${plural(stats.spreadCopies, "shallow copy", "shallow copies")}`;
+  if (rank === 2 && stats.loops) return `O(n) local — ${plural(stats.loops, "iteration", "iterations")}`;
+  return rank === 2 ? "O(n) local — collection traversal" : "O(1) local";
+}
+
+function buildTimeSummary(stats) {
+  const timeRank = stats.recursion ? Math.max(2, deriveTimeRank(stats)) : deriveTimeRank(stats);
+  let timeLabel = timeLabelForRank(stats, timeRank);
+  if (stats.asyncBoundaries || stats.externalCalls) timeLabel += " · I/O/callee-bound";
+  else if (stats.callCount && !stats.recursion) timeLabel += " · callee-bound";
+  if (stats.branches >= 8 && timeRank === 0) timeLabel += " · branch-heavy";
+  return { timeRank, timeScore: timeScore(timeRank), timeLabel };
+}
+
+function buildMemorySummary(stats) {
+  let memoryRank = 0;
+  let memoryLabel = "O(1) auxiliary";
+  const variableAllocation = stats.spreadCopies || stats.producerCalls;
+  if (variableAllocation) {
+    memoryRank = stats.maxVariableAllocationDepth >= 2 ? 4 : 2;
+    memoryLabel = memoryRank >= 4 ? "O(n^2) — nested collection copies" : stats.spreadCopies
+      ? `O(n) — ${plural(stats.spreadCopies, "shallow copy", "shallow copies")}`
+      : "O(n) — produced collection";
+  } else if (stats.recursion) {
+    memoryRank = 1;
+    memoryLabel = "O(depth) stack — recursive";
+  } else if (stats.allocations) {
+    memoryLabel = "O(1) auxiliary — fixed allocations";
+  }
+  return { memoryRank, memoryScore: memoryScore(memoryRank), memoryLabel };
+}
+
+export function buildLabels(stats) {
+  return { ...buildTimeSummary(stats), ...buildMemorySummary(stats) };
+}
+
+export function buildEvidence(stats) {
+  const out = [];
+  if (stats.loops) out.push(plural(stats.loops, "iteration", "iterations"));
+  if (stats.maxLoopDepth > 1) out.push(`loop depth ${stats.maxLoopDepth}`);
+  if (stats.sorts) out.push(plural(stats.sorts, "sort", "sorts"));
+  if (stats.spreadCopies) out.push(plural(stats.spreadCopies, "shallow copy", "shallow copies"));
+  if (stats.branches) out.push(plural(stats.branches, "branch point", "branch points"));
+  if (stats.awaits) out.push(plural(stats.awaits, "await boundary", "await boundaries"));
+  if (stats.callCount) out.push(plural(stats.callCount, "call", "calls"));
+  if (stats.recursion) out.push("direct recursion");
+  return out;
+}

package/src/analysis/source-complexity.walk.js

@@ -0,0 +1,174 @@
+// Syntax-tree walk that gathers complexity stats and assembles the summary report.
+
+import {
+  LOOP_NODES, CALL_NODES, RETURN_NODES, AWAIT_NODES, OBJECT_NODES,
+  FIXED_ALLOCATION_NODES, VARIABLE_ALLOCATION_NODES, SPREAD_NODES,
+  DECLARATION_BOUNDARIES, EXPRESSION_CALLABLES, ARGUMENT_NODES,
+  ITERATOR_CALLS, PRODUCER_CALLS, LINEAR_CALLS, SORT_CALLS, BRANCH_NODES
+} from "./source-complexity.constants.js";
+import {
+  field, children, sameNode, normalizedName, looksLikeIoCall, callName,
+  logicalBranch, isDefaultCase, directParameterCount, countObjectPatternFields, sourceRange
+} from "./source-complexity.ast.js";
+import { buildLabels, buildEvidence } from "./source-complexity.report.js";
+
+function createStats(parameters, family) {
+  return {
+    params: directParameterCount(parameters, family),
+    objectFields: countObjectPatternFields(parameters),
+    branches: 0,
+    loops: 0,
+    maxLoopDepth: 0,
+    returns: 0,
+    awaits: 0,
+    callCount: 0,
+    externalCalls: 0,
+    asyncBoundaries: 0,
+    allocations: 0,
+    objectLiterals: 0,
+    spreadCopies: 0,
+    sorts: 0,
+    linearOps: 0,
+    producerCalls: 0,
+    recursion: false,
+    maxSortLoopDepth: 0,
+    maxVariableAllocationDepth: 0
+  };
+}
+
+function shouldSkipNode(root, node, state) {
+  if (sameNode(node, root)) return false;
+  const type = String(node.type || "");
+  if (DECLARATION_BOUNDARIES.has(type)) return true;
+  if (!EXPRESSION_CALLABLES.has(type) || state.callbackContext) return false;
+  const parent = state.parent;
+  return !(CALL_NODES.has(String(parent?.type || "")) && sameNode(field(parent, "function"), node));
+}
+
+function nodeFacts(node, state) {
+  const type = String(node.type || "");
+  const isCall = CALL_NODES.has(type);
+  const nameAtCall = isCall ? callName(node) : "";
+  const normalizedCall = normalizedName(nameAtCall);
+  return {
+    type,
+    isCall,
+    isLoop: LOOP_NODES.has(type),
+    nameAtCall,
+    normalizedCall,
+    iteratorCall: isCall && ITERATOR_CALLS.has(normalizedCall),
+    sortCall: isCall && SORT_CALLS.has(normalizedCall),
+    producerCall: isCall && PRODUCER_CALLS.has(normalizedCall),
+    currentDepth: Math.max(0, Number(state.loopDepth) || 0)
+  };
+}
+
+function recordBasicSignals(stats, node, facts) {
+  const { type, currentDepth } = facts;
+  if (BRANCH_NODES.has(type) && !(type.includes("case") && isDefaultCase(node))) stats.branches++;
+  else if (logicalBranch(node)) stats.branches++;
+  if (RETURN_NODES.has(type)) stats.returns++;
+  if (AWAIT_NODES.has(type)) { stats.awaits++; stats.asyncBoundaries++; }
+  if (OBJECT_NODES.has(type)) stats.objectLiterals++;
+  if (FIXED_ALLOCATION_NODES.has(type)) stats.allocations++;
+  if (!VARIABLE_ALLOCATION_NODES.has(type)) return;
+  stats.producerCalls++;
+  stats.maxVariableAllocationDepth = Math.max(stats.maxVariableAllocationDepth, currentDepth + 1);
+}
+
+function recordSpread(stats, facts, parent) {
+  if (!SPREAD_NODES.has(facts.type) || /parameters|parameter_list/.test(String(parent?.type || ""))) return;
+  stats.spreadCopies++;
+  stats.linearOps++;
+  stats.maxVariableAllocationDepth = Math.max(stats.maxVariableAllocationDepth, facts.currentDepth + 1);
+}
+
+function recordCall(stats, facts, state, targetName) {
+  if (!facts.isCall) return;
+  stats.callCount++;
+  if (state.awaited || looksLikeIoCall(facts.nameAtCall)) stats.externalCalls++;
+  if (targetName && facts.normalizedCall === targetName) stats.recursion = true;
+  if (facts.sortCall) {
+    stats.sorts++;
+    stats.maxSortLoopDepth = Math.max(stats.maxSortLoopDepth, facts.currentDepth);
+  } else if (LINEAR_CALLS.has(facts.normalizedCall) && !facts.iteratorCall) stats.linearOps++;
+  if (!facts.producerCall) return;
+  stats.producerCalls++;
+  stats.allocations++;
+  stats.maxVariableAllocationDepth = Math.max(stats.maxVariableAllocationDepth, facts.currentDepth + 1);
+}
+
+function recordLoop(stats, facts) {
+  if (!facts.isLoop && !facts.iteratorCall) return facts.currentDepth;
+  const nextDepth = facts.currentDepth + 1;
+  stats.loops++;
+  stats.maxLoopDepth = Math.max(stats.maxLoopDepth, nextDepth);
+  return nextDepth;
+}
+
+function depthForChild(node, child, facts, nextDepth) {
+  const childIsArgs = ARGUMENT_NODES.has(String(child.type || ""));
+  if (facts.iteratorCall && childIsArgs) return nextDepth;
+  if (!facts.isLoop) return facts.currentDepth;
+  const loopBody = field(node, "body");
+  if (loopBody) return sameNode(child, loopBody) ? nextDepth : facts.currentDepth;
+  return facts.type === "for_in_clause" ? facts.currentDepth : nextDepth;
+}
+
+function walkSyntax(root, node, state, context) {
+  if (!node || shouldSkipNode(root, node, state)) return;
+  const parent = state.parent || null;
+  const callbackContext = state.callbackContext || ARGUMENT_NODES.has(String(parent?.type || ""));
+  const facts = nodeFacts(node, state);
+  recordBasicSignals(context.stats, node, facts);
+  recordSpread(context.stats, facts, parent);
+  recordCall(context.stats, facts, state, context.targetName);
+  const nextDepth = recordLoop(context.stats, facts);
+  for (const child of children(node)) {
+    const childIsArgs = ARGUMENT_NODES.has(String(child.type || ""));
+    walkSyntax(root, child, {
+      parent: node,
+      loopDepth: depthForChild(node, child, facts, nextDepth),
+      callbackContext: callbackContext || childIsArgs,
+      awaited: AWAIT_NODES.has(facts.type) && !facts.isCall
+    }, context);
+  }
+}
+
+export function analyzeSyntaxComplexity(root, { family = "", name = "" } = {}) {
+  const parameters = field(root, "parameters") || field(root, "parameter");
+  const stats = createStats(parameters, family);
+  walkSyntax(root, root, {}, { stats, targetName: normalizedName(name) });
+
+  const labels = buildLabels(stats);
+  const range = sourceRange(root);
+  const evidence = buildEvidence(stats);
+  const structuralWork = stats.loops || stats.sorts || stats.spreadCopies || stats.linearOps;
+  const confidence = stats.recursion ? "low" : structuralWork ? "medium" : stats.callCount ? "low" : "high";
+  return {
+    ...range,
+    family,
+    params: stats.params,
+    objectFields: stats.objectFields,
+    branches: stats.branches,
+    cyclomatic: stats.branches + 1,
+    loops: stats.loops,
+    maxLoopDepth: stats.maxLoopDepth,
+    returns: stats.returns,
+    awaits: stats.awaits,
+    callCount: stats.callCount,
+    externalCalls: stats.externalCalls,
+    asyncBoundaries: stats.asyncBoundaries,
+    allocations: stats.allocations,
+    objectLiterals: stats.objectLiterals,
+    spreadCopies: stats.spreadCopies,
+    sorts: stats.sorts,
+    linearOps: stats.linearOps,
+    recursion: stats.recursion,
+    ...labels,
+    scope: "local",
+    complexityScope: "local",
+    confidence,
+    evidence
+  };
+}

package/src/build-graph.js

@@ -0,0 +1,102 @@
+// Graph build — weavatrix's own web-tree-sitter builder.
+// Emits <weavatrix-graphs/<repo>>/graph.json for the rest of the pipeline.
+//
+// The parse itself runs in a WORKER THREAD (build-worker.js): in-process it pinned Electron's main
+// event loop for the whole repo walk, and since Windows routes window input through the main process
+// the ENTIRE app froze on big repos. The worker writes graph.json itself and returns only counts +
+// summaries. If the worker can't even start (exotic packaging), we fall back to the in-process build
+// rather than lose the feature.
+import { existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { Worker } from "node:worker_threads";
+import { graphOutDirForRepo, repoTopFolders, summarizeCommunities, summarizeHotspots, filterGraphForMode, filterGraphByScope } from "./graph/layout.js";
+
+// The worker path deadlocks web-tree-sitter's WASM in Electron's worker threads (fine in plain Node) — off
+// until that's Electron-safe. In-process + event-loop yielding keeps the window responsive without it.
+const USE_BUILD_WORKER = false;
+
+// Hard ceiling so a wedged parse (WASM stuck, pathological file, symlink loop) can NEVER leave the UI on
+// an eternal "BUILDING GRAPH…". On timeout we terminate the worker and reject as a REAL failure (no
+// workerStartFailed → we do NOT fall back to the in-process build, which would hang the same way and
+// freeze the whole app on the main thread). 4 min is generous for very large repos.
+const BUILD_WORKER_TIMEOUT_MS = 4 * 60 * 1000;
+
+function buildGraphInWorker(payload) {
+  return new Promise((resolve, reject) => {
+    let worker;
+    try {
+      worker = new Worker(new URL("./graph/build-worker.js", import.meta.url), { workerData: payload });
+    } catch (e) {
+      reject(Object.assign(e, { workerStartFailed: true }));
+      return;
+    }
+    let settled = false;
+    let timer = null;
+    const done = (fn, v) => {
+      if (settled) return;
+      settled = true;
+      if (timer) { clearTimeout(timer); timer = null; }
+      fn(v);
+    };
+    timer = setTimeout(() => {
+      try { worker.terminate(); } catch { /* already gone */ }
+      done(reject, new Error(`graph build timed out after ${Math.round(BUILD_WORKER_TIMEOUT_MS / 1000)}s (the parser is wedged on this repo — try again, or report it)`));
+    }, BUILD_WORKER_TIMEOUT_MS);
+    worker.once("message", (msg) => {
+      if (msg && msg.ok) done(resolve, msg);
+      else done(reject, new Error((msg && msg.error) || "graph worker failed"));
+    });
+    worker.once("error", (e) => done(reject, Object.assign(e, { workerStartFailed: true })));
+    worker.once("exit", (code) => { if (code !== 0) done(reject, Object.assign(new Error(`graph worker exited with code ${code}`), { workerStartFailed: true })); });
+  });
+}
+
+async function buildAndWriteInProcess(repoPath, { mode, scope, graphJson, central }) {
+  const { buildInternalGraph } = await import("./graph/internal-builder.js");
+  let graph = await buildInternalGraph(repoPath);
+  // mode (no-tests/tests-only) + path-scope reuse the same pure filters graph-builder used.
+  if (mode === "no-tests" || mode === "tests-only") graph = filterGraphForMode(graph, mode);
+  if (scope) graph = filterGraphByScope(graph, scope);
+  mkdirSync(central, { recursive: true });
+  writeFileSync(graphJson, JSON.stringify(graph), "utf8");
+  return {
+    nodes: graph.nodes.length,
+    links: graph.links.length,
+    communities: summarizeCommunities(graphJson),
+    hotspots: summarizeHotspots(graphJson),
+  };
+}
+
+export async function buildGraphForRepo(repoPath, { mode = "full", scope = "", outDir } = {}) {
+  if (!existsSync(repoPath)) return { ok: false, error: "Repo path not found", builder: "internal" };
+  const central = outDir || graphOutDirForRepo(repoPath);
+  const graphJson = join(central, "graph.json");
+  try {
+    // In-process is the ONLY path now. The worker (buildGraphInWorker) hung web-tree-sitter's WASM inside an
+    // Electron worker thread → an eternal "BUILDING GRAPH…" for JS repos, even though the same code finishes
+    // in ~3s on the main thread (and in a plain-Node worker). buildInternalGraph now YIELDS the event loop
+    // between file chunks, so the main-thread parse no longer freezes the window — the reason the worker was
+    // introduced. buildGraphInWorker/USE_BUILD_WORKER are kept for a future Electron-safe re-enable.
+    const built = USE_BUILD_WORKER
+      ? await buildGraphInWorker({ repoPath, mode, scope, graphJson, central }).catch((e) => {
+          if (e && e.workerStartFailed) return buildAndWriteInProcess(repoPath, { mode, scope, graphJson, central });
+          throw e;
+        })
+      : await buildAndWriteInProcess(repoPath, { mode, scope, graphJson, central });
+    return {
+      ok: true,
+      builder: "internal",
+      mode,
+      scope,
+      topFolders: repoTopFolders(repoPath),
+      report: "",
+      graphFile: "", // no graph.html — weavatrix renders its own GUI board/relations views
+      graphDir: central,
+      communities: built.communities,
+      hotspots: built.hotspots,
+      log: `built-in builder: ${built.nodes} nodes, ${built.links} links`
+    };
+  } catch (error) {
+    return { ok: false, error: `graph build failed: ${error.message}`, builder: "internal" };
+  }
+}

package/src/config.js

@@ -0,0 +1,5 @@
+// weavatrix config (Node).
+import { fileURLToPath } from "node:url";
+
+const MAIN_DIR = fileURLToPath(new URL(".", import.meta.url));
+export const ROOT_DIR = MAIN_DIR; // fallback cwd for repo-list helpers when a call passes none

package/src/graph/build-worker.js

@@ -0,0 +1,30 @@
+// build-worker.js — runs the web-tree-sitter graph build OFF Electron's main thread. In-process the
+// parse blocks the main event loop for the whole repo walk (big repos = many seconds), and on Windows
+// window input routing lives on the main process — so the ENTIRE app froze during "BUILDING THE
+// GRAPH…". The worker builds, filters, writes graph.json and computes the summaries; only the small
+// result object crosses back (never the graph itself — structured-cloning a huge graph would stall
+// the main thread again).
+import { parentPort, workerData } from "node:worker_threads";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { buildInternalGraph } from "./internal-builder.js";
+import { filterGraphForMode, filterGraphByScope, summarizeCommunities, summarizeHotspots } from "./layout.js";
+
+(async () => {
+  const { repoPath, mode, scope, graphJson, central } = workerData || {};
+  try {
+    let graph = await buildInternalGraph(repoPath);
+    if (mode === "no-tests" || mode === "tests-only") graph = filterGraphForMode(graph, mode);
+    if (scope) graph = filterGraphByScope(graph, scope);
+    mkdirSync(central, { recursive: true });
+    writeFileSync(graphJson, JSON.stringify(graph), "utf8");
+    parentPort.postMessage({
+      ok: true,
+      nodes: graph.nodes.length,
+      links: graph.links.length,
+      communities: summarizeCommunities(graphJson),
+      hotspots: summarizeHotspots(graphJson),
+    });
+  } catch (e) {
+    parentPort.postMessage({ ok: false, error: (e && e.message) || String(e) });
+  }
+})();

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

@@ -0,0 +1,40 @@
+// C# extractor. Symbols: class/interface/struct/enum (+record/delegate via optional queries) +
+// method/constructor + properties/fields. Calls: `Foo()` / `x.Foo()` (name only). Heritage: base_list
+// (C# merges extends+implements into one list). `using` directives name NAMESPACES, not files, and a
+// namespace maps to a file only by convention — so no import edges are attempted; cross-file
+// connectivity comes from the name-based calls pass, same as the other non-JS languages.
+const SYMS_CORE = `
+  (class_declaration name: (identifier) @class)
+  (interface_declaration name: (identifier) @class)
+  (struct_declaration name: (identifier) @class)
+  (enum_declaration name: (identifier) @class)
+  (method_declaration name: (identifier) @method)
+  (constructor_declaration name: (identifier) @method)
+  (property_declaration name: (identifier) @field)`;
+// Grammar-version-dependent node types, compiled SEPARATELY: one unknown node type voids the whole
+// query it appears in, so these must never ride along with SYMS_CORE.
+const SYMS_OPTIONAL = [
+  `(record_declaration name: (identifier) @class)`,
+  `(delegate_declaration name: (identifier) @method)`,
+  `(field_declaration (variable_declaration (variable_declarator (identifier) @field)))`,
+];
+
+export default {
+  family: "csharp",
+  grammars: ["c_sharp"],
+  exts: { ".cs": "c_sharp" },
+  isWeb: false,
+  calls: `
+    (invocation_expression function: (identifier) @callee)
+    (invocation_expression function: (member_access_expression name: (identifier) @callee))`,
+  heritage: [`(base_list (identifier) @super)`, `(base_list (generic_name (identifier) @super))`],
+
+  pass1(ctx) {
+    const { grammar, tree, caps, addSym } = ctx;
+    for (const src of [SYMS_CORE, ...SYMS_OPTIONAL]) {
+      for (const cap of caps(grammar, src, tree.rootNode)) {
+        addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
+      }
+    }
+  },
+};

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

@@ -0,0 +1,29 @@
+// CSS / SCSS / LESS extractor (web reference graph, not a call graph — orchestrator skips pass 2 for it).
+// Symbols: class/id selectors (indexed in selectorIndex so HTML class/id usage can reference the file).
+// Imports: `@import "x.css"`. NOTE: no dedicated SCSS grammar in tree-sitter-wasms, so nested SCSS selectors
+// are under-captured (files still appear as nodes + resolve JS `import styles from './x.scss'`).
+export default {
+  family: "css",
+  grammars: ["css"],
+  exts: { ".css": "css", ".scss": "css", ".less": "css" },
+  isWeb: true,
+  calls: "",
+  heritage: [],
+
+  pass1(ctx) {
+    const { grammar, tree, fileRel, caps, addNode, links, nodeIds, syms, selectorIndex, addImportEdge, resolveHref } = ctx;
+    const addSel = (label, line) => {
+      const id = `${fileRel}#${label}@${line}`;
+      if (nodeIds.has(id)) return;
+      addNode({ id, label, file_type: "code", source_file: fileRel, source_location: `L${line}` });
+      links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
+      syms.push({ id, name: label, start: line });
+      let s = selectorIndex.get(label); if (!s) selectorIndex.set(label, (s = new Set())); s.add(fileRel);
+    };
+    for (const cap of caps(grammar, `(class_selector (class_name) @c)`, tree.rootNode)) addSel("." + cap.node.text, cap.node.startPosition.row + 1);
+    for (const cap of caps(grammar, `(id_selector (id_name) @i)`, tree.rootNode)) addSel("#" + cap.node.text, cap.node.startPosition.row + 1);
+    for (const cap of caps(grammar, `(import_statement (string_value) @s)`, tree.rootNode)) {
+      const tgt = resolveHref(fileRel, cap.node.text.replace(/^["']|["']$/g, "")); if (tgt) addImportEdge(tgt);
+    }
+  },
+};

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

@@ -0,0 +1,53 @@
+// Go extractor. Symbols: func/method(receiver)/type(struct+interface)/top-level var+const.
+// Imports: `import "mod/pkg"` → the package DIRECTORY's files (Go package = dir), resolved via go.mod prefix.
+// Unresolved paths are RECORDED as external imports (stdlib → builtin, modules → ecosystem "Go") so
+// dependency analysis can diff them against go.mod. Calls: bare `foo()` (same-file + same-package resolve
+// in the orchestrator; cross-pkg `pkg.Func()` is a selector — see resolveGoPackage/pass2). No inheritance.
+import { goSpecToPkg } from "./spec-pkg.js";
+
+export default {
+  family: "go",
+  grammars: ["go"],
+  exts: { ".go": "go" },
+  isWeb: false,
+  calls: `(call_expression function: (identifier) @callee)`,
+  // cross-package `pkg.Func()` — the orchestrator resolves @operand (imported package alias) → its dir, then
+  // finds the method there. Without this, funcs called only from other packages look falsely DEAD.
+  selectorCall: `(call_expression function: (selector_expression) @sel)`,
+  heritage: [],
+
+  pass1(ctx) {
+    const { grammar, tree, fileRel, caps, addSym, addImportEdge, addExternalImport, imports, resolveGoImport, dirFiles, goModule, goRequires } = ctx;
+
+    // ---- symbols ----
+    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn) (method_declaration name: (field_identifier) @method)`, tree.rootNode))
+      addSym(cap.node.text, cap.node.startPosition.row + 1, true, { sourceNode: cap.node.parent });
+    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode))
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+    for (const cap of caps(grammar, `(source_file (var_declaration (var_spec name: (identifier) @var))) (source_file (const_declaration (const_spec name: (identifier) @const)))`, tree.rootNode))
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+
+    // ---- imports: package path → package directory → all its .go files ----
+    // Also record the package's local name (alias or last path segment) → dir, so cross-package `pkg.Func()`
+    // selector calls can resolve in pass 2 (see internal-builder resolveCall).
+    for (const cap of caps(grammar, `(import_spec) @spec`, tree.rootNode)) {
+      const spec = cap.node;
+      const pathNode = spec.namedChildren.find((c) => c.type === "interpreted_string_literal");
+      if (!pathNode) continue;
+      const importPath = pathNode.text.replace(/^["'`]|["'`]$/g, "");
+      const d = resolveGoImport(importPath);
+      if (!d) {
+        // not a repo package: stdlib (builtin) or an external module — record for dependency analysis
+        const line = pathNode.startPosition.row + 1;
+        const r = goSpecToPkg(importPath, { requires: goRequires || [], ownModule: goModule || "" });
+        if (r) addExternalImport({ spec: importPath, pkg: r.pkg, builtin: r.builtin, ecosystem: "Go", kind: "go-import", line });
+        else addExternalImport({ spec: importPath, kind: "go-import", line, unresolved: true }); // own-module path with no matching dir
+        continue;
+      }
+      for (const f of dirFiles.get(d) || []) addImportEdge(f);   // Go import = whole package (all files in the dir)
+      const aliasNode = spec.namedChildren.find((c) => c.type === "package_identifier");
+      const local = aliasNode ? aliasNode.text : importPath.split("/").pop();
+      if (local && local !== "_" && local !== ".") imports.set(local, { imported: "*", targetDir: d, goPackage: true });
+    }
+  },
+};

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

@@ -0,0 +1,29 @@
+// HTML extractor (web reference graph, not a call graph — orchestrator skips pass 2 for it).
+// Edges: `<link href>` / `<script src>` / `<img src>` → the referenced file (imports). Usage: class="…" / id="…"
+// → recorded in htmlUsages, resolved (after all CSS parsed) to the CSS file(s) defining that selector.
+export default {
+  family: "html",
+  grammars: ["html"],
+  exts: { ".html": "html", ".htm": "html" },
+  isWeb: true,
+  calls: "",
+  heritage: [],
+
+  pass1(ctx) {
+    const { grammar, tree, fileRel, caps, addImportEdge, resolveHref, htmlUsages } = ctx;
+    for (const cap of caps(grammar, `(attribute) @attr`, tree.rootNode)) {
+      const attr = cap.node;
+      const nameNode = attr.namedChildren.find((c) => c.type === "attribute_name"); if (!nameNode) continue;
+      const qv = attr.namedChildren.find((c) => c.type === "quoted_attribute_value");
+      const valNode = (qv && qv.namedChildren.find((c) => c.type === "attribute_value")) || attr.namedChildren.find((c) => c.type === "attribute_value");
+      const name = nameNode.text.toLowerCase(); const value = valNode ? valNode.text : "";
+      if (!value) continue;
+      const tagNode = attr.parent && attr.parent.namedChildren.find((c) => c.type === "tag_name");
+      const tag = tagNode ? tagNode.text.toLowerCase() : "";
+      if (name === "href" && tag === "link") { const t = resolveHref(fileRel, value); if (t) addImportEdge(t); }
+      else if (name === "src" && (tag === "script" || tag === "img")) { const t = resolveHref(fileRel, value); if (t) addImportEdge(t); }
+      else if (name === "class") { for (const cls of value.split(/\s+/).filter(Boolean)) htmlUsages.push({ htmlFile: fileRel, label: "." + cls }); }
+      else if (name === "id") { htmlUsages.push({ htmlFile: fileRel, label: "#" + value }); }
+    }
+  },
+};

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

@@ -0,0 +1,29 @@
+// Java extractor. Symbols: class/interface/enum + method/constructor + fields.
+// Imports: `import a.b.C;` → the C.java file (package path = dir; suffix-matched). Calls: `x.method()` /
+// `method()` (name only). Heritage: `extends` + `implements`.
+const SYMS = `
+  (class_declaration name: (identifier) @class)
+  (interface_declaration name: (identifier) @class)
+  (enum_declaration name: (identifier) @class)
+  (method_declaration name: (identifier) @method)
+  (constructor_declaration name: (identifier) @method)
+  (field_declaration declarator: (variable_declarator name: (identifier) @field))`;
+
+export default {
+  family: "java",
+  grammars: ["java"],
+  exts: { ".java": "java" },
+  isWeb: false,
+  calls: `(method_invocation name: (identifier) @callee)`,
+  heritage: [`(superclass (type_identifier) @super)`, `(super_interfaces (type_list (type_identifier) @super))`],
+
+  pass1(ctx) {
+    const { grammar, tree, caps, addSym, addImportEdge, imports, resolveJavaImport } = ctx;
+    for (const cap of caps(grammar, SYMS, tree.rootNode)) addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
+    for (const cap of caps(grammar, `(import_declaration (scoped_identifier) @imp)`, tree.rootNode)) {
+      const parts = cap.node.text.split("."); const cls = parts[parts.length - 1];
+      const tgt = resolveJavaImport(parts); if (!tgt) continue;
+      addImportEdge(tgt); imports.set(cls, { imported: "*", targetFile: tgt });
+    }
+  },
+};