PyPI - sql-code-graph - Versions diffs - 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl - Mend

sql-code-graph 1.2.2py3-none-any.whl → 1.3.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/METADATA +1 -1
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/RECORD +15 -14
sqlcg/__init__.py +1 -1
sqlcg/cli/commands/db.py +23 -0
sqlcg/cli/commands/git.py +11 -4
sqlcg/cli/commands/index.py +167 -4
sqlcg/cli/commands/mcp.py +70 -3
sqlcg/cli/commands/reindex.py +146 -76
sqlcg/core/kuzu_backend.py +10 -6
sqlcg/metrics/store.py +48 -0
sqlcg/server/server.py +165 -70
sqlcg/server/tools.py +155 -14
sqlcg/server/writer.py +634 -0
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/WHEEL +0 -0
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.3.0.dist-info}/entry_points.txt +0 -0

sqlcg/server/server.py CHANGED Viewed

@@ -79,34 +79,46 @@ async def _control_socket_task(
     stop_event: "anyio.Event",
     backend_lock: "anyio.Lock",
     start_time: float,
+    writer_queue: "WriterQueue",
 ) -> None:
     """Accept control connections on ``<db>.sock`` and dispatch ops.
     Supported ops:
-    - ``{"op": "status"}`` → running state, pid, db_path, freshness, uptime.
-      Unframed (legacy single-recv protocol).
+    - ``{"op": "status"}`` → running state, pid, db_path, freshness, uptime,
+      writer_queue block.  **Length-prefixed framing** (v1.3.0, B3): the
+      response uses ``<decimal-byte-length>\\n<json-body>`` so large queue
+      payloads are read in full by the recv-exactly client.
     - ``{"op": "stop"}`` → sends ``{"ok": true}`` then signals stop via
-      *stop_event*.  Unframed.
-    - ``{"op": "reindex", "root", "from", "to", "dialect"}`` → runs
-      ``Indexer.resync_changed`` off the event-loop thread via
-      ``anyio.to_thread.run_sync``, serialised behind *backend_lock* (R1, R2).
-      Unframed.
+      *stop_event*.  Unframed (mcp_stop uses s.recv(128) — do NOT change).
+    - ``{"op": "index", "root", "dialect", "wait"}`` → enqueues a full index
+      onto *writer_queue* (rule 1 — supersedes all pending).  Supports
+      ``wait=true`` (stream progress frames + terminal ``done:true``) and
+      ``wait=false`` (immediate ``{ok, queued, position}``).
+    - ``{"op": "reindex", "root", "from", "to", "dialect", "wait"}`` →
+      enqueues an incremental resync (coalescing rules 2–3). ``from`` may be
+      ``null``/omitted to resolve at drain start (W3).  Same ``wait`` semantics
+      as ``index``.  The handler enqueues only — it never touches the backend
+      (B1 invariant: only the drain task resolves a backend, under backend_lock).
     - ``{"op": "query", "cypher": ..., "params": ...}`` → executes a
       read-only Cypher query on the single backend connection, serialised
       behind *backend_lock*.  **Length-prefixed framing** (v1.2.0):
       ``<decimal-byte-length>\\n<json-body>`` on both request and response.
-    Framing protocol (v1.2.0, ``query`` op only):
-      Request: ``b"<len>\\n" + json_body`` — server detects by sniffing the
-      first line; a bare decimal integer → framed.  Unframed requests always
-      start with ``{`` (never a digit), so the sniff is unambiguous.
-      Response: same ``<len>\\n<body>`` format for framed requests; unframed
-      response for unframed requests.  Old clients that use the unframed
-      ``s.recv(65536)`` + ``json.loads`` pattern will get a loud
-      ``json.JSONDecodeError`` if they accidentally receive a framed response —
-      NOT silent truncation.  Only the new ``read_client`` sends framed
-      requests, so this does not affect existing callers.
+    Framing protocol:
+      Requests: a bare decimal integer on the first line → framed.  Unframed
+      JSON always starts with ``{``, so the sniff is unambiguous.
+      Responses: framed (``<len>\\n<body>``) for ``query`` and ``status``;
+      unframed for ``stop``/``reindex``/``index`` (unless ``wait=true`` which
+      uses the multi-frame streaming protocol).
+    Multi-frame streaming protocol (``index``/``reindex`` with ``wait=true``):
+      The server sends a sequence of length-prefixed frames on the same
+      connection.  Progress frames carry ``{done: false, files_done, files_total}``.
+      The terminal frame carries ``{ok: true, done: true, summary: {...}}`` on
+      success or ``{ok: false, done: true, error: ...}`` on failure (W7).
+      The client reads frames in a loop and stops when it sees ``done == true``
+      — it does NOT rely on EOF as the terminator.
     R2 (single connection): all backend operations go through ``backend_lock``
     so concurrent calls never touch the single Kuzu connection simultaneously.
@@ -126,6 +138,7 @@ async def _control_socket_task(
     from anyio.streams.buffered import BufferedByteReceiveStream
     from sqlcg.core.config import get_db_path as _get_db_path
+    from sqlcg.server.writer import WriterRequest
     # Read-only keyword allow-list for the ``query`` op.  Only these leading
     # keywords are permitted — anything that starts with a write keyword is
@@ -211,7 +224,13 @@ async def _control_socket_task(
                         "stale_by_commits": stale,
                         "connected_clients": 1,  # stdio transport = 1 by design
                         "uptime": time.time() - start_time,
+                        "writer_queue": writer_queue.coalesce_view(),
                     }
+                    # status response is framed (B3, v1.3.0) — same framing as query
+                    # so recv-exactly clients read it in full regardless of payload size.
+                    resp_bytes = json.dumps(resp).encode()
+                    await stream.send(f"{len(resp_bytes)}\n".encode() + resp_bytes)
+                    return
                 elif op == "stop":
                     resp = {"ok": True}
@@ -222,35 +241,91 @@ async def _control_socket_task(
                     stop_event.set()
                     return
+                elif op == "index":
+                    # Step 3.1 — enqueue a full index; never touches the backend here (B1).
+                    root = req.get("root")
+                    dialect = req.get("dialect")
+                    wait = req.get("wait", False)
+                    requested_by = req.get("requested_by", "cli")
+                    if not root:
+                        resp = {"error": "index op requires root"}
+                        await stream.send(json.dumps(resp).encode() + b"\n")
+                        return
+                    writer_req = WriterRequest(
+                        op="index",
+                        root=root,
+                        dialect=dialect,
+                        from_sha=None,
+                        to_sha=None,
+                        requested_by=requested_by,
+                    )
+                    if wait:
+                        # Attach-and-wait: register a memory channel then stream frames.
+                        send_ch, recv_ch = anyio.create_memory_object_stream(max_buffer_size=64)
+                        writer_req._waiters.append(send_ch)
+                        position = await writer_queue.enqueue(writer_req)
+                        # Send the queued acknowledgement frame first.
+                        queued_frame = json.dumps(
+                            {"ok": True, "done": False, "queued": True, "position": position}
+                        ).encode()
+                        await stream.send(f"{len(queued_frame)}\n".encode() + queued_frame)
+                        # Stream progress frames until done:true terminal frame.
+                        async with recv_ch:
+                            async for terminal in recv_ch:
+                                frame_bytes = json.dumps(terminal).encode()
+                                await stream.send(f"{len(frame_bytes)}\n".encode() + frame_bytes)
+                                if terminal.get("done"):
+                                    break
+                    else:
+                        position = await writer_queue.enqueue(writer_req)
+                        resp = {"ok": True, "queued": True, "position": position}
+                        await stream.send(json.dumps(resp).encode() + b"\n")
+                    return
                 elif op == "reindex":
+                    # Step 2.3 (B1) — enqueue; the drain is the only backend consumer.
+                    # The handler NEVER calls backend_ref() (B1 invariant).
                     root = req.get("root")
-                    from_sha = req.get("from")
+                    from_sha = req.get("from")  # may be None (W3 — server resolves at drain)
                     to_sha = req.get("to")
                     dialect = req.get("dialect")
-                    if not root or not from_sha or not to_sha:
-                        resp = {"error": "reindex op requires root, from, to"}
+                    wait = req.get("wait", False)
+                    requested_by = req.get("requested_by", "cli")
+                    if not root:
+                        resp = {"error": "reindex op requires root"}
+                        await stream.send(json.dumps(resp).encode() + b"\n")
+                        return
+                    writer_req = WriterRequest(
+                        op="reindex",
+                        root=root,
+                        dialect=dialect,
+                        from_sha=from_sha,
+                        to_sha=to_sha,
+                        requested_by=requested_by,
+                    )
+                    if wait:
+                        send_ch, recv_ch = anyio.create_memory_object_stream(max_buffer_size=64)
+                        writer_req._waiters.append(send_ch)
+                        position = await writer_queue.enqueue(writer_req)
+                        queued_frame = json.dumps(
+                            {"ok": True, "done": False, "queued": True, "position": position}
+                        ).encode()
+                        await stream.send(f"{len(queued_frame)}\n".encode() + queued_frame)
+                        async with recv_ch:
+                            async for terminal in recv_ch:
+                                frame_bytes = json.dumps(terminal).encode()
+                                await stream.send(f"{len(frame_bytes)}\n".encode() + frame_bytes)
+                                if terminal.get("done"):
+                                    break
                     else:
-                        from sqlcg.indexer.indexer import Indexer
-                        db = backend_ref()
-                        if db is None:
-                            resp = {"error": "backend not available"}
-                        else:
-                            indexer = Indexer()
-                            def _do_reindex() -> dict:
-                                return indexer.resync_changed(
-                                    _Path(root),
-                                    from_sha,
-                                    to_sha,
-                                    db,
-                                    dialect,
-                                )
-                            async with backend_lock:
-                                # R1: run off event-loop thread; R2: lock serialises
-                                summary = await _to_thread.run_sync(_do_reindex)
-                            resp = {"ok": True, "summary": summary}
+                        position = await writer_queue.enqueue(writer_req)
+                        resp = {"ok": True, "queued": True, "position": position}
+                        await stream.send(json.dumps(resp).encode() + b"\n")
+                    return
                 elif op == "query":
                     # Framed op (v1.2.0): read-only Cypher query over the socket.
@@ -297,36 +372,37 @@ async def _control_socket_task(
 async def _stop_watcher(
     stop_event: "anyio.Event",
     db_path: "Path",
+    backend_lock: "anyio.Lock",
+    shutdown_requested: "anyio.Event",
 ) -> None:
     """Wait for stop_event then perform graceful shutdown.
-    When the control socket ``stop`` op fires ``stop_event``, this task:
-    1. Shuts down the backend (flush pending writes).
-    2. Removes the control files (.sock, .pid).
-    3. Calls ``os._exit(0)`` to terminate the process immediately.
-    We use ``os._exit(0)`` rather than a cancel-scope approach because the
-    MCP ``stdio_server`` runs stdin readline in a thread via
-    ``anyio.to_thread.run_sync`` with ``abandon_on_cancel=False`` (the
-    default).  When stdin is a pipe, the read-end cannot be closed from within
-    the subprocess to interrupt the blocking readline — the parent holds the
-    write end open.  ``os._exit`` bypasses the thread-drain wait entirely and
-    exits the process without calling ``atexit`` handlers or running
-    ``finally`` blocks in other tasks.
-    R8 ordering: backend is shut down HERE (before os._exit), not in main().
-    The ``finally`` block in ``main()`` will also try to shutdown/cleanup but
-    ``os._exit`` prevents it from running — so we do it explicitly here.
+    B2 shutdown ordering:
+      1. Set shutdown_requested so the drain loop exits cleanly and
+         de_escalate_to_ro skips the RO reopen.
+      2. Acquire backend_lock — waits until any active drain has fully
+         de-escalated (so the in-flight RW write is committed, not torn).
+      3. Call shutdown_backend() under the lock.
+      4. Release backend_lock.
+      5. Remove control files.
+      6. Call os._exit(0).
+    We use ``os._exit(0)`` because the MCP ``stdio_server`` blocks on a pipe
+    read (``anyio.to_thread.run_sync`` with ``abandon_on_cancel=False``).
+    We cannot interrupt it without killing the process.
     """
     import sqlcg.server.tools as _tools
     from sqlcg.server.control import cleanup_control_files
     await stop_event.wait()
-    # Graceful teardown before hard exit
-    try:
-        _tools.shutdown_backend()
-    except Exception:
-        pass
+    # B2(b): signal de_escalate_to_ro to skip the RO reopen.
+    shutdown_requested.set()
+    # B2(a): wait for any active drain to finish (acquires backend_lock).
+    async with backend_lock:
+        try:
+            _tools.shutdown_backend()
+        except Exception:
+            pass
     try:
         cleanup_control_files(db_path)
     except Exception:
@@ -355,9 +431,10 @@ async def _sigterm_watcher(
 async def _run_with_control(db_path: "Path", start_time: float) -> None:
     """Run the stdio MCP loop and the control-socket task in a shared TaskGroup.
-    Stop mechanism (R8 teardown ordering):
+    Stop mechanism (B2 teardown ordering):
     - Control socket ``stop`` op → ``stop_event.set()`` → ``_stop_watcher``
-      shuts down backend + removes control files + calls ``os._exit(0)``.
+      sets shutdown_requested, acquires backend_lock (waits for active drain),
+      shuts down backend, removes control files, calls ``os._exit(0)``.
     - External SIGTERM → ``_sigterm_watcher`` → same path via ``stop_event``.
     - Normal EOF on stdin (editor closes connection) → stdio loop returns →
       ``tg.cancel_scope.cancel()`` → tasks cancelled → ``main()`` finally
@@ -368,19 +445,35 @@ async def _run_with_control(db_path: "Path", start_time: float) -> None:
     with ``abandon_on_cancel=False``).  We cannot interrupt it without
     killing the process; ``_stop_watcher`` does cleanup first.
-    ``backend_lock`` is created once here and passed into
-    ``_control_socket_task`` so concurrent control ops (reindex, query) are
-    serialised behind a single lock on the Kuzu connection (R2).
+    ``backend_lock`` is created once here and passed into both
+    ``_control_socket_task`` and the ``drain_loop`` task so that:
+    - concurrent control ops (reindex, query) are serialised (R2), and
+    - _stop_watcher can acquire the lock to wait for an active drain (B2).
     """
     import anyio
     import sqlcg.server.tools as _tools
+    from sqlcg.server.writer import WriterQueue, drain_loop
     stop_event = anyio.Event()
-    backend_lock = anyio.Lock()  # R2: serialise all backend ops (Kuzu not thread-safe)
+    shutdown_requested = anyio.Event()
+    backend_lock = anyio.Lock()  # R2 + B2: serialise all backend ops
+    # Inject metrics into the queue so coalesce/drain events are persisted.
+    writer_queue = WriterQueue(metrics=_tools._metrics)
+    db_path_str = str(db_path)
     async with anyio.create_task_group() as tg:
         if sys.platform != "win32":
+            # Drain task: consumes WriterQueue; sole backend consumer (B1).
+            tg.start_soon(
+                drain_loop,
+                writer_queue,
+                db_path_str,
+                backend_lock,
+                shutdown_requested,
+            )
             # Spawn control socket alongside the stdio loop.
             tg.start_soon(
                 _control_socket_task,
@@ -389,9 +482,10 @@ async def _run_with_control(db_path: "Path", start_time: float) -> None:
                 stop_event,
                 backend_lock,
                 start_time,
+                writer_queue,
             )
             # Watch stop_event; shuts down and calls os._exit(0).
-            tg.start_soon(_stop_watcher, stop_event, db_path)
+            tg.start_soon(_stop_watcher, stop_event, db_path, backend_lock, shutdown_requested)
             # Watch for SIGTERM; fires stop_event for same clean path.
             tg.start_soon(_sigterm_watcher, stop_event)
@@ -457,5 +551,6 @@ if TYPE_CHECKING:
     import anyio
     from sqlcg.core.graph_db import GraphBackend
+    from sqlcg.server.writer import WriterQueue
 from sqlcg.server.control import sock_path  # noqa: E402  (used in _control_socket_task)

sqlcg/server/tools.py CHANGED Viewed

@@ -6,6 +6,10 @@ import time
 from collections import deque
 from contextlib import contextmanager
 from pathlib import Path
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    import anyio
 from sqlcg.core.config import get_db_path, get_presentation_prefixes
 from sqlcg.core.freshness import compute_freshness
@@ -100,26 +104,77 @@ _backend: GraphBackend | None = None
 # Module-level metrics store singleton
 _metrics: MetricsStore | None = None
+# Module-level backend lock — injected by server.py _run_with_control so that
+# MCP write tools (index_repo) share the same lock as the drain loop.
+# None when no server event-loop is running (unit tests, direct DB access).
+_backend_lock: "anyio.Lock | None" = None
+# True when init_backend has opened the backend in RO serving mode.
+# Checked by MCP write tools to decide whether to escalate.
+_serving_ro: bool = False
+# The path that init_backend() actually opened.  Captured at init time so
+# MCP write tools (index_repo escalation) use this path, not get_db_path()
+# which returns the default ~/.sqlcg/graph.db regardless of what was passed
+# to init_backend.  Bug B fix: without this, every escalation opened the real
+# live DB instead of the path the server (or test) configured.
+_init_db_path: str | None = None
+def _set_backend_lock(lock: "anyio.Lock | None") -> None:
+    """Register the backend lock from the server's task group.
+    Called by server.py _run_with_control so MCP write tools use the same
+    lock as the drain loop — ensuring no concurrent RW access.
+    """
+    global _backend_lock
+    _backend_lock = lock
 def init_backend(db_path: str | None = None) -> None:
     """Initialize the module-level backend singleton.
+    Startup sequence (OD-2 — measured on kuzu 0.11.3):
+      1. Open read-write → create schema if absent (init_schema is a no-op on
+         an already-initialized DB — it does NOT migrate).
+      2. Run the schema-version gate (Step 1.4): refuse non-zero if the stored
+         version differs from the current build's SCHEMA_VERSION.
+      3. Close the RW backend.
+      4. Reopen read-only and store as the serving singleton.
+    This ensures ``init_schema()`` — which issues DDL — never runs on the RO
+    connection (DDL raises on RO; ``Cannot create an empty database under READ
+    ONLY mode.`` is raised on a non-existent DB opened RO).
     Args:
         db_path: Path to KùzuDB database. If None, uses get_db_path().
     Raises:
-        RuntimeError: If backend initialization fails
+        RuntimeError: If backend initialization fails or schema version
+            is stale (the caller must not swallow this — server must exit).
     """
-    global _backend, _metrics
+    global _backend, _metrics, _serving_ro, _init_db_path
     path = db_path or str(get_db_path())
-    backend = KuzuBackend(path)
+    _init_db_path = path
+    # Step 1 — RW open + create schema if absent.
+    rw_backend = KuzuBackend(path, read_only=False)
     try:
-        backend.init_schema()
+        rw_backend.init_schema()
     except Exception as exc:
-        backend.close()
+        rw_backend.close()
         raise RuntimeError(f"Backend initialization failed: {exc}") from exc
-    _backend = backend
-    logger.debug(f"Backend initialized: {path}")
+    # Step 2 — schema-version gate (Step 1.4).
+    _assert_schema_current(rw_backend, path)
+    # Step 3 — close RW.
+    rw_backend.close()
+    # Step 4 — reopen RO as the serving singleton.
+    _backend = KuzuBackend(path, read_only=True)
+    _serving_ro = True
+    logger.debug(f"Backend initialized (RO serving): {path}")
     # Initialize metrics store (best-effort, failures are logged as WARNING)
     try:
@@ -136,7 +191,7 @@ def shutdown_backend() -> None:
     Closes the database connection and clears the global reference.
     Safe to call multiple times.
     """
-    global _backend, _metrics
+    global _backend, _metrics, _serving_ro, _init_db_path
     if _backend is not None:
         _backend.close()
         _backend = None
@@ -144,6 +199,8 @@ def shutdown_backend() -> None:
     if _metrics is not None:
         _metrics.close()
         _metrics = None
+    _serving_ro = False
+    _init_db_path = None
 def _get_backend() -> GraphBackend:
@@ -157,6 +214,80 @@ def _get_backend() -> GraphBackend:
     return _backend
+def _get_or_escalate_rw(db_path_str: str, should_escalate: bool) -> GraphBackend:
+    """Return the current backend for write use.
+    When the server has opened the backend RO (should_escalate=True), escalates
+    to RW using escalate_to_rw so the MCP write tool can write.  When the
+    backend is already RW (direct call in tests / non-server context),
+    returns it directly.
+    Args:
+        db_path_str: Path string for escalation.
+        should_escalate: True when the server has opened the backend RO.
+    """
+    if not should_escalate:
+        return _get_backend()
+    from sqlcg.server.writer import escalate_to_rw
+    return escalate_to_rw(db_path_str, current=_backend)
+def _de_escalate_to_ro_from_tool(db_path_str: str) -> None:
+    """De-escalate from RW back to RO after a MCP write tool finishes.
+    Best-effort: logs on failure but does not raise.
+    """
+    from sqlcg.server.writer import de_escalate_to_ro
+    try:
+        de_escalate_to_ro(db_path_str)
+    except Exception as exc:
+        logger.warning(f"de_escalate_to_ro failed in MCP write tool: {exc}")
+def _escalation_db_path() -> str:
+    """Return the DB path to use for RW escalation in MCP write tools.
+    When init_backend() was called with an explicit path, returns that path.
+    Falls back to get_db_path() only when init_backend has not been called
+    (e.g. direct invocation in tests that set up a backend themselves).
+    Bug B fix: index_repo previously called str(get_db_path()) directly,
+    which always returns the default ~/.sqlcg/graph.db regardless of the path
+    init_backend() was given.  This caused escalation to open the real live DB
+    even when init_backend was called with a tmp_path in tests.
+    """
+    if _init_db_path is not None:
+        return _init_db_path
+    return str(get_db_path())
+def _assert_schema_current(backend: GraphBackend, path: str) -> None:
+    """Refuse to start when the stored schema version differs from the current build.
+    Called inside the RW-ensure window of init_backend (Step 1.4) after
+    init_schema() has run the create-if-absent step.
+    Args:
+        backend: An open (RW) backend to query.
+        path: The db_path string — included in the error message for context.
+    Raises:
+        RuntimeError: Stored version present and != current SCHEMA_VERSION.
+            Message names both versions and the sqlcg db reset remedy.
+    """
+    from sqlcg.core.schema import SCHEMA_VERSION
+    stored = backend.get_schema_version()
+    if stored is not None and stored != SCHEMA_VERSION:
+        msg = (
+            f"Database schema is v{stored}, but this build expects v{SCHEMA_VERSION} — "
+            f"run 'sqlcg db reset && sqlcg index <path>' to re-index."
+        )
+        raise RuntimeError(msg)
 @contextmanager
 def _open_backend():
     """Context manager to get the initialized backend.
@@ -462,19 +593,27 @@ def index_repo(repo_path: str, dialect: str = "ansi") -> dict:
     success = True
     try:
-        db = _get_backend()
-        indexer = Indexer()
         path = Path(repo_path).resolve()
         if not path.exists():
             raise ValueError(f"Repository path does not exist: {repo_path}")
         if not path.is_dir():
             raise ValueError(f"Repository path is not a directory: {repo_path}")
+        # If the backend is in RO serving mode (set by init_backend), escalate
+        # to RW for the duration of this write op, then de-escalate after.
+        # Bug B fix: use _escalation_db_path() instead of str(get_db_path()) so
+        # that escalation targets the DB init_backend() actually opened, not the
+        # default ~/.sqlcg/graph.db.
+        db_path_str = _escalation_db_path()
+        is_ro = _serving_ro
+        rw_db = _get_or_escalate_rw(db_path_str, is_ro)
+        indexer = Indexer()
         # Ensure the Repo node exists for this repository
         from sqlcg.core.schema import NodeLabel, RelType
         abs_path = str(path)
-        db.upsert_node(
+        rw_db.upsert_node(
             NodeLabel.REPO,
             abs_path,
             {
@@ -484,14 +623,14 @@ def index_repo(repo_path: str, dialect: str = "ansi") -> dict:
         )
         # Index the repository (with absolute path)
-        result = indexer.index_repo(path, dialect, db)
+        result = indexer.index_repo(path, dialect, rw_db)
         # Create BELONGS_TO relationships from File nodes to Repo node
         # Query for all File nodes in this repo and link them to the Repo
         repo_prefix = abs_path.rstrip("/") + "/"
-        file_rows = db.run_read(INDEX_REPO_FILES_QUERY, {"repo_prefix": repo_prefix})
+        file_rows = rw_db.run_read(INDEX_REPO_FILES_QUERY, {"repo_prefix": repo_prefix})
         for row in file_rows:
-            db.upsert_edge(
+            rw_db.upsert_edge(
                 NodeLabel.FILE,
                 row["path"],
                 NodeLabel.REPO,
@@ -499,6 +638,8 @@ def index_repo(repo_path: str, dialect: str = "ansi") -> dict:
                 RelType.BELONGS_TO,
                 {},
             )
+        if is_ro:
+            _de_escalate_to_ro_from_tool(db_path_str)
         logger.info(f"Indexed {result['files_parsed']} files with {result['tables_found']} tables")

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

sql-code-graph 1.2.2py3-none-any.whl → 1.3.0py3-none-any.whl