weavatrix 0.3.14 → 1.1.0

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

@@ -1,40 +0,0 @@
-// 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

@@ -1,29 +0,0 @@
-// 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

@@ -1,140 +0,0 @@
-// 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";
-
-// Return the named Go type behind pointers/generics/parentheses. Qualified names are
-// kept (`speaker.Speaker`) so pass 2 can route them through the import alias table.
-export function goTypeName(node) {
-  if (!node) return null;
-  if (node.type === "type_identifier") return node.text;
-  if (node.type === "qualified_type") return node.text.replace(/\s+/g, "");
-  if (node.type === "generic_type") return goTypeName(node.childForFieldName?.("type") || node.namedChildren?.[0]);
-  if (["pointer_type", "parenthesized_type", "unary_expression"].includes(node.type)) {
-    return goTypeName(node.childForFieldName?.("type") || node.childForFieldName?.("operand") || node.namedChildren?.[0]);
-  }
-  if ((node.namedChildren?.length || 0) === 1) return goTypeName(node.namedChildren[0]);
-  return null;
-}
-
-const namedFieldChildren = (node, name) => {
-  const children = node?.childrenForFieldName?.(name);
-  if (Array.isArray(children) && children.length) return children;
-  const child = node?.childForFieldName?.(name);
-  return child ? [child] : [];
-};
-
-function goStructFields(typeNode) {
-  if (typeNode?.type !== "struct_type") return null;
-  const fields = {};
-  const visit = (node) => {
-    if (!node) return;
-    if (node.type === "field_declaration") {
-      const type = goTypeName(node.childForFieldName?.("type"));
-      if (!type) return;
-      const names = namedFieldChildren(node, "name");
-      if (names.length) for (const name of names) fields[name.text] = type;
-      else {
-        // An embedded field is addressed by the base type name (`h.Speaker`).
-        const embedded = type.split(".").pop();
-        if (embedded) fields[embedded] = type;
-      }
-      return;
-    }
-    for (const child of node.namedChildren || []) visit(child);
-  };
-  visit(typeNode);
-  return fields;
-}
-
-function goResultType(declaration) {
-  const result = declaration?.childForFieldName?.("result");
-  if (!result) return null;
-  if (result.type !== "parameter_list") return goTypeName(result);
-  const declarations = (result.namedChildren || []).filter((child) => child.type === "parameter_declaration");
-  // A call used in `value, err := New()` contributes its first result to the
-  // first binding. Preserve that receiver type instead of discarding every
-  // multi-result signature just because a trailing error is present.
-  return goTypeName(declarations[0]?.childForFieldName?.("type"));
-}
-
-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, goModules, goRequires } = ctx;
-    const owningModule = (goModules || []).filter((item) => !item.root || fileRel === item.root || fileRel.startsWith(`${item.root}/`))
-      .sort((left, right) => right.root.length - left.root.length)[0];
-
-    // ---- symbols ----
-    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn)`, tree.rootNode)) {
-      const declaration = cap.node.parent;
-      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
-        sourceNode: declaration,
-        selectionNode: cap.node,
-        symbolKind: "function",
-        returnType: goResultType(declaration),
-      });
-    }
-    for (const cap of caps(grammar, `(method_declaration name: (field_identifier) @method)`, tree.rootNode)) {
-      const declaration = cap.node.parent;
-      const receiver = declaration.childForFieldName?.("receiver");
-      const receiverDeclaration = receiver?.namedChildren?.find((child) => child.type === "parameter_declaration");
-      const receiverType = goTypeName(receiverDeclaration?.childForFieldName?.("type"));
-      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
-        sourceNode: declaration,
-        selectionNode: cap.node,
-        symbolKind: "method",
-        memberOf: receiverType || undefined,
-        receiverType: receiverType || undefined,
-        returnType: goResultType(declaration),
-      });
-    }
-    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode)) {
-      const specification = cap.node.parent;
-      const typeNode = specification.childForFieldName?.("type");
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
-        sourceNode: specification,
-        selectionNode: cap.node,
-        symbolKind: typeNode?.type === "interface_type" ? "interface" : "type",
-        symbolSpace: "type",
-        fieldTypes: goStructFields(typeNode),
-      });
-    }
-    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: owningModule?.requires || goRequires || [], ownModule: owningModule?.module || 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

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

@@ -1,142 +0,0 @@
-// Java call resolution beyond bare same-file method names. Tree-sitter gives us the declared type of
-// fields, parameters and locals; imports/same-package resolution then identifies the project type that
-// owns a receiver method. This restores useful cross-file call flow without inventing external nodes or
-// pretending to perform compiler-exact overload/dynamic-dispatch resolution.
-const TYPE_DECLARATIONS = new Set([
-  "class_declaration", "interface_declaration", "enum_declaration",
-  "record_declaration", "annotation_type_declaration",
-]);
-const CALLABLE_DECLARATIONS = new Set([
-  "method_declaration", "constructor_declaration", "lambda_expression",
-]);
-const BINDING_DECLARATIONS = new Set([
-  "formal_parameter", "spread_parameter", "catch_formal_parameter",
-  "enhanced_for_statement", "resource",
-]);
-
-const contains = (scope, node) => scope && node
-  && scope.startIndex <= node.startIndex && scope.endIndex >= node.endIndex;
-
-function nearest(node, accepted) {
-  for (let current = node?.parent, hops = 0; current && hops < 30; current = current.parent, hops++) {
-    if (accepted.has(current.type)) return current;
-  }
-  return null;
-}
-
-function baseTypeName(typeNode, field) {
-  if (!typeNode) return null;
-  if (typeNode.type === "type_identifier") return typeNode.text;
-  if (typeNode.type === "scoped_type_identifier") return typeNode.text.split(".").pop() || null;
-  const nested = field(typeNode, "type") || field(typeNode, "element")
-    || typeNode.namedChildren?.find((child) => [
-      "type_identifier", "scoped_type_identifier", "generic_type", "array_type", "annotated_type",
-    ].includes(child.type));
-  return nested && nested !== typeNode ? baseTypeName(nested, field) : null;
-}
-
-function collectBindings(root, field) {
-  const bindings = [];
-  const add = (nameNode, typeNode, declaration, scope, allowForward = false) => {
-    const typeName = baseTypeName(typeNode, field);
-    if (!nameNode?.text || !typeName || !scope) return;
-    bindings.push({
-      name: nameNode.text,
-      typeName,
-      declaration,
-      scope,
-      allowForward,
-    });
-  };
-  const stack = [root];
-  while (stack.length) {
-    const node = stack.pop();
-    if (!node) continue;
-    if (node.type === "field_declaration" || node.type === "local_variable_declaration") {
-      const type = field(node, "type");
-      const owner = node.type === "field_declaration"
-        ? nearest(node, TYPE_DECLARATIONS)
-        : nearest(node, new Set(["block", ...CALLABLE_DECLARATIONS]));
-      for (const child of node.namedChildren || []) {
-        if (child.type !== "variable_declarator") continue;
-        add(field(child, "name"), type, node, owner, node.type === "field_declaration");
-      }
-    } else if (BINDING_DECLARATIONS.has(node.type)) {
-      const scope = node.type === "enhanced_for_statement"
-        ? node
-        : nearest(node, CALLABLE_DECLARATIONS) || nearest(node, new Set(["catch_clause", "try_with_resources_statement"]));
-      add(field(node, "name"), field(node, "type"), node, scope);
-    }
-    for (const child of node.namedChildren || []) stack.push(child);
-  }
-  return bindings;
-}
-
-function receiverName(node, field) {
-  if (!node) return null;
-  if (node.type === "identifier" || node.type === "type_identifier") return node.text;
-  if (node.type === "scoped_type_identifier") return node.text.split(".").pop() || null;
-  if (node.type === "field_access") {
-    const object = field(node, "object");
-    if (["this", "super"].includes(object?.type)) return field(node, "field")?.text || null;
-  }
-  return null;
-}
-
-function bindingAt(bindings, name, callNode) {
-  return bindings
-    .filter((item) => item.name === name && contains(item.scope, callNode)
-      && (item.allowForward || item.declaration.startIndex <= callNode.startIndex))
-    .sort((left, right) => {
-      const leftSpan = left.scope.endIndex - left.scope.startIndex;
-      const rightSpan = right.scope.endIndex - right.scope.startIndex;
-      return leftSpan - rightSpan || right.declaration.startIndex - left.declaration.startIndex;
-    })[0] || null;
-}
-
-function methodIn(file, name, argumentCount, symIdsByFileName, nodeById) {
-  const candidates = (symIdsByFileName.get(file)?.get(name) || [])
-    .map((id) => nodeById.get(id))
-    .filter((node) => ["method", "constructor"].includes(node?.symbol_kind));
-  if (candidates.length === 1) return candidates[0].id;
-  const exact = candidates.filter((node) => node.parameter_count === argumentCount);
-  return exact.length === 1 ? exact[0].id : null;
-}
-
-export function addJavaCalls({
-  grammar, tree, fileRel, caps, field, enclosing, links, nodeById,
-  symIdsByFileName, resolveCall, resolveJavaType,
-}) {
-  const bindings = collectBindings(tree.rootNode, field);
-  for (const cap of caps(grammar, `(method_invocation) @call`, tree.rootNode)) {
-    const call = cap.node;
-    const name = field(call, "name")?.text;
-    const argumentCount = field(call, "arguments")?.namedChildren?.length ?? 0;
-    const caller = enclosing(fileRel, call.startPosition.row + 1);
-    if (!name || !caller) continue;
-
-    const receiver = field(call, "object");
-    let target = null;
-    let resolution = "unqualified";
-    if (!receiver || ["this", "super"].includes(receiver.type)) {
-      target = resolveCall(name, fileRel);
-    } else {
-      const localName = receiverName(receiver, field);
-      const binding = localName && bindingAt(bindings, localName, call);
-      const declaredType = binding?.typeName || localName;
-      const typeTarget = declaredType && resolveJavaType(declaredType, fileRel);
-      const targetFile = typeTarget && nodeById.get(typeTarget)?.source_file;
-      target = targetFile && methodIn(targetFile, name, argumentCount, symIdsByFileName, nodeById);
-      resolution = binding ? "receiver-declared-type" : "static-type";
-    }
-    if (!target || target === caller.id) continue;
-    links.push({
-      source: caller.id,
-      target,
-      relation: "calls",
-      confidence: "INFERRED",
-      line: call.startPosition.row + 1,
-      javaResolution: resolution,
-    });
-  }
-}

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

@@ -1,215 +0,0 @@
-// Java extractor. Keeps file-level imports/calls while modelling the Java ownership and type system:
-// classes/interfaces/enums/records own their methods, heritage distinguishes extends from implements,
-// and project-local type references resolve to the declaration node (never to synthetic type-name nodes).
-import { addJavaCalls } from "./lang-java-calls.js";
-
-const TYPE_CORE = `
-  (class_declaration name: (identifier) @class)
-  (interface_declaration name: (identifier) @interface)
-  (enum_declaration name: (identifier) @enum)`;
-// Keep grammar-version-dependent declarations separate: one unknown node type invalidates a whole query.
-const TYPE_OPTIONAL = [
-  `(record_declaration name: (identifier) @record)`,
-  `(annotation_type_declaration name: (identifier) @annotation)`,
-];
-const MEMBERS = `
-  (method_declaration name: (identifier) @method)
-  (constructor_declaration name: (identifier) @constructor)
-  (field_declaration declarator: (variable_declarator name: (identifier) @field))`;
-
-const TYPE_DECLARATIONS = new Set([
-  "class_declaration", "interface_declaration", "enum_declaration",
-  "record_declaration", "annotation_type_declaration",
-]);
-const FIELD_DECLARATIONS = new Set(["field_declaration"]);
-
-const ancestor = (node, accepted) => {
-  let current = node?.parent;
-  for (let hops = 0; current && hops < 12; hops++, current = current.parent) {
-    if (accepted.has(current.type)) return current;
-  }
-  return null;
-};
-
-const visibilityOf = (declaration, owner) => {
-  const modifiers = declaration?.namedChildren?.find((node) => node.type === "modifiers")?.text || "";
-  if (/\bprivate\b/.test(modifiers)) return "private";
-  if (/\bprotected\b/.test(modifiers)) return "protected";
-  if (/\bpublic\b/.test(modifiers)) return "public";
-  if (["interface_declaration", "annotation_type_declaration"].includes(owner?.type)) return "public";
-  return "package";
-};
-
-const lineOf = (node) => node.startPosition.row + 1;
-const parameterCountOf = (declaration) => {
-  const parameters = declaration?.childForFieldName?.("parameters");
-  if (!parameters) return null;
-  return (parameters.namedChildren || []).filter((node) => [
-    "formal_parameter", "spread_parameter", "receiver_parameter",
-  ].includes(node.type)).length;
-};
-const symbolBaseId = (fileRel, nameNode) => `${fileRel}#${nameNode.text}@${lineOf(nameNode)}`;
-const declarationKey = (node) => `${node?.startIndex ?? -1}:${node?.endIndex ?? -1}`;
-const exactJavaTarget = (resolveJavaImport, parts) => {
-  const target = resolveJavaImport(parts);
-  const suffix = parts.join("/") + ".java";
-  return target && (target === suffix || target.endsWith("/" + suffix)) ? target : null;
-};
-
-export default {
-  family: "java",
-  grammars: ["java"],
-  exts: { ".java": "java" },
-  isWeb: false,
-  customCalls: true,
-  calls: `(method_invocation name: (identifier) @callee)`,
-  // Capturing the base type_identifier (rather than the whole generic/scoped type) gives the shared
-  // resolver the imported/local declaration name. Each query is deliberately non-overlapping.
-  heritage: [
-    { relation: "inherits", query: `(superclass (type_identifier) @super)` },
-    { relation: "inherits", query: `(superclass (generic_type (type_identifier) @super))` },
-    { relation: "inherits", query: `(superclass (scoped_type_identifier name: (type_identifier) @super))` },
-    { relation: "inherits", query: `(superclass (generic_type (scoped_type_identifier name: (type_identifier) @super)))` },
-    { relation: "inherits", query: `(extends_interfaces (type_list (type_identifier) @super))` },
-    { relation: "inherits", query: `(extends_interfaces (type_list (generic_type (type_identifier) @super)))` },
-    { relation: "inherits", query: `(extends_interfaces (type_list (scoped_type_identifier name: (type_identifier) @super)))` },
-    { relation: "inherits", query: `(extends_interfaces (type_list (generic_type (scoped_type_identifier name: (type_identifier) @super))))` },
-    { relation: "implements", query: `(super_interfaces (type_list (type_identifier) @super))` },
-    { relation: "implements", query: `(super_interfaces (type_list (generic_type (type_identifier) @super)))` },
-    { relation: "implements", query: `(super_interfaces (type_list (scoped_type_identifier name: (type_identifier) @super)))` },
-    { relation: "implements", query: `(super_interfaces (type_list (generic_type (scoped_type_identifier name: (type_identifier) @super))))` },
-  ],
-
-  pass1(ctx) {
-    const {
-      grammar, tree, fileRel, caps, field, addSym, addImportEdge, imports,
-      resolveJavaImport, fileSet, links, nodeIds, addExternalImport,
-    } = ctx;
-    const ownerIds = new Map();
-    const addJavaSym = (nameNode, callable, extra) => {
-      const base = symbolBaseId(fileRel, nameNode);
-      // Compact/generated Java can put an owner, constructor and overloads with the same name on one
-      // line. Preserve historical IDs normally; disambiguate only an actual collision by source column.
-      const id = nodeIds.has(base) ? `${base}:c${nameNode.startPosition.column + 1}` : base;
-      addSym(nameNode.text, lineOf(nameNode), callable, {
-        ...extra,
-        selectionNode: nameNode,
-        ...(id === base ? {} : { idSuffix: id.slice(base.length) }),
-      });
-      return nodeIds.has(id) ? id : null;
-    };
-
-    // Add owners first even though tree-sitter captures are source-ordered. This makes ownership edges
-    // deterministic for nested types and methods declared before/after other nested declarations.
-    for (const src of [TYPE_CORE, ...TYPE_OPTIONAL]) {
-      for (const cap of caps(grammar, src, tree.rootNode)) {
-        const declaration = cap.node.parent;
-        const id = addJavaSym(cap.node, false, {
-          sourceNode: cap.node.parent,
-          symbolKind: cap.name,
-        });
-        if (id) ownerIds.set(declarationKey(declaration), id);
-      }
-    }
-
-    for (const cap of caps(grammar, MEMBERS, tree.rootNode)) {
-      const declaration = cap.name === "field" ? ancestor(cap.node, FIELD_DECLARATIONS) : cap.node.parent;
-      const owner = ancestor(cap.node, TYPE_DECLARATIONS);
-      const ownerNameNode = owner && field(owner, "name");
-      const memberKind = cap.name === "constructor" ? "constructor" : cap.name;
-      const memberId = addJavaSym(cap.node, cap.name !== "field", {
-        sourceNode: declaration,
-        symbolKind: memberKind,
-        ...(["method", "constructor"].includes(memberKind) ? { parameterCount: parameterCountOf(declaration) } : {}),
-        ...(ownerNameNode ? { memberOf: ownerNameNode.text } : {}),
-        visibility: visibilityOf(declaration, owner),
-      });
-      if (!ownerNameNode || cap.name === "field") continue;
-      const ownerId = ownerIds.get(declarationKey(owner));
-      if (ownerId && memberId && ownerId !== memberId) {
-        links.push({ source: ownerId, target: memberId, relation: "method", confidence: "EXTRACTED" });
-      }
-    }
-
-    const wildcardPackages = [];
-    const staticWildcardTargets = [];
-    const importStatements = caps(grammar, `(import_declaration) @imp`, tree.rootNode);
-    for (const cap of importStatements) {
-      const match = cap.node.text.match(/^\s*import\s+(static\s+)?([\w.]+?)(\.\*)?\s*;?\s*$/);
-      if (!match) continue;
-      const isStatic = !!match[1];
-      const parts = match[2].split(".").filter(Boolean);
-      const wildcard = !!match[3];
-      const line = lineOf(cap.node);
-      if (!isStatic && wildcard) {
-        wildcardPackages.push(parts);
-        const packagePath = `${parts.join("/")}/`;
-        const projectLocal = [...fileSet].some((file) => file.startsWith(packagePath) || file.includes(`/${packagePath}`));
-        if (!projectLocal) addExternalImport({ spec: `${parts.join(".")}.*`, pkg: parts.join("."), builtin: ["java", "jdk", "sun"].includes(parts[0]), ecosystem: "Maven", kind: "java-import", line });
-        continue;
-      }
-      if (!isStatic) {
-        const target = exactJavaTarget(resolveJavaImport, parts);
-        if (!target) {
-          addExternalImport({ spec: parts.join("."), pkg: parts.join("."), builtin: ["java", "jdk", "sun"].includes(parts[0]), ecosystem: "Maven", kind: "java-import", line });
-          continue;
-        }
-        const local = parts[parts.length - 1];
-        addImportEdge(target, { line, specifier: parts.join("."), compileOnly: true });
-        imports.set(local, { imported: local, targetFile: target });
-        continue;
-      }
-
-      // Static imports end in a member name. Walk prefixes until the declaring project class resolves.
-      let target = null; let classParts = null;
-      const max = wildcard ? parts.length : parts.length - 1;
-      for (let take = max; take > 0 && !target; take--) {
-        const candidate = parts.slice(0, take);
-        target = exactJavaTarget(resolveJavaImport, candidate);
-        if (target) classParts = candidate;
-      }
-      if (!target) {
-        addExternalImport({ spec: parts.join("."), pkg: parts.join("."), builtin: ["java", "jdk", "sun"].includes(parts[0]), ecosystem: "Maven", kind: "java-static-import", line });
-        continue;
-      }
-      addImportEdge(target, { line, specifier: `${isStatic ? "static " : ""}${parts.join(".")}${wildcard ? ".*" : ""}`, compileOnly: true });
-      if (wildcard) staticWildcardTargets.push(target);
-      else {
-        const member = parts[classParts.length];
-        if (member) imports.set(member, { imported: member, targetFile: target });
-      }
-    }
-
-    // Seed the shared pass-2 resolver with Java's implicit same-package types and wildcard imports.
-    // Exact-path validation is important: the general basename fallback is useful for explicit imports,
-    // but must not bind an unimported Foo to an unrelated package's Foo.java.
-    const slash = fileRel.lastIndexOf("/");
-    const ownDir = slash < 0 ? "" : fileRel.slice(0, slash);
-    const bindType = (name) => {
-      if (!name || imports.has(name)) return;
-      const samePackage = `${ownDir ? ownDir + "/" : ""}${name}.java`;
-      if (fileSet.has(samePackage)) {
-        imports.set(name, { imported: name, targetFile: samePackage });
-        return;
-      }
-      for (const pkg of wildcardPackages) {
-        const target = exactJavaTarget(resolveJavaImport, [...pkg, name]);
-        if (target) { imports.set(name, { imported: name, targetFile: target }); return; }
-      }
-    };
-    for (const cap of caps(grammar, `(type_identifier) @type`, tree.rootNode)) bindType(cap.node.text);
-    for (const cap of caps(grammar, `(scoped_type_identifier) @type`, tree.rootNode)) {
-      const parts = cap.node.text.split(".").filter(Boolean);
-      const target = exactJavaTarget(resolveJavaImport, parts);
-      const name = parts[parts.length - 1];
-      if (target && name && !imports.has(name)) imports.set(name, { imported: name, targetFile: target });
-    }
-    if (staticWildcardTargets.length === 1) {
-      for (const cap of caps(grammar, `(method_invocation name: (identifier) @callee)`, tree.rootNode)) {
-        if (!imports.has(cap.node.text)) imports.set(cap.node.text, { imported: cap.node.text, targetFile: staticWildcardTargets[0] });
-      }
-    }
-  },
-
-  pass2: addJavaCalls,
-};