codegraph-nav 0.1.0__py3-none-any.whl

codegraph_nav/graph/store.py

@@ -0,0 +1,517 @@
+"""GraphStore — SQLite-backed graph storage with WAL mode.
+
+Provides CRUD operations for nodes, edges, and flows. All queries use
+parameterized SQL to prevent injection. Batch operations respect the
+SQLite 999-variable limit.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import cast
+
+from .schema import BATCH_SIZE, ensure_schema, is_fts5_available
+
+
+class GraphStore:
+    """SQLite graph store with WAL mode for concurrent access."""
+
+    def __init__(self, db_path: str | Path):
+        self.db_path = Path(db_path)
+        self._conn = sqlite3.connect(str(self.db_path), timeout=30, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.execute("PRAGMA busy_timeout=5000")
+        self._schema_version = ensure_schema(self._conn)
+        self._fts_available: bool | None = None
+
+    @property
+    def conn(self) -> sqlite3.Connection:
+        return self._conn
+
+    @property
+    def fts_available(self) -> bool:
+        if self._fts_available is None:
+            self._fts_available = is_fts5_available(self._conn)
+        return self._fts_available
+
+    def close(self):
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+    # ------------------------------------------------------------------
+    # Node CRUD
+    # ------------------------------------------------------------------
+
+    def upsert_node(
+        self,
+        kind: str,
+        name: str,
+        qualified_name: str,
+        file_path: str,
+        line_start: int | None = None,
+        line_end: int | None = None,
+        language: str | None = None,
+        parent_name: str | None = None,
+        signature: str | None = None,
+        is_test: bool = False,
+        file_hash: str | None = None,
+        extra: dict | None = None,
+    ) -> int:
+        """Insert or replace a node. Returns the node ID."""
+        now = time.time()
+        extra_json = json.dumps(extra) if extra else "{}"
+        cur = self._conn.execute(
+            """INSERT OR REPLACE INTO nodes
+               (kind, name, qualified_name, file_path, line_start, line_end,
+                language, parent_name, signature, is_test, file_hash, extra, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                kind,
+                name,
+                qualified_name,
+                file_path,
+                line_start,
+                line_end,
+                language,
+                parent_name,
+                signature,
+                int(is_test),
+                file_hash,
+                extra_json,
+                now,
+            ),
+        )
+        self._conn.commit()
+        assert cur.lastrowid is not None
+        return cur.lastrowid
+
+    def batch_upsert_nodes(self, nodes: list[dict]):
+        """Bulk insert/replace nodes."""
+        now = time.time()
+        rows = []
+        for n in nodes:
+            extra_json = json.dumps(n.get("extra", {})) if n.get("extra") else "{}"
+            rows.append(
+                (
+                    n["kind"],
+                    n["name"],
+                    n["qualified_name"],
+                    n["file_path"],
+                    n.get("line_start"),
+                    n.get("line_end"),
+                    n.get("language"),
+                    n.get("parent_name"),
+                    n.get("signature"),
+                    int(n.get("is_test", False)),
+                    n.get("file_hash"),
+                    extra_json,
+                    now,
+                )
+            )
+        self._conn.executemany(
+            """INSERT OR REPLACE INTO nodes
+               (kind, name, qualified_name, file_path, line_start, line_end,
+                language, parent_name, signature, is_test, file_hash, extra, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            rows,
+        )
+        self._conn.commit()
+
+    def get_node(self, qualified_name: str) -> sqlite3.Row | None:
+        return cast(
+            "sqlite3.Row | None",
+            self._conn.execute(
+                "SELECT * FROM nodes WHERE qualified_name = ?", (qualified_name,)
+            ).fetchone(),
+        )
+
+    def get_node_by_id(self, node_id: int) -> sqlite3.Row | None:
+        return cast(
+            "sqlite3.Row | None",
+            self._conn.execute("SELECT * FROM nodes WHERE id = ?", (node_id,)).fetchone(),
+        )
+
+    def get_nodes_by_file(self, file_path: str) -> list[sqlite3.Row]:
+        return self._conn.execute(
+            "SELECT * FROM nodes WHERE file_path = ?", (file_path,)
+        ).fetchall()
+
+    def get_nodes_by_name(self, name: str) -> list[sqlite3.Row]:
+        return self._conn.execute("SELECT * FROM nodes WHERE name = ?", (name,)).fetchall()
+
+    def get_all_nodes(self, kind: str | None = None) -> list[sqlite3.Row]:
+        if kind:
+            return self._conn.execute("SELECT * FROM nodes WHERE kind = ?", (kind,)).fetchall()
+        return self._conn.execute("SELECT * FROM nodes").fetchall()
+
+    def delete_file_nodes(self, file_path: str):
+        """Delete all nodes and their edges for a file."""
+        # Get qualified names for edge cleanup
+        qns = [
+            row[0]
+            for row in self._conn.execute(
+                "SELECT qualified_name FROM nodes WHERE file_path = ?", (file_path,)
+            ).fetchall()
+        ]
+        if qns:
+            for i in range(0, len(qns), BATCH_SIZE):
+                batch = qns[i : i + BATCH_SIZE]
+                placeholders = ",".join("?" for _ in batch)
+                self._conn.execute(
+                    f"DELETE FROM edges WHERE source_qualified IN ({placeholders})",
+                    batch,
+                )
+                self._conn.execute(
+                    f"DELETE FROM edges WHERE target_qualified IN ({placeholders})",
+                    batch,
+                )
+        self._conn.execute("DELETE FROM nodes WHERE file_path = ?", (file_path,))
+        # Also delete edges originating from this file
+        self._conn.execute("DELETE FROM edges WHERE file_path = ?", (file_path,))
+        self._conn.commit()
+
+    def get_file_hash(self, file_path: str) -> str | None:
+        """Get stored hash for a File node."""
+        row = self._conn.execute(
+            "SELECT file_hash FROM nodes WHERE file_path = ? AND kind = 'File'",
+            (file_path,),
+        ).fetchone()
+        return row[0] if row else None
+
+    # ------------------------------------------------------------------
+    # Edge CRUD
+    # ------------------------------------------------------------------
+
+    def upsert_edge(
+        self,
+        kind: str,
+        source_qualified: str,
+        target_qualified: str,
+        file_path: str,
+        extra: dict | None = None,
+    ) -> int:
+        """Insert an edge (ignores duplicates)."""
+        now = time.time()
+        extra_json = json.dumps(extra) if extra else "{}"
+        cur = self._conn.execute(
+            """INSERT OR IGNORE INTO edges
+               (kind, source_qualified, target_qualified, file_path, extra, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (kind, source_qualified, target_qualified, file_path, extra_json, now),
+        )
+        self._conn.commit()
+        assert cur.lastrowid is not None
+        return cur.lastrowid
+
+    def batch_upsert_edges(self, edges: list[dict]):
+        """Bulk insert edges (ignores duplicates)."""
+        now = time.time()
+        rows = []
+        for e in edges:
+            extra_json = json.dumps(e.get("extra", {})) if e.get("extra") else "{}"
+            rows.append(
+                (
+                    e["kind"],
+                    e["source_qualified"],
+                    e["target_qualified"],
+                    e["file_path"],
+                    extra_json,
+                    now,
+                )
+            )
+        self._conn.executemany(
+            """INSERT OR IGNORE INTO edges
+               (kind, source_qualified, target_qualified, file_path, extra, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            rows,
+        )
+        self._conn.commit()
+
+    def get_edges_from(self, source_qualified: str, kind: str | None = None) -> list[sqlite3.Row]:
+        if kind:
+            return self._conn.execute(
+                "SELECT * FROM edges WHERE source_qualified = ? AND kind = ?",
+                (source_qualified, kind),
+            ).fetchall()
+        return self._conn.execute(
+            "SELECT * FROM edges WHERE source_qualified = ?", (source_qualified,)
+        ).fetchall()
+
+    def get_edges_to(self, target_qualified: str, kind: str | None = None) -> list[sqlite3.Row]:
+        if kind:
+            return self._conn.execute(
+                "SELECT * FROM edges WHERE target_qualified = ? AND kind = ?",
+                (target_qualified, kind),
+            ).fetchall()
+        return self._conn.execute(
+            "SELECT * FROM edges WHERE target_qualified = ?", (target_qualified,)
+        ).fetchall()
+
+    # ------------------------------------------------------------------
+    # Flow operations
+    # ------------------------------------------------------------------
+
+    def insert_flow(
+        self,
+        name: str,
+        entry_point_id: int,
+        depth: int,
+        node_count: int,
+        file_count: int,
+        criticality: float,
+        path_ids: list[int],
+    ) -> int:
+        """Insert a flow and its memberships."""
+        now = time.time()
+        cur = self._conn.execute(
+            """INSERT INTO flows
+               (name, entry_point_id, depth, node_count, file_count, criticality,
+                path_json, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                name,
+                entry_point_id,
+                depth,
+                node_count,
+                file_count,
+                criticality,
+                json.dumps(path_ids),
+                now,
+            ),
+        )
+        flow_id = cur.lastrowid
+        assert flow_id is not None
+        memberships = [(flow_id, node_id, pos) for pos, node_id in enumerate(path_ids)]
+        self._conn.executemany(
+            "INSERT OR IGNORE INTO flow_memberships (flow_id, node_id, position) VALUES (?, ?, ?)",
+            memberships,
+        )
+        self._conn.commit()
+        return flow_id
+
+    def get_flows(self, sort_by: str = "criticality", limit: int = 20) -> list[sqlite3.Row]:
+        order = "criticality DESC" if sort_by == "criticality" else "name ASC"
+        return self._conn.execute(
+            f"SELECT * FROM flows ORDER BY {order} LIMIT ?", (limit,)
+        ).fetchall()
+
+    def get_flow_memberships(self, node_id: int) -> list[sqlite3.Row]:
+        return self._conn.execute(
+            "SELECT * FROM flow_memberships WHERE node_id = ?", (node_id,)
+        ).fetchall()
+
+    def count_flow_memberships(self, node_id: int) -> int:
+        row = self._conn.execute(
+            "SELECT COUNT(*) FROM flow_memberships WHERE node_id = ?", (node_id,)
+        ).fetchone()
+        return row[0] if row else 0
+
+    def clear_flows(self):
+        """Delete all flows and memberships."""
+        self._conn.execute("DELETE FROM flow_memberships")
+        self._conn.execute("DELETE FROM flows")
+        self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Community operations
+    # ------------------------------------------------------------------
+
+    def insert_community(
+        self,
+        name: str,
+        cohesion: float,
+        node_count: int = 0,
+        file_prefix: str | None = None,
+        keywords: list[str] | None = None,
+    ) -> int:
+        """Insert a community. Returns community ID."""
+        now = time.time()
+        kw_json = json.dumps(keywords or [])
+        cur = self._conn.execute(
+            """INSERT INTO communities (name, node_count, cohesion, file_prefix, keywords, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (name, node_count, cohesion, file_prefix, kw_json, now),
+        )
+        self._conn.commit()
+        assert cur.lastrowid is not None
+        return cur.lastrowid
+
+    def add_community_members(self, community_id: int, node_ids: list[int]):
+        """Add nodes to a community."""
+        rows = [(community_id, nid) for nid in node_ids]
+        self._conn.executemany(
+            "INSERT OR IGNORE INTO community_members (community_id, node_id) VALUES (?, ?)",
+            rows,
+        )
+        self._conn.commit()
+
+    def get_communities(self, sort_by: str = "node_count", limit: int = 20) -> list[sqlite3.Row]:
+        order = {"node_count": "node_count DESC", "cohesion": "cohesion DESC", "name": "name ASC"}
+        order_sql = order.get(sort_by, "node_count DESC")
+        return self._conn.execute(
+            f"SELECT * FROM communities ORDER BY {order_sql} LIMIT ?", (limit,)
+        ).fetchall()
+
+    def get_community_members(self, community_id: int) -> list[sqlite3.Row]:
+        return self._conn.execute(
+            """SELECT n.* FROM nodes n
+               JOIN community_members cm ON cm.node_id = n.id
+               WHERE cm.community_id = ?""",
+            (community_id,),
+        ).fetchall()
+
+    def get_node_community(self, node_id: int) -> sqlite3.Row | None:
+        row = self._conn.execute(
+            """SELECT c.* FROM communities c
+               JOIN community_members cm ON cm.community_id = c.id
+               WHERE cm.node_id = ?""",
+            (node_id,),
+        ).fetchone()
+        return cast("sqlite3.Row | None", row)
+
+    def clear_communities(self):
+        """Delete all communities and memberships."""
+        self._conn.execute("DELETE FROM community_members")
+        self._conn.execute("DELETE FROM communities")
+        self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Route operations
+    # ------------------------------------------------------------------
+
+    def insert_route(
+        self,
+        method: str,
+        path: str,
+        file_path: str,
+        handler_name: str | None = None,
+        framework: str | None = None,
+        tags: list[str] | None = None,
+        confidence: str = "high",
+    ) -> int:
+        now = time.time()
+        tags_json = json.dumps(tags or [])
+        cur = self._conn.execute(
+            """INSERT INTO routes (method, path, file_path, handler_name, framework, tags, confidence, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (method, path, file_path, handler_name, framework, tags_json, confidence, now),
+        )
+        self._conn.commit()
+        assert cur.lastrowid is not None
+        return cur.lastrowid
+
+    def get_routes(
+        self, framework: str | None = None, file_path: str | None = None
+    ) -> list[sqlite3.Row]:
+        if framework and file_path:
+            return self._conn.execute(
+                "SELECT * FROM routes WHERE framework = ? AND file_path = ?",
+                (framework, file_path),
+            ).fetchall()
+        if framework:
+            return self._conn.execute(
+                "SELECT * FROM routes WHERE framework = ?", (framework,)
+            ).fetchall()
+        if file_path:
+            return self._conn.execute(
+                "SELECT * FROM routes WHERE file_path = ?", (file_path,)
+            ).fetchall()
+        return self._conn.execute("SELECT * FROM routes").fetchall()
+
+    def clear_routes(self):
+        self._conn.execute("DELETE FROM routes")
+        self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Schema/ORM operations
+    # ------------------------------------------------------------------
+
+    def insert_schema(
+        self,
+        name: str,
+        file_path: str,
+        orm: str | None = None,
+        fields: list[dict] | None = None,
+        relations: list[str] | None = None,
+    ) -> int:
+        now = time.time()
+        fields_json = json.dumps(fields or [])
+        relations_json = json.dumps(relations or [])
+        cur = self._conn.execute(
+            """INSERT INTO schemas (name, file_path, orm, fields, relations, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?)""",
+            (name, file_path, orm, fields_json, relations_json, now),
+        )
+        self._conn.commit()
+        assert cur.lastrowid is not None
+        return cur.lastrowid
+
+    def get_schemas(self, orm: str | None = None) -> list[sqlite3.Row]:
+        if orm:
+            return self._conn.execute("SELECT * FROM schemas WHERE orm = ?", (orm,)).fetchall()
+        return self._conn.execute("SELECT * FROM schemas").fetchall()
+
+    def clear_schemas(self):
+        self._conn.execute("DELETE FROM schemas")
+        self._conn.commit()
+
+    # ------------------------------------------------------------------
+    # Stats
+    # ------------------------------------------------------------------
+
+    def get_stats(self) -> dict:
+        """Get graph statistics."""
+        node_count = self._conn.execute("SELECT COUNT(*) FROM nodes").fetchone()[0]
+        edge_count = self._conn.execute("SELECT COUNT(*) FROM edges").fetchone()[0]
+        file_count = self._conn.execute(
+            "SELECT COUNT(*) FROM nodes WHERE kind = 'File'"
+        ).fetchone()[0]
+        flow_count = self._conn.execute("SELECT COUNT(*) FROM flows").fetchone()[0]
+        community_count = self._conn.execute("SELECT COUNT(*) FROM communities").fetchone()[0]
+        route_count = self._conn.execute("SELECT COUNT(*) FROM routes").fetchone()[0]
+        schema_count = self._conn.execute("SELECT COUNT(*) FROM schemas").fetchone()[0]
+
+        kind_counts = {}
+        for row in self._conn.execute("SELECT kind, COUNT(*) FROM nodes GROUP BY kind").fetchall():
+            kind_counts[row[0]] = row[1]
+
+        edge_kind_counts = {}
+        for row in self._conn.execute("SELECT kind, COUNT(*) FROM edges GROUP BY kind").fetchall():
+            edge_kind_counts[row[0]] = row[1]
+
+        return {
+            "nodes": node_count,
+            "edges": edge_count,
+            "files": file_count,
+            "flows": flow_count,
+            "communities": community_count,
+            "routes": route_count,
+            "schemas": schema_count,
+            "nodes_by_kind": kind_counts,
+            "edges_by_kind": edge_kind_counts,
+            "fts_available": self.fts_available,
+            "schema_version": self._schema_version,
+        }
+
+    # ------------------------------------------------------------------
+    # Batch helpers
+    # ------------------------------------------------------------------
+
+    def batch_get_nodes(self, qualified_names: set[str]) -> list[sqlite3.Row]:
+        """Fetch nodes by qualified names in batches."""
+        results = []
+        qns = list(qualified_names)
+        for i in range(0, len(qns), BATCH_SIZE):
+            batch = qns[i : i + BATCH_SIZE]
+            placeholders = ",".join("?" for _ in batch)
+            rows = self._conn.execute(
+                f"SELECT * FROM nodes WHERE qualified_name IN ({placeholders})",
+                batch,
+            ).fetchall()
+            results.extend(rows)
+        return results