weavatrix 0.3.14 → 1.1.0

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

@@ -1,291 +0,0 @@
-// JS / TS / JSX / TSX extractor for the built-in graph builder.
-// Symbols: functions, generators, classes, methods, top-level const/let/var (data + arrow/fn consts).
-// Imports: ESM `import`, CJS `require`, path-aliases (tsconfig/vite), and barrel re-exports (`export … from`).
-// Calls: bare `foo()`. Heritage: `class X extends Y`. Everything runs through the shared ctx (see internal-builder.js).
-import {
-  CALLABLE, FUNCS, TOPVARS, TYPES, REQUIRE, parseExportSpecifiers,
-  importTypeOnly, reexportTypeOnly,
-} from './js/queries.js';
-import {boundedUrlImportTarget} from './js/dynamic-import.js';
-
-export default {
-  family: "js",
-  grammars: ["javascript", "typescript", "tsx"],
-  exts: { ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".ts": "typescript", ".tsx": "tsx" },
-  isWeb: false,
-  calls: `(call_expression function: (identifier) @callee)`,
-  heritage: [`(class_heritage (identifier) @super)`, `(class_heritage (extends_clause value: (identifier) @super))`],
-
-  pass1(ctx) {
-    const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, addExternalImport, markExported, imports, resolveJsImport, resolveAlias } = ctx;
-    const recordJsExport = typeof ctx.recordJsExport === "function" ? ctx.recordJsExport : () => {};
-    // exported-ness of a declaration = an export_statement ancestor (export function/class/const …).
-    // BOUNDED climb: web-tree-sitter's node.parent is O(depth) (re-walks a cursor from the root each call),
-    // so an UNBOUNDED walk to `program` for every symbol was O(depth^3) and HUNG the build for minutes/hours
-    // on deeply-nested / minified / bundled JS (regression). An export_statement is always a NEAR ancestor of
-    // the declaration head (≤ ~5 hops), and hitting a statement_block means we're nested inside a function →
-    // not a module-level export → bail immediately. See [[graph-builder-internalization]].
-    // Early-out for nested scopes keeps this O(1); class members are intentionally never module exports even
-    // when their owner class is exported. The hop cap remains a backstop for malformed/deep syntax trees.
-    const exportStatementOf = (node) => {
-      let p = node.parent;
-      for (let hops = 0; p && hops < 6; hops++) {
-        if (p.type === "export_statement") return p;
-        if (p.type === "program" || p.type === "statement_block" || p.type === "class_body") return null;
-        p = p.parent;
-      }
-      return null;
-    };
-    const isExportedDecl = (node) => !!exportStatementOf(node);
-    const isModuleDeclaration = (node) => {
-      let p = node.parent;
-      for (let hops = 0; p && hops < 8; hops++) {
-        if (p.type === "program") return true;
-        if (p.type === "statement_block" || p.type === "class_body") return false;
-        p = p.parent;
-      }
-      return false;
-    };
-    // a bare (package) specifier = non-relative AND not a path alias; alias-that-missed is a broken local, not a dep
-    const isBareSpec = (spec) => !!spec && !spec.startsWith(".") && resolveAlias(fileRel, spec) == null;
-    // broken local import (relative or alias path resolving to no file) — recorded for the "unresolved-import"
-    // finding. Asset imports (svg/css-modules-adjacent/fonts/…) and ?query-suffixed specs that resolve once
-    // the query is stripped (Vite ?raw/?url/?worker) are NOT code-graph concerns.
-    const ASSET_RE = /\.(svg|png|jpe?g|gif|webp|avif|ico|bmp|woff2?|ttf|eot|otf|mp[34]|webm|wasm|pdf|txt|md|html?)$/i;
-    const recordUnresolved = (rawSpec, kind, line, typeOnly = false) => {
-      const clean = String(rawSpec || "").split("?")[0];
-      if (!clean || ASSET_RE.test(clean)) return;
-      if (clean !== rawSpec && resolveJsImport(fileRel, clean)) return; // only the ?query broke resolution
-      addExternalImport({ spec: rawSpec, kind, line, unresolved: true, typeOnly });
-    };
-
-    // ---- symbols (export flag captured at declaration time) ----
-    const methodMetadata = (nameNode) => {
-      let method = nameNode.parent;
-      while (method && method.type !== "method_definition") method = method.parent;
-      let owner = method?.parent;
-      while (owner && !["class_declaration", "class"].includes(owner.type)) owner = owner.parent;
-      const ownerName = owner && field(owner, "name")?.text;
-      const visibility = /^\s*private\b/.test(method?.text || "") ? "private"
-        : /^\s*protected\b/.test(method?.text || "") ? "protected" : "public";
-      return { symbolKind: "method", ...(ownerName ? { memberOf: ownerName } : {}), visibility };
-    };
-    for (const cap of caps(grammar, FUNCS, tree.rootNode)) {
-      const isMethod = cap.name === "method";
-      const exportStatement = !isMethod && exportStatementOf(cap.node);
-      addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name !== "class", {
-        sourceNode: cap.node.parent,
-        selectionNode: cap.node,
-        ...(exportStatement ? { exported: true } : {}),
-        ...(isMethod
-          ? {...methodMetadata(cap.node), symbolSpace: "value"}
-          : {
-              symbolKind: cap.name === "class" ? "class" : "function",
-              symbolSpace: cap.name === "class" ? "both" : "value",
-              moduleDeclaration: isModuleDeclaration(cap.node),
-            })
-      });
-      if (exportStatement) {
-        recordJsExport({
-          kind: "local",
-          exported: /^\s*export\s+default\b/.test(exportStatement.text) ? "default" : cap.node.text,
-          local: cap.node.text,
-          typeOnly: false,
-          line: exportStatement.startPosition.row + 1,
-        });
-      }
-    }
-    for (const cap of caps(grammar, TOPVARS, tree.rootNode)) {
-      const nameNode = field(cap.node, "name"); if (!nameNode || nameNode.type !== "identifier") continue;
-      const val = field(cap.node, "value");
-      const exported = isExportedDecl(cap.node);
-      addSym(nameNode.text, nameNode.startPosition.row + 1, !!(val && CALLABLE.test(val.type)), {
-        sourceNode: val || cap.node,
-        selectionNode: nameNode,
-        ...(exported ? { exported: true } : {}),
-        symbolKind: "variable",
-        symbolSpace: "value",
-        moduleDeclaration: true
-      });
-      if (exported) recordJsExport({
-        kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false,
-        line: exportStatementOf(cap.node)?.startPosition.row + 1 || nameNode.startPosition.row + 1,
-      });
-    }
-
-    // TypeScript has separate type and value namespaces. Keep interface/type declarations as
-    // first-class type-space nodes instead of folding them into a same-named runtime declaration.
-    // Enums and classes intentionally occupy both spaces because TypeScript emits runtime values.
-    if (grammar !== "javascript") for (const cap of caps(grammar, TYPES, tree.rootNode)) {
-      const declaration = cap.node.parent;
-      const exportStatement = exportStatementOf(cap.node);
-      const symbolKind = cap.name === "interface" ? "interface" : cap.name === "type" ? "type" : "enum";
-      const symbolSpace = cap.name === "enum" ? "both" : "type";
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
-        sourceNode: declaration,
-        selectionNode: cap.node,
-        idSuffix: symbolSpace === "type" ? ":type" : "",
-        ...(exportStatement ? {exported: true} : {}),
-        symbolKind,
-        symbolSpace,
-        moduleDeclaration: isModuleDeclaration(cap.node),
-      });
-      if (exportStatement) recordJsExport({
-        kind: "local",
-        exported: cap.node.text,
-        local: cap.node.text,
-        typeOnly: symbolSpace === "type",
-        line: exportStatement.startPosition.row + 1,
-        symbolSpace,
-      });
-    }
-
-    // ---- ESM imports ----
-    for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
-      const node = cap.node; const srcNode = field(node, "source");
-      const rawSpec = srcNode ? srcNode.text.replace(/^['"`]|['"`]$/g, "") : "";
-      const line = node.startPosition.row + 1;
-      const typeOnly = importTypeOnly(node);
-      const tgt = resolveJsImport(fileRel, rawSpec);
-      if (!tgt) {
-        if (isBareSpec(rawSpec)) addExternalImport({ spec: rawSpec, kind: "esm", line, typeOnly });
-        else if (rawSpec) recordUnresolved(rawSpec, "esm", line, typeOnly);
-        continue;
-      }
-      addImportEdge(tgt, { typeOnly, line, specifier: rawSpec });
-      const clause = node.namedChildren.find((c) => c.type === "import_clause"); if (!clause) continue;
-      for (const c of clause.namedChildren) {
-        if (c.type === "identifier") imports.set(c.text, { imported: "default", targetFile: tgt, typeOnly, line, specifier: rawSpec });
-        else if (c.type === "namespace_import") { const id = c.namedChildren.find((x) => x.type === "identifier"); if (id) imports.set(id.text, { imported: "*", targetFile: tgt, typeOnly, line, specifier: rawSpec }); }
-        else if (c.type === "named_imports") for (const s of c.namedChildren) { if (s.type !== "import_specifier") continue; const nm = field(s, "name"), al = field(s, "alias"); if (nm) imports.set((al || nm).text, { imported: nm.text, targetFile: tgt, typeOnly: typeOnly || /^\s*type\b/.test(s.text), line, specifier: rawSpec }); }
-      }
-    }
-
-    // ---- CJS require (declarator form: local bindings + import edges) ----
-    for (const cap of caps(grammar, REQUIRE, tree.rootNode)) {
-      if (cap.name !== "src") continue;
-      let dv = cap.node; while (dv && dv.type !== "variable_declarator") dv = dv.parent;
-      const tgt = resolveJsImport(fileRel, cap.node.text); if (!tgt) continue;
-      addImportEdge(tgt, { typeOnly: false, line: cap.node.startPosition.row + 1, specifier: cap.node.text });
-      const lhs = dv && field(dv, "name");
-      if (lhs && lhs.type === "identifier") imports.set(lhs.text, { imported: "*", targetFile: tgt, line: cap.node.startPosition.row + 1, specifier: cap.node.text });
-      else if (lhs && lhs.type === "object_pattern") for (const p of lhs.namedChildren) { const key = field(p, "key") || (p.type === "shorthand_property_identifier_pattern" ? p : null); const val = field(p, "value"); const local = (val && val.type === "identifier") ? val : key; if (key && local) imports.set(local.text, { imported: key.text, targetFile: tgt, line: cap.node.startPosition.row + 1, specifier: cap.node.text }); }
-    }
-
-    // ---- CJS require, ALL forms (side-effect require("dotenv/config") included): bare-pkg records +
-    // non-literal require(x) → dynamic marker so dep analysis can suppress false "unused" positives ----
-    for (const cap of caps(grammar, `(call_expression function: (identifier) @fn)`, tree.rootNode)) {
-      if (cap.node.text !== "require") continue;
-      const call = cap.node.parent; const args = field(call, "arguments");
-      const arg = args && args.namedChildren ? args.namedChildren[0] : null;
-      const line = call.startPosition.row + 1;
-      if (arg && arg.type === "string") {
-        const rawSpec = arg.text.replace(/^['"`]|['"`]$/g, "");
-        if (resolveJsImport(fileRel, rawSpec)) continue;
-        if (isBareSpec(rawSpec)) addExternalImport({ spec: rawSpec, kind: "cjs", line });
-        else recordUnresolved(rawSpec, "cjs", line);
-      } else {
-        addExternalImport({ dynamic: true, kind: "cjs", line });
-      }
-    }
-
-    // ---- dynamic import(): literal bare → package record; literal local → dynamic marker with target;
-    // non-literal → bare dynamic marker ----
-    for (const cap of caps(grammar, `(call_expression function: (import) @imp)`, tree.rootNode)) {
-      const call = cap.node.parent; const args = field(call, "arguments");
-      const arg = args && args.namedChildren ? args.namedChildren[0] : null;
-      const line = call.startPosition.row + 1;
-      if (arg && arg.type === "string") {
-        const rawSpec = arg.text.replace(/^['"`]|['"`]$/g, "");
-        const tgt = resolveJsImport(fileRel, rawSpec);
-        if (tgt) addExternalImport({ dynamic: true, spec: rawSpec, target: tgt, kind: "dynamic", line });
-        else if (isBareSpec(rawSpec)) addExternalImport({ spec: rawSpec, kind: "dynamic", line });
-        else if (rawSpec) recordUnresolved(rawSpec, "dynamic", line);
-      } else {
-        const bounded = boundedUrlImportTarget(arg, {field, fileRel, resolveJsImport});
-        addExternalImport({ dynamic: true, kind: "dynamic", line, ...(bounded ? {spec: bounded.rawSpec, target: bounded.target} : {}) });
-      }
-    }
-
-    // ---- re-exports (barrel/index files): edge so the real target isn't falsely DEAD; bare source → external ----
-    for (const cap of caps(grammar, `(export_statement) @exp`, tree.rootNode)) {
-      const node = cap.node; const srcNode = field(node, "source");
-      if (!srcNode) continue;
-      const rawSpec = srcNode.text.replace(/^['"`]|['"`]$/g, "");
-      const line = node.startPosition.row + 1;
-      const typeOnly = reexportTypeOnly(node);
-      const tgt = resolveJsImport(fileRel, rawSpec);
-      if (tgt) {
-        addImportEdge(tgt, { relation: "re_exports", typeOnly, line, specifier: rawSpec });
-        const text = node.text.trim();
-        const star = text.match(/^export\s+(type\s+)?\*\s+from\b/);
-        const namespace = text.match(/^export\s+(type\s+)?\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
-        const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}\s+from\b/);
-        if (namespace) {
-          recordJsExport({ kind: "namespace", exported: namespace[2], imported: "*", targetFile: tgt, typeOnly: !!namespace[1], line, specifier: rawSpec });
-        } else if (star) {
-          recordJsExport({ kind: "star", exported: "*", imported: "*", targetFile: tgt, typeOnly: !!star[1], line, specifier: rawSpec });
-        } else if (clause) {
-          for (const spec of parseExportSpecifiers(clause[2])) {
-            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly, line, specifier: rawSpec });
-          }
-        }
-      }
-      else if (isBareSpec(rawSpec)) addExternalImport({ spec: rawSpec, kind: "reexport", line, typeOnly });
-      else if (rawSpec) recordUnresolved(rawSpec, "reexport", line, typeOnly);
-    }
-
-    // Local aliases (`export { internal as publicName }`) and default identifiers are part of the
-    // same export table used by the post-pass barrel resolver. Sourced clauses were recorded above.
-    for (const cap of caps(grammar, `(export_statement) @exp`, tree.rootNode)) {
-      const node = cap.node;
-      if (field(node, "source")) continue;
-      const text = node.text.trim();
-      const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}/);
-      if (clause) for (const spec of parseExportSpecifiers(clause[2])) {
-        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly, line: node.startPosition.row + 1 });
-      }
-      const identifierDefault = text.match(/^export\s+default\s+([A-Za-z_$][\w$]*)\s*;?$/);
-      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false, line: node.startPosition.row + 1 });
-      const defaultValue = field(node, "value");
-      if (defaultValue?.type === "object") {
-        // Service facades commonly expose local helpers through `export default { getSchema,
-        // save: persist }`. Record the public member -> local binding instead of treating the
-        // object as an opaque default export.
-        recordJsExport({kind: "facade-root", exported: "default", local: "default", typeOnly: false, line: node.startPosition.row + 1});
-        for (const property of defaultValue.namedChildren || []) {
-          if (["shorthand_property_identifier", "shorthand_property_identifier_pattern"].includes(property.type)) {
-            recordJsExport({kind: "facade-member", member: property.text, local: property.text, typeOnly: false, line: node.startPosition.row + 1});
-            markExported(property.text);
-            continue;
-          }
-          if (property.type !== "pair") continue;
-          const key = field(property, "key");
-          const value = field(property, "value");
-          if (!key || value?.type !== "identifier") continue;
-          const member = key.text.replace(/^['"`]|['"`]$/g, "");
-          if (!/^[A-Za-z_$][\w$]*$/.test(member)) continue;
-          recordJsExport({kind: "facade-member", member, local: value.text, typeOnly: false, line: node.startPosition.row + 1});
-          markExported(value.text);
-        }
-      }
-    }
-
-    // ---- export markers beyond declarations: `export { a, b }`, `export default X`, CJS module.exports ----
-    for (const cap of caps(grammar, `(export_statement (export_clause (export_specifier name: (identifier) @n)))`, tree.rootNode)) {
-      let st = cap.node.parent; while (st && st.type !== "export_statement") st = st.parent;
-      if (st && !field(st, "source")) markExported(cap.node.text); // with a source it's a re-export, not a local symbol
-    }
-    for (const cap of caps(grammar, `(export_statement value: (identifier) @def)`, tree.rootNode)) markExported(cap.node.text);
-    for (const cap of caps(grammar, `(assignment_expression left: (member_expression) @lhs right: (identifier) @rhs)`, tree.rootNode)) {
-      if (cap.name !== "rhs") continue;
-      const lhs = field(cap.node.parent, "left"); const l = lhs ? lhs.text : "";
-      if (l === "module.exports" || l.startsWith("exports.") || l.startsWith("module.exports.")) markExported(cap.node.text);
-    }
-    for (const cap of caps(grammar, `(assignment_expression left: (member_expression) right: (object (shorthand_property_identifier) @p))`, tree.rootNode)) {
-      let ae = cap.node.parent; while (ae && ae.type !== "assignment_expression") ae = ae.parent;
-      const lhs = ae && field(ae, "left");
-      if (lhs && (lhs.text === "module.exports" || lhs.text.startsWith("exports."))) markExported(cap.node.text);
-    }
-  },
-};

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

@@ -1,235 +0,0 @@
-// Python extractor. Symbols: def/class (methods included) + module-level assignments (data consts).
-// Imports: `import a.b [as c]` and `from [.]*mod import name [as alias]` with dotted + relative (leading-dot)
-// resolution to <path>.py / <path>/__init__.py — tried from the repo root, src/ (src-layout), and the
-// importing file's own directory (script-style sys.path). Absolute imports that resolve to NO repo file
-// are recorded as external imports (stdlib → builtin, else ecosystem "PyPI") for dependency analysis.
-// Calls: bare `foo()`. Heritage: class superclasses.
-import { pySpecToPkg, PY_STDLIB } from "./spec-pkg.js";
-
-export default {
-  family: "py",
-  grammars: ["python"],
-  exts: { ".py": "python", ".pyi": "python" },
-  isWeb: false,
-  customCalls: true,
-  calls: `(call function: (identifier) @callee)`,
-  heritage: [`(class_definition superclasses: (argument_list (identifier) @super))`],
-
-  pass1(ctx) {
-    const { grammar, tree, fileRel, code, caps, field, addSym, addImportEdge, addExternalImport, markExported, imports, links, nameToId, resolvePyPath, pyBaseDir, pyTopDirs } = ctx;
-    // the importing file's own dir is on sys.path when it runs as a script — try siblings for absolute
-    // imports, EXCEPT stdlib names (a sibling logging.py must not shadow `import logging`; py3 absolute
-    // imports always pick the stdlib, and a wrong internal edge distorts dead-code + reachability)
-    const scriptDir = pyBaseDir(fileRel, 1);
-    const resolveAbs = (parts) => resolvePyPath("", parts) || (scriptDir && !PY_STDLIB.has(parts[0]) ? resolvePyPath(scriptDir, parts) : null);
-    const recordExternal = (dottedName, line) => {
-      const top = String(dottedName).split(".")[0];
-      if (pyTopDirs && pyTopDirs.has(top)) return; // repo-local namespace package (no __init__.py) — internal, not a dep
-      const r = pySpecToPkg(top);
-      if (r && !r.ambiguous) addExternalImport({ spec: dottedName, pkg: r.pkg, builtin: r.builtin, ecosystem: "PyPI", kind: "py-import", line });
-    };
-
-    // ---- symbols (decorated defs are framework-entered — @app.route/@app.event/@pytest.fixture — the
-    // flag keeps dead-code checks from calling them dead; tree wraps them in decorated_definition) ----
-    const ownedMethods = [];
-    for (const cap of caps(grammar, `(function_definition name: (identifier) @fn) (class_definition name: (identifier) @class)`, tree.rootNode)) {
-      const decorated = cap.node.parent?.parent?.type === "decorated_definition";
-      let ownerName = null;
-      if (cap.name === "fn") {
-        let parent = cap.node.parent?.parent;
-        while (parent && !["function_definition", "class_definition", "module"].includes(parent.type)) parent = parent.parent;
-        if (parent?.type === "class_definition") ownerName = field(parent, "name")?.text || null;
-      }
-      const visibility = /^__[^_].*/.test(cap.node.text) ? "private"
-        : /^_[^_]/.test(cap.node.text) ? "protected" : "public";
-      const id = addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "fn", {
-        sourceNode: cap.node.parent,
-        selectionNode: cap.node,
-        ...(decorated ? { decorated: true } : {}),
-        symbolKind: cap.name === "class" ? "class" : ownerName ? "method" : "function",
-        ...(ownerName ? {memberOf: ownerName, visibility} : {moduleDeclaration: true}),
-      });
-      if (ownerName) ownedMethods.push({ownerName, id});
-    }
-    for (const method of ownedMethods) {
-      const ownerId = nameToId.get(method.ownerName);
-      if (ownerId) links.push({source: ownerId, target: method.id, relation: "contains", confidence: "EXTRACTED"});
-    }
-    for (const cap of caps(grammar, `(module (expression_statement (assignment left: (identifier) @var)))`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent, selectionNode: cap.node, symbolKind: "variable", moduleDeclaration: true });
-
-    // Static __all__ is authoritative for wildcard imports. The assignment itself remains indexed,
-    // while listed declarations are marked as the explicit public module surface.
-    const allMatch = String(code || "").match(/(?:^|\n)\s*__all__\s*=\s*[\[(]([\s\S]*?)[\])]/m);
-    if (allMatch) for (const match of allMatch[1].matchAll(/["']([A-Za-z_]\w*)["']/g)) markExported(match[1]);
-
-    // ---- import a.b [as c] ----
-    for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
-      for (const child of cap.node.namedChildren) {
-        const modNode = child.type === "aliased_import" ? field(child, "name") : (child.type === "dotted_name" ? child : null);
-        if (!modNode) continue;
-        const parts = modNode.text.split(".");
-        const tgt = resolveAbs(parts);
-        if (tgt) { addImportEdge(tgt); const local = child.type === "aliased_import" ? field(child, "alias")?.text : parts[0]; if (local) imports.set(local, { imported: "*", targetFile: tgt }); }
-        else recordExternal(modNode.text, modNode.startPosition.row + 1);
-      }
-    }
-
-    // ---- from [.]*mod import name [, name as alias] ----
-    for (const cap of caps(grammar, `(import_from_statement) @imp`, tree.rootNode)) {
-      const node = cap.node; const modNode = field(node, "module_name");
-      let dots = 0, modParts = [];
-      if (modNode) {
-        if (modNode.type === "relative_import") { const t = modNode.text; while (dots < t.length && t[dots] === ".") dots++; const rest = t.slice(dots); modParts = rest ? rest.split(".") : []; }
-        else if (modNode.type === "dotted_name") modParts = modNode.text.split(".");
-      }
-      const baseDir = pyBaseDir(fileRel, dots);
-      const wildcard = node.namedChildren.some((child) => child.type === "wildcard_import");
-      if (wildcard) {
-        const modFile = resolvePyPath(baseDir, modParts) || (dots === 0 ? resolveAbs(modParts) : null);
-        if (modFile) {
-          addImportEdge(modFile);
-          imports.set(`*:${node.startPosition.row + 1}`, {imported: "*", targetFile: modFile, wildcard: true, line: node.startPosition.row + 1});
-        } else if (dots === 0 && modParts.length) recordExternal(modParts.join("."), node.startPosition.row + 1);
-        continue;
-      }
-      const names = node.namedChildren.filter((c) => c !== modNode && (c.type === "dotted_name" || c.type === "aliased_import"));
-      let externalDone = false; // one record per statement, not per imported name
-      for (const nm of names) {
-        const impName = nm.type === "aliased_import" ? field(nm, "name")?.text : nm.text;
-        const local = nm.type === "aliased_import" ? field(nm, "alias")?.text : impName;
-        if (!impName) continue;
-        const asSub = resolvePyPath(baseDir, [...modParts, impName]) || (dots === 0 ? resolveAbs([...modParts, impName]) : null);   // name may itself be a submodule file
-        if (asSub) { addImportEdge(asSub); if (local) imports.set(local, { imported: "*", targetFile: asSub }); continue; }
-        const modFile = resolvePyPath(baseDir, modParts) || (dots === 0 ? resolveAbs(modParts) : null);
-        if (modFile) { addImportEdge(modFile); if (local) imports.set(local, { imported: impName, targetFile: modFile }); }
-        else if (dots === 0 && modParts.length && !externalDone) { externalDone = true; recordExternal(modParts.join("."), node.startPosition.row + 1); }
-      }
-    }
-  },
-
-  pass2(ctx) {
-    const {grammar, tree, fileRel, caps, field, enclosing, links, nodeById, perFileSymbols, symByFileName, importedLocals, resolveCall} = ctx;
-    const imports = importedLocals.get(fileRel) || new Map();
-    const wildcardImports = [...imports.values()].filter((entry) => entry?.wildcard && entry.targetFile);
-    const emitted = new Set();
-    const addCall = (caller, target, line, evidence) => {
-      if (!caller || !target || target === caller.id) return;
-      const key = `${caller.id}\0${target}\0${line}`;
-      if (emitted.has(key) || links.some((link) => link.source === caller.id && link.target === target && link.relation === "calls" && link.line === line)) return;
-      emitted.add(key);
-      const provenance = ["receiver-type", "wildcard-import", "module-member"].includes(evidence) ? "RESOLVED" : "INFERRED";
-      links.push({source: caller.id, target, relation: "calls", confidence: "INFERRED", provenance, line, pythonResolution: evidence});
-    };
-    const moduleSymbol = (targetFile, name) => {
-      const id = symByFileName.get(targetFile)?.get(name);
-      if (!id) return null;
-      const node = nodeById.get(id);
-      return node?.member_of ? null : id;
-    };
-    const wildcardCandidates = (name) => {
-      const candidates = [];
-      for (const imp of wildcardImports) {
-        const symbols = perFileSymbols.get(imp.targetFile) || [];
-        const explicitAll = symbols.some((symbol) => symbol.name === "__all__");
-        const symbol = symbols.find((entry) => entry.name === name && !entry.memberOf);
-        if (!symbol || (explicitAll ? nodeById.get(symbol.id)?.exported !== true : name.startsWith("_"))) continue;
-        candidates.push(symbol.id);
-      }
-      return [...new Set(candidates)];
-    };
-    const classInfo = (name) => {
-      const local = symByFileName.get(fileRel)?.get(name);
-      if (local && nodeById.get(local)?.symbol_kind === "class") return {id: local, name, file: fileRel};
-      const imp = imports.get(name);
-      if (imp?.targetFile && !imp.wildcard) {
-        const targetFile = imp.originFile || imp.targetFile;
-        const targetName = imp.originName || imp.imported || name;
-        const id = symByFileName.get(targetFile)?.get(targetName);
-        if (id && nodeById.get(id)?.symbol_kind === "class") return {id, name: targetName, file: targetFile};
-      }
-      const wildcard = wildcardCandidates(name).filter((id) => nodeById.get(id)?.symbol_kind === "class");
-      if (wildcard.length === 1) {
-        const node = nodeById.get(wildcard[0]);
-        return {id: wildcard[0], name: node.label || name, file: node.source_file};
-      }
-      return null;
-    };
-    const methodOf = (klass, method) => (perFileSymbols.get(klass.file) || [])
-      .find((symbol) => symbol.memberOf === String(nodeById.get(klass.id)?.label || klass.name).replace(/\(.*$/, "") && symbol.name === method)?.id || null;
-    const bindings = new Map();
-    const shadows = new Set();
-    const scopeKey = (caller, name) => `${caller?.id || ""}\0${name}`;
-    const bind = (caller, name, klass) => { if (caller && name && klass) bindings.set(scopeKey(caller, name), klass); };
-    const typeName = (node) => {
-      const text = String(node?.text || "").replace(/^['"]|['"]$/g, "");
-      return (text.match(/[A-Za-z_]\w*/) || [])[0] || "";
-    };
-
-    for (const cap of caps(grammar, `(parameters (identifier) @param) (typed_parameter) @typed`, tree.rootNode)) {
-      const line = cap.node.startPosition.row + 1;
-      const caller = enclosing(fileRel, line);
-      if (!caller) continue;
-      if (cap.name === "param") {
-        shadows.add(scopeKey(caller, cap.node.text));
-        continue;
-      }
-      const name = cap.node.namedChildren.find((child) => child.type === "identifier")?.text;
-      if (!name) continue;
-      shadows.add(scopeKey(caller, name));
-      bind(caller, name, classInfo(typeName(field(cap.node, "type"))));
-    }
-    for (const cap of caps(grammar, `(assignment) @assign`, tree.rootNode)) {
-      const assignment = cap.node;
-      const caller = enclosing(fileRel, assignment.startPosition.row + 1);
-      if (!caller) continue;
-      const left = field(assignment, "left");
-      const right = field(assignment, "right");
-      let receiver = "";
-      if (left?.type === "identifier") receiver = left.text;
-      else if (left?.type === "attribute") receiver = left.text;
-      if (!receiver) continue;
-      shadows.add(scopeKey(caller, receiver));
-      const annotation = typeName(field(assignment, "type"));
-      const constructor = right?.type === "call" && field(right, "function")?.type === "identifier"
-        ? field(right, "function").text : "";
-      bind(caller, receiver, classInfo(annotation || constructor));
-    }
-
-    for (const cap of caps(grammar, `(call function: (identifier) @callee)`, tree.rootNode)) {
-      const line = cap.node.startPosition.row + 1;
-      const caller = enclosing(fileRel, line);
-      if (!caller || shadows.has(scopeKey(caller, cap.node.text))) continue;
-      let target = resolveCall(cap.node.text, fileRel);
-      if (target && nodeById.get(target)?.member_of) target = null;
-      let evidence = "bare";
-      if (!target) {
-        const candidates = wildcardCandidates(cap.node.text);
-        if (candidates.length === 1) { target = candidates[0]; evidence = "wildcard-import"; }
-      }
-      addCall(caller, target, line, evidence);
-    }
-
-    for (const cap of caps(grammar, `(call function: (attribute) @attributeCall)`, tree.rootNode)) {
-      const attribute = cap.node;
-      const object = field(attribute, "object");
-      const member = field(attribute, "attribute");
-      if (!object || !member) continue;
-      const line = attribute.startPosition.row + 1;
-      const caller = enclosing(fileRel, line);
-      if (!caller) continue;
-      if (object.type === "identifier") {
-        const moduleImport = imports.get(object.text);
-        if (moduleImport?.targetFile && moduleImport.imported === "*" && !moduleImport.wildcard) {
-          addCall(caller, moduleSymbol(moduleImport.targetFile, member.text), line, "module-member");
-          continue;
-        }
-      }
-      let klass = null;
-      if (["self", "cls"].includes(object.text) && caller.memberOf) klass = classInfo(caller.memberOf);
-      if (!klass) klass = bindings.get(scopeKey(caller, object.text));
-      if (!klass && object.type === "call" && field(object, "function")?.type === "identifier") klass = classInfo(field(object, "function").text);
-      addCall(caller, klass && methodOf(klass, member.text), line, "receiver-type");
-    }
-  },
-};

package/src/graph/builder/lang-rust-calls.js

@@ -1,63 +0,0 @@
-// Rust scoped-call resolution (`Path::method()`), split from lang-rust.js. Resolved with the full
-// qualifier in hand so an external associated function (`OpenOptions::new()`, `Vec::from()`) never binds
-// its bare final name to an unrelated same-named function in the directory. Only heads with real evidence
-// produce an edge: crate/self/super anchors, `use`-bound names (including sibling-crate modules),
-// fully-qualified sibling crates, and local types whose exact impl method is indexed. A std/external
-// type head is left unresolved on purpose.
-
-// Symbol kinds that can own an associated function via `Type::method`.
-const TYPE_KINDS = new Set(["struct", "enum", "trait", "type", "union"]);
-
-// `pathParts` and `inlineAncestors` stay owned by lang-rust.js (pass 1 uses them too) and are passed in,
-// so this module never imports back from lang-rust.js.
-export function rustScopedCalls(ctx, { pathParts, inlineAncestors }) {
-  const { grammar, tree, fileRel, caps, enclosing, links, nodeById, importedLocals,
-          dirSymbols, resolveNamedSymbol, resolveRustMethod, resolveRustPath, resolveRustCratePath } = ctx;
-  const dir = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : "";
-  const localSyms = dirSymbols?.get(dir);
-  const emitCall = (node, target) => {
-    const caller = enclosing(fileRel, node.startPosition.row + 1);
-    if (caller && target && target !== caller.id) {
-      links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: node.startPosition.row + 1 });
-    }
-  };
-  for (const cap of caps(grammar, `(call_expression function: (scoped_identifier) @path)`, tree.rootNode)) {
-    const node = cap.node;
-    const segments = pathParts(node);
-    if (segments.length < 2) continue;
-    const head = segments[0];
-    const method = segments.at(-1);
-
-    if (["crate", "self", "super"].includes(head)) {
-      const resolved = resolveRustPath(fileRel, segments, { inlineModules: inlineAncestors(node), unqualified: false });
-      if (resolved) emitCall(node, resolveNamedSymbol(resolved.targetFile, method, "value"));
-      continue;
-    }
-
-    const bound = importedLocals?.get(fileRel)?.get(head);
-    if (bound?.targetFile) {
-      emitCall(node, resolveNamedSymbol(bound.targetFile, method, "value"));
-      continue;
-    }
-
-    const crateResolved = resolveRustCratePath ? resolveRustCratePath(head, segments.slice(1, -1)) : null;
-    if (crateResolved) {
-      emitCall(node, resolveNamedSymbol(crateResolved.targetFile, method, "value"));
-      continue;
-    }
-
-    // Local type's associated function: resolve the exact impl member. Nothing else (enum-variant
-    // construction, external types) has an indexed target, so it produces no edge.
-    const headId = localSyms?.get(head);
-    if (headId && TYPE_KINDS.has(nodeById.get(headId)?.symbol_kind)) {
-      emitCall(node, resolveRustMethod(dir, head, method));
-      continue;
-    }
-
-    // Head is a locally-declared outlined module used without `use` (`mod utils; utils::init()`), the
-    // dominant flat-file idiom. resolveRustPath matches only a REAL repo module file, so an external type
-    // head (OpenOptions, Vec) resolves to null and still produces no edge — no dir-scope mis-binding.
-    const modResolved = resolveRustPath?.(fileRel, segments.slice(0, -1), { inlineModules: inlineAncestors(node), unqualified: true });
-    if (modResolved) emitCall(node, resolveNamedSymbol(modResolved.targetFile, method, "value"));
-  }
-}