codegraph-nav 0.1.0__py3-none-any.whl

codegraph_nav/graph/builder.py

@@ -0,0 +1,409 @@
+"""GraphBuilder — Build SQLite graph from .codegraph.json code map.
+
+Converts the flat JSON symbol index into a queryable graph with nodes,
+edges (CALLS, CONTAINS, INHERITS, IMPORTS_FROM, TESTED_BY), and an
+optional FTS5 full-text index. Supports incremental builds via file hashing.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any
+
+from .schema import make_qualified_name
+from .store import GraphStore
+
+# Regex patterns for test file detection (same as mcp/server.py)
+_TEST_FILE_PATTERNS = [
+    re.compile(r"test_[^/]*\.py$"),
+    re.compile(r"[^/]*_test\.py$"),
+    re.compile(r"[^/]*\.test\.[jt]sx?$"),
+    re.compile(r"[^/]*\.spec\.[jt]sx?$"),
+    re.compile(r"(^|/)tests/"),
+    re.compile(r"(^|/)__tests__/"),
+    re.compile(r"(^|/)test/"),
+]
+
+
+def _is_test_file(file_path: str) -> bool:
+    for p in _TEST_FILE_PATTERNS:
+        if p.search(file_path):
+            return True
+    return False
+
+
+def _detect_language(file_path: str) -> str:
+    ext = Path(file_path).suffix.lower()
+    return {
+        ".py": "python",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".mjs": "javascript",
+        ".java": "java",
+        ".go": "go",
+        ".rs": "rust",
+        ".rb": "ruby",
+        ".php": "php",
+        ".c": "c",
+        ".h": "c",
+        ".cpp": "cpp",
+        ".hpp": "cpp",
+    }.get(ext, "unknown")
+
+
+def _extract_bases_from_signature(signature: str | None) -> list[str]:
+    """Extract base class names from a class signature like 'class Foo(Base, Mixin)'."""
+    if not signature:
+        return []
+    m = re.search(r"class\s+\w+\((.*?)\)", signature)
+    if not m:
+        return []
+    bases_str = m.group(1)
+    return [b.strip() for b in bases_str.split(",") if b.strip()]
+
+
+class GraphBuilder:
+    """Builds a graph DB from a code_map dict."""
+
+    def __init__(self, store: GraphStore):
+        self.store = store
+
+    def build_from_code_map(
+        self,
+        code_map: dict,
+        root_path: str = "",
+        incremental: bool = True,
+    ) -> dict:
+        """Build graph DB from code_map. Returns build stats.
+
+        Args:
+            code_map: The code map dict (from .codegraph.json).
+            root_path: Project root path.
+            incremental: If True, skip unchanged files (by hash).
+
+        Returns:
+            Dict with files_processed, files_skipped, nodes_created, edges_created, etc.
+        """
+        start = time.time()
+        files = code_map.get("files", {})
+        index = code_map.get("index", {})
+
+        stats: dict[str, float] = {
+            "files_processed": 0,
+            "files_skipped": 0,
+            "nodes_created": 0,
+            "edges_created": 0,
+            "errors": 0,
+        }
+
+        # Phase 1: Build nodes and intra-file edges
+        # Collect all symbol qualified names for resolution
+        all_symbols: dict[str, list[str]] = {}  # name_lower → [qualified_names]
+
+        # First pass: determine which files need processing
+        files_to_process = {}
+        files_to_skip = set()
+
+        for file_path, file_info in files.items():
+            file_hash = file_info.get("hash", "")
+            if incremental:
+                stored_hash = self.store.get_file_hash(file_path)
+                if stored_hash and stored_hash == file_hash:
+                    files_to_skip.add(file_path)
+                    stats["files_skipped"] += 1
+                    continue
+            files_to_process[file_path] = file_info
+
+        # Delete stale files (in DB but not in code_map)
+        db_files = {row["file_path"] for row in self.store.get_all_nodes("File")}
+        stale_files = db_files - set(files.keys())
+        for stale in stale_files:
+            self.store.delete_file_nodes(stale)
+
+        # Load existing symbols from skipped files for resolution
+        for file_path in files_to_skip:
+            for row in self.store.get_nodes_by_file(file_path):
+                name_lower = row["name"].lower()
+                all_symbols.setdefault(name_lower, []).append(row["qualified_name"])
+
+        # Second pass: process files
+        for file_path, file_info in files_to_process.items():
+            try:
+                self._process_file(file_path, file_info, all_symbols, stats)
+            except Exception:
+                stats["errors"] += 1
+
+        # Phase 2: Resolve CALLS edges (cross-file)
+        self._resolve_calls_edges(files, index, all_symbols, stats)
+
+        # Phase 3: Create IMPORTS_FROM edges
+        self._create_import_edges(files, stats)
+
+        # Phase 4: Create TESTED_BY edges
+        self._create_tested_by_edges(files, all_symbols, stats)
+
+        # Phase 5: Rebuild FTS5 index
+        if self.store.fts_available:
+            self._rebuild_fts()
+
+        stats["build_time"] = round(time.time() - start, 3)
+        return stats
+
+    def _process_file(
+        self,
+        file_path: str,
+        file_info: dict,
+        all_symbols: dict[str, list[str]],
+        stats: dict,
+    ):
+        """Process a single file: create nodes and intra-file edges."""
+        file_hash = file_info.get("hash", "")
+        language = _detect_language(file_path)
+        is_test = _is_test_file(file_path)
+        symbols = file_info.get("symbols", [])
+
+        # Delete old data for this file
+        self.store.delete_file_nodes(file_path)
+
+        # Create File node
+        file_qn = file_path
+        nodes = [
+            {
+                "kind": "File",
+                "name": Path(file_path).name,
+                "qualified_name": file_qn,
+                "file_path": file_path,
+                "language": language,
+                "is_test": is_test,
+                "file_hash": file_hash,
+            }
+        ]
+
+        edges: list[dict[str, Any]] = []
+
+        for sym in symbols:
+            name = sym.get("name", "")
+            sym_type = sym.get("type", "function")
+            parent = sym.get("parent")
+            lines = sym.get("lines", [0, 0])
+            line_start = lines[0] if lines else None
+            line_end = lines[1] if len(lines) > 1 else line_start
+
+            kind = {
+                "function": "Function",
+                "class": "Class",
+                "method": "Method",
+                "variable": "Variable",
+            }.get(sym_type, "Function")
+
+            qn = make_qualified_name(file_path, name, parent)
+
+            nodes.append(
+                {
+                    "kind": kind,
+                    "name": name,
+                    "qualified_name": qn,
+                    "file_path": file_path,
+                    "line_start": line_start,
+                    "line_end": line_end,
+                    "language": language,
+                    "parent_name": parent,
+                    "signature": sym.get("signature"),
+                    "is_test": is_test,
+                    "file_hash": file_hash,
+                }
+            )
+
+            # Track for resolution
+            all_symbols.setdefault(name.lower(), []).append(qn)
+
+            # CONTAINS edge: file → symbol, or class → method
+            if parent:
+                parent_qn = make_qualified_name(file_path, parent)
+                edges.append(
+                    {
+                        "kind": "CONTAINS",
+                        "source_qualified": parent_qn,
+                        "target_qualified": qn,
+                        "file_path": file_path,
+                    }
+                )
+            else:
+                edges.append(
+                    {
+                        "kind": "CONTAINS",
+                        "source_qualified": file_qn,
+                        "target_qualified": qn,
+                        "file_path": file_path,
+                    }
+                )
+
+            # INHERITS edge for classes
+            if kind == "Class":
+                bases = _extract_bases_from_signature(sym.get("signature"))
+                for base_name in bases:
+                    # Store with unresolved target; will resolve later
+                    edges.append(
+                        {
+                            "kind": "INHERITS",
+                            "source_qualified": qn,
+                            "target_qualified": f"__unresolved__::{base_name}",
+                            "file_path": file_path,
+                            "extra": {"raw_target": base_name},
+                        }
+                    )
+
+            # CALLS edges (intra-file, same file deps)
+            deps = sym.get("deps") or sym.get("dependencies") or []
+            for dep_name in deps:
+                # Try same-file resolution
+                dep_qn = None
+                for s in symbols:
+                    if s.get("name") == dep_name:
+                        dep_qn = make_qualified_name(file_path, dep_name, s.get("parent"))
+                        break
+                if not dep_qn:
+                    dep_qn = f"__unresolved__::{dep_name}"
+
+                edges.append(
+                    {
+                        "kind": "CALLS",
+                        "source_qualified": qn,
+                        "target_qualified": dep_qn,
+                        "file_path": file_path,
+                        "extra": {"raw_target": dep_name},
+                    }
+                )
+
+        self.store.batch_upsert_nodes(nodes)
+        self.store.batch_upsert_edges(edges)
+        stats["files_processed"] += 1
+        stats["nodes_created"] += len(nodes)
+        stats["edges_created"] += len(edges)
+
+    def _resolve_calls_edges(
+        self,
+        files: dict,
+        index: dict,
+        all_symbols: dict[str, list[str]],
+        stats: dict,
+    ):
+        """Resolve __unresolved__ CALLS/INHERITS edges using the global index."""
+        unresolved = self.store.conn.execute(
+            "SELECT id, kind, source_qualified, target_qualified, file_path, extra "
+            "FROM edges WHERE target_qualified LIKE '__unresolved__%'"
+        ).fetchall()
+
+        updates = []
+        for edge in unresolved:
+            raw_target = edge["target_qualified"].split("::", 1)[-1]
+            source_file = edge["file_path"]
+
+            # Resolution strategies
+            resolved_qn = None
+
+            # 1. Check index for symbol name
+            candidates = all_symbols.get(raw_target.lower(), [])
+            if len(candidates) == 1:
+                resolved_qn = candidates[0]
+            elif len(candidates) > 1:
+                # Prefer same-file, then imported files
+                file_imports = files.get(source_file, {}).get("imports", [])
+                for c in candidates:
+                    c_file = c.split("::")[0]
+                    if c_file == source_file:
+                        resolved_qn = c
+                        break
+                if not resolved_qn:
+                    for c in candidates:
+                        c_file = c.split("::")[0]
+                        if c_file in file_imports or any(
+                            c_file.endswith(imp) for imp in file_imports
+                        ):
+                            resolved_qn = c
+                            break
+                if not resolved_qn:
+                    resolved_qn = candidates[0]  # best guess
+
+            if resolved_qn:
+                updates.append((resolved_qn, edge["id"]))
+
+        if updates:
+            self.store.conn.executemany(
+                "UPDATE edges SET target_qualified = ? WHERE id = ?",
+                updates,
+            )
+            self.store.conn.commit()
+
+    def _create_import_edges(self, files: dict, stats: dict):
+        """Create IMPORTS_FROM edges from file import data."""
+        edges = []
+        for file_path, file_info in files.items():
+            for imp in file_info.get("imports", []):
+                # imp might be a file path or module name
+                target_qn = imp if imp in files else None
+                if not target_qn:
+                    # Try finding the file
+                    for fpath in files:
+                        if fpath.endswith(imp) or imp in fpath:
+                            target_qn = fpath
+                            break
+                if target_qn:
+                    edges.append(
+                        {
+                            "kind": "IMPORTS_FROM",
+                            "source_qualified": file_path,
+                            "target_qualified": target_qn,
+                            "file_path": file_path,
+                        }
+                    )
+        if edges:
+            self.store.batch_upsert_edges(edges)
+            stats["edges_created"] += len(edges)
+
+    def _create_tested_by_edges(
+        self,
+        files: dict,
+        all_symbols: dict[str, list[str]],
+        stats: dict,
+    ):
+        """Infer TESTED_BY edges: test functions that CALL production functions."""
+        edges = []
+        for file_path, file_info in files.items():
+            if not _is_test_file(file_path):
+                continue
+            for sym in file_info.get("symbols", []):
+                if not sym.get("name", "").startswith("test_"):
+                    continue
+                test_qn = make_qualified_name(file_path, sym["name"], sym.get("parent"))
+                # Look at what this test calls
+                deps = sym.get("deps") or sym.get("dependencies") or []
+                for dep_name in deps:
+                    # Find production symbol
+                    candidates = all_symbols.get(dep_name.lower(), [])
+                    for c in candidates:
+                        c_file = c.split("::")[0]
+                        if not _is_test_file(c_file):
+                            edges.append(
+                                {
+                                    "kind": "TESTED_BY",
+                                    "source_qualified": c,
+                                    "target_qualified": test_qn,
+                                    "file_path": file_path,
+                                }
+                            )
+                            break  # One TESTED_BY per dep
+
+        if edges:
+            self.store.batch_upsert_edges(edges)
+            stats["edges_created"] += len(edges)
+
+    def _rebuild_fts(self):
+        """Rebuild FTS5 index from nodes table."""
+        from .search import rebuild_fts_index
+
+        rebuild_fts_index(self.store.conn)