sql-code-graph 1.2.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

sqlcg/cli/commands/mcp.py

@@ -78,7 +78,12 @@ def mcp_status() -> None:
     """Print server status JSON (connects to control socket).
 
     Returns JSON with fields: running, pid, db_path, indexed_sha, head_sha,
-    stale_by_commits, connected_clients, uptime when a server is live.
+    stale_by_commits, connected_clients, uptime, writer_queue when a server
+    is live.
+
+    The status response is length-prefixed framed (v1.3.0, B3) so large
+    writer_queue payloads are received in full — the client uses the
+    recv-exactly makefile+readline+read(n) pattern, NOT a single recv(4096).
 
     When no server is found: {"running": false}.
     When the PID file exists with a live process but the socket is unavailable:
@@ -89,6 +94,7 @@ def mcp_status() -> None:
     to the PID-file probe — never hangs or errors on a dead socket.
     """
     import socket as _socket
+    from datetime import datetime
 
     from sqlcg.server.control import is_pid_alive, read_pid, sock_path
 
@@ -98,8 +104,69 @@ def mcp_status() -> None:
             s.settimeout(2)
             s.connect(str(sp))
             s.sendall(json.dumps({"op": "status"}).encode() + b"\n")
-            data = s.recv(4096)
-        console.print_json(data.decode())
+            # Framed recv-exactly (B3 / OD-4): read length line then exactly that many bytes.
+            # This replaces the old s.recv(4096) which would truncate large writer_queue payloads.
+            f = s.makefile("rb")
+            length_line = f.readline()
+            if length_line:
+                try:
+                    body_len = int(length_line.strip())
+                    data = f.read(body_len)
+                except (ValueError, OSError):
+                    data = length_line  # fallback: treat first line as body
+            else:
+                data = b""
+
+        status = json.loads(data.decode())
+
+        # Pretty-print the base fields.
+        console.print_json(json.dumps({k: v for k, v in status.items() if k != "writer_queue"}))
+
+        # Render the writer_queue block separately for readability.
+        wq = status.get("writer_queue")
+        if wq:
+            console.print("\n[bold]writer_queue[/bold]")
+            active = wq.get("active")
+            if active:
+                console.print(f"  active: op={active.get('op')!r} root={active.get('root')!r}")
+                prog = wq.get("active_progress", {})
+                if prog.get("state") == "running":
+                    files_done = prog.get("files_done", 0)
+                    files_total = prog.get("files_total")
+                    if files_total:
+                        console.print(f"    progress: {files_done}/{files_total} files")
+            else:
+                console.print("  active: none")
+
+            pending = wq.get("pending", [])
+            console.print(f"  pending: {len(pending)}")
+
+            total_coalesced = wq.get("coalesced_since_start", 0)
+            by_reason = wq.get("coalesced_by_reason", {})
+            if total_coalesced:
+                from sqlcg.server.writer import (
+                    COALESCE_COLLAPSED_INTO_PENDING_REINDEX,
+                    COALESCE_REINDEX_DROPPED_INDEX_PENDING,
+                    COALESCE_SUPERSEDED_BY_INDEX,
+                )
+
+                n_sup = by_reason.get(COALESCE_SUPERSEDED_BY_INDEX, 0)
+                n_col = by_reason.get(COALESCE_COLLAPSED_INTO_PENDING_REINDEX, 0)
+                n_drop = by_reason.get(COALESCE_REINDEX_DROPPED_INDEX_PENDING, 0)
+                console.print(
+                    f"  coalesced: {total_coalesced} "
+                    f"(superseded_by_index={n_sup}, "
+                    f"collapsed_into_pending_reindex={n_col}, "
+                    f"reindex_dropped_index_pending={n_drop})"
+                )
+                last_at = wq.get("last_coalesce_at")
+                last_reason = wq.get("last_coalesce_reason")
+                if last_at and last_reason:
+                    last_human = datetime.fromtimestamp(last_at).strftime("%Y-%m-%d %H:%M:%S")
+                    console.print(f"  last coalesce: {last_reason} at {last_human}")
+            else:
+                console.print("  coalesced: 0")
+
     except (FileNotFoundError, ConnectionRefusedError, OSError):
         # Socket unavailable — probe via PID file (R3: stale-socket fall-through)
         rec = read_pid()

sqlcg/cli/commands/reindex.py

@@ -21,7 +21,7 @@ console = Console()
 # Client-side socket timeout for the --notify control-socket path.
 # A real DWH server-side resync_changed measured ~89 s (41 changed files + closure);
 # 300 s covers that with headroom while keeping the wait bounded on a wedged server.
-# This is a CLI transport bound, NOT a KuzuConfig/indexer constant.
+# This is a CLI transport bound, NOT a DbConfig/indexer constant.
 _NOTIFY_SOCKET_TIMEOUT_S = 300
 
 
@@ -70,92 +70,37 @@ def reindex_cmd(  # noqa: B008
     Exits with an error if the database schema version does not match the current
     build — run 'sqlcg db reset && sqlcg db init && sqlcg index <path>' to re-init.
     """
-    import json
-    import socket as _socket
-
     from sqlcg.core.config import config_file_present, get_backend, get_db_path, get_dialect
     from sqlcg.core.schema import SCHEMA_VERSION
     from sqlcg.indexer.indexer import Indexer
-    from sqlcg.server.control import sock_path
 
     # Resolve to absolute path so ignore-spec and git delta receive an absolute root
     path = path.resolve()
 
-    # --notify: if a server is live, route reindex through the socket (R3 fallback)
-    if notify:
-        sp = sock_path()
-        try:
-            with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
-                s.settimeout(_NOTIFY_SOCKET_TIMEOUT_S)
-                s.connect(str(sp))
-                # Resolve SHAs before sending — standalone mode reads from DB via socket
-                effective_from = from_sha
-                if effective_from is None:
-                    # Standalone mode: we cannot read stored SHA here without opening the
-                    # DB (which would conflict with the running server).  If no --from is
-                    # given with --notify, we send from="stored" as a sentinel and fall
-                    # back to direct write; the caller should pass --from explicitly.
-                    raise OSError(  # noqa: TRY301
-                        "--notify without --from requires direct DB access; falling through"
-                    )
-                # Resolve symbolic refs (HEAD, branch names) to concrete 40-char SHAs
-                # before sending — prevents literal "HEAD" from being stored in the graph.
-                effective_from = _resolve_ref(path, effective_from)
-                effective_to = _resolve_ref(path, to_sha) if to_sha else _get_head(path)
-                payload = {
-                    "op": "reindex",
-                    "root": str(path),
-                    "from": effective_from,
-                    "to": effective_to,
-                    "dialect": dialect,
-                }
-                s.sendall(json.dumps(payload).encode() + b"\n")
-                data = s.recv(65536)
-            result = json.loads(data)
-            if "error" in result:
-                console.print(f"[red]Server reindex error: {result['error']}[/red]")
-                raise typer.Exit(1)
-            if not quiet:
-                srv_summary = result.get("summary", {})
-                console.print(
-                    f"[green]Resynced via server[/green] "
-                    f"+{srv_summary.get('added', 0)} added, "
-                    f"~{srv_summary.get('modified', 0)} modified, "
-                    f"-{srv_summary.get('deleted', 0)} deleted"
-                )
-            raise typer.Exit(0)
-        except TimeoutError:
-            # Bug 1 fix: server is alive and working (accepted the connection, holds the
-            # lock, will finish and persist).  Do NOT fall through to the direct-write
-            # path — that would hit the held lock and produce a false "Database is locked"
-            # error.  Exit 0 so the git hook stays non-fatal; the server will complete.
-            # (socket.timeout is an alias of TimeoutError, a subclass of OSError — this
-            # clause must be listed before the broad OSError clause below.)
-            import sys
-
-            print(
-                f"Server is still applying the reindex (timed out waiting after "
-                f"{_NOTIFY_SOCKET_TIMEOUT_S}s); the graph will update when it finishes "
-                f"— check 'sqlcg mcp status'.",
-                file=sys.stderr,
-            )
-            raise typer.Exit(0) from None
-        except (FileNotFoundError, ConnectionRefusedError, OSError):
-            # R3: no live server (stale socket, socket absent, fallback condition) —
-            # fall through to the existing direct-write path unchanged.
-            # NOTE: socket.timeout / TimeoutError is an OSError subclass, so the
-            # dedicated timeout clause above must be listed first (already is).
-            pass
-        except typer.Exit:
-            raise
-        except Exception as exc:
-            console.print(f"[red]--notify routing failed: {exc}[/red]")
-            raise typer.Exit(1) from exc
-
-    # Resolve dialect
+    # Resolve dialect before routing so the WriterRequest always carries a concrete
+    # dialect (never the literal sentinel "auto").  Bug A: the route call was before
+    # this resolution, causing the server to receive "auto" and fail with
+    # "Unknown dialect 'auto'" on every server-routed reindex.
     if dialect == "auto":
         dialect = get_dialect(path)
 
+    # Step 3.3 — route manual reindex through the socket when a server is live.
+    # The --notify flag is kept for backward compatibility but no longer required;
+    # manual reindex (no --notify) now also probes the socket by default.
+    # W3: from=null is sent when from_sha is None — the server resolves the stored
+    # SHA at drain start (no more "requires direct DB access" refusal).
+    _is_hook_path = notify  # hook path: fire-and-forget; manual path: wait by default
+    _routed = _try_route_reindex_via_server(
+        path=path,
+        from_sha=from_sha,
+        to_sha=to_sha,
+        dialect=dialect,
+        wait=not _is_hook_path,
+        quiet=quiet,
+    )
+    if _routed:
+        return
+
     if not quiet and not config_file_present(path):
         console.print(
             f"[yellow]No .sqlcg.toml found at {path}/.sqlcg.toml — "
@@ -248,6 +193,131 @@ def reindex_cmd(  # noqa: B008
                 )
 
 
+def _try_route_reindex_via_server(
+    *,
+    path: Path,
+    from_sha: str | None,
+    to_sha: str | None,
+    dialect: str | None,
+    wait: bool,
+    quiet: bool,
+) -> bool:
+    """Probe for a live server and route the reindex through the socket if found.
+
+    W3: ``from`` may be ``None`` — the server resolves the stored indexed SHA
+    at drain start.  Symbolic refs are resolved to concrete SHAs before sending
+    (prevents literal "HEAD" being stored in the graph).
+
+    Returns True if the reindex was handled via the server (caller should return).
+    Returns False if no server is live (caller should fall through to direct path).
+    """
+    import json
+    import socket as _socket
+
+    from sqlcg.server.control import sock_path
+
+    sp = sock_path()
+    if not sp.exists():
+        return False
+
+    # Resolve symbolic SHAs if provided (the hook path already resolves them).
+    effective_from = _resolve_ref(path, from_sha) if from_sha is not None else None
+    effective_to = _resolve_ref(path, to_sha) if to_sha is not None else None
+
+    payload = {
+        "op": "reindex",
+        "root": str(path),
+        "from": effective_from,  # None → server resolves at drain start (W3)
+        "to": effective_to,
+        "dialect": dialect,
+        "wait": wait,
+        "requested_by": "hook" if not wait else "cli",
+    }
+    payload_bytes = json.dumps(payload).encode()
+    frame = f"{len(payload_bytes)}\n".encode() + payload_bytes
+
+    try:
+        with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+            s.settimeout(_NOTIFY_SOCKET_TIMEOUT_S)
+            s.connect(str(sp))
+            s.sendall(frame)
+
+            f = s.makefile("rb")
+            if not wait:
+                # Fire-and-forget: read one framed acknowledgement.
+                length_line = f.readline()
+                if length_line:
+                    try:
+                        body_len = int(length_line.strip())
+                        resp_bytes = f.read(body_len)
+                        result = json.loads(resp_bytes)
+                        if "error" in result:
+                            console.print(f"[red]Server reindex error: {result['error']}[/red]")
+                            raise typer.Exit(1)
+                        if not quiet:
+                            pos = result.get("position", "?")
+                            console.print(
+                                f"[green]Reindex queued via server[/green] (position {pos})"
+                            )
+                    except (ValueError, json.JSONDecodeError):
+                        pass
+                return True
+
+            # wait=True: stream framed frames until done:true.
+            while True:
+                length_line = f.readline()
+                if not length_line:
+                    break
+                try:
+                    body_len = int(length_line.strip())
+                except ValueError:
+                    break
+                frame_bytes = f.read(body_len)
+                frame_resp = json.loads(frame_bytes)
+
+                if frame_resp.get("done"):
+                    if not frame_resp.get("ok"):
+                        err = frame_resp.get("error", "unknown error")
+                        console.print(f"[red]Server reindex error: {err}[/red]")
+                        raise typer.Exit(1)
+                    srv_summary = frame_resp.get("summary", {})
+                    if not quiet:
+                        if srv_summary.get("fell_back_to_full"):
+                            console.print(
+                                "[yellow]Closure exceeded depth cap — fell back to full index "
+                                "(via server).[/yellow]"
+                            )
+                        else:
+                            console.print(
+                                f"[green]Resynced via server[/green] "
+                                f"+{srv_summary.get('added', 0)} added, "
+                                f"~{srv_summary.get('modified', 0)} modified, "
+                                f"-{srv_summary.get('deleted', 0)} deleted"
+                            )
+                    break
+
+        return True
+
+    except TimeoutError:
+        import sys
+
+        print(
+            f"Server is still applying the reindex (timed out waiting after "
+            f"{_NOTIFY_SOCKET_TIMEOUT_S}s); the graph will update when it finishes "
+            "— check 'sqlcg mcp status'.",
+            file=sys.stderr,
+        )
+        raise typer.Exit(0) from None
+    except (FileNotFoundError, ConnectionRefusedError, OSError):
+        # No live server — fall through to direct path.
+        return False
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        console.print(f"[red]Socket routing failed: {exc}[/red]")
+        raise typer.Exit(1) from exc
+
+
 def _resolve_ref(root: Path, ref: str) -> str:
     """Resolve a git ref (HEAD, branch, tag, or concrete SHA) to a 40-char SHA.
 

sqlcg/cli/commands/uninstall.py

@@ -26,7 +26,7 @@ def uninstall_cmd(  # noqa: B008
     """Uninstall sqlcg from Claude Code and optionally clean up resources.
 
     Step 1: Remove MCP registration from ~/.claude/settings.json
-    Step 2: Optionally delete the KùzuDB graph database
+    Step 2: Optionally delete the DuckDB graph database
     Step 3: Remove git hook sentinel block from .git/hooks/post-checkout
     Step 4: Remove sqlcg skill directory from ~/.claude/skills/sqlcg/ and
             <repo>/.claude/skills/sqlcg/
@@ -34,7 +34,7 @@ def uninstall_cmd(  # noqa: B008
     # Step 1: Remove MCP entry from settings.json
     _step1_remove_mcp_entry()
 
-    # Step 2: Offer to delete the KùzuDB (unless --keep-db flag is set)
+    # Step 2: Offer to delete the database (unless --keep-db flag is set)
     if not keep_db:
         _step2_delete_database(force)
     else:
@@ -84,7 +84,7 @@ def _step1_remove_mcp_entry() -> None:
 
 
 def _step2_delete_database(force: bool) -> None:
-    """Offer to delete the KùzuDB graph database."""
+    """Offer to delete the DuckDB graph database."""
     db_path = _get_db_path()
 
     if not db_path:
@@ -93,13 +93,6 @@ def _step2_delete_database(force: bool) -> None:
 
     db_path_obj = Path(db_path)
 
-    # Check if it's a kuzu backend (not Neo4j)
-    # If db_path is a directory or ends with standard kuzu patterns, it's likely kuzu
-    # For now, we'll assume anything in .sqlcg/kuzu is kuzu
-    if not _is_kuzu_backend(db_path):
-        console.print("[dim]Database is not KùzuDB — skipping deletion[/dim]")
-        return
-
     if not db_path_obj.exists():
         console.print(f"[dim]Database not found at {db_path}[/dim]")
         return
@@ -117,9 +110,11 @@ def _step2_delete_database(force: bool) -> None:
         console.print("[dim]Keeping database[/dim]")
         return
 
-    # Delete the database directory
+    # DuckDB is a single file (+ optional .wal sibling); delete both.
     try:
-        shutil.rmtree(db_path_obj, ignore_errors=True)
+        for target in (db_path_obj, db_path_obj.with_name(db_path_obj.name + ".wal")):
+            if target.exists():
+                target.unlink()
         console.print(f"[green]Deleted graph database at {db_path}[/green]")
     except Exception as e:
         console.print(f"[yellow]Warning:[/yellow] Failed to delete database: {e}")
@@ -222,18 +217,12 @@ def _step3_remove_git_hook(repo_path: Path) -> None:
 
 def _get_db_path() -> str | None:
     """Get the configured database path from environment or default."""
-    from sqlcg.core.config import KuzuConfig
+    from sqlcg.core.config import DbConfig
 
-    db_path = str(KuzuConfig.from_env().db_path)
+    db_path = str(DbConfig.from_env().db_path)
     return db_path if Path(db_path).exists() else None
 
 
-def _is_kuzu_backend(db_path: str) -> bool:
-    """Check if the database is a KùzuDB backend (not Neo4j)."""
-    backend = os.getenv("SQLCG_BACKEND", "kuzu").lower()
-    return backend in ("kuzu", "")  # Default to kuzu if unset
-
-
 # Candidate skill directory locations to remove (global first, then project-relative)
 # Each entry is a callable(repo_path) -> Path resolving to the sqlcg skill dir.
 _SKILL_DIR_TARGETS = [

sqlcg/core/__init__.py

@@ -2,7 +2,5 @@
 
 from sqlcg.core import schema
 from sqlcg.core.graph_db import GraphBackend
-from sqlcg.core.kuzu_backend import KuzuBackend
-from sqlcg.core.neo4j_backend import Neo4jBackend
 
-__all__ = ["GraphBackend", "KuzuBackend", "Neo4jBackend", "schema"]
+__all__ = ["GraphBackend", "schema"]

sqlcg/core/config.py

@@ -11,64 +11,37 @@ if TYPE_CHECKING:
     from sqlcg.core.graph_db import GraphBackend
 
 
-class KuzuConfig(BaseModel):
-    """Configuration for KùzuDB backend."""
+class DbConfig(BaseModel):
+    """Configuration for the DuckDB backend."""
 
     db_path: Path = Field(default_factory=lambda: Path.home() / ".sqlcg" / "graph.db")
-    buffer_pool_size_mb: int = Field(
-        default=0,
-        description="KuzuDB buffer pool size in MB (0 = use KuzuDB default)",
-    )
     log_path: Path = Field(
         default_factory=lambda: Path.home() / ".sqlcg" / "index.log",
         description="Path for parse-warning log file written during indexing",
     )
 
     @classmethod
-    def from_env(cls) -> "KuzuConfig":
-        """Load KùzuDB config from environment variables.
+    def from_env(cls) -> "DbConfig":
+        """Load database config from environment variables.
 
         Returns:
-            KuzuConfig instance with environment-overridden values if present.
+            DbConfig instance with environment-overridden values if present.
         """
         env_path = os.getenv("SQLCG_DB_PATH")
-        env_buf = os.getenv("SQLCG_BUFFER_POOL_MB")
         env_log = os.getenv("SQLCG_LOG_PATH")
         return cls(
             db_path=Path(env_path) if env_path else Path.home() / ".sqlcg" / "graph.db",
-            buffer_pool_size_mb=int(env_buf) if env_buf else 0,
             log_path=Path(env_log) if env_log else Path.home() / ".sqlcg" / "index.log",
         )
 
 
-class Neo4jConfig(BaseModel):
-    """Configuration for Neo4j backend."""
-
-    uri: str = Field(default="bolt://localhost:7687")
-    user: str = Field(default="neo4j")
-    password: str = Field(default="password")
-
-    @classmethod
-    def from_env(cls) -> "Neo4jConfig":
-        """Load Neo4j config from environment variables.
-
-        Returns:
-            Neo4jConfig instance with environment-overridden values if present.
-        """
-        return cls(
-            uri=os.getenv("NEO4J_URI", "bolt://localhost:7687"),
-            user=os.getenv("NEO4J_USER", "neo4j"),
-            password=os.getenv("NEO4J_PASSWORD", "password"),
-        )
-
-
 def get_db_path() -> Path:
     """Get the database path from environment or use default.
 
     Returns:
-        Path to the KùzuDB database file
+        Path to the DuckDB database file
     """
-    return KuzuConfig.from_env().db_path
+    return DbConfig.from_env().db_path
 
 
 def config_file_present(path: Path) -> bool:
@@ -347,58 +320,29 @@ def get_external_consumers(path: Path) -> list[ExternalConsumerSpec]:
 
 
 def get_backend(read_only: bool = False) -> "GraphBackend":
-    """Get a graph backend instance respecting the SQLCG_BACKEND env var.
+    """Get a DuckDBBackend instance.
+
+    The ``read_only`` parameter is accepted for API compatibility but is
+    ignored — DuckDB uses a single R/W handle for the process lifetime.
+    Concurrent read safety is provided by DuckDB's MVCC (readers see a
+    consistent snapshot during an in-flight write transaction).
+
+    Cross-process access: whichever process opens the DuckDB file first holds
+    an exclusive lock; other processes cannot open it at all (even read-only).
+    CLI read commands therefore route through the live MCP server via
+    ``read_client.run_read_routed`` (v1.2.0) when a server is live, and open
+    the file directly only when no server is running.
 
     Args:
-        read_only: Open the database in read-only mode. For KuzuBackend this
-            enables multiple concurrent read-only opens (reader/reader
-            concurrency), but does NOT allow reads while a read-write writer
-            holds the exclusive process lock — that requires routing through the
-            live MCP server via ``read_client.run_read_routed`` (v1.2.0).
-            Ignored for Neo4jBackend (Neo4j has no single-writer process lock;
-            the flag is a no-op and the normal connection is opened).
-            All writer call sites (index, reindex, db init/reset, server
-            init_backend) use the default ``False``.
+        read_only: Ignored for DuckDB. Accepted for API compatibility.
 
     Returns:
-        A GraphBackend instance (KuzuBackend by default, or Neo4jBackend)
+        A DuckDBBackend instance.
 
     Raises:
-        ValueError: If backend type is not recognized
-
-    Note:
-        CLI read commands (find, analyze, db info, gain) route through a live
-        MCP server via ``read_client.run_read_routed`` (v1.2.0) when a server
-        is live, falling back to ``get_backend(read_only=True)`` when no server
-        is present. The fallback path still contends for the process lock under
-        an active writer (Windows / no-server fallback only).
+        duckdb.IOException: If the file is locked by another process.
     """
-    backend_type = os.getenv("SQLCG_BACKEND", "kuzu")
-
-    if backend_type == "kuzu":
-        from sqlcg.core.kuzu_backend import KuzuBackend
+    from sqlcg.core.duckdb_backend import DuckDBBackend
 
-        kuzu_cfg = KuzuConfig.from_env()
-        try:
-            return KuzuBackend(
-                str(kuzu_cfg.db_path),
-                buffer_pool_size_mb=kuzu_cfg.buffer_pool_size_mb,
-                read_only=read_only,
-            )
-        except RuntimeError as exc:
-            if read_only and "READ ONLY" in str(exc):
-                # KùzuDB refuses to open a non-existent or empty DB in read-only
-                # mode ("Cannot create an empty database under READ ONLY mode").
-                # Surface the same empty-DB guidance the user sees from `db info`.
-                raise RuntimeError(
-                    "Database not initialised — run 'sqlcg db init' and 'sqlcg index <path>' first."
-                ) from exc
-            raise
-    elif backend_type == "neo4j":
-        from sqlcg.core.neo4j_backend import Neo4jBackend
-
-        neo4j_cfg = Neo4jConfig.from_env()
-        # read_only is ignored for Neo4j — no single-writer process lock.
-        return Neo4jBackend(neo4j_cfg.uri, neo4j_cfg.user, neo4j_cfg.password)
-    else:
-        raise ValueError(f"Unknown backend type: {backend_type}")
+    cfg = DbConfig.from_env()
+    return DuckDBBackend(str(cfg.db_path))