okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/graphify/extract.py

@@ -1,3277 +0,0 @@
-"""Deterministic structural extraction from source code using tree-sitter. Outputs nodes+edges dicts."""
-from __future__ import annotations
-import importlib
-import json
-import os
-import re
-import sys
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Callable, Any
-from .cache import load_cached, save_cached
-
-
-def _make_id(*parts: str) -> str:
-    """Build a stable node ID from one or more name parts."""
-    combined = "_".join(p.strip("_.") for p in parts if p)
-    cleaned = re.sub(r"[^a-zA-Z0-9]+", "_", combined)
-    return cleaned.strip("_").lower()
-
-
-# ── LanguageConfig dataclass ─────────────────────────────────────────────────
-
-@dataclass
-class LanguageConfig:
-    ts_module: str                                   # e.g. "tree_sitter_python"
-    ts_language_fn: str = "language"                 # attr to call: e.g. tslang.language()
-
-    class_types: frozenset = frozenset()
-    function_types: frozenset = frozenset()
-    import_types: frozenset = frozenset()
-    call_types: frozenset = frozenset()
-    static_prop_types: frozenset = frozenset()
-    helper_fn_names: frozenset = frozenset()
-    container_bind_methods: frozenset = frozenset()
-    event_listener_properties: frozenset = frozenset()
-
-    # Name extraction
-    name_field: str = "name"
-    name_fallback_child_types: tuple = ()
-
-    # Body detection
-    body_field: str = "body"
-    body_fallback_child_types: tuple = ()   # e.g. ("declaration_list", "compound_statement")
-
-    # Call name extraction
-    call_function_field: str = "function"           # field on call node for callee
-    call_accessor_node_types: frozenset = frozenset()  # member/attribute nodes
-    call_accessor_field: str = "attribute"          # field on accessor for method name
-
-    # Stop recursion at these types in walk_calls
-    function_boundary_types: frozenset = frozenset()
-
-    # Import handler: called for import nodes instead of generic handling
-    import_handler: Callable | None = None
-
-    # Optional custom name resolver for functions (C, C++ declarator unwrapping)
-    resolve_function_name_fn: Callable | None = None
-
-    # Extra label formatting for functions: if True, functions get "name()" label
-    function_label_parens: bool = True
-
-    # Extra walk hook called after generic dispatch (for JS arrow functions, C# namespaces, etc.)
-    extra_walk_fn: Callable | None = None
-
-
-# ── Generic helpers ───────────────────────────────────────────────────────────
-
-def _read_text(node, source: bytes) -> str:
-    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
-
-
-def _resolve_name(node, source: bytes, config: LanguageConfig) -> str | None:
-    """Get the name from a node using config.name_field, falling back to child types."""
-    if config.resolve_function_name_fn is not None:
-        # For C/C++ where the name is inside a declarator
-        return None  # caller handles this separately
-    n = node.child_by_field_name(config.name_field)
-    if n:
-        return _read_text(n, source)
-    for child in node.children:
-        if child.type in config.name_fallback_child_types:
-            return _read_text(child, source)
-    return None
-
-
-def _find_body(node, config: LanguageConfig):
-    """Find the body node using config.body_field, falling back to child types."""
-    b = node.child_by_field_name(config.body_field)
-    if b:
-        return b
-    for child in node.children:
-        if child.type in config.body_fallback_child_types:
-            return child
-    return None
-
-
-# ── Import handlers ───────────────────────────────────────────────────────────
-
-def _import_python(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    t = node.type
-    if t == "import_statement":
-        for child in node.children:
-            if child.type in ("dotted_name", "aliased_import"):
-                raw = _read_text(child, source)
-                module_name = raw.split(" as ")[0].strip().lstrip(".")
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-    elif t == "import_from_statement":
-        module_node = node.child_by_field_name("module_name")
-        if module_node:
-            raw = _read_text(module_node, source)
-            if raw.startswith("."):
-                # Relative import - resolve to full path so IDs match file node IDs
-                dots = len(raw) - len(raw.lstrip("."))
-                module_name = raw.lstrip(".")
-                base = Path(str_path).parent
-                for _ in range(dots - 1):
-                    base = base.parent
-                rel = (module_name.replace(".", "/") + ".py") if module_name else "__init__.py"
-                tgt_nid = _make_id(str(base / rel))
-            else:
-                tgt_nid = _make_id(raw)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports_from",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-
-
-def _import_js(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type == "string":
-            raw = _read_text(child, source).strip("'\"` ")
-            if not raw:
-                break
-            if raw.startswith("."):
-                # Relative import - resolve to full path so IDs match file node IDs
-                # normpath removes ".." segments so the ID matches the target file's own node ID
-                resolved = Path(os.path.normpath(Path(str_path).parent / raw))
-                # TypeScript ESM: imports written as .js but actual file is .ts/.tsx
-                if resolved.suffix == ".js":
-                    resolved = resolved.with_suffix(".ts")
-                elif resolved.suffix == ".jsx":
-                    resolved = resolved.with_suffix(".tsx")
-                tgt_nid = _make_id(str(resolved))
-            else:
-                # Bare/scoped import (node_modules) - use last segment; dropped as external
-                module_name = raw.split("/")[-1]
-                if not module_name:
-                    break
-                tgt_nid = _make_id(module_name)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports_from",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-            break
-
-
-def _import_java(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    def _walk_scoped(n) -> str:
-        parts: list[str] = []
-        cur = n
-        while cur:
-            if cur.type == "scoped_identifier":
-                name_node = cur.child_by_field_name("name")
-                if name_node:
-                    parts.append(_read_text(name_node, source))
-                cur = cur.child_by_field_name("scope")
-            elif cur.type == "identifier":
-                parts.append(_read_text(cur, source))
-                break
-            else:
-                break
-        parts.reverse()
-        return ".".join(parts)
-
-    for child in node.children:
-        if child.type in ("scoped_identifier", "identifier"):
-            path_str = _walk_scoped(child)
-            module_name = path_str.split(".")[-1].strip("*").strip(".") or (
-                path_str.split(".")[-2] if len(path_str.split(".")) > 1 else path_str
-            )
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_c(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type in ("string_literal", "system_lib_string", "string"):
-            raw = _read_text(child, source).strip('"<> ')
-            module_name = raw.split("/")[-1].split(".")[0]
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_csharp(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type in ("qualified_name", "identifier", "name_equals"):
-            raw = _read_text(child, source)
-            module_name = raw.split(".")[-1].strip()
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_kotlin(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    path_node = node.child_by_field_name("path")
-    if path_node:
-        raw = _read_text(path_node, source)
-        module_name = raw.split(".")[-1].strip()
-        if module_name:
-            tgt_nid = _make_id(module_name)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-        return
-    # Fallback: find identifier child
-    for child in node.children:
-        if child.type == "identifier":
-            raw = _read_text(child, source)
-            tgt_nid = _make_id(raw)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-            break
-
-
-def _import_scala(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type in ("stable_id", "identifier"):
-            raw = _read_text(child, source)
-            module_name = raw.split(".")[-1].strip("{} ")
-            if module_name and module_name != "_":
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_php(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type in ("qualified_name", "name", "identifier"):
-            raw = _read_text(child, source)
-            module_name = raw.split("\\")[-1].strip()
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-# ── C/C++ function name helpers ───────────────────────────────────────────────
-
-def _get_c_func_name(node, source: bytes) -> str | None:
-    """Recursively unwrap declarator to find the innermost identifier (C)."""
-    if node.type == "identifier":
-        return _read_text(node, source)
-    decl = node.child_by_field_name("declarator")
-    if decl:
-        return _get_c_func_name(decl, source)
-    for child in node.children:
-        if child.type == "identifier":
-            return _read_text(child, source)
-    return None
-
-
-def _get_cpp_func_name(node, source: bytes) -> str | None:
-    """Recursively unwrap declarator to find the innermost identifier (C++)."""
-    if node.type == "identifier":
-        return _read_text(node, source)
-    if node.type == "qualified_identifier":
-        name_node = node.child_by_field_name("name")
-        if name_node:
-            return _read_text(name_node, source)
-    decl = node.child_by_field_name("declarator")
-    if decl:
-        return _get_cpp_func_name(decl, source)
-    for child in node.children:
-        if child.type == "identifier":
-            return _read_text(child, source)
-    return None
-
-
-# ── JS/TS extra walk for arrow functions ──────────────────────────────────────
-
-def _js_extra_walk(node, source: bytes, file_nid: str, stem: str, str_path: str,
-                   nodes: list, edges: list, seen_ids: set, function_bodies: list,
-                   parent_class_nid: str | None, add_node_fn, add_edge_fn) -> bool:
-    """Handle lexical_declaration (arrow functions) for JS/TS. Returns True if handled."""
-    if node.type == "lexical_declaration":
-        for child in node.children:
-            if child.type == "variable_declarator":
-                value = child.child_by_field_name("value")
-                if value and value.type == "arrow_function":
-                    name_node = child.child_by_field_name("name")
-                    if name_node:
-                        func_name = _read_text(name_node, source)
-                        line = child.start_point[0] + 1
-                        func_nid = _make_id(stem, func_name)
-                        add_node_fn(func_nid, f"{func_name}()", line)
-                        add_edge_fn(file_nid, func_nid, "contains", line)
-                        body = value.child_by_field_name("body")
-                        if body:
-                            function_bodies.append((func_nid, body))
-        return True
-    return False
-
-
-# ── C# extra walk for namespace declarations ──────────────────────────────────
-
-def _csharp_extra_walk(node, source: bytes, file_nid: str, stem: str, str_path: str,
-                       nodes: list, edges: list, seen_ids: set, function_bodies: list,
-                       parent_class_nid: str | None, add_node_fn, add_edge_fn,
-                       walk_fn) -> bool:
-    """Handle namespace_declaration for C#. Returns True if handled."""
-    if node.type == "namespace_declaration":
-        name_node = node.child_by_field_name("name")
-        if name_node:
-            ns_name = _read_text(name_node, source)
-            ns_nid = _make_id(stem, ns_name)
-            line = node.start_point[0] + 1
-            add_node_fn(ns_nid, ns_name, line)
-            add_edge_fn(file_nid, ns_nid, "contains", line)
-        body = node.child_by_field_name("body")
-        if body:
-            for child in body.children:
-                walk_fn(child, parent_class_nid)
-        return True
-    return False
-
-
-# ── Swift extra walk for enum cases ──────────────────────────────────────────
-
-def _swift_extra_walk(node, source: bytes, file_nid: str, stem: str, str_path: str,
-                      nodes: list, edges: list, seen_ids: set, function_bodies: list,
-                      parent_class_nid: str | None, add_node_fn, add_edge_fn) -> bool:
-    """Handle enum_entry for Swift. Returns True if handled."""
-    if node.type == "enum_entry" and parent_class_nid:
-        for child in node.children:
-            if child.type == "simple_identifier":
-                case_name = _read_text(child, source)
-                case_nid = _make_id(parent_class_nid, case_name)
-                line = node.start_point[0] + 1
-                add_node_fn(case_nid, case_name, line)
-                add_edge_fn(parent_class_nid, case_nid, "case_of", line)
-        return True
-    return False
-
-
-# ── Language configs ──────────────────────────────────────────────────────────
-
-_PYTHON_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_python",
-    class_types=frozenset({"class_definition"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"import_statement", "import_from_statement"}),
-    call_types=frozenset({"call"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"attribute"}),
-    call_accessor_field="attribute",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_python,
-)
-
-_JS_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_javascript",
-    class_types=frozenset({"class_declaration"}),
-    function_types=frozenset({"function_declaration", "method_definition"}),
-    import_types=frozenset({"import_statement"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_expression"}),
-    call_accessor_field="property",
-    function_boundary_types=frozenset({"function_declaration", "arrow_function", "method_definition"}),
-    import_handler=_import_js,
-)
-
-_TS_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_typescript",
-    ts_language_fn="language_typescript",
-    class_types=frozenset({"class_declaration"}),
-    function_types=frozenset({"function_declaration", "method_definition"}),
-    import_types=frozenset({"import_statement"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_expression"}),
-    call_accessor_field="property",
-    function_boundary_types=frozenset({"function_declaration", "arrow_function", "method_definition"}),
-    import_handler=_import_js,
-)
-
-_JAVA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_java",
-    class_types=frozenset({"class_declaration", "interface_declaration"}),
-    function_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"method_invocation"}),
-    call_function_field="name",
-    call_accessor_node_types=frozenset(),
-    function_boundary_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_handler=_import_java,
-)
-
-_C_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_c",
-    class_types=frozenset(),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"preproc_include"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"field_expression"}),
-    call_accessor_field="field",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_c,
-    resolve_function_name_fn=_get_c_func_name,
-)
-
-_CPP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_cpp",
-    class_types=frozenset({"class_specifier"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"preproc_include"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"field_expression", "qualified_identifier"}),
-    call_accessor_field="field",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_c,
-    resolve_function_name_fn=_get_cpp_func_name,
-)
-
-_RUBY_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_ruby",
-    class_types=frozenset({"class"}),
-    function_types=frozenset({"method", "singleton_method"}),
-    import_types=frozenset(),
-    call_types=frozenset({"call"}),
-    call_function_field="method",
-    call_accessor_node_types=frozenset(),
-    name_fallback_child_types=("constant", "scope_resolution", "identifier"),
-    body_fallback_child_types=("body_statement",),
-    function_boundary_types=frozenset({"method", "singleton_method"}),
-)
-
-_CSHARP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_c_sharp",
-    class_types=frozenset({"class_declaration", "interface_declaration"}),
-    function_types=frozenset({"method_declaration"}),
-    import_types=frozenset({"using_directive"}),
-    call_types=frozenset({"invocation_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_access_expression"}),
-    call_accessor_field="name",
-    body_fallback_child_types=("declaration_list",),
-    function_boundary_types=frozenset({"method_declaration"}),
-    import_handler=_import_csharp,
-)
-
-_KOTLIN_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_kotlin",
-    class_types=frozenset({"class_declaration", "object_declaration"}),
-    function_types=frozenset({"function_declaration"}),
-    import_types=frozenset({"import_header"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"navigation_expression"}),
-    call_accessor_field="",
-    name_fallback_child_types=("simple_identifier",),
-    body_fallback_child_types=("function_body", "class_body"),
-    function_boundary_types=frozenset({"function_declaration"}),
-    import_handler=_import_kotlin,
-)
-
-_SCALA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_scala",
-    class_types=frozenset({"class_definition", "object_definition"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"field_expression"}),
-    call_accessor_field="field",
-    name_fallback_child_types=("identifier",),
-    body_fallback_child_types=("template_body",),
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_scala,
-)
-
-_PHP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_php",
-    ts_language_fn="language_php",
-    class_types=frozenset({"class_declaration"}),
-    function_types=frozenset({"function_definition", "method_declaration"}),
-    import_types=frozenset({"namespace_use_clause"}),
-    call_types=frozenset({"function_call_expression", "member_call_expression", "scoped_call_expression", "class_constant_access_expression"}),
-    static_prop_types=frozenset({"scoped_property_access_expression"}),
-    helper_fn_names=frozenset({"config"}),
-    container_bind_methods=frozenset({"bind", "singleton", "scoped", "instance"}),
-    event_listener_properties=frozenset({"listen", "subscribe"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_call_expression"}),
-    call_accessor_field="name",
-    name_fallback_child_types=("name",),
-    body_fallback_child_types=("declaration_list", "compound_statement"),
-    function_boundary_types=frozenset({"function_definition", "method_declaration"}),
-    import_handler=_import_php,
-)
-
-
-def _import_lua(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    """Extract require('module') from Lua variable_declaration nodes."""
-    text = _read_text(node, source)
-    import re
-    m = re.search(r"""require\s*[\('"]\s*['"]?([^'")\s]+)""", text)
-    if m:
-        module_name = m.group(1).split(".")[-1]
-        if module_name:
-            edges.append({
-                "source": file_nid,
-                "target": module_name,
-                "relation": "imports",
-                "confidence": "EXTRACTED",
-                "confidence_score": 1.0,
-                "source_file": str_path,
-                "source_location": str(node.start_point[0] + 1),
-                "weight": 1.0,
-            })
-
-
-_LUA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_lua",
-    ts_language_fn="language",
-    class_types=frozenset(),
-    function_types=frozenset({"function_declaration"}),
-    import_types=frozenset({"variable_declaration"}),
-    call_types=frozenset({"function_call"}),
-    call_function_field="name",
-    call_accessor_node_types=frozenset({"method_index_expression"}),
-    call_accessor_field="name",
-    name_fallback_child_types=("identifier", "method_index_expression"),
-    body_fallback_child_types=("block",),
-    function_boundary_types=frozenset({"function_declaration"}),
-    import_handler=_import_lua,
-)
-
-
-def _import_swift(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str) -> None:
-    for child in node.children:
-        if child.type == "identifier":
-            raw = _read_text(child, source)
-            tgt_nid = _make_id(raw)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-            break
-
-
-_SWIFT_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_swift",
-    class_types=frozenset({"class_declaration", "protocol_declaration"}),
-    function_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"navigation_expression"}),
-    call_accessor_field="",
-    name_fallback_child_types=("simple_identifier", "type_identifier", "user_type"),
-    body_fallback_child_types=("class_body", "protocol_body", "function_body", "enum_class_body"),
-    function_boundary_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
-    import_handler=_import_swift,
-)
-
-
-# ── Generic extractor ─────────────────────────────────────────────────────────
-
-def _extract_generic(path: Path, config: LanguageConfig) -> dict:
-    """Generic AST extractor driven by LanguageConfig."""
-    try:
-        mod = importlib.import_module(config.ts_module)
-        from tree_sitter import Language, Parser
-        lang_fn = getattr(mod, config.ts_language_fn, None)
-        if lang_fn is None:
-            # Fallback for PHP: try "language_php" then "language"
-            lang_fn = getattr(mod, "language", None)
-        if lang_fn is None:
-            return {"nodes": [], "edges": [], "error": f"No language function in {config.ts_module}"}
-        language = Language(lang_fn())
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": f"{config.ts_module} not installed"}
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    try:
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, object]] = []
-    pending_listen_edges: list[tuple[str, str, int]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid,
-                "label": label,
-                "file_type": "code",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({
-            "source": src,
-            "target": tgt,
-            "relation": relation,
-            "confidence": confidence,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": weight,
-        })
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def walk(node, parent_class_nid: str | None = None) -> None:
-        t = node.type
-
-        # Import types
-        if t in config.import_types:
-            if config.import_handler:
-                config.import_handler(node, source, file_nid, stem, edges, str_path)
-            return
-
-        # Class types
-        if t in config.class_types:
-            # Resolve class name
-            name_node = node.child_by_field_name(config.name_field)
-            if name_node is None:
-                for child in node.children:
-                    if child.type in config.name_fallback_child_types:
-                        name_node = child
-                        break
-            if not name_node:
-                return
-            class_name = _read_text(name_node, source)
-            class_nid = _make_id(stem, class_name)
-            line = node.start_point[0] + 1
-            add_node(class_nid, class_name, line)
-            add_edge(file_nid, class_nid, "contains", line)
-
-            # Python-specific: inheritance
-            if config.ts_module == "tree_sitter_python":
-                args = node.child_by_field_name("superclasses")
-                if args:
-                    for arg in args.children:
-                        if arg.type == "identifier":
-                            base = _read_text(arg, source)
-                            base_nid = _make_id(stem, base)
-                            if base_nid not in seen_ids:
-                                base_nid = _make_id(base)
-                                if base_nid not in seen_ids:
-                                    nodes.append({
-                                        "id": base_nid,
-                                        "label": base,
-                                        "file_type": "code",
-                                        "source_file": "",
-                                        "source_location": "",
-                                    })
-                                    seen_ids.add(base_nid)
-                            add_edge(class_nid, base_nid, "inherits", line)
-
-            # Swift-specific: conformance / inheritance
-            if config.ts_module == "tree_sitter_swift":
-                for child in node.children:
-                    if child.type == "inheritance_specifier":
-                        for sub in child.children:
-                            if sub.type in ("user_type", "type_identifier"):
-                                base = _read_text(sub, source)
-                                base_nid = _make_id(stem, base)
-                                if base_nid not in seen_ids:
-                                    base_nid = _make_id(base)
-                                    if base_nid not in seen_ids:
-                                        nodes.append({
-                                            "id": base_nid,
-                                            "label": base,
-                                            "file_type": "code",
-                                            "source_file": "",
-                                            "source_location": "",
-                                        })
-                                        seen_ids.add(base_nid)
-                                add_edge(class_nid, base_nid, "inherits", line)
-
-            # C#-specific: inheritance / interface implementation via base_list
-            if config.ts_module == "tree_sitter_c_sharp":
-                for child in node.children:
-                    if child.type == "base_list":
-                        for sub in child.children:
-                            if sub.type in ("identifier", "generic_name"):
-                                if sub.type == "generic_name":
-                                    name_child = sub.child_by_field_name("name")
-                                    base = _read_text(name_child, source) if name_child else _read_text(sub.children[0], source)
-                                else:
-                                    base = _read_text(sub, source)
-                                base_nid = _make_id(stem, base)
-                                if base_nid not in seen_ids:
-                                    base_nid = _make_id(base)
-                                    if base_nid not in seen_ids:
-                                        nodes.append({
-                                            "id": base_nid,
-                                            "label": base,
-                                            "file_type": "code",
-                                            "source_file": "",
-                                            "source_location": "",
-                                        })
-                                        seen_ids.add(base_nid)
-                                add_edge(class_nid, base_nid, "inherits", line)
-
-            # Find body and recurse
-            body = _find_body(node, config)
-            if body:
-                for child in body.children:
-                    walk(child, parent_class_nid=class_nid)
-            return
-
-        # Event listener property arrays: $listen = [Event::class => [Listener::class]]
-        if (t == "property_declaration"
-                and parent_class_nid
-                and config.event_listener_properties):
-            for element in node.children:
-                if element.type != "property_element":
-                    continue
-                prop_name: str | None = None
-                array_node = None
-                for c in element.children:
-                    if c.type == "variable_name":
-                        for sc in c.children:
-                            if sc.type == "name":
-                                prop_name = _read_text(sc, source)
-                                break
-                    elif c.type == "array_creation_expression":
-                        array_node = c
-                if (prop_name is None
-                        or prop_name not in config.event_listener_properties
-                        or array_node is None):
-                    continue
-                for entry in array_node.children:
-                    if entry.type != "array_element_initializer":
-                        continue
-                    event_cls: str | None = None
-                    listener_arr = None
-                    for sub in entry.children:
-                        if sub.type == "class_constant_access_expression" and event_cls is None:
-                            for sc in sub.children:
-                                if sc.is_named and sc.type in ("name", "qualified_name"):
-                                    event_cls = _read_text(sc, source)
-                                    break
-                        elif sub.type == "array_creation_expression":
-                            listener_arr = sub
-                    if not event_cls or listener_arr is None:
-                        continue
-                    for listener_entry in listener_arr.children:
-                        if listener_entry.type != "array_element_initializer":
-                            continue
-                        for item in listener_entry.children:
-                            if item.type != "class_constant_access_expression":
-                                continue
-                            for sc in item.children:
-                                if sc.is_named and sc.type in ("name", "qualified_name"):
-                                    listener_cls = _read_text(sc, source)
-                                    line_no = item.start_point[0] + 1
-                                    pending_listen_edges.append((event_cls, listener_cls, line_no))
-                                    break
-                            break
-            return
-
-        # Function types
-        if t in config.function_types:
-            # Swift deinit/subscript have no name field — resolve before generic fallback
-            if t == "deinit_declaration":
-                func_name: str | None = "deinit"
-            elif t == "subscript_declaration":
-                func_name = "subscript"
-            elif config.resolve_function_name_fn is not None:
-                # C/C++ style: use declarator
-                declarator = node.child_by_field_name("declarator")
-                func_name = None
-                if declarator:
-                    func_name = config.resolve_function_name_fn(declarator, source)
-            else:
-                name_node = node.child_by_field_name(config.name_field)
-                if name_node is None:
-                    for child in node.children:
-                        if child.type in config.name_fallback_child_types:
-                            name_node = child
-                            break
-                func_name = _read_text(name_node, source) if name_node else None
-
-            if not func_name:
-                return
-
-            line = node.start_point[0] + 1
-            if parent_class_nid:
-                func_nid = _make_id(parent_class_nid, func_name)
-                add_node(func_nid, f".{func_name}()", line)
-                add_edge(parent_class_nid, func_nid, "method", line)
-            else:
-                func_nid = _make_id(stem, func_name)
-                add_node(func_nid, f"{func_name}()", line)
-                add_edge(file_nid, func_nid, "contains", line)
-
-            body = _find_body(node, config)
-            if body:
-                function_bodies.append((func_nid, body))
-            return
-
-        # JS/TS arrow functions and C# namespaces — language-specific extra handling
-        if config.ts_module in ("tree_sitter_javascript", "tree_sitter_typescript"):
-            if _js_extra_walk(node, source, file_nid, stem, str_path,
-                              nodes, edges, seen_ids, function_bodies,
-                              parent_class_nid, add_node, add_edge):
-                return
-
-        if config.ts_module == "tree_sitter_c_sharp":
-            if _csharp_extra_walk(node, source, file_nid, stem, str_path,
-                                   nodes, edges, seen_ids, function_bodies,
-                                   parent_class_nid, add_node, add_edge, walk):
-                return
-
-        if config.ts_module == "tree_sitter_swift":
-            if _swift_extra_walk(node, source, file_nid, stem, str_path,
-                                  nodes, edges, seen_ids, function_bodies,
-                                  parent_class_nid, add_node, add_edge):
-                return
-
-        # Default: recurse
-        for child in node.children:
-            walk(child, parent_class_nid=None)
-
-    walk(root)
-
-    # ── Call-graph pass ───────────────────────────────────────────────────────
-    label_to_nid: dict[str, str] = {}
-    for n in nodes:
-        raw = n["label"]
-        normalised = raw.strip("()").lstrip(".")
-        label_to_nid[normalised.lower()] = n["id"]
-
-    seen_call_pairs: set[tuple[str, str]] = set()
-    seen_static_ref_pairs: set[tuple[str, str, str]] = set()
-    seen_helper_ref_pairs: set[tuple[str, str, str]] = set()
-    seen_bind_pairs: set[tuple[str, str, str]] = set()
-    raw_calls: list[dict] = []  # unresolved calls for cross-file resolution in extract()
-
-    def _php_class_const_scope(n) -> str | None:
-        scope = n.child_by_field_name("scope")
-        if scope is None:
-            for c in n.children:
-                if c.is_named and c.type in ("name", "qualified_name", "identifier"):
-                    scope = c
-                    break
-        if scope is None:
-            return None
-        return _read_text(scope, source)
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type in config.function_boundary_types:
-            return
-
-        if node.type in config.call_types:
-            callee_name: str | None = None
-
-            # Special handling per language
-            if config.ts_module == "tree_sitter_swift":
-                # Swift: first child may be simple_identifier or navigation_expression
-                first = node.children[0] if node.children else None
-                if first:
-                    if first.type == "simple_identifier":
-                        callee_name = _read_text(first, source)
-                    elif first.type == "navigation_expression":
-                        for child in first.children:
-                            if child.type == "navigation_suffix":
-                                for sc in child.children:
-                                    if sc.type == "simple_identifier":
-                                        callee_name = _read_text(sc, source)
-            elif config.ts_module == "tree_sitter_kotlin":
-                # Kotlin: first child may be simple_identifier or navigation_expression
-                first = node.children[0] if node.children else None
-                if first:
-                    if first.type == "simple_identifier":
-                        callee_name = _read_text(first, source)
-                    elif first.type == "navigation_expression":
-                        for child in reversed(first.children):
-                            if child.type == "simple_identifier":
-                                callee_name = _read_text(child, source)
-                                break
-            elif config.ts_module == "tree_sitter_scala":
-                # Scala: first child
-                first = node.children[0] if node.children else None
-                if first:
-                    if first.type == "identifier":
-                        callee_name = _read_text(first, source)
-                    elif first.type == "field_expression":
-                        field = first.child_by_field_name("field")
-                        if field:
-                            callee_name = _read_text(field, source)
-                        else:
-                            for child in reversed(first.children):
-                                if child.type == "identifier":
-                                    callee_name = _read_text(child, source)
-                                    break
-            elif config.ts_module == "tree_sitter_c_sharp" and node.type == "invocation_expression":
-                # C#: try name field, then first named child
-                name_node = node.child_by_field_name("name")
-                if name_node:
-                    callee_name = _read_text(name_node, source)
-                else:
-                    for child in node.children:
-                        if child.is_named:
-                            raw = _read_text(child, source)
-                            if "." in raw:
-                                callee_name = raw.split(".")[-1]
-                            else:
-                                callee_name = raw
-                            break
-            elif config.ts_module == "tree_sitter_php":
-                # PHP: distinguish call expression subtypes
-                if node.type == "function_call_expression":
-                    func_node = node.child_by_field_name("function")
-                    if func_node:
-                        callee_name = _read_text(func_node, source)
-                elif node.type == "scoped_call_expression":
-                    # Static method call: Helper::format() → callee = "Helper"
-                    scope_node = node.child_by_field_name("scope")
-                    if scope_node:
-                        callee_name = _read_text(scope_node, source)
-                else:
-                    name_node = node.child_by_field_name("name")
-                    if name_node:
-                        callee_name = _read_text(name_node, source)
-            elif config.ts_module == "tree_sitter_cpp":
-                # C++: function field, then field_expression/qualified_identifier
-                func_node = node.child_by_field_name(config.call_function_field) if config.call_function_field else None
-                if func_node:
-                    if func_node.type == "identifier":
-                        callee_name = _read_text(func_node, source)
-                    elif func_node.type in ("field_expression", "qualified_identifier"):
-                        name = func_node.child_by_field_name("field") or func_node.child_by_field_name("name")
-                        if name:
-                            callee_name = _read_text(name, source)
-            else:
-                # Generic: get callee from call_function_field
-                func_node = node.child_by_field_name(config.call_function_field) if config.call_function_field else None
-                if func_node:
-                    if func_node.type == "identifier":
-                        callee_name = _read_text(func_node, source)
-                    elif func_node.type in config.call_accessor_node_types:
-                        if config.call_accessor_field:
-                            attr = func_node.child_by_field_name(config.call_accessor_field)
-                            if attr:
-                                callee_name = _read_text(attr, source)
-                    else:
-                        # Try reading the node directly (e.g. Java name field is the callee)
-                        callee_name = _read_text(func_node, source)
-
-            if callee_name:
-                tgt_nid = label_to_nid.get(callee_name.lower())
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair = (caller_nid, tgt_nid)
-                    if pair not in seen_call_pairs:
-                        seen_call_pairs.add(pair)
-                        line = node.start_point[0] + 1
-                        edges.append({
-                            "source": caller_nid,
-                            "target": tgt_nid,
-                            "relation": "calls",
-                            "confidence": "EXTRACTED",
-                            "source_file": str_path,
-                            "source_location": f"L{line}",
-                            "weight": 1.0,
-                        })
-                elif callee_name and not tgt_nid:
-                    # Callee not in this file — save for cross-file resolution in extract()
-                    raw_calls.append({
-                        "caller_nid": caller_nid,
-                        "callee": callee_name,
-                        "source_file": str_path,
-                        "source_location": f"L{node.start_point[0] + 1}",
-                    })
-
-            # Helper function calls: config('foo.bar') → uses_config edge to "foo"
-            if (callee_name and callee_name in config.helper_fn_names):
-                args_node = node.child_by_field_name("arguments")
-                first_key: str | None = None
-                if args_node:
-                    for arg in args_node.children:
-                        if arg.type != "argument":
-                            continue
-                        for inner in arg.children:
-                            if inner.type == "string":
-                                for sc in inner.children:
-                                    if sc.type == "string_content":
-                                        first_key = _read_text(sc, source)
-                                        break
-                                break
-                        if first_key:
-                            break
-                if first_key:
-                    segment = first_key.split(".")[0]
-                    tgt_nid = (label_to_nid.get(segment.lower())
-                               or label_to_nid.get(f"{segment}.php".lower()))
-                    if tgt_nid and tgt_nid != caller_nid:
-                        relation = f"uses_{callee_name}"
-                        pair3 = (caller_nid, tgt_nid, relation)
-                        if pair3 not in seen_helper_ref_pairs:
-                            seen_helper_ref_pairs.add(pair3)
-                            line = node.start_point[0] + 1
-                            edges.append({
-                                "source": caller_nid,
-                                "target": tgt_nid,
-                                "relation": relation,
-                                "confidence": "EXTRACTED",
-                                "confidence_score": 1.0,
-                                "source_file": str_path,
-                                "source_location": f"L{line}",
-                                "weight": 1.0,
-                            })
-
-            # Service container bindings: $this->app->bind(Foo::class, Bar::class)
-            if (node.type == "member_call_expression"
-                    and callee_name
-                    and callee_name in config.container_bind_methods):
-                args_node = node.child_by_field_name("arguments")
-                class_args: list[str] = []
-                if args_node:
-                    for arg in args_node.children:
-                        if arg.type != "argument":
-                            continue
-                        for inner in arg.children:
-                            if inner.type == "class_constant_access_expression":
-                                cls = _php_class_const_scope(inner)
-                                if cls:
-                                    class_args.append(cls)
-                                break
-                        if len(class_args) >= 2:
-                            break
-                if len(class_args) == 2:
-                    contract_name, impl_name = class_args
-                    contract_nid = label_to_nid.get(contract_name.lower())
-                    impl_nid = label_to_nid.get(impl_name.lower())
-                    if contract_nid and impl_nid and contract_nid != impl_nid:
-                        pair3 = (contract_nid, impl_nid, "bound_to")
-                        if pair3 not in seen_bind_pairs:
-                            seen_bind_pairs.add(pair3)
-                            line = node.start_point[0] + 1
-                            edges.append({
-                                "source": contract_nid,
-                                "target": impl_nid,
-                                "relation": "bound_to",
-                                "confidence": "EXTRACTED",
-                                "confidence_score": 1.0,
-                                "source_file": str_path,
-                                "source_location": f"L{line}",
-                                "weight": 1.0,
-                            })
-
-        # Static property access: Foo::$bar → uses_static_prop edge
-        if node.type in config.static_prop_types:
-            scope_node = node.child_by_field_name("scope")
-            if scope_node is None:
-                for child in node.children:
-                    if child.is_named and child.type in ("name", "qualified_name", "identifier"):
-                        scope_node = child
-                        break
-            if scope_node is not None:
-                class_name = _read_text(scope_node, source)
-                tgt_nid = label_to_nid.get(class_name.lower())
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair3 = (caller_nid, tgt_nid, "uses_static_prop")
-                    if pair3 not in seen_static_ref_pairs:
-                        seen_static_ref_pairs.add(pair3)
-                        line = node.start_point[0] + 1
-                        edges.append({
-                            "source": caller_nid,
-                            "target": tgt_nid,
-                            "relation": "uses_static_prop",
-                            "confidence": "EXTRACTED",
-                            "confidence_score": 1.0,
-                            "source_file": str_path,
-                            "source_location": f"L{line}",
-                            "weight": 1.0,
-                        })
-
-        # PHP class constant access: Foo::BAR → references_constant edge
-        if config.ts_module == "tree_sitter_php" and node.type == "class_constant_access_expression":
-            class_name = _php_class_const_scope(node)
-            if class_name:
-                tgt_nid = label_to_nid.get(class_name.lower())
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair3 = (caller_nid, tgt_nid, "references_constant")
-                    if pair3 not in seen_static_ref_pairs:
-                        seen_static_ref_pairs.add(pair3)
-                        line = node.start_point[0] + 1
-                        edges.append({
-                            "source": caller_nid,
-                            "target": tgt_nid,
-                            "relation": "references_constant",
-                            "confidence": "EXTRACTED",
-                            "confidence_score": 1.0,
-                            "source_file": str_path,
-                            "source_location": f"L{line}",
-                            "weight": 1.0,
-                        })
-
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body_node in function_bodies:
-        walk_calls(body_node, caller_nid)
-
-    # ── Event listener pass ───────────────────────────────────────────────────
-    seen_listen_pairs: set[tuple[str, str]] = set()
-    for event_name, listener_name, line in pending_listen_edges:
-        event_nid = label_to_nid.get(event_name.lower())
-        listener_nid = label_to_nid.get(listener_name.lower())
-        if not event_nid or not listener_nid or event_nid == listener_nid:
-            continue
-        pair2 = (event_nid, listener_nid)
-        if pair2 in seen_listen_pairs:
-            continue
-        seen_listen_pairs.add(pair2)
-        edges.append({
-            "source": event_nid,
-            "target": listener_nid,
-            "relation": "listened_by",
-            "confidence": "EXTRACTED",
-            "confidence_score": 1.0,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    # ── Clean edges ───────────────────────────────────────────────────────────
-    valid_ids = seen_ids
-    clean_edges = []
-    for edge in edges:
-        src, tgt = edge["source"], edge["target"]
-        if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):
-            clean_edges.append(edge)
-
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
-
-
-# ── Python rationale extraction ───────────────────────────────────────────────
-
-_RATIONALE_PREFIXES = ("# NOTE:", "# IMPORTANT:", "# HACK:", "# WHY:", "# RATIONALE:", "# TODO:", "# FIXME:")
-
-
-def _extract_python_rationale(path: Path, result: dict) -> None:
-    """Post-pass: extract docstrings and rationale comments from Python source.
-    Mutates result in-place by appending to result['nodes'] and result['edges'].
-    """
-    try:
-        import tree_sitter_python as tspython
-        from tree_sitter import Language, Parser
-        language = Language(tspython.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception:
-        return
-
-    stem = path.stem
-    str_path = str(path)
-    nodes = result["nodes"]
-    edges = result["edges"]
-    seen_ids = {n["id"] for n in nodes}
-    file_nid = _make_id(str(path))
-
-    def _get_docstring(body_node) -> tuple[str, int] | None:
-        if not body_node:
-            return None
-        for child in body_node.children:
-            if child.type == "expression_statement":
-                for sub in child.children:
-                    if sub.type in ("string", "concatenated_string"):
-                        text = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
-                        text = text.strip("\"'").strip('"""').strip("'''").strip()
-                        if len(text) > 20:
-                            return text, child.start_point[0] + 1
-            break
-        return None
-
-    def _add_rationale(text: str, line: int, parent_nid: str) -> None:
-        label = text[:80].replace("\r\n", " ").replace("\r", " ").replace("\n", " ").strip()
-        rid = _make_id(stem, "rationale", str(line))
-        if rid not in seen_ids:
-            seen_ids.add(rid)
-            nodes.append({
-                "id": rid,
-                "label": label,
-                "file_type": "rationale",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-        edges.append({
-            "source": rid,
-            "target": parent_nid,
-            "relation": "rationale_for",
-            "confidence": "EXTRACTED",
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    # Module-level docstring
-    ds = _get_docstring(root)
-    if ds:
-        _add_rationale(ds[0], ds[1], file_nid)
-
-    # Class and function docstrings
-    def walk_docstrings(node, parent_nid: str) -> None:
-        t = node.type
-        if t == "class_definition":
-            name_node = node.child_by_field_name("name")
-            body = node.child_by_field_name("body")
-            if name_node and body:
-                class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
-                nid = _make_id(stem, class_name)
-                ds = _get_docstring(body)
-                if ds:
-                    _add_rationale(ds[0], ds[1], nid)
-                for child in body.children:
-                    walk_docstrings(child, nid)
-            return
-        if t == "function_definition":
-            name_node = node.child_by_field_name("name")
-            body = node.child_by_field_name("body")
-            if name_node and body:
-                func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
-                nid = _make_id(parent_nid, func_name) if parent_nid != file_nid else _make_id(stem, func_name)
-                ds = _get_docstring(body)
-                if ds:
-                    _add_rationale(ds[0], ds[1], nid)
-            return
-        for child in node.children:
-            walk_docstrings(child, parent_nid)
-
-    walk_docstrings(root, file_nid)
-
-    # Rationale comments (# NOTE:, # IMPORTANT:, etc.)
-    source_text = source.decode("utf-8", errors="replace")
-    for lineno, line_text in enumerate(source_text.splitlines(), start=1):
-        stripped = line_text.strip()
-        if any(stripped.startswith(p) for p in _RATIONALE_PREFIXES):
-            _add_rationale(stripped, lineno, file_nid)
-
-
-# ── Public API ────────────────────────────────────────────────────────────────
-
-def extract_python(path: Path) -> dict:
-    """Extract classes, functions, and imports from a .py file via tree-sitter AST."""
-    result = _extract_generic(path, _PYTHON_CONFIG)
-    if "error" not in result:
-        _extract_python_rationale(path, result)
-    return result
-
-
-def extract_js(path: Path) -> dict:
-    """Extract classes, functions, arrow functions, and imports from a .js/.ts/.tsx file."""
-    config = _TS_CONFIG if path.suffix in (".ts", ".tsx") else _JS_CONFIG
-    return _extract_generic(path, config)
-
-
-def extract_java(path: Path) -> dict:
-    """Extract classes, interfaces, methods, constructors, and imports from a .java file."""
-    return _extract_generic(path, _JAVA_CONFIG)
-
-
-def extract_c(path: Path) -> dict:
-    """Extract functions and includes from a .c/.h file."""
-    return _extract_generic(path, _C_CONFIG)
-
-
-def extract_cpp(path: Path) -> dict:
-    """Extract functions, classes, and includes from a .cpp/.cc/.cxx/.hpp file."""
-    return _extract_generic(path, _CPP_CONFIG)
-
-
-def extract_ruby(path: Path) -> dict:
-    """Extract classes, methods, singleton methods, and calls from a .rb file."""
-    return _extract_generic(path, _RUBY_CONFIG)
-
-
-def extract_csharp(path: Path) -> dict:
-    """Extract classes, interfaces, methods, namespaces, and usings from a .cs file."""
-    return _extract_generic(path, _CSHARP_CONFIG)
-
-
-def extract_kotlin(path: Path) -> dict:
-    """Extract classes, objects, functions, and imports from a .kt/.kts file."""
-    return _extract_generic(path, _KOTLIN_CONFIG)
-
-
-def extract_scala(path: Path) -> dict:
-    """Extract classes, objects, functions, and imports from a .scala file."""
-    return _extract_generic(path, _SCALA_CONFIG)
-
-
-def extract_php(path: Path) -> dict:
-    """Extract classes, functions, methods, namespace uses, and calls from a .php file."""
-    return _extract_generic(path, _PHP_CONFIG)
-
-
-def extract_blade(path: Path) -> dict:
-    """Extract @include, <livewire:> components, and wire:click bindings from Blade templates."""
-    import re
-    try:
-        src = path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return {"error": f"cannot read {path}"}
-
-    file_nid = _make_id(str(path))
-    nodes = [{"id": file_nid, "label": path.name, "file_type": "code",
-              "source_file": str(path), "source_location": None}]
-    edges = []
-
-    # @include('path.to.partial') or @include("path.to.partial")
-    for m in re.finditer(r"@include\(['\"]([^'\"]+)['\"]", src):
-        tgt = m.group(1).replace(".", "/")
-        tgt_nid = _make_id(tgt)
-        if tgt_nid not in {n["id"] for n in nodes}:
-            nodes.append({"id": tgt_nid, "label": m.group(1), "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-        edges.append({"source": file_nid, "target": tgt_nid, "relation": "includes",
-                      "confidence": "EXTRACTED", "confidence_score": 1.0,
-                      "source_file": str(path), "source_location": None, "weight": 1.0})
-
-    # <livewire:component.name /> or <livewire:component.name>
-    for m in re.finditer(r"<livewire:([\w.\-]+)", src):
-        tgt_nid = _make_id(m.group(1))
-        if tgt_nid not in {n["id"] for n in nodes}:
-            nodes.append({"id": tgt_nid, "label": m.group(1), "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-        edges.append({"source": file_nid, "target": tgt_nid, "relation": "uses_component",
-                      "confidence": "EXTRACTED", "confidence_score": 1.0,
-                      "source_file": str(path), "source_location": None, "weight": 1.0})
-
-    # wire:click="methodName"
-    for m in re.finditer(r'wire:click=["\']([^"\']+)["\']', src):
-        tgt_nid = _make_id(m.group(1))
-        if tgt_nid not in {n["id"] for n in nodes}:
-            nodes.append({"id": tgt_nid, "label": m.group(1), "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-        edges.append({"source": file_nid, "target": tgt_nid, "relation": "binds_method",
-                      "confidence": "EXTRACTED", "confidence_score": 1.0,
-                      "source_file": str(path), "source_location": None, "weight": 1.0})
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def extract_dart(path: Path) -> dict:
-    """Extract classes, mixins, functions, imports, and calls from a .dart file using regex."""
-    try:
-        src = path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return {"error": f"cannot read {path}"}
-
-    file_nid = _make_id(str(path))
-    nodes = [{"id": file_nid, "label": path.name, "file_type": "code",
-              "source_file": str(path), "source_location": None}]
-    edges = []
-    defined: set[str] = set()
-
-    # Classes and mixins
-    for m in re.finditer(r"^\s*(?:abstract\s+)?(?:class|mixin)\s+(\w+)", src, re.MULTILINE):
-        nid = _make_id(str(path), m.group(1))
-        if nid not in defined:
-            nodes.append({"id": nid, "label": m.group(1), "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-            edges.append({"source": file_nid, "target": nid, "relation": "defines",
-                          "confidence": "EXTRACTED", "confidence_score": 1.0,
-                          "source_file": str(path), "source_location": None, "weight": 1.0})
-            defined.add(nid)
-
-    # Top-level and member functions/methods
-    for m in re.finditer(r"^\s*(?:static\s+|async\s+)?(?:\w+\s+)+(\w+)\s*\(", src, re.MULTILINE):
-        name = m.group(1)
-        if name in {"if", "for", "while", "switch", "catch", "return"}:
-            continue
-        nid = _make_id(str(path), name)
-        if nid not in defined:
-            nodes.append({"id": nid, "label": name, "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-            edges.append({"source": file_nid, "target": nid, "relation": "defines",
-                          "confidence": "EXTRACTED", "confidence_score": 1.0,
-                          "source_file": str(path), "source_location": None, "weight": 1.0})
-            defined.add(nid)
-
-    # import 'package:...' or import '...'
-    for m in re.finditer(r"""^import\s+['"]([^'"]+)['"]""", src, re.MULTILINE):
-        pkg = m.group(1)
-        tgt_nid = _make_id(pkg)
-        if tgt_nid not in defined:
-            nodes.append({"id": tgt_nid, "label": pkg, "file_type": "code",
-                          "source_file": str(path), "source_location": None})
-            defined.add(tgt_nid)
-        edges.append({"source": file_nid, "target": tgt_nid, "relation": "imports",
-                      "confidence": "EXTRACTED", "confidence_score": 1.0,
-                      "source_file": str(path), "source_location": None, "weight": 1.0})
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def extract_verilog(path: Path) -> dict:
-    """Extract modules, functions, tasks, package imports, and instantiations from .v/.sv files."""
-    try:
-        import tree_sitter_verilog as tsverilog
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree_sitter_verilog not installed"}
-
-    try:
-        language = Language(tsverilog.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({"id": nid, "label": label, "file_type": "code",
-                          "source_file": str_path, "source_location": f"L{line}",
-                          "confidence_score": 1.0})
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", score: float = 1.0) -> None:
-        edges.append({"source": src, "target": tgt, "relation": relation,
-                      "confidence": confidence, "confidence_score": score,
-                      "source_file": str_path, "source_location": f"L{line}", "weight": 1.0})
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def walk(node, module_nid: str | None = None) -> None:
-        t = node.type
-
-        if t == "module_declaration":
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                mod_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                nid = _make_id(stem, mod_name)
-                add_node(nid, mod_name, line)
-                add_edge(file_nid, nid, "defines", line)
-                for child in node.children:
-                    walk(child, nid)
-                return
-
-        elif t in ("function_declaration", "function_prototype"):
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                func_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                parent = module_nid or file_nid
-                nid = _make_id(parent, func_name)
-                add_node(nid, f"{func_name}()", line)
-                add_edge(parent, nid, "contains", line)
-
-        elif t == "task_declaration":
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                task_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                parent = module_nid or file_nid
-                nid = _make_id(parent, task_name)
-                add_node(nid, task_name, line)
-                add_edge(parent, nid, "contains", line)
-
-        elif t == "package_import_declaration":
-            for child in node.children:
-                if child.type == "package_import_item":
-                    pkg_text = _read_text(child, source)
-                    pkg_name = pkg_text.split("::")[0].strip()
-                    if pkg_name:
-                        line = node.start_point[0] + 1
-                        tgt_nid = _make_id(pkg_name)
-                        add_node(tgt_nid, pkg_name, line)
-                        src = module_nid or file_nid
-                        add_edge(src, tgt_nid, "imports_from", line)
-
-        elif t == "module_instantiation":
-            # module_type instantiates another module
-            type_node = node.child_by_field_name("module_type")
-            if type_node and module_nid:
-                inst_type = _read_text(type_node, source).strip()
-                if inst_type:
-                    line = node.start_point[0] + 1
-                    tgt_nid = _make_id(inst_type)
-                    add_node(tgt_nid, inst_type, line)
-                    add_edge(module_nid, tgt_nid, "instantiates", line)
-
-        for child in node.children:
-            walk(child, module_nid)
-
-    walk(root)
-    return {"nodes": nodes, "edges": edges}
-
-
-def extract_lua(path: Path) -> dict:
-    """Extract functions, methods, require() imports, and calls from a .lua file."""
-    return _extract_generic(path, _LUA_CONFIG)
-
-
-def extract_swift(path: Path) -> dict:
-    """Extract classes, structs, protocols, functions, imports, and calls from a .swift file."""
-    return _extract_generic(path, _SWIFT_CONFIG)
-
-
-# ── Julia extractor (custom walk) ────────────────────────────────────────────
-
-def extract_julia(path: Path) -> dict:
-    """Extract modules, structs, functions, imports, and calls from a .jl file."""
-    try:
-        import tree_sitter_julia as tsjulia
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree-sitter-julia not installed"}
-
-    try:
-        language = Language(tsjulia.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, object]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid,
-                "label": label,
-                "file_type": "code",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({
-            "source": src,
-            "target": tgt,
-            "relation": relation,
-            "confidence": confidence,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": weight,
-        })
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def _func_name_from_signature(sig_node) -> str | None:
-        """Extract function name from a Julia signature node (call_expression > identifier)."""
-        for child in sig_node.children:
-            if child.type == "call_expression":
-                callee = child.children[0] if child.children else None
-                if callee and callee.type == "identifier":
-                    return _read_text(callee, source)
-        return None
-
-    def walk_calls(body_node, func_nid: str) -> None:
-        if body_node is None:
-            return
-        t = body_node.type
-        if t in ("function_definition", "short_function_definition"):
-            return
-        if t == "call_expression" and body_node.children:
-            callee = body_node.children[0]
-            # Direct call: foo(...)
-            if callee.type == "identifier":
-                callee_name = _read_text(callee, source)
-                target_nid = _make_id(stem, callee_name)
-                add_edge(func_nid, target_nid, "calls", body_node.start_point[0] + 1,
-                         confidence="EXTRACTED")
-            # Method call: obj.method(...)
-            elif callee.type == "field_expression" and len(callee.children) >= 3:
-                method_node = callee.children[-1]
-                method_name = _read_text(method_node, source)
-                target_nid = _make_id(stem, method_name)
-                add_edge(func_nid, target_nid, "calls", body_node.start_point[0] + 1,
-                         confidence="EXTRACTED")
-        for child in body_node.children:
-            walk_calls(child, func_nid)
-
-    def walk(node, scope_nid: str) -> None:
-        t = node.type
-
-        # Module
-        if t == "module_definition":
-            name_node = next((c for c in node.children if c.type == "identifier"), None)
-            if name_node:
-                mod_name = _read_text(name_node, source)
-                mod_nid = _make_id(stem, mod_name)
-                line = node.start_point[0] + 1
-                add_node(mod_nid, mod_name, line)
-                add_edge(file_nid, mod_nid, "defines", line)
-                for child in node.children:
-                    walk(child, mod_nid)
-            return
-
-        # Struct (struct / mutable struct — both map to struct_definition in tree-sitter-julia)
-        if t == "struct_definition":
-            # type_head may contain: identifier (simple) or binary_expression (Foo <: Bar)
-            type_head = next((c for c in node.children if c.type == "type_head"), None)
-            if type_head:
-                bin_expr = next((c for c in type_head.children if c.type == "binary_expression"), None)
-                if bin_expr:
-                    # First identifier is the struct name, last is the supertype
-                    identifiers = [c for c in bin_expr.children if c.type == "identifier"]
-                    if identifiers:
-                        struct_name = _read_text(identifiers[0], source)
-                        struct_nid = _make_id(stem, struct_name)
-                        line = node.start_point[0] + 1
-                        add_node(struct_nid, struct_name, line)
-                        add_edge(scope_nid, struct_nid, "defines", line)
-                        if len(identifiers) >= 2:
-                            super_name = _read_text(identifiers[-1], source)
-                            add_edge(struct_nid, _make_id(stem, super_name), "inherits",
-                                     line, confidence="EXTRACTED")
-                else:
-                    name_node = next((c for c in type_head.children if c.type == "identifier"), None)
-                    if name_node:
-                        struct_name = _read_text(name_node, source)
-                        struct_nid = _make_id(stem, struct_name)
-                        line = node.start_point[0] + 1
-                        add_node(struct_nid, struct_name, line)
-                        add_edge(scope_nid, struct_nid, "defines", line)
-            return
-
-        # Abstract type
-        if t == "abstract_definition":
-            # type_head > identifier
-            type_head = next((c for c in node.children if c.type == "type_head"), None)
-            if type_head:
-                name_node = next((c for c in type_head.children if c.type == "identifier"), None)
-                if name_node:
-                    abs_name = _read_text(name_node, source)
-                    abs_nid = _make_id(stem, abs_name)
-                    line = node.start_point[0] + 1
-                    add_node(abs_nid, abs_name, line)
-                    add_edge(scope_nid, abs_nid, "defines", line)
-            return
-
-        # Function: function foo(...) ... end
-        if t == "function_definition":
-            sig_node = next((c for c in node.children if c.type == "signature"), None)
-            if sig_node:
-                func_name = _func_name_from_signature(sig_node)
-                if func_name:
-                    func_nid = _make_id(stem, func_name)
-                    line = node.start_point[0] + 1
-                    add_node(func_nid, f"{func_name}()", line)
-                    add_edge(scope_nid, func_nid, "defines", line)
-                    function_bodies.append((func_nid, node))
-            return
-
-        # Short function: foo(x) = expr
-        if t == "assignment":
-            lhs = node.children[0] if node.children else None
-            if lhs and lhs.type == "call_expression" and lhs.children:
-                callee = lhs.children[0]
-                if callee.type == "identifier":
-                    func_name = _read_text(callee, source)
-                    func_nid = _make_id(stem, func_name)
-                    line = node.start_point[0] + 1
-                    add_node(func_nid, f"{func_name}()", line)
-                    add_edge(scope_nid, func_nid, "defines", line)
-                    # Only walk the RHS (index 2 after lhs and operator) to avoid self-loops
-                    rhs = node.children[-1] if len(node.children) >= 3 else None
-                    if rhs:
-                        function_bodies.append((func_nid, rhs))
-            return
-
-        # Using / Import
-        if t in ("using_statement", "import_statement"):
-            line = node.start_point[0] + 1
-            for child in node.children:
-                if child.type == "identifier":
-                    mod_name = _read_text(child, source)
-                    imp_nid = _make_id(mod_name)
-                    add_node(imp_nid, mod_name, line)
-                    add_edge(scope_nid, imp_nid, "imports", line)
-                elif child.type == "selected_import":
-                    identifiers = [c for c in child.children if c.type == "identifier"]
-                    if identifiers:
-                        pkg_name = _read_text(identifiers[0], source)
-                        pkg_nid = _make_id(pkg_name)
-                        add_node(pkg_nid, pkg_name, line)
-                        add_edge(scope_nid, pkg_nid, "imports", line)
-            return
-
-        for child in node.children:
-            walk(child, scope_nid)
-
-    walk(root, file_nid)
-
-    for func_nid, body_node in function_bodies:
-        # For function_definition nodes, walk children directly to avoid
-        # the boundary check returning early on the top-level node itself.
-        # Skip the "signature" child — it contains the function's own call_expression
-        # which would create a self-loop.
-        if body_node.type == "function_definition":
-            for child in body_node.children:
-                if child.type != "signature":
-                    walk_calls(child, func_nid)
-        else:
-            walk_calls(body_node, func_nid)
-
-    return {"nodes": nodes, "edges": edges}
-
-
-# ── Go extractor (custom walk) ────────────────────────────────────────────────
-
-def extract_go(path: Path) -> dict:
-    """Extract functions, methods, type declarations, and imports from a .go file."""
-    try:
-        import tree_sitter_go as tsgo
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree-sitter-go not installed"}
-
-    try:
-        language = Language(tsgo.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    # Use directory name as package scope so methods on the same type across
-    # multiple files in a package share one canonical type node.
-    pkg_scope = path.parent.name or stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, object]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid,
-                "label": label,
-                "file_type": "code",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({
-            "source": src,
-            "target": tgt,
-            "relation": relation,
-            "confidence": confidence,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": weight,
-        })
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def walk(node) -> None:
-        t = node.type
-
-        if t == "function_declaration":
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                func_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                func_nid = _make_id(stem, func_name)
-                add_node(func_nid, f"{func_name}()", line)
-                add_edge(file_nid, func_nid, "contains", line)
-                body = node.child_by_field_name("body")
-                if body:
-                    function_bodies.append((func_nid, body))
-            return
-
-        if t == "method_declaration":
-            receiver = node.child_by_field_name("receiver")
-            receiver_type: str | None = None
-            if receiver:
-                for param in receiver.children:
-                    if param.type == "parameter_declaration":
-                        type_node = param.child_by_field_name("type")
-                        if type_node:
-                            raw = _read_text(type_node, source).lstrip("*").strip()
-                            receiver_type = raw
-                        break
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                method_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                if receiver_type:
-                    parent_nid = _make_id(pkg_scope, receiver_type)
-                    add_node(parent_nid, receiver_type, line)
-                    method_nid = _make_id(parent_nid, method_name)
-                    add_node(method_nid, f".{method_name}()", line)
-                    add_edge(parent_nid, method_nid, "method", line)
-                else:
-                    method_nid = _make_id(stem, method_name)
-                    add_node(method_nid, f"{method_name}()", line)
-                    add_edge(file_nid, method_nid, "contains", line)
-                body = node.child_by_field_name("body")
-                if body:
-                    function_bodies.append((method_nid, body))
-            return
-
-        if t == "type_declaration":
-            for child in node.children:
-                if child.type == "type_spec":
-                    name_node = child.child_by_field_name("name")
-                    if name_node:
-                        type_name = _read_text(name_node, source)
-                        line = child.start_point[0] + 1
-                        type_nid = _make_id(pkg_scope, type_name)
-                        add_node(type_nid, type_name, line)
-                        add_edge(file_nid, type_nid, "contains", line)
-            return
-
-        if t == "import_declaration":
-            for child in node.children:
-                if child.type == "import_spec_list":
-                    for spec in child.children:
-                        if spec.type == "import_spec":
-                            path_node = spec.child_by_field_name("path")
-                            if path_node:
-                                raw = _read_text(path_node, source).strip('"')
-                                module_name = raw.split("/")[-1]
-                                tgt_nid = _make_id(module_name)
-                                add_edge(file_nid, tgt_nid, "imports_from", spec.start_point[0] + 1)
-                elif child.type == "import_spec":
-                    path_node = child.child_by_field_name("path")
-                    if path_node:
-                        raw = _read_text(path_node, source).strip('"')
-                        module_name = raw.split("/")[-1]
-                        tgt_nid = _make_id(module_name)
-                        add_edge(file_nid, tgt_nid, "imports_from", child.start_point[0] + 1)
-            return
-
-        for child in node.children:
-            walk(child)
-
-    walk(root)
-
-    label_to_nid: dict[str, str] = {}
-    for n in nodes:
-        raw = n["label"]
-        normalised = raw.strip("()").lstrip(".")
-        label_to_nid[normalised.lower()] = n["id"]
-
-    seen_call_pairs: set[tuple[str, str]] = set()
-    raw_calls: list[dict] = []
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type in ("function_declaration", "method_declaration"):
-            return
-        if node.type == "call_expression":
-            func_node = node.child_by_field_name("function")
-            callee_name: str | None = None
-            if func_node:
-                if func_node.type == "identifier":
-                    callee_name = _read_text(func_node, source)
-                elif func_node.type == "selector_expression":
-                    field = func_node.child_by_field_name("field")
-                    if field:
-                        callee_name = _read_text(field, source)
-            if callee_name:
-                tgt_nid = label_to_nid.get(callee_name.lower())
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair = (caller_nid, tgt_nid)
-                    if pair not in seen_call_pairs:
-                        seen_call_pairs.add(pair)
-                        line = node.start_point[0] + 1
-                        edges.append({
-                            "source": caller_nid,
-                            "target": tgt_nid,
-                            "relation": "calls",
-                            "confidence": "EXTRACTED",
-                            "source_file": str_path,
-                            "source_location": f"L{line}",
-                            "weight": 1.0,
-                        })
-                elif callee_name:
-                    raw_calls.append({
-                        "caller_nid": caller_nid,
-                        "callee": callee_name,
-                        "source_file": str_path,
-                        "source_location": f"L{node.start_point[0] + 1}",
-                    })
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body_node in function_bodies:
-        walk_calls(body_node, caller_nid)
-
-    valid_ids = seen_ids
-    clean_edges = []
-    for edge in edges:
-        src, tgt = edge["source"], edge["target"]
-        if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):
-            clean_edges.append(edge)
-
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
-
-
-# ── Rust extractor (custom walk) ──────────────────────────────────────────────
-
-def extract_rust(path: Path) -> dict:
-    """Extract functions, structs, enums, traits, impl methods, and use declarations from a .rs file."""
-    try:
-        import tree_sitter_rust as tsrust
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree-sitter-rust not installed"}
-
-    try:
-        language = Language(tsrust.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, object]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid,
-                "label": label,
-                "file_type": "code",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({
-            "source": src,
-            "target": tgt,
-            "relation": relation,
-            "confidence": confidence,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": weight,
-        })
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def walk(node, parent_impl_nid: str | None = None) -> None:
-        t = node.type
-
-        if t == "function_item":
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                func_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                if parent_impl_nid:
-                    func_nid = _make_id(parent_impl_nid, func_name)
-                    add_node(func_nid, f".{func_name}()", line)
-                    add_edge(parent_impl_nid, func_nid, "method", line)
-                else:
-                    func_nid = _make_id(stem, func_name)
-                    add_node(func_nid, f"{func_name}()", line)
-                    add_edge(file_nid, func_nid, "contains", line)
-                body = node.child_by_field_name("body")
-                if body:
-                    function_bodies.append((func_nid, body))
-            return
-
-        if t in ("struct_item", "enum_item", "trait_item"):
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                item_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                item_nid = _make_id(stem, item_name)
-                add_node(item_nid, item_name, line)
-                add_edge(file_nid, item_nid, "contains", line)
-            return
-
-        if t == "impl_item":
-            type_node = node.child_by_field_name("type")
-            impl_nid: str | None = None
-            if type_node:
-                type_name = _read_text(type_node, source).strip()
-                impl_nid = _make_id(stem, type_name)
-                add_node(impl_nid, type_name, node.start_point[0] + 1)
-            body = node.child_by_field_name("body")
-            if body:
-                for child in body.children:
-                    walk(child, parent_impl_nid=impl_nid)
-            return
-
-        if t == "use_declaration":
-            arg = node.child_by_field_name("argument")
-            if arg:
-                raw = _read_text(arg, source)
-                clean = raw.split("{")[0].rstrip(":").rstrip("*").rstrip(":")
-                module_name = clean.split("::")[-1].strip()
-                if module_name:
-                    tgt_nid = _make_id(module_name)
-                    add_edge(file_nid, tgt_nid, "imports_from", node.start_point[0] + 1)
-            return
-
-        for child in node.children:
-            walk(child, parent_impl_nid=None)
-
-    walk(root)
-
-    label_to_nid: dict[str, str] = {}
-    for n in nodes:
-        raw = n["label"]
-        normalised = raw.strip("()").lstrip(".")
-        label_to_nid[normalised.lower()] = n["id"]
-
-    seen_call_pairs: set[tuple[str, str]] = set()
-    raw_calls: list[dict] = []
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type == "function_item":
-            return
-        if node.type == "call_expression":
-            func_node = node.child_by_field_name("function")
-            callee_name: str | None = None
-            if func_node:
-                if func_node.type == "identifier":
-                    callee_name = _read_text(func_node, source)
-                elif func_node.type == "field_expression":
-                    field = func_node.child_by_field_name("field")
-                    if field:
-                        callee_name = _read_text(field, source)
-                elif func_node.type == "scoped_identifier":
-                    name = func_node.child_by_field_name("name")
-                    if name:
-                        callee_name = _read_text(name, source)
-            if callee_name:
-                tgt_nid = label_to_nid.get(callee_name.lower())
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair = (caller_nid, tgt_nid)
-                    if pair not in seen_call_pairs:
-                        seen_call_pairs.add(pair)
-                        line = node.start_point[0] + 1
-                        edges.append({
-                            "source": caller_nid,
-                            "target": tgt_nid,
-                            "relation": "calls",
-                            "confidence": "EXTRACTED",
-                            "source_file": str_path,
-                            "source_location": f"L{line}",
-                            "weight": 1.0,
-                        })
-                else:
-                    raw_calls.append({
-                        "caller_nid": caller_nid,
-                        "callee": callee_name,
-                        "source_file": str_path,
-                        "source_location": f"L{node.start_point[0] + 1}",
-                    })
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body_node in function_bodies:
-        walk_calls(body_node, caller_nid)
-
-    valid_ids = seen_ids
-    clean_edges = []
-    for edge in edges:
-        src, tgt = edge["source"], edge["target"]
-        if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):
-            clean_edges.append(edge)
-
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
-
-
-# ── Zig ───────────────────────────────────────────────────────────────────────
-
-def extract_zig(path: Path) -> dict:
-    """Extract functions, structs, enums, unions, and imports from a .zig file."""
-    try:
-        import tree_sitter_zig as tszig
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree_sitter_zig not installed"}
-
-    try:
-        language = Language(tszig.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, Any]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({"id": nid, "label": label, "file_type": "code",
-                          "source_file": str_path, "source_location": f"L{line}"})
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({"source": src, "target": tgt, "relation": relation,
-                      "confidence": confidence, "source_file": str_path,
-                      "source_location": f"L{line}", "weight": weight})
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def _extract_import(node) -> None:
-        for child in node.children:
-            if child.type == "builtin_function":
-                bi = None
-                args = None
-                for c in child.children:
-                    if c.type == "builtin_identifier":
-                        bi = _read_text(c, source)
-                    elif c.type == "arguments":
-                        args = c
-                if bi in ("@import", "@cImport") and args:
-                    for arg in args.children:
-                        if arg.type in ("string_literal", "string"):
-                            raw = _read_text(arg, source).strip('"')
-                            module_name = raw.split("/")[-1].split(".")[0]
-                            if module_name:
-                                tgt_nid = _make_id(module_name)
-                                add_edge(file_nid, tgt_nid, "imports_from",
-                                         node.start_point[0] + 1)
-                            return
-            elif child.type == "field_expression":
-                _extract_import(child)
-                return
-
-    def walk(node, parent_struct_nid: str | None = None) -> None:
-        t = node.type
-
-        if t == "function_declaration":
-            name_node = node.child_by_field_name("name")
-            if name_node:
-                func_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                if parent_struct_nid:
-                    func_nid = _make_id(parent_struct_nid, func_name)
-                    add_node(func_nid, f".{func_name}()", line)
-                    add_edge(parent_struct_nid, func_nid, "method", line)
-                else:
-                    func_nid = _make_id(stem, func_name)
-                    add_node(func_nid, f"{func_name}()", line)
-                    add_edge(file_nid, func_nid, "contains", line)
-                body = node.child_by_field_name("body")
-                if body:
-                    function_bodies.append((func_nid, body))
-            return
-
-        if t == "variable_declaration":
-            name_node = None
-            value_node = None
-            for child in node.children:
-                if child.type == "identifier":
-                    name_node = child
-                elif child.type in ("struct_declaration", "enum_declaration",
-                                    "union_declaration", "builtin_function",
-                                    "field_expression"):
-                    value_node = child
-
-            if value_node and value_node.type == "struct_declaration":
-                if name_node:
-                    struct_name = _read_text(name_node, source)
-                    line = node.start_point[0] + 1
-                    struct_nid = _make_id(stem, struct_name)
-                    add_node(struct_nid, struct_name, line)
-                    add_edge(file_nid, struct_nid, "contains", line)
-                    for child in value_node.children:
-                        walk(child, parent_struct_nid=struct_nid)
-                return
-
-            if value_node and value_node.type in ("enum_declaration", "union_declaration"):
-                if name_node:
-                    type_name = _read_text(name_node, source)
-                    line = node.start_point[0] + 1
-                    type_nid = _make_id(stem, type_name)
-                    add_node(type_nid, type_name, line)
-                    add_edge(file_nid, type_nid, "contains", line)
-                return
-
-            if value_node and value_node.type in ("builtin_function", "field_expression"):
-                _extract_import(node)
-            return
-
-        for child in node.children:
-            walk(child, parent_struct_nid)
-
-    walk(root)
-
-    seen_call_pairs: set[tuple[str, str]] = set()
-    raw_calls: list[dict] = []
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type == "function_declaration":
-            return
-        if node.type == "call_expression":
-            fn = node.child_by_field_name("function")
-            if fn:
-                callee = _read_text(fn, source).split(".")[-1]
-                tgt_nid = next((n["id"] for n in nodes if n["label"] in
-                                (f"{callee}()", f".{callee}()")), None)
-                if tgt_nid and tgt_nid != caller_nid:
-                    pair = (caller_nid, tgt_nid)
-                    if pair not in seen_call_pairs:
-                        seen_call_pairs.add(pair)
-                        add_edge(caller_nid, tgt_nid, "calls",
-                                 node.start_point[0] + 1,
-                                 confidence="EXTRACTED", weight=1.0)
-                elif callee:
-                    raw_calls.append({
-                        "caller_nid": caller_nid,
-                        "callee": callee,
-                        "source_file": str_path,
-                        "source_location": f"L{node.start_point[0] + 1}",
-                    })
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body_node in function_bodies:
-        walk_calls(body_node, caller_nid)
-
-    clean_edges = [e for e in edges if e["source"] in seen_ids and
-                   (e["target"] in seen_ids or e["relation"] == "imports_from")]
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
-
-
-# ── PowerShell ────────────────────────────────────────────────────────────────
-
-def extract_powershell(path: Path) -> dict:
-    """Extract functions, classes, methods, and using statements from a .ps1 file."""
-    try:
-        import tree_sitter_powershell as tsps
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree_sitter_powershell not installed"}
-
-    try:
-        language = Language(tsps.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, Any]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({"id": nid, "label": label, "file_type": "code",
-                          "source_file": str_path, "source_location": f"L{line}"})
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({"source": src, "target": tgt, "relation": relation,
-                      "confidence": confidence, "source_file": str_path,
-                      "source_location": f"L{line}", "weight": weight})
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    _PS_SKIP = frozenset({
-        "using", "return", "if", "else", "elseif", "foreach", "for",
-        "while", "do", "switch", "try", "catch", "finally", "throw",
-        "break", "continue", "exit", "param", "begin", "process", "end",
-    })
-
-    def _find_script_block_body(node):
-        for child in node.children:
-            if child.type == "script_block":
-                for sc in child.children:
-                    if sc.type == "script_block_body":
-                        return sc
-                return child
-        return None
-
-    def walk(node, parent_class_nid: str | None = None) -> None:
-        t = node.type
-
-        if t == "function_statement":
-            name_node = next((c for c in node.children if c.type == "function_name"), None)
-            if name_node:
-                func_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                func_nid = _make_id(stem, func_name)
-                add_node(func_nid, f"{func_name}()", line)
-                add_edge(file_nid, func_nid, "contains", line)
-                body = _find_script_block_body(node)
-                if body:
-                    function_bodies.append((func_nid, body))
-            return
-
-        if t == "class_statement":
-            name_node = next((c for c in node.children if c.type == "simple_name"), None)
-            if name_node:
-                class_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                class_nid = _make_id(stem, class_name)
-                add_node(class_nid, class_name, line)
-                add_edge(file_nid, class_nid, "contains", line)
-                for child in node.children:
-                    walk(child, parent_class_nid=class_nid)
-            return
-
-        if t == "class_method_definition":
-            name_node = next((c for c in node.children if c.type == "simple_name"), None)
-            if name_node:
-                method_name = _read_text(name_node, source)
-                line = node.start_point[0] + 1
-                if parent_class_nid:
-                    method_nid = _make_id(parent_class_nid, method_name)
-                    add_node(method_nid, f".{method_name}()", line)
-                    add_edge(parent_class_nid, method_nid, "method", line)
-                else:
-                    method_nid = _make_id(stem, method_name)
-                    add_node(method_nid, f"{method_name}()", line)
-                    add_edge(file_nid, method_nid, "contains", line)
-                body = _find_script_block_body(node)
-                if body:
-                    function_bodies.append((method_nid, body))
-            return
-
-        if t == "command":
-            cmd_name_node = next((c for c in node.children if c.type == "command_name"), None)
-            if cmd_name_node:
-                cmd_text = _read_text(cmd_name_node, source).lower()
-                if cmd_text == "using":
-                    tokens = []
-                    for child in node.children:
-                        if child.type == "command_elements":
-                            for el in child.children:
-                                if el.type == "generic_token":
-                                    tokens.append(_read_text(el, source))
-                    module_tokens = [t for t in tokens
-                                     if t.lower() not in ("namespace", "module", "assembly")]
-                    if module_tokens:
-                        module_name = module_tokens[-1].split(".")[-1]
-                        add_edge(file_nid, _make_id(module_name), "imports_from",
-                                 node.start_point[0] + 1)
-            return
-
-        for child in node.children:
-            walk(child, parent_class_nid)
-
-    walk(root)
-
-    label_to_nid = {n["label"].strip("()").lstrip(".").lower(): n["id"] for n in nodes}
-    seen_call_pairs: set[tuple[str, str]] = set()
-    raw_calls: list[dict] = []
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type in ("function_statement", "class_statement"):
-            return
-        if node.type == "command":
-            cmd_name_node = next((c for c in node.children if c.type == "command_name"), None)
-            if cmd_name_node:
-                cmd_text = _read_text(cmd_name_node, source)
-                if cmd_text.lower() not in _PS_SKIP:
-                    tgt_nid = label_to_nid.get(cmd_text.lower())
-                    if tgt_nid and tgt_nid != caller_nid:
-                        pair = (caller_nid, tgt_nid)
-                        if pair not in seen_call_pairs:
-                            seen_call_pairs.add(pair)
-                            add_edge(caller_nid, tgt_nid, "calls",
-                                     node.start_point[0] + 1,
-                                     confidence="EXTRACTED", weight=1.0)
-                    elif cmd_text:
-                        raw_calls.append({
-                            "caller_nid": caller_nid,
-                            "callee": cmd_text,
-                            "source_file": str_path,
-                            "source_location": f"L{node.start_point[0] + 1}",
-                        })
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body_node in function_bodies:
-        walk_calls(body_node, caller_nid)
-
-    clean_edges = [e for e in edges if e["source"] in seen_ids and
-                   (e["target"] in seen_ids or e["relation"] == "imports_from")]
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
-
-
-# ── Cross-file import resolution ──────────────────────────────────────────────
-
-def _resolve_cross_file_imports(
-    per_file: list[dict],
-    paths: list[Path],
-) -> list[dict]:
-    """
-    Two-pass import resolution: turn file-level imports into class-level edges.
-
-    Pass 1 - build a global map: class/function name → node_id, per stem.
-    Pass 2 - for each `from .module import Name`, look up Name in the global
-              map and add a direct INFERRED edge from each class in the
-              importing file to the imported entity.
-
-    This turns:
-        auth.py --imports_from--> models.py          (obvious, filtered out)
-    Into:
-        DigestAuth --uses--> Response  [INFERRED]    (cross-file, interesting!)
-        BasicAuth  --uses--> Request   [INFERRED]
-    """
-    try:
-        import tree_sitter_python as tspython
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return []
-
-    language = Language(tspython.language())
-    parser = Parser(language)
-
-    # Pass 1: name → node_id across all files
-    # Map: stem → {ClassName: node_id}
-    stem_to_entities: dict[str, dict[str, str]] = {}
-    for file_result in per_file:
-        for node in file_result.get("nodes", []):
-            src = node.get("source_file", "")
-            if not src:
-                continue
-            stem = Path(src).stem
-            label = node.get("label", "")
-            nid = node.get("id", "")
-            # Only index real classes/functions (not file nodes, not method stubs)
-            if label and not label.endswith((")", ".py")) and "_" not in label[:1]:
-                stem_to_entities.setdefault(stem, {})[label] = nid
-
-    # Pass 2: for each file, find `from .X import A, B, C` and resolve
-    new_edges: list[dict] = []
-    stem_to_path: dict[str, Path] = {p.stem: p for p in paths}
-
-    for file_result, path in zip(per_file, paths):
-        stem = path.stem
-        str_path = str(path)
-
-        # Find all classes defined in this file (the importers)
-        local_classes = [
-            n["id"] for n in file_result.get("nodes", [])
-            if n.get("source_file") == str_path
-            and not n["label"].endswith((")", ".py"))
-            and n["id"] != _make_id(stem)  # exclude file-level node
-        ]
-        if not local_classes:
-            continue
-
-        # Parse imports from this file
-        try:
-            source = path.read_bytes()
-            tree = parser.parse(source)
-        except Exception:
-            continue
-
-        def walk_imports(node) -> None:
-            if node.type == "import_from_statement":
-                # Find the module name - handles both absolute and relative imports.
-                # Relative: `from .models import X` → relative_import → dotted_name
-                # Absolute: `from models import X`  → module_name field
-                target_stem: str | None = None
-                for child in node.children:
-                    if child.type == "relative_import":
-                        # Dig into relative_import → dotted_name → identifier
-                        for sub in child.children:
-                            if sub.type == "dotted_name":
-                                raw = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
-                                target_stem = raw.split(".")[-1]
-                                break
-                        break
-                    if child.type == "dotted_name" and target_stem is None:
-                        raw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                        target_stem = raw.split(".")[-1]
-
-                if not target_stem or target_stem not in stem_to_entities:
-                    return
-
-                # Collect imported names: dotted_name children of import_from_statement
-                # that come AFTER the 'import' keyword token.
-                imported_names: list[str] = []
-                past_import_kw = False
-                for child in node.children:
-                    if child.type == "import":
-                        past_import_kw = True
-                        continue
-                    if not past_import_kw:
-                        continue
-                    if child.type == "dotted_name":
-                        imported_names.append(
-                            source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                        )
-                    elif child.type == "aliased_import":
-                        # `import X as Y` - take the original name
-                        name_node = child.child_by_field_name("name")
-                        if name_node:
-                            imported_names.append(
-                                source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
-                            )
-
-                line = node.start_point[0] + 1
-                for name in imported_names:
-                    tgt_nid = stem_to_entities[target_stem].get(name)
-                    if tgt_nid:
-                        for src_class_nid in local_classes:
-                            new_edges.append({
-                                "source": src_class_nid,
-                                "target": tgt_nid,
-                                "relation": "uses",
-                                "confidence": "INFERRED",
-                                "source_file": str_path,
-                                "source_location": f"L{line}",
-                                "weight": 0.8,
-                            })
-            for child in node.children:
-                walk_imports(child)
-
-        walk_imports(tree.root_node)
-
-    return new_edges
-
-
-def extract_objc(path: Path) -> dict:
-    """Extract interfaces, implementations, protocols, methods, and imports from .m/.mm/.h files."""
-    try:
-        import tree_sitter_objc as tsobjc
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree_sitter_objc not installed"}
-
-    try:
-        language = Language(tsobjc.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    method_bodies: list[tuple[str, Any]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({"id": nid, "label": label, "file_type": "code",
-                          "source_file": str_path, "source_location": f"L{line}"})
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({"source": src, "target": tgt, "relation": relation,
-                      "confidence": confidence, "source_file": str_path,
-                      "source_location": f"L{line}", "weight": weight})
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    def _read(node) -> str:
-        return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
-
-    def _get_name(node, field: str) -> str | None:
-        n = node.child_by_field_name(field)
-        return _read(n) if n else None
-
-    def walk(node, parent_nid: str | None = None) -> None:
-        t = node.type
-        line = node.start_point[0] + 1
-
-        if t == "preproc_include":
-            # #import <Foundation/Foundation.h> or #import "MyClass.h"
-            for child in node.children:
-                if child.type == "system_lib_string":
-                    raw = _read(child).strip("<>")
-                    module = raw.split("/")[-1].replace(".h", "")
-                    if module:
-                        tgt_nid = _make_id(module)
-                        add_edge(file_nid, tgt_nid, "imports", line)
-                elif child.type == "string_literal":
-                    # recurse into string_literal to find string_content
-                    for sub in child.children:
-                        if sub.type == "string_content":
-                            raw = _read(sub)
-                            module = raw.split("/")[-1].replace(".h", "")
-                            if module:
-                                tgt_nid = _make_id(module)
-                                add_edge(file_nid, tgt_nid, "imports", line)
-            return
-
-        if t == "class_interface":
-            # @interface ClassName : SuperClass <Protocols>
-            # children: @interface, identifier(name), ':', identifier(super), parameterized_arguments, ...
-            identifiers = [c for c in node.children if c.type == "identifier"]
-            if not identifiers:
-                for child in node.children:
-                    walk(child, parent_nid)
-                return
-            name = _read(identifiers[0])
-            cls_nid = _make_id(stem, name)
-            add_node(cls_nid, name, line)
-            add_edge(file_nid, cls_nid, "contains", line)
-            # superclass is second identifier after ':'
-            colon_seen = False
-            for child in node.children:
-                if child.type == ":":
-                    colon_seen = True
-                elif colon_seen and child.type == "identifier":
-                    super_nid = _make_id(_read(child))
-                    add_edge(cls_nid, super_nid, "inherits", line)
-                    colon_seen = False
-                elif child.type == "parameterized_arguments":
-                    # protocols adopted
-                    for sub in child.children:
-                        if sub.type == "type_name":
-                            for s in sub.children:
-                                if s.type == "type_identifier":
-                                    proto_nid = _make_id(_read(s))
-                                    add_edge(cls_nid, proto_nid, "imports", line)
-                elif child.type == "method_declaration":
-                    walk(child, cls_nid)
-            return
-
-        if t == "class_implementation":
-            # @implementation ClassName
-            name = None
-            for child in node.children:
-                if child.type == "identifier":
-                    name = _read(child)
-                    break
-            if not name:
-                for child in node.children:
-                    walk(child, parent_nid)
-                return
-            impl_nid = _make_id(stem, name)
-            if impl_nid not in seen_ids:
-                add_node(impl_nid, name, line)
-                add_edge(file_nid, impl_nid, "contains", line)
-            for child in node.children:
-                if child.type == "implementation_definition":
-                    for sub in child.children:
-                        walk(sub, impl_nid)
-            return
-
-        if t == "protocol_declaration":
-            name = None
-            for child in node.children:
-                if child.type == "identifier":
-                    name = _read(child)
-                    break
-            if name:
-                proto_nid = _make_id(stem, name)
-                add_node(proto_nid, f"<{name}>", line)
-                add_edge(file_nid, proto_nid, "contains", line)
-                for child in node.children:
-                    walk(child, proto_nid)
-            return
-
-        if t in ("method_declaration", "method_definition"):
-            container = parent_nid or file_nid
-            # method name is the first identifier child (simple selector)
-            # for compound selectors: identifier + method_parameter pairs
-            parts = []
-            for child in node.children:
-                if child.type == "identifier":
-                    parts.append(_read(child))
-                elif child.type == "method_parameter":
-                    for sub in child.children:
-                        if sub.type == "identifier":
-                            # selector keyword before ':'
-                            pass
-            method_name = "".join(parts) if parts else None
-            if method_name:
-                method_nid = _make_id(container, method_name)
-                add_node(method_nid, f"-{method_name}", line)
-                add_edge(container, method_nid, "method", line)
-                if t == "method_definition":
-                    method_bodies.append((method_nid, node))
-            return
-
-        for child in node.children:
-            walk(child, parent_nid)
-
-    walk(root)
-
-    # Second pass: resolve calls inside method bodies
-    all_method_nids = {n["id"] for n in nodes if n["id"] != file_nid}
-    seen_calls: set[tuple[str, str]] = set()
-    for caller_nid, body_node in method_bodies:
-        def walk_calls(n) -> None:
-            if n.type == "message_expression":
-                # [receiver selector]
-                for child in n.children:
-                    if child.type in ("selector", "keyword_argument_list"):
-                        sel = []
-                        if child.type == "selector":
-                            sel.append(_read(child))
-                        else:
-                            for sub in child.children:
-                                if sub.type == "keyword_argument":
-                                    for s in sub.children:
-                                        if s.type == "selector":
-                                            sel.append(_read(s))
-                        method_name = "".join(sel)
-                        for candidate in all_method_nids:
-                            if candidate.endswith(_make_id("", method_name).lstrip("_")):
-                                pair = (caller_nid, candidate)
-                                if pair not in seen_calls and caller_nid != candidate:
-                                    seen_calls.add(pair)
-                                    add_edge(caller_nid, candidate, "calls", body_node.start_point[0] + 1,
-                                             confidence="EXTRACTED", weight=1.0)
-            for child in n.children:
-                walk_calls(child)
-        walk_calls(body_node)
-
-    return {"nodes": nodes, "edges": edges, "input_tokens": 0, "output_tokens": 0}
-
-
-def extract_elixir(path: Path) -> dict:
-    """Extract modules, functions, imports, and calls from a .ex/.exs file."""
-    try:
-        import tree_sitter_elixir as tselixir
-        from tree_sitter import Language, Parser
-    except ImportError:
-        return {"nodes": [], "edges": [], "error": "tree_sitter_elixir not installed"}
-
-    try:
-        language = Language(tselixir.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    stem = path.stem
-    str_path = str(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    function_bodies: list[tuple[str, Any]] = []
-
-    def add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({"id": nid, "label": label, "file_type": "code",
-                          "source_file": str_path, "source_location": f"L{line}"})
-
-    def add_edge(src: str, tgt: str, relation: str, line: int,
-                 confidence: str = "EXTRACTED", weight: float = 1.0) -> None:
-        edges.append({"source": src, "target": tgt, "relation": relation,
-                      "confidence": confidence, "source_file": str_path,
-                      "source_location": f"L{line}", "weight": weight})
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name, 1)
-
-    _IMPORT_KEYWORDS = frozenset({"alias", "import", "require", "use"})
-
-    def _get_alias_text(node) -> str | None:
-        for child in node.children:
-            if child.type == "alias":
-                return source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-        return None
-
-    def walk(node, parent_module_nid: str | None = None) -> None:
-        if node.type != "call":
-            for child in node.children:
-                walk(child, parent_module_nid)
-            return
-
-        identifier_node = None
-        arguments_node = None
-        do_block_node = None
-        for child in node.children:
-            if child.type == "identifier":
-                identifier_node = child
-            elif child.type == "arguments":
-                arguments_node = child
-            elif child.type == "do_block":
-                do_block_node = child
-
-        if identifier_node is None:
-            for child in node.children:
-                walk(child, parent_module_nid)
-            return
-
-        keyword = source[identifier_node.start_byte:identifier_node.end_byte].decode("utf-8", errors="replace")
-        line = node.start_point[0] + 1
-
-        if keyword == "defmodule":
-            module_name = _get_alias_text(arguments_node) if arguments_node else None
-            if not module_name:
-                return
-            module_nid = _make_id(stem, module_name)
-            add_node(module_nid, module_name, line)
-            add_edge(file_nid, module_nid, "contains", line)
-            if do_block_node:
-                for child in do_block_node.children:
-                    walk(child, parent_module_nid=module_nid)
-            return
-
-        if keyword in ("def", "defp"):
-            func_name = None
-            if arguments_node:
-                for child in arguments_node.children:
-                    if child.type == "call":
-                        for sub in child.children:
-                            if sub.type == "identifier":
-                                func_name = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
-                                break
-                    elif child.type == "identifier":
-                        func_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                        break
-            if not func_name:
-                return
-            container = parent_module_nid or file_nid
-            func_nid = _make_id(container, func_name)
-            add_node(func_nid, f"{func_name}()", line)
-            if parent_module_nid:
-                add_edge(parent_module_nid, func_nid, "method", line)
-            else:
-                add_edge(file_nid, func_nid, "contains", line)
-            if do_block_node:
-                function_bodies.append((func_nid, do_block_node))
-            return
-
-        if keyword in _IMPORT_KEYWORDS and arguments_node:
-            module_name = _get_alias_text(arguments_node)
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                add_edge(file_nid, tgt_nid, "imports", line)
-            return
-
-        for child in node.children:
-            walk(child, parent_module_nid)
-
-    walk(root)
-
-    label_to_nid: dict[str, str] = {}
-    for n in nodes:
-        normalised = n["label"].strip("()").lstrip(".")
-        label_to_nid[normalised.lower()] = n["id"]
-
-    seen_call_pairs: set[tuple[str, str]] = set()
-    raw_calls: list[dict] = []
-    _SKIP_KEYWORDS = frozenset({
-        "def", "defp", "defmodule", "defmacro", "defmacrop",
-        "defstruct", "defprotocol", "defimpl", "defguard",
-        "alias", "import", "require", "use",
-        "if", "unless", "case", "cond", "with", "for",
-    })
-
-    def walk_calls(node, caller_nid: str) -> None:
-        if node.type != "call":
-            for child in node.children:
-                walk_calls(child, caller_nid)
-            return
-        for child in node.children:
-            if child.type == "identifier":
-                kw = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                if kw in _SKIP_KEYWORDS:
-                    for c in node.children:
-                        walk_calls(c, caller_nid)
-                    return
-                break
-        callee_name: str | None = None
-        for child in node.children:
-            if child.type == "dot":
-                dot_text = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                parts = dot_text.rstrip(".").split(".")
-                if parts:
-                    callee_name = parts[-1]
-                break
-            if child.type == "identifier":
-                callee_name = source[child.start_byte:child.end_byte].decode("utf-8", errors="replace")
-                break
-        if callee_name:
-            tgt_nid = label_to_nid.get(callee_name.lower())
-            if tgt_nid and tgt_nid != caller_nid:
-                pair = (caller_nid, tgt_nid)
-                if pair not in seen_call_pairs:
-                    seen_call_pairs.add(pair)
-                    add_edge(caller_nid, tgt_nid, "calls",
-                             node.start_point[0] + 1, confidence="EXTRACTED", weight=1.0)
-            else:
-                raw_calls.append({
-                    "caller_nid": caller_nid,
-                    "callee": callee_name,
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                })
-        for child in node.children:
-            walk_calls(child, caller_nid)
-
-    for caller_nid, body in function_bodies:
-        walk_calls(body, caller_nid)
-
-    clean_edges = [e for e in edges if e["source"] in seen_ids and
-                   (e["target"] in seen_ids or e["relation"] == "imports")]
-    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls, "input_tokens": 0, "output_tokens": 0}
-
-
-# ── Main extract and collect_files ────────────────────────────────────────────
-
-
-def _check_tree_sitter_version() -> None:
-    """Raise a clear error if tree-sitter is too old for the new Language API."""
-    try:
-        from tree_sitter import LANGUAGE_VERSION
-    except ImportError:
-        raise ImportError(
-            "tree-sitter is not installed. Run: pip install 'tree-sitter>=0.23.0'"
-        )
-    # Language API v2 starts at LANGUAGE_VERSION 14
-    if LANGUAGE_VERSION < 14:
-        import tree_sitter as _ts
-        raise RuntimeError(
-            f"tree-sitter {getattr(_ts, '__version__', 'unknown')} is too old. "
-            f"graphify requires tree-sitter >= 0.23.0 (Language API v2). "
-            f"Run: pip install --upgrade tree-sitter"
-        )
-
-
-def extract(paths: list[Path], cache_root: Path | None = None) -> dict:
-    """Extract AST nodes and edges from a list of code files.
-
-    Two-pass process:
-    1. Per-file structural extraction (classes, functions, imports)
-    2. Cross-file import resolution: turns file-level imports into
-       class-level INFERRED edges (DigestAuth --uses--> Response)
-
-    Args:
-        paths: files to extract from
-        cache_root: explicit root for graphify-out/cache/ (overrides the
-            inferred common path prefix). Pass Path('.') when running on a
-            subdirectory so the cache stays at ./graphify-out/cache/.
-    """
-    _check_tree_sitter_version()
-    per_file: list[dict] = []
-
-    # Infer a common root for cache keys
-    try:
-        if not paths:
-            root = Path(".")
-        elif len(paths) == 1:
-            root = paths[0].parent
-        else:
-            common_len = sum(
-                1 for i in range(min(len(p.parts) for p in paths))
-                if len({p.parts[i] for p in paths}) == 1
-            )
-            root = Path(*paths[0].parts[:common_len]) if common_len else Path(".")
-    except Exception:
-        root = Path(".")
-
-    _DISPATCH: dict[str, Any] = {
-        ".py": extract_python,
-        ".js": extract_js,
-        ".jsx": extract_js,
-        ".mjs": extract_js,
-        ".ts": extract_js,
-        ".tsx": extract_js,
-        ".go": extract_go,
-        ".rs": extract_rust,
-        ".java": extract_java,
-        ".c": extract_c,
-        ".h": extract_c,
-        ".cpp": extract_cpp,
-        ".cc": extract_cpp,
-        ".cxx": extract_cpp,
-        ".hpp": extract_cpp,
-        ".rb": extract_ruby,
-        ".cs": extract_csharp,
-        ".kt": extract_kotlin,
-        ".kts": extract_kotlin,
-        ".scala": extract_scala,
-        ".php": extract_php,
-        ".swift": extract_swift,
-        ".lua": extract_lua,
-        ".toc": extract_lua,
-        ".zig": extract_zig,
-        ".ps1": extract_powershell,
-        ".ex": extract_elixir,
-        ".exs": extract_elixir,
-        ".m": extract_objc,
-        ".mm": extract_objc,
-        ".jl": extract_julia,
-        ".vue": extract_js,
-        ".svelte": extract_js,
-        ".dart": extract_dart,
-        ".v": extract_verilog,
-        ".sv": extract_verilog,
-    }
-
-    total = len(paths)
-    _PROGRESS_INTERVAL = 100
-    for i, path in enumerate(paths):
-        if total >= _PROGRESS_INTERVAL and i % _PROGRESS_INTERVAL == 0 and i > 0:
-            print(f"  AST extraction: {i}/{total} files ({i * 100 // total}%)", flush=True)
-        # .blade.php must be checked before suffix lookup since Path.suffix returns .php
-        if path.name.endswith(".blade.php"):
-            extractor = extract_blade
-        else:
-            extractor = _DISPATCH.get(path.suffix)
-        if extractor is None:
-            continue
-        cached = load_cached(path, cache_root or root)
-        if cached is not None:
-            per_file.append(cached)
-            continue
-        result = extractor(path)
-        if "error" not in result:
-            save_cached(path, result, cache_root or root)
-        per_file.append(result)
-    if total >= _PROGRESS_INTERVAL:
-        print(f"  AST extraction: {total}/{total} files (100%)", flush=True)
-
-    all_nodes: list[dict] = []
-    all_edges: list[dict] = []
-    for result in per_file:
-        all_nodes.extend(result.get("nodes", []))
-        all_edges.extend(result.get("edges", []))
-
-    # Add cross-file class-level edges (Python only - uses Python parser internally)
-    py_paths = [p for p in paths if p.suffix == ".py"]
-    if py_paths:
-        py_results = [r for r, p in zip(per_file, paths) if p.suffix == ".py"]
-        try:
-            cross_file_edges = _resolve_cross_file_imports(py_results, py_paths)
-            all_edges.extend(cross_file_edges)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning("Cross-file import resolution failed, skipping: %s", exc)
-
-    # Cross-file call resolution for all languages
-    # Each extractor saved unresolved calls in raw_calls. Now that we have all
-    # nodes from all files, resolve any callee that exists in another file.
-    global_label_to_nid: dict[str, str] = {}
-    for n in all_nodes:
-        raw = n.get("label", "")
-        normalised = raw.strip("()").lstrip(".")
-        if normalised:
-            global_label_to_nid[normalised.lower()] = n["id"]
-
-    existing_pairs = {(e["source"], e["target"]) for e in all_edges}
-    for result in per_file:
-        for rc in result.get("raw_calls", []):
-            callee = rc.get("callee", "")
-            if not callee:
-                continue
-            tgt = global_label_to_nid.get(callee.lower())
-            caller = rc["caller_nid"]
-            if tgt and tgt != caller and (caller, tgt) not in existing_pairs:
-                existing_pairs.add((caller, tgt))
-                all_edges.append({
-                    "source": caller,
-                    "target": tgt,
-                    "relation": "calls",
-                    "confidence": "INFERRED",
-                    "confidence_score": 0.8,
-                    "source_file": rc.get("source_file", ""),
-                    "source_location": rc.get("source_location"),
-                    "weight": 1.0,
-                })
-
-    return {
-        "nodes": all_nodes,
-        "edges": all_edges,
-        "input_tokens": 0,
-        "output_tokens": 0,
-    }
-
-
-def collect_files(target: Path, *, follow_symlinks: bool = False, root: Path | None = None) -> list[Path]:
-    if target.is_file():
-        return [target]
-    _EXTENSIONS = {
-        ".py", ".js", ".ts", ".tsx", ".go", ".rs",
-        ".java", ".c", ".h", ".cpp", ".cc", ".cxx", ".hpp",
-        ".rb", ".cs", ".kt", ".kts", ".scala", ".php", ".swift",
-        ".lua", ".toc", ".zig", ".ps1",
-        ".m", ".mm",
-    }
-    from graphify.detect import _load_graphifyignore, _is_ignored
-    ignore_root = root if root is not None else target
-    patterns = _load_graphifyignore(ignore_root)
-
-    def _ignored(p: Path) -> bool:
-        return bool(patterns and _is_ignored(p, ignore_root, patterns))
-
-    if not follow_symlinks:
-        results: list[Path] = []
-        for ext in sorted(_EXTENSIONS):
-            results.extend(
-                p for p in target.rglob(f"*{ext}")
-                if not any(part.startswith(".") for part in p.parts)
-                and not _ignored(p)
-            )
-        return sorted(results)
-    # Walk with symlink following + cycle detection
-    results = []
-    for dirpath, dirnames, filenames in os.walk(target, followlinks=True):
-        if os.path.islink(dirpath):
-            real = os.path.realpath(dirpath)
-            parent_real = os.path.realpath(os.path.dirname(dirpath))
-            if parent_real == real or parent_real.startswith(real + os.sep):
-                dirnames.clear()
-                continue
-        dp = Path(dirpath)
-        if any(part.startswith(".") for part in dp.parts):
-            dirnames.clear()
-            continue
-        for fname in filenames:
-            p = dp / fname
-            if p.suffix in _EXTENSIONS and not fname.startswith(".") and not _ignored(p):
-                results.append(p)
-    return sorted(results)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python -m graphify.extract <file_or_dir> ...", file=sys.stderr)
-        sys.exit(1)
-
-    paths: list[Path] = []
-    for arg in sys.argv[1:]:
-        paths.extend(collect_files(Path(arg)))
-
-    result = extract(paths)
-    print(json.dumps(result, indent=2))