code-review-graph-codeblackwell 2.3.6.post1__py3-none-any.whl

code_review_graph/registry.py

@@ -0,0 +1,319 @@
+"""Multi-repo registry and connection pool.
+
+Manages a registry of multiple repositories at ``~/.code-review-graph/registry.json``
+and provides a connection pool for concurrent access to multiple graph databases.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+import threading
+from collections import OrderedDict
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Default registry path
+_REGISTRY_DIR = Path.home() / ".code-review-graph"
+_REGISTRY_PATH = _REGISTRY_DIR / "registry.json"
+
+
+class Registry:
+    """Manages a JSON-based registry of code-review-graph repositories.
+
+    Each entry stores the repo path and an optional alias.
+    The registry lives at ``~/.code-review-graph/registry.json``.
+    """
+
+    def __init__(self, path: Path | None = None) -> None:
+        self._path = path or _REGISTRY_PATH
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        self._repos: list[dict[str, str]] = []
+        self._load()
+
+    def _load(self) -> None:
+        """Load registry from disk."""
+        if self._path.exists():
+            try:
+                data = json.loads(self._path.read_text(encoding="utf-8", errors="replace"))
+                self._repos = data.get("repos", [])
+            except (json.JSONDecodeError, KeyError, TypeError):
+                logger.warning("Invalid registry file, starting fresh: %s", self._path)
+                self._repos = []
+        else:
+            self._repos = []
+
+    def _save(self) -> None:
+        """Write registry to disk."""
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        data = {"repos": self._repos}
+        self._path.write_text(
+            json.dumps(data, indent=2) + "\n", encoding="utf-8"
+        )
+
+    def register(
+        self, path: str, alias: str | None = None, data_dir: str | None = None,
+    ) -> dict[str, str]:
+        """Register a repository path.
+
+        Validates that the path contains a ``.git`` or ``.code-review-graph``
+        directory.
+
+        Args:
+            path: Absolute or relative path to the repository root.
+            alias: Optional short alias for the repository.
+            data_dir: Optional external directory for graph database.
+
+        Returns:
+            The registered entry dict.
+
+        Raises:
+            ValueError: If the path is not a valid repository.
+        """
+        resolved = Path(path).resolve()
+        if not resolved.is_dir():
+            raise ValueError(f"Path is not a directory: {resolved}")
+        has_repo_marker = (
+            (resolved / ".git").exists()
+            or (resolved / ".svn").exists()
+            or (resolved / ".code-review-graph").exists()
+        )
+        if not has_repo_marker:
+            raise ValueError(
+                f"Path does not look like a repository "
+                f"(no .git, .svn, or .code-review-graph): {resolved}"
+            )
+
+        with self._lock:
+            # Check for duplicate path
+            str_path = str(resolved)
+            for entry in self._repos:
+                if entry["path"] == str_path:
+                    # Update alias and/or data_dir if provided
+                    if alias:
+                        entry["alias"] = alias
+                    if data_dir:
+                        entry["data_dir"] = str(Path(data_dir).resolve())
+                    self._save()
+                    return entry
+
+            new_entry: dict[str, str] = {"path": str_path}
+            if alias:
+                new_entry["alias"] = alias
+            if data_dir:
+                new_entry["data_dir"] = str(Path(data_dir).resolve())
+            self._repos.append(new_entry)
+            self._save()
+            return new_entry
+
+    def unregister(self, path_or_alias: str) -> bool:
+        """Remove a repository by path or alias.
+
+        Args:
+            path_or_alias: Either the absolute path or the alias.
+
+        Returns:
+            True if an entry was removed, False otherwise.
+        """
+        with self._lock:
+            resolved = str(Path(path_or_alias).resolve())
+            original_len = len(self._repos)
+            self._repos = [
+                entry for entry in self._repos
+                if entry["path"] != resolved
+                and entry.get("alias") != path_or_alias
+            ]
+            if len(self._repos) < original_len:
+                self._save()
+                return True
+            return False
+
+    def list_repos(self) -> list[dict[str, str]]:
+        """Return list of all registered repositories.
+
+        Returns:
+            List of dicts with 'path' and optional 'alias' keys.
+        """
+        with self._lock:
+            return list(self._repos)
+
+    def find_by_alias(self, alias: str) -> dict[str, str] | None:
+        """Look up a repository by its alias.
+
+        Args:
+            alias: The alias to search for.
+
+        Returns:
+            The matching entry, or None.
+        """
+        with self._lock:
+            for entry in self._repos:
+                if entry.get("alias") == alias:
+                    return dict(entry)
+            return None
+
+    def find_by_path(self, path: str) -> dict[str, str] | None:
+        """Look up a repository by its path.
+
+        Args:
+            path: The path to search for.
+
+        Returns:
+            The matching entry, or None.
+        """
+        resolved = str(Path(path).resolve())
+        with self._lock:
+            for entry in self._repos:
+                if entry["path"] == resolved:
+                    return dict(entry)
+            return None
+
+    def set_data_dir(self, path: str, data_dir: str) -> dict[str, str]:
+        """Set the external data directory for a repository.
+
+        Args:
+            path: Repository path (absolute or relative).
+            data_dir: External directory path to store graph database.
+
+        Returns:
+            The updated or created registry entry.
+        """
+        resolved = str(Path(path).resolve())
+        data_resolved = str(Path(data_dir).resolve())
+
+        with self._lock:
+            # Check for existing entry
+            for entry in self._repos:
+                if entry["path"] == resolved:
+                    entry["data_dir"] = data_resolved
+                    self._save()
+                    return dict(entry)
+
+            # Create new entry if not found
+            new_entry = {
+                "path": resolved,
+                "data_dir": data_resolved
+            }
+            self._repos.append(new_entry)
+            self._save()
+            return new_entry
+
+    def get_data_dir_for_repo(self, path: str) -> str | None:
+        """Get the stored data directory for a repository.
+
+        Args:
+            path: Repository path (absolute or relative).
+
+        Returns:
+            The stored data_dir path, or None if not set.
+        """
+        resolved = str(Path(path).resolve())
+        with self._lock:
+            for entry in self._repos:
+                if entry["path"] == resolved:
+                    return entry.get("data_dir")
+            return None
+
+
+class ConnectionPool:
+    """LRU connection pool for SQLite graph databases.
+
+    Caches open connections keyed by database path, evicting the least
+    recently used connection when the pool is full.
+    """
+
+    def __init__(self, max_size: int = 10) -> None:
+        self._max_size = max_size
+        self._pool: OrderedDict[str, sqlite3.Connection] = OrderedDict()
+        self._lock = threading.Lock()
+
+    def get(self, db_path: str) -> sqlite3.Connection:
+        """Get or create a connection for the given database path.
+
+        Args:
+            db_path: Path to the SQLite database file.
+
+        Returns:
+            An open SQLite connection.
+        """
+        key = str(Path(db_path).resolve())
+        with self._lock:
+            if key in self._pool:
+                self._pool.move_to_end(key)
+                return self._pool[key]
+
+            # Evict LRU if full
+            while len(self._pool) >= self._max_size:
+                evict_key, evict_conn = self._pool.popitem(last=False)
+                try:
+                    evict_conn.close()
+                except sqlite3.Error:
+                    logger.debug("Failed to close evicted connection: %s", evict_key)
+                logger.debug("Evicted connection: %s", evict_key)
+
+            conn = sqlite3.connect(
+                key, timeout=30, check_same_thread=False,
+                isolation_level=None,
+            )
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA busy_timeout=5000")
+            self._pool[key] = conn
+            return conn
+
+    def close_all(self) -> None:
+        """Close all connections in the pool."""
+        with self._lock:
+            for key, conn in self._pool.items():
+                try:
+                    conn.close()
+                except sqlite3.Error:
+                    logger.debug("Failed to close connection: %s", key)
+            self._pool.clear()
+
+    @property
+    def size(self) -> int:
+        """Current number of open connections."""
+        with self._lock:
+            return len(self._pool)
+
+
+def resolve_repo(
+    registry: Registry,
+    repo: str | None,
+    cwd: str | None = None,
+) -> str | None:
+    """Resolve a repo parameter to an absolute path.
+
+    Resolution order:
+    1. If repo is given, try as alias first.
+    2. If repo is given and not an alias, try as a direct path.
+    3. If repo is None, use cwd.
+
+    Args:
+        registry: The Registry instance.
+        repo: Alias or path string, or None.
+        cwd: Current working directory fallback.
+
+    Returns:
+        Resolved absolute path string, or None if unresolvable.
+    """
+    if repo:
+        # Try alias first
+        entry = registry.find_by_alias(repo)
+        if entry:
+            return entry["path"]
+
+        # Try as direct path
+        path = Path(repo).resolve()
+        if path.is_dir():
+            return str(path)
+
+    # Fall back to CWD
+    if cwd:
+        return str(Path(cwd).resolve())
+
+    return None

code_review_graph/rescript_resolver.py

@@ -0,0 +1,206 @@
+"""Post-build pass that resolves ReScript cross-module references.
+
+The per-file parser emits CALLS/IMPORTS_FROM edges with bare targets like
+``LogicUtils.safeParse`` because the parser only sees one file at a time.
+This module runs after ``full_build`` / incremental updates and rewrites
+those targets to canonical qualified names like
+``<abs-path>/LogicUtils.res::safeParse`` so ``callers_of``,
+``get_impact_radius`` and ``importers_of`` work correctly across files.
+
+Resolutions performed:
+    1. ``Module.fn`` / ``Module.Sub.fn`` CALLS edges → canonical node
+       when a ``.res`` / ``.resi`` file with matching basename exists.
+    2. Bare ``fn(...)`` CALLS edges in a file that ``open`` / ``include``\\s
+       a module → canonical node in that module's file.
+    3. IMPORTS_FROM edges targeting a module name (open / include / jsx /
+       module_alias / external_module) → the target file path, so
+       ``importers_of(<path>)`` finds every consuming file.
+
+Only the ``target_qualified`` column is updated; source and edge kind are
+preserved. Edges that cannot be resolved are left unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .graph import GraphStore
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_rescript_cross_module(store: GraphStore) -> dict:
+    """Resolve ReScript cross-module targets in the graph store.
+
+    Safe to call multiple times: already-resolved edges (targets containing
+    ``::``) are skipped.
+
+    Returns a dict with resolution counts for telemetry.
+    """
+    conn = store._conn  # intentional: post-build maintenance pass
+
+    # Basename (module name) → absolute file path, preferring .res over .resi.
+    basename_to_path: dict[str, str] = {}
+    rescript_files: set[str] = set()
+    for file_path in store.get_all_files():
+        p = Path(file_path)
+        suffix = p.suffix.lower()
+        if suffix not in (".res", ".resi"):
+            continue
+        rescript_files.add(file_path)
+        stem = p.stem
+        existing = basename_to_path.get(stem)
+        if existing is None or existing.lower().endswith(".resi"):
+            # Prefer implementation (.res) over interface (.resi).
+            basename_to_path[stem] = file_path
+
+    if not basename_to_path:
+        return {"files_indexed": 0, "calls_resolved": 0, "imports_resolved": 0}
+
+    # Per-file opens/includes so we can resolve bare calls.
+    opens_by_file: dict[str, list[str]] = {}
+    imports_rows = conn.execute(
+        "SELECT source_qualified, target_qualified, file_path, extra "
+        "FROM edges WHERE kind = 'IMPORTS_FROM'"
+    ).fetchall()
+    for row in imports_rows:
+        fp = row["file_path"]
+        if fp not in rescript_files:
+            continue
+        try:
+            extra = json.loads(row["extra"] or "{}")
+        except (json.JSONDecodeError, TypeError):
+            extra = {}
+        kind = extra.get("rescript_import_kind")
+        if kind in ("open", "include"):
+            # Strip nested submodule — root determines file.
+            root = row["target_qualified"].split(".", 1)[0]
+            opens_by_file.setdefault(fp, []).append(root)
+
+    # --- 1 + 2. Resolve CALLS edges ---
+    call_rows = conn.execute(
+        "SELECT id, source_qualified, target_qualified, file_path "
+        "FROM edges WHERE kind = 'CALLS'"
+    ).fetchall()
+
+    call_updates: list[tuple[str, int]] = []
+    for row in call_rows:
+        target = row["target_qualified"]
+        if "::" in target:
+            continue  # already resolved
+
+        resolved = _resolve_call_target(
+            target,
+            row["file_path"],
+            basename_to_path,
+            opens_by_file,
+            store,
+        )
+        if resolved and resolved != target:
+            call_updates.append((resolved, row["id"]))
+
+    # --- 3. Resolve IMPORTS_FROM edge targets to file paths ---
+    import_updates: list[tuple[str, int]] = []
+    import_rows_full = conn.execute(
+        "SELECT id, target_qualified, file_path FROM edges "
+        "WHERE kind = 'IMPORTS_FROM'"
+    ).fetchall()
+    for row in import_rows_full:
+        target = row["target_qualified"]
+        if target in rescript_files:
+            continue  # already a file path
+        if "/" in target or "\\" in target:
+            continue  # looks like a path already (e.g. relative JS import)
+        root = target.split(".", 1)[0]
+        file_target = basename_to_path.get(root)
+        if file_target and file_target != target:
+            import_updates.append((file_target, row["id"]))
+
+    cur = conn.cursor()
+    for new_target, edge_id in call_updates:
+        cur.execute(
+            "UPDATE edges SET target_qualified = ? WHERE id = ?",
+            (new_target, edge_id),
+        )
+    for new_target, edge_id in import_updates:
+        cur.execute(
+            "UPDATE edges SET target_qualified = ? WHERE id = ?",
+            (new_target, edge_id),
+        )
+    conn.commit()
+    store._invalidate_cache()
+
+    result = {
+        "files_indexed": len(basename_to_path),
+        "calls_resolved": len(call_updates),
+        "imports_resolved": len(import_updates),
+    }
+    logger.info("ReScript cross-module resolution: %s", result)
+    return result
+
+
+def _resolve_call_target(
+    target: str,
+    file_path: str,
+    basename_to_path: dict[str, str],
+    opens_by_file: dict[str, list[str]],
+    store: GraphStore,
+) -> str | None:
+    """Resolve a CALLS edge's ``target_qualified`` to a canonical qualified
+    node name. Returns None when no resolution is possible.
+    """
+    # Dotted: `Module.fn` or `Module.Sub.fn`.
+    if "." in target:
+        head, _, rest = target.partition(".")
+        target_file = basename_to_path.get(head)
+        if target_file is None:
+            return None
+        candidate = _pick_existing_qualified(target_file, rest, store)
+        return candidate
+
+    # Bare: `fn` — only resolvable via an open/include in the calling file.
+    for opened in opens_by_file.get(file_path, []):
+        target_file = basename_to_path.get(opened)
+        if target_file is None:
+            continue
+        candidate = f"{target_file}::{target}"
+        if store.get_node(candidate) is not None:
+            return candidate
+    return None
+
+
+def _pick_existing_qualified(
+    target_file: str, rest: str, store: GraphStore,
+) -> str | None:
+    """Given ``LogicUtils.foo.bar``, try ``file::foo.bar`` then
+    ``file::Foo.bar`` then ``file::foo``. Return the first one that
+    corresponds to an existing node.
+    """
+    # Direct: rest as the qualified name tail.
+    direct = f"{target_file}::{rest}"
+    if store.get_node(direct) is not None:
+        return direct
+
+    # Dotted rest like `Sub.fn`: parent_name = Sub, name = fn.
+    # _qualify formats it the same way, so `direct` would already match if
+    # the node was stored with that exact qualified name.
+
+    # Some targets include a trailing member-access that isn't part of
+    # the qualified node (e.g. `LogicUtils.safeParse.resp` — property on
+    # the result). Try peeling from the right.
+    parts = rest.split(".")
+    while len(parts) > 1:
+        parts.pop()
+        candidate = f"{target_file}::{'.'.join(parts)}"
+        if store.get_node(candidate) is not None:
+            return candidate
+    # Last resort: top-level `file::name` (first part only).
+    first = rest.split(".", 1)[0]
+    candidate = f"{target_file}::{first}"
+    if store.get_node(candidate) is not None:
+        return candidate
+    return None