knowledge-master 0.2.0__tar.gz → 0.3.0__tar.gz

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-master
-Version: 0.2.0
+Version: 0.3.0
 Summary: Local-first knowledge graph for developers. Your AI agent's permanent memory.
 Author: Milenko Mitrovic
 License: MIT
@@ -28,6 +28,11 @@ Requires-Dist: rich<15.0,>=14.0.0
 Requires-Dist: fastapi<1.0,>=0.115.0
 Requires-Dist: uvicorn<1.0,>=0.34.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
 Provides-Extra: office
 Requires-Dist: python-docx<2.0,>=1.1.0; extra == "office"
 Requires-Dist: openpyxl<4.0,>=3.1.0; extra == "office"

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/knowledge_master/parsers/git_repo.py

@@ -9,7 +9,7 @@ from rich.progress import Progress
 
 from .. import chunking, embeddings, store
 from ..intelligence import extract_all
-from ..static_analysis import build_import_graph
+from ..static_analysis import build_import_graph_all
 
 INDEXABLE_EXTENSIONS = {
     ".py", ".ts", ".tsx", ".js", ".rs", ".go", ".java",
@@ -62,8 +62,8 @@ def index_repo(repo_path: str, graph=None, branch: str = "HEAD", on_progress=Non
     # Run intelligence extraction
     intel = extract_all(repo_path, graph)
 
-    # Run static analysis (import graph, symbols)
-    static = build_import_graph(repo_path, graph)
+    # Run static analysis (import graph, symbols) — all languages
+    static = build_import_graph_all(repo_path, graph)
 
     return {"repo": repo_name, "files_indexed": total, "intelligence": intel, "static_analysis": static}
 

knowledge_master-0.3.0/knowledge_master/static_analysis.py

@@ -0,0 +1,306 @@
+"""Static analysis — extract import graphs, symbols, and call relationships from code."""
+
+import ast
+import os
+from pathlib import Path
+
+
+def extract_python_graph(file_path: str) -> dict:
+    """Extract imports, exports (top-level functions/classes), and calls from a Python file."""
+    try:
+        source = Path(file_path).read_text(errors="ignore")
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        return {"imports": [], "exports": [], "calls": [], "path": file_path}
+
+    imports = []
+    exports = []
+    calls = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({"module": alias.name, "alias": alias.asname, "names": []})
+        elif isinstance(node, ast.ImportFrom):
+            imports.append({
+                "module": node.module or "",
+                "names": [a.name for a in node.names],
+                "level": node.level,
+            })
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if node.col_offset == 0:  # top-level function
+                exports.append({"name": node.name, "type": "function", "line": node.lineno})
+        elif isinstance(node, ast.ClassDef):
+            if node.col_offset == 0:  # top-level class
+                bases = [_node_name(b) for b in node.bases]
+                exports.append({"name": node.name, "type": "class", "line": node.lineno, "bases": bases})
+
+    return {"imports": imports, "exports": exports, "calls": calls, "path": file_path}
+
+
+def resolve_import(module: str, level: int, source_file: str, repo_root: str) -> str | None:
+    """Resolve an import to a file path within the repo."""
+    if level > 0:
+        # Relative import: go up `level` directories from source file's package
+        source_dir = Path(os.path.join(repo_root, source_file)).parent
+        for _ in range(level - 1):
+            source_dir = source_dir.parent
+        parts = module.split(".") if module else []
+        candidate = source_dir / Path(*parts) if parts else source_dir
+    else:
+        # Absolute import — check if it's a local module
+        parts = module.split(".")
+        candidate = Path(repo_root) / Path(*parts)
+
+    # Try as module.py or package/__init__.py
+    as_file = str(candidate) + ".py"
+    as_pkg = str(candidate / "__init__.py")
+
+    if os.path.exists(as_file):
+        return os.path.relpath(as_file, repo_root)
+    if os.path.exists(as_pkg):
+        return os.path.relpath(as_pkg, repo_root)
+
+    return None
+
+
+def build_import_graph(repo_path: str, graph):
+    """Walk a repo, extract Python imports, store as IMPORTS edges between File nodes."""
+    repo_path = str(Path(repo_path).resolve())
+    repo_name = Path(repo_path).name
+    py_files = list(Path(repo_path).rglob("*.py"))
+    py_files = [f for f in py_files if not any(
+        p in f.parts for p in (".venv", "venv", "node_modules", "__pycache__", ".git", "site-packages")
+    )]
+
+    file_exports = {}  # relative_path -> [exported symbols]
+    file_imports = {}  # relative_path -> [import info]
+
+    # Pass 1: collect exports and imports
+    for py_file in py_files:
+        relative = os.path.relpath(str(py_file), repo_path)
+        result = extract_python_graph(str(py_file))
+        file_exports[relative] = result["exports"]
+        file_imports[relative] = result["imports"]
+
+        # Store Function/Class nodes
+        for export in result["exports"]:
+            node_type = "Function" if export["type"] == "function" else "Class"
+            graph.query(
+                f"MERGE (s:{node_type} {{name: $name, file: $file, repo: $repo}}) SET s.line = $line",
+                params={"name": export["name"], "file": relative, "repo": repo_name, "line": export["line"]},
+            )
+            # Link symbol to file
+            graph.query(
+                f"""MATCH (s:{node_type} {{name: $name, file: $file}}), (d:Document {{path: $file}})
+                    MERGE (s)-[:DEFINED_IN]->(d)""",
+                params={"name": export["name"], "file": relative},
+            )
+
+    # Pass 2: resolve imports to file paths, create IMPORTS edges
+    edges_created = 0
+    for source_file, imports in file_imports.items():
+        for imp in imports:
+            module = imp.get("module", "")
+            level = imp.get("level", 0)
+            names = imp.get("names", [])
+
+            if module:
+                # from module import X  or  import module
+                target_file = resolve_import(module, level, source_file, repo_path)
+                if target_file and target_file in file_exports:
+                    graph.query(
+                        """MERGE (src:Document {path: $src})
+                           MERGE (dst:Document {path: $dst})
+                           MERGE (src)-[:IMPORTS {names: $names}]->(dst)""",
+                        params={"src": source_file, "dst": target_file, "names": names},
+                    )
+                    edges_created += 1
+            elif level > 0 and names:
+                # from . import module1, module2 — each name is a sibling module
+                for name in names:
+                    target_file = resolve_import(name, level, source_file, repo_path)
+                    if target_file and target_file in file_exports:
+                        graph.query(
+                            """MERGE (src:Document {path: $src})
+                               MERGE (dst:Document {path: $dst})
+                               MERGE (src)-[:IMPORTS {names: $imp_names}]->(dst)""",
+                            params={"src": source_file, "dst": target_file, "imp_names": [name]},
+                        )
+                        edges_created += 1
+
+    return {"files_analyzed": len(py_files), "import_edges": edges_created, "symbols": sum(len(v) for v in file_exports.values())}
+
+
+def _node_name(node) -> str:
+    """Get string name from an AST node."""
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return f"{_node_name(node.value)}.{node.attr}"
+    return ""
+
+
+def build_import_graph_all(repo_path: str, graph):
+    """Build import graph for all supported languages in the repo."""
+    repo_path = str(Path(repo_path).resolve())
+    results = {"python": {}, "typescript": {}, "go": {}, "rust": {}}
+
+    # Python (AST-based)
+    results["python"] = build_import_graph(repo_path, graph)
+
+    # TypeScript/JavaScript (tree-sitter)
+    results["typescript"] = _build_ts_import_graph(repo_path, graph)
+
+    # Go (tree-sitter)
+    results["go"] = _build_go_import_graph(repo_path, graph)
+
+    # Rust (tree-sitter)
+    results["rust"] = _build_rust_import_graph(repo_path, graph)
+
+    total_edges = sum(r.get("import_edges", 0) for r in results.values())
+    total_symbols = sum(r.get("symbols", 0) for r in results.values())
+    total_files = sum(r.get("files_analyzed", 0) for r in results.values())
+
+    return {"files_analyzed": total_files, "import_edges": total_edges, "symbols": total_symbols, "by_language": results}
+
+
+def _build_ts_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for TypeScript/JavaScript files."""
+    from .ts_parsers import extract_typescript_graph, resolve_ts_import
+
+    skip = {".git", "node_modules", "dist", "build", ".venv", "__pycache__"}
+    ts_files = []
+    for ext in (".ts", ".tsx", ".js", ".jsx"):
+        for f in Path(repo_path).rglob(f"*{ext}"):
+            if not any(p in f.parts for p in skip):
+                ts_files.append(f)
+
+    if not ts_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    edges = 0
+    symbols = 0
+    for ts_file in ts_files:
+        relative = os.path.relpath(str(ts_file), repo_path)
+        try:
+            result = extract_typescript_graph(str(ts_file))
+        except Exception:
+            continue
+
+        # Store exports as symbols
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'typescript'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        # Resolve imports and create edges
+        for imp in result["imports"]:
+            target = resolve_ts_import(imp["module"], relative, repo_path)
+            if target:
+                graph.query(
+                    """MERGE (src:Document {path: $src})
+                       MERGE (dst:Document {path: $dst})
+                       MERGE (src)-[:IMPORTS {names: $names, lang: 'typescript'}]->(dst)""",
+                    params={"src": relative, "dst": target, "names": imp.get("names", [])},
+                )
+                edges += 1
+
+    return {"files_analyzed": len(ts_files), "import_edges": edges, "symbols": symbols}
+
+
+def _build_go_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for Go files."""
+    from .ts_parsers import extract_go_graph, resolve_go_import
+
+    skip = {".git", "vendor", "node_modules"}
+    go_files = [f for f in Path(repo_path).rglob("*.go") if not any(p in f.parts for p in skip)]
+
+    if not go_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    # Read go.mod for module name
+    go_module = ""
+    gomod = Path(repo_path) / "go.mod"
+    if gomod.exists():
+        for line in gomod.read_text().splitlines():
+            if line.startswith("module "):
+                go_module = line.split()[1]
+                break
+
+    edges = 0
+    symbols = 0
+    for go_file in go_files:
+        relative = os.path.relpath(str(go_file), repo_path)
+        try:
+            result = extract_go_graph(str(go_file))
+        except Exception:
+            continue
+
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'go'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        for imp in result["imports"]:
+            target = resolve_go_import(imp["module"], repo_path, go_module)
+            if target:
+                graph.query(
+                    """MERGE (src:Document {path: $src})
+                       MERGE (dst:Document {path: $dst})
+                       MERGE (src)-[:IMPORTS {names: $names, lang: 'go'}]->(dst)""",
+                    params={"src": relative, "dst": target, "names": []},
+                )
+                edges += 1
+
+    return {"files_analyzed": len(go_files), "import_edges": edges, "symbols": symbols}
+
+
+def _build_rust_import_graph(repo_path: str, graph) -> dict:
+    """Build import graph for Rust files."""
+    from .ts_parsers import extract_rust_graph
+
+    skip = {".git", "target", "node_modules"}
+    rs_files = [f for f in Path(repo_path).rglob("*.rs") if not any(p in f.parts for p in skip)]
+
+    if not rs_files:
+        return {"files_analyzed": 0, "import_edges": 0, "symbols": 0}
+
+    edges = 0
+    symbols = 0
+    for rs_file in rs_files:
+        relative = os.path.relpath(str(rs_file), repo_path)
+        try:
+            result = extract_rust_graph(str(rs_file))
+        except Exception:
+            continue
+
+        for export in result["exports"]:
+            graph.query(
+                "MERGE (f:Function {name: $name, file: $file}) SET f.line = $line, f.lang = 'rust'",
+                params={"name": export["name"], "file": relative, "line": export.get("line", 0)},
+            )
+            symbols += 1
+
+        # Rust mod resolution: mod foo -> foo.rs or foo/mod.rs
+        for imp in result["imports"]:
+            if imp.get("is_mod"):
+                mod_name = imp["module"]
+                src_dir = Path(os.path.join(repo_path, relative)).parent
+                for candidate in [src_dir / f"{mod_name}.rs", src_dir / mod_name / "mod.rs"]:
+                    if candidate.exists():
+                        target = os.path.relpath(str(candidate), repo_path)
+                        graph.query(
+                            """MERGE (src:Document {path: $src})
+                               MERGE (dst:Document {path: $dst})
+                               MERGE (src)-[:IMPORTS {names: [], lang: 'rust'}]->(dst)""",
+                            params={"src": relative, "dst": target},
+                        )
+                        edges += 1
+                        break
+
+    return {"files_analyzed": len(rs_files), "import_edges": edges, "symbols": symbols}

knowledge_master-0.3.0/knowledge_master/ts_parsers.py

@@ -0,0 +1,192 @@
+"""Tree-sitter based import graph extraction for TypeScript, Go, and Rust."""
+
+import os
+from pathlib import Path
+
+from tree_sitter import Language, Parser
+import tree_sitter_typescript as ts_ts
+import tree_sitter_go as ts_go
+import tree_sitter_rust as ts_rust
+import tree_sitter_javascript as ts_js
+
+# Initialize languages
+TYPESCRIPT = Language(ts_ts.language_typescript())
+TSX = Language(ts_ts.language_tsx())
+JAVASCRIPT = Language(ts_js.language())
+GO = Language(ts_go.language())
+RUST = Language(ts_rust.language())
+
+
+def extract_typescript_graph(file_path: str) -> dict:
+    """Extract imports and exports from a TypeScript/JavaScript file."""
+    source = Path(file_path).read_bytes()
+    lang = TSX if file_path.endswith(".tsx") else (JAVASCRIPT if file_path.endswith(".js") else TYPESCRIPT)
+    parser = Parser(lang)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # import { X } from './module'  |  import X from 'module'
+        if node.type == "import_statement":
+            source_node = node.child_by_field_name("source")
+            if source_node:
+                module = source_node.text.decode().strip("'\"")
+                names = []
+                for child in node.children:
+                    if child.type == "import_clause":
+                        for spec in _walk(child):
+                            if spec.type == "identifier":
+                                names.append(spec.text.decode())
+                            elif spec.type == "import_specifier":
+                                name_node = spec.child_by_field_name("name")
+                                if name_node:
+                                    names.append(name_node.text.decode())
+                imports.append({"module": module, "names": names})
+
+        # require('module')
+        elif node.type == "call_expression":
+            func = node.child_by_field_name("function")
+            if func and func.text == b"require":
+                args = node.child_by_field_name("arguments")
+                if args and args.child_count > 1:
+                    arg = args.children[1]
+                    if arg.type == "string":
+                        imports.append({"module": arg.text.decode().strip("'\""), "names": []})
+
+        # export function/class/const
+        elif node.type in ("export_statement", "export_default_declaration"):
+            decl = node.child_by_field_name("declaration")
+            if decl:
+                name_node = decl.child_by_field_name("name")
+                if name_node:
+                    exports.append({"name": name_node.text.decode(), "type": decl.type, "line": decl.start_point[0] + 1})
+            # export { x, y }
+            for child in node.children:
+                if child.type == "export_clause":
+                    for spec in _walk(child):
+                        if spec.type == "export_specifier":
+                            name_node = spec.child_by_field_name("name")
+                            if name_node:
+                                exports.append({"name": name_node.text.decode(), "type": "re-export", "line": spec.start_point[0] + 1})
+
+        # Top-level function/class declarations
+        elif node.type in ("function_declaration", "class_declaration") and node.parent.type in ("program", "export_statement"):
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                exports.append({"name": name_node.text.decode(), "type": node.type, "line": node.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def extract_go_graph(file_path: str) -> dict:
+    """Extract imports and exports from a Go file."""
+    source = Path(file_path).read_bytes()
+    parser = Parser(GO)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # import "pkg" or import ( "pkg1"; "pkg2" )
+        if node.type == "import_declaration":
+            for child in _walk(node):
+                if child.type == "import_spec":
+                    path_node = child.child_by_field_name("path")
+                    if path_node:
+                        module = path_node.text.decode().strip('"')
+                        imports.append({"module": module, "names": []})
+                elif child.type == "interpreted_string_literal":
+                    imports.append({"module": child.text.decode().strip('"'), "names": []})
+
+        # Exported functions (capitalized)
+        elif node.type == "function_declaration":
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                name = name_node.text.decode()
+                if name[0].isupper():  # Go exports are capitalized
+                    exports.append({"name": name, "type": "function", "line": node.start_point[0] + 1})
+
+        # Exported types
+        elif node.type == "type_declaration":
+            for spec in node.children:
+                if spec.type == "type_spec":
+                    name_node = spec.child_by_field_name("name")
+                    if name_node:
+                        name = name_node.text.decode()
+                        if name[0].isupper():
+                            exports.append({"name": name, "type": "type", "line": spec.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def extract_rust_graph(file_path: str) -> dict:
+    """Extract use statements and pub items from a Rust file."""
+    source = Path(file_path).read_bytes()
+    parser = Parser(RUST)
+    tree = parser.parse(source)
+
+    imports = []
+    exports = []
+
+    for node in _walk(tree.root_node):
+        # use std::collections::HashMap;  |  use crate::module::Item;
+        if node.type == "use_declaration":
+            path_text = ""
+            for child in _walk(node):
+                if child.type in ("scoped_identifier", "identifier", "use_wildcard", "scoped_use_list"):
+                    path_text = child.text.decode()
+                    break
+            if path_text:
+                module = path_text.split("::")[0]
+                names = path_text.split("::")[-1:] if "::" in path_text else []
+                imports.append({"module": module, "path": path_text, "names": names})
+
+        # mod declarations
+        elif node.type == "mod_item":
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                imports.append({"module": name_node.text.decode(), "names": [], "is_mod": True})
+
+        # pub fn / pub struct / pub enum
+        elif node.type in ("function_item", "struct_item", "enum_item", "impl_item"):
+            is_pub = any(c.type == "visibility_modifier" for c in node.children)
+            name_node = node.child_by_field_name("name")
+            if name_node and is_pub:
+                exports.append({"name": name_node.text.decode(), "type": node.type.replace("_item", ""), "line": node.start_point[0] + 1})
+
+    return {"imports": imports, "exports": exports, "path": file_path}
+
+
+def resolve_ts_import(module: str, source_file: str, repo_root: str) -> str | None:
+    """Resolve a TypeScript/JS import to a file path."""
+    if not module.startswith("."):
+        return None  # external package
+
+    source_dir = Path(os.path.join(repo_root, source_file)).parent
+    candidate = source_dir / module
+
+    for suffix in [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"]:
+        path = str(candidate) + suffix
+        if os.path.exists(path):
+            return os.path.relpath(path, repo_root)
+    return None
+
+
+def resolve_go_import(module: str, repo_root: str, go_module: str = "") -> str | None:
+    """Resolve a Go import to a directory in the repo."""
+    if go_module and module.startswith(go_module):
+        relative = module[len(go_module):].lstrip("/")
+        candidate = os.path.join(repo_root, relative)
+        if os.path.isdir(candidate):
+            return relative
+    return None
+
+
+def _walk(node):
+    """Recursively walk tree-sitter nodes."""
+    yield node
+    for child in node.children:
+        yield from _walk(child)

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/knowledge_master.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-master
-Version: 0.2.0
+Version: 0.3.0
 Summary: Local-first knowledge graph for developers. Your AI agent's permanent memory.
 Author: Milenko Mitrovic
 License: MIT
@@ -28,6 +28,11 @@ Requires-Dist: rich<15.0,>=14.0.0
 Requires-Dist: fastapi<1.0,>=0.115.0
 Requires-Dist: uvicorn<1.0,>=0.34.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
 Provides-Extra: office
 Requires-Dist: python-docx<2.0,>=1.1.0; extra == "office"
 Requires-Dist: openpyxl<4.0,>=3.1.0; extra == "office"

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/knowledge_master.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ knowledge_master/rerank.py
 knowledge_master/server.py
 knowledge_master/static_analysis.py
 knowledge_master/store.py
+knowledge_master/ts_parsers.py
 knowledge_master/watcher.py
 knowledge_master/web.py
 knowledge_master.egg-info/PKG-INFO

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/knowledge_master.egg-info/requires.txt

@@ -7,6 +7,11 @@ rich<15.0,>=14.0.0
 fastapi<1.0,>=0.115.0
 uvicorn<1.0,>=0.34.0
 pyyaml>=6.0
+tree-sitter>=0.23.0
+tree-sitter-javascript>=0.23.0
+tree-sitter-typescript>=0.23.0
+tree-sitter-go>=0.23.0
+tree-sitter-rust>=0.23.0
 
 [dev]
 pytest>=8.0

{knowledge_master-0.2.0 → knowledge_master-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "knowledge-master"
-version = "0.2.0"
+version = "0.3.0"
 description = "Local-first knowledge graph for developers. Your AI agent's permanent memory."
 requires-python = ">=3.11"
 license = {text = "MIT"}
@@ -27,6 +27,11 @@ dependencies = [
     "fastapi>=0.115.0,<1.0",
     "uvicorn>=0.34.0,<1.0",
     "pyyaml>=6.0",
+    "tree-sitter>=0.23.0",
+    "tree-sitter-javascript>=0.23.0",
+    "tree-sitter-typescript>=0.23.0",
+    "tree-sitter-go>=0.23.0",
+    "tree-sitter-rust>=0.23.0",
 ]
 
 [project.optional-dependencies]

knowledge_master-0.2.0/knowledge_master/static_analysis.py

@@ -1,141 +0,0 @@
-"""Static analysis — extract import graphs, symbols, and call relationships from code."""
-
-import ast
-import os
-from pathlib import Path
-
-
-def extract_python_graph(file_path: str) -> dict:
-    """Extract imports, exports (top-level functions/classes), and calls from a Python file."""
-    try:
-        source = Path(file_path).read_text(errors="ignore")
-        tree = ast.parse(source)
-    except (SyntaxError, ValueError):
-        return {"imports": [], "exports": [], "calls": [], "path": file_path}
-
-    imports = []
-    exports = []
-    calls = []
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                imports.append({"module": alias.name, "alias": alias.asname, "names": []})
-        elif isinstance(node, ast.ImportFrom):
-            imports.append({
-                "module": node.module or "",
-                "names": [a.name for a in node.names],
-                "level": node.level,
-            })
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            if node.col_offset == 0:  # top-level function
-                exports.append({"name": node.name, "type": "function", "line": node.lineno})
-        elif isinstance(node, ast.ClassDef):
-            if node.col_offset == 0:  # top-level class
-                bases = [_node_name(b) for b in node.bases]
-                exports.append({"name": node.name, "type": "class", "line": node.lineno, "bases": bases})
-
-    return {"imports": imports, "exports": exports, "calls": calls, "path": file_path}
-
-
-def resolve_import(module: str, level: int, source_file: str, repo_root: str) -> str | None:
-    """Resolve an import to a file path within the repo."""
-    if level > 0:
-        # Relative import: go up `level` directories from source file's package
-        source_dir = Path(os.path.join(repo_root, source_file)).parent
-        for _ in range(level - 1):
-            source_dir = source_dir.parent
-        parts = module.split(".") if module else []
-        candidate = source_dir / Path(*parts) if parts else source_dir
-    else:
-        # Absolute import — check if it's a local module
-        parts = module.split(".")
-        candidate = Path(repo_root) / Path(*parts)
-
-    # Try as module.py or package/__init__.py
-    as_file = str(candidate) + ".py"
-    as_pkg = str(candidate / "__init__.py")
-
-    if os.path.exists(as_file):
-        return os.path.relpath(as_file, repo_root)
-    if os.path.exists(as_pkg):
-        return os.path.relpath(as_pkg, repo_root)
-
-    return None
-
-
-def build_import_graph(repo_path: str, graph):
-    """Walk a repo, extract Python imports, store as IMPORTS edges between File nodes."""
-    repo_path = str(Path(repo_path).resolve())
-    repo_name = Path(repo_path).name
-    py_files = list(Path(repo_path).rglob("*.py"))
-    py_files = [f for f in py_files if not any(
-        p in f.parts for p in (".venv", "venv", "node_modules", "__pycache__", ".git", "site-packages")
-    )]
-
-    file_exports = {}  # relative_path -> [exported symbols]
-    file_imports = {}  # relative_path -> [import info]
-
-    # Pass 1: collect exports and imports
-    for py_file in py_files:
-        relative = os.path.relpath(str(py_file), repo_path)
-        result = extract_python_graph(str(py_file))
-        file_exports[relative] = result["exports"]
-        file_imports[relative] = result["imports"]
-
-        # Store Function/Class nodes
-        for export in result["exports"]:
-            node_type = "Function" if export["type"] == "function" else "Class"
-            graph.query(
-                f"MERGE (s:{node_type} {{name: $name, file: $file, repo: $repo}}) SET s.line = $line",
-                params={"name": export["name"], "file": relative, "repo": repo_name, "line": export["line"]},
-            )
-            # Link symbol to file
-            graph.query(
-                f"""MATCH (s:{node_type} {{name: $name, file: $file}}), (d:Document {{path: $file}})
-                    MERGE (s)-[:DEFINED_IN]->(d)""",
-                params={"name": export["name"], "file": relative},
-            )
-
-    # Pass 2: resolve imports to file paths, create IMPORTS edges
-    edges_created = 0
-    for source_file, imports in file_imports.items():
-        for imp in imports:
-            module = imp.get("module", "")
-            level = imp.get("level", 0)
-            names = imp.get("names", [])
-
-            if module:
-                # from module import X  or  import module
-                target_file = resolve_import(module, level, source_file, repo_path)
-                if target_file and target_file in file_exports:
-                    graph.query(
-                        """MERGE (src:Document {path: $src})
-                           MERGE (dst:Document {path: $dst})
-                           MERGE (src)-[:IMPORTS {names: $names}]->(dst)""",
-                        params={"src": source_file, "dst": target_file, "names": names},
-                    )
-                    edges_created += 1
-            elif level > 0 and names:
-                # from . import module1, module2 — each name is a sibling module
-                for name in names:
-                    target_file = resolve_import(name, level, source_file, repo_path)
-                    if target_file and target_file in file_exports:
-                        graph.query(
-                            """MERGE (src:Document {path: $src})
-                               MERGE (dst:Document {path: $dst})
-                               MERGE (src)-[:IMPORTS {names: $imp_names}]->(dst)""",
-                            params={"src": source_file, "dst": target_file, "imp_names": [name]},
-                        )
-                        edges_created += 1
-
-    return {"files_analyzed": len(py_files), "import_edges": edges_created, "symbols": sum(len(v) for v in file_exports.values())}
-
-
-def _node_name(node) -> str:
-    """Get string name from an AST node."""
-    if isinstance(node, ast.Name):
-        return node.id
-    elif isinstance(node, ast.Attribute):
-        return f"{_node_name(node.value)}.{node.attr}"
-    return ""