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

sqlcg/cli/commands/db.py

@@ -1,6 +1,5 @@
 """Database management commands."""
 
-import os
 import shutil
 from pathlib import Path
 
@@ -20,18 +19,8 @@ console = Console()
 
 
 @app.command("init")
-def db_init(
-    buffer_pool_size: int = typer.Option(
-        0,
-        "--buffer-pool-size",
-        help="KuzuDB buffer pool size in MB (0 = default). "
-        "Set to 256-512 on memory-constrained machines.",
-    ),
-) -> None:
+def db_init() -> None:
     """Initialise the graph database (idempotent)."""
-    if buffer_pool_size > 0:
-        os.environ["SQLCG_BUFFER_POOL_MB"] = str(buffer_pool_size)
-
     db_path = get_db_path()
     db_path.parent.mkdir(parents=True, exist_ok=True)
     with get_backend() as backend:
@@ -45,19 +34,40 @@ def db_reset(  # noqa: B008
     repo: str | None = typer.Option(None, "--repo", help="Reset only this repo path"),  # noqa: B008
 ) -> None:
     """Wipe the database or a single repo's subgraph."""
+    import socket as _socket
+
+    from sqlcg.server.control import sock_path
+
+    # Refuse cleanly when a server is live.
+    sp = sock_path()
+    if sp.exists():
+        try:
+            with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                s.connect(str(sp))
+            console.print(
+                "[red]A server is running on this database; stop it first "
+                "('sqlcg mcp stop') before resetting the database.[/red]"
+            )
+            raise typer.Exit(1)
+        except (FileNotFoundError, ConnectionRefusedError, OSError):
+            pass
+
     if repo:
-        # Delete all nodes for this repo (use run_write for mutation)
+        # Delete all nodes for this repo: delete File nodes (cascades to all
+        # related nodes via delete_nodes_for_file) and the Repo node itself.
         with get_backend() as backend:
-            backend.run_write(
-                "MATCH (r:Repo {path: $p}) DETACH DELETE r",
-                {"p": repo},
+            # Get all files for this repo
+            file_rows = backend.run_read(
+                'SELECT path FROM "File" WHERE repo_path = ?',
+                {"repo_path": repo},
             )
+            for fr in file_rows:
+                backend.delete_nodes_for_file(fr["path"])
+            backend.run_write('DELETE FROM "Repo" WHERE path = ?', {"p": repo})
         console.print(f"[yellow]Reset repo[/yellow] {repo}")
     else:
-        # Full reset — delete the DB. Kuzu may store it as a single file (current,
-        # e.g. 0.11.x) or a directory (older versions); also drop the .wal sidecar.
-        # shutil.rmtree silently no-ops on a regular file (NotADirectoryError +
-        # ignore_errors), so dispatch on the actual filesystem type.
+        # Full reset — delete the DuckDB file (single file, not a directory).
         db_path = get_db_path()
         removed = False
         for target in (db_path, db_path.with_name(db_path.name + ".wal")):
@@ -76,56 +86,46 @@ def db_reset(  # noqa: B008
 @app.command("info")
 def db_info() -> None:
     """Show database stats."""
-    # db info is a read-only command.  All Cypher reads route through the live
-    # server (run_read_routed) to avoid "Database is locked" while the MCP server
-    # holds the write lock.  get_schema_version / get_indexed_sha are inlined as
-    # run_read_routed calls using their known Cypher so they too route through the
-    # socket when a server is live; this avoids a direct-open that would hit the lock.
+    # db info routes through the live server (run_read_routed) to avoid holding
+    # the DuckDB file lock when the MCP server is running.
 
     # Schema version
-    schema_rows = run_read_routed("MATCH (v:SchemaVersion) RETURN v.version AS version LIMIT 1", {})
+    schema_rows = run_read_routed('SELECT version FROM "SchemaVersion" LIMIT 1', {})
     version = (schema_rows[0]["version"] if schema_rows else None) or "unknown"
     console.print(f"Schema version: {version}")
 
-    # Freshness block — only shown when the DB has been indexed from a git repo
+    # Freshness block
     try:
-        sha_rows = run_read_routed(
-            "MATCH (v:SchemaVersion) RETURN v.indexed_sha AS sha LIMIT 1", {}
-        )
+        sha_rows = run_read_routed('SELECT indexed_sha AS sha FROM "SchemaVersion" LIMIT 1', {})
         indexed_sha = sha_rows[0]["sha"] if sha_rows else None
-        repo_rows = run_read_routed("MATCH (r:Repo) RETURN r.path AS path LIMIT 1", {})
+        repo_rows = run_read_routed('SELECT path FROM "Repo" LIMIT 1', {})
         if repo_rows and indexed_sha is not None and repo_rows[0].get("path"):
             repo_root = Path(repo_rows[0]["path"])
             f = compute_freshness(repo_root, indexed_sha)
             console.print(render_freshness_line(f))
-    except NotImplementedError:
-        # Neo4j backend raises NotImplementedError for get_indexed_sha — skip silently
-        pass
     except Exception as e:
-        # Any unexpected error in the freshness block must not crash db info
         logger.debug(f"Freshness check skipped: {e}")
 
-    # Show node counts for all labels
+    # Node counts
     for label in NodeLabel:
         try:
-            result = run_read_routed(f"MATCH (n:{label}) RETURN COUNT(*) AS count", {})
+            result = run_read_routed(f'SELECT count(*) AS count FROM "{label}"', {})
             count = result[0]["count"] if result else 0
             console.print(f"  {label}: {count}")
         except Exception as e:
-            # Log unexpected exceptions instead of silently skipping
             logger.error(f"Error getting count for {label}: {e}")
             console.print(f"  [red]{label}: error[/red]")
 
-    # Health check section
-    repo_count_result = run_read_routed("MATCH (n:Repo) RETURN COUNT(n) AS count", {})
+    # Health check
+    repo_count_result = run_read_routed('SELECT count(*) AS count FROM "Repo"', {})
     repo_count = repo_count_result[0]["count"] if repo_count_result else 0
 
     if repo_count == 0:
-        console.print(  # noqa: E501
+        console.print(
             "[red]Database is empty. Run 'sqlcg db init' and 'sqlcg index <path>' first.[/red]"
         )
     else:
-        query_count_result = run_read_routed("MATCH (n:SqlQuery) RETURN COUNT(n) AS count", {})
+        query_count_result = run_read_routed('SELECT count(*) AS count FROM "SqlQuery"', {})
         query_count = query_count_result[0]["count"] if query_count_result else 0
 
         if query_count == 0:
@@ -134,7 +134,7 @@ def db_info() -> None:
                 "the graph.[/yellow]"
             )
         else:
-            col_count_result = run_read_routed("MATCH (n:SqlColumn) RETURN COUNT(n) AS count", {})
+            col_count_result = run_read_routed('SELECT count(*) AS count FROM "SqlColumn"', {})
             col_count = col_count_result[0]["count"] if col_count_result else 0
 
             if col_count == 0:
@@ -144,12 +144,10 @@ def db_info() -> None:
                     "will return empty results.[/yellow]"
                 )
 
-    # Print COLUMN_LINEAGE edges count
-    edges_result = run_read_routed("MATCH ()-[r:COLUMN_LINEAGE]->() RETURN COUNT(r) AS count", {})
+    edges_result = run_read_routed('SELECT count(*) AS count FROM "COLUMN_LINEAGE"', {})
     edges_count = edges_result[0]["count"] if edges_result else 0
     console.print(f"  COLUMN_LINEAGE edges: {edges_count}")
 
-    # Print star resolution metrics (T-07)
     from sqlcg.core.queries import COUNT_STAR_EXPANSIONS_QUERY, COUNT_STAR_SOURCES_QUERY
 
     star_source_result = run_read_routed(COUNT_STAR_SOURCES_QUERY, {})
@@ -160,11 +158,11 @@ def db_info() -> None:
     star_expansion_count = star_expansion_result[0]["n"] if star_expansion_result else 0
     console.print(f"  STAR_EXPANSION lineage edges: {star_expansion_count}")
 
-    # Print parsing mode distribution
-    mode_query = (
-        "MATCH (q:SqlQuery) RETURN q.parsing_mode AS mode, COUNT(q) AS cnt ORDER BY cnt DESC"
+    mode_rows = run_read_routed(
+        'SELECT parsing_mode AS mode, count(*) AS cnt FROM "SqlQuery"'
+        " GROUP BY parsing_mode ORDER BY cnt DESC",
+        {},
     )
-    mode_rows = run_read_routed(mode_query, {})
     if mode_rows and "mode" in mode_rows[0]:
         console.print("\n  Parsing mode distribution:")
         for row in mode_rows:
@@ -174,7 +172,7 @@ def db_info() -> None:
 @app.command("list-repos")
 def list_repos() -> None:
     """List all indexed repositories."""
-    result = run_read_routed("MATCH (r:Repo) RETURN r.path AS path, r.name AS name", {})
+    result = run_read_routed('SELECT path, name FROM "Repo"', {})
 
     if not result:
         console.print("[yellow]No repositories indexed[/yellow]")

sqlcg/cli/commands/find.py

@@ -4,7 +4,6 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from sqlcg.core.schema import NodeLabel
 from sqlcg.server.read_client import run_read_routed
 
 app = typer.Typer(help="Search the graph")
@@ -19,14 +18,13 @@ def find_table(  # noqa: B008
     """Find a table by name."""
     name = name.lower()  # graph keys are lowercased at index time (C2 normalization)
     results = run_read_routed(
-        f"MATCH (t:{NodeLabel.TABLE}) WHERE t.qualified CONTAINS $name "
-        "RETURN t.qualified AS qualified, t.kind AS kind LIMIT 50",
+        "SELECT qualified, kind FROM \"SqlTable\" WHERE qualified LIKE '%' || ? || '%' LIMIT 50",
         {"name": name},
     )
     if not raw:
         from sqlcg.server.noise_filter import NoiseFilter
 
-        nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+        nf = NoiseFilter.from_config()
         ids = [r["qualified"] for r in results]
         kept, _ = nf.filter_nodes(ids)
         kept_set = set(kept)
@@ -42,14 +40,13 @@ def find_column(  # noqa: B008
     """Find a column by table.column reference."""
     ref = ref.lower()  # graph keys are lowercased at index time (C2 normalization)
     results = run_read_routed(
-        f"MATCH (c:{NodeLabel.COLUMN}) WHERE c.id CONTAINS $ref RETURN c.id AS id LIMIT 50",
+        "SELECT id FROM \"SqlColumn\" WHERE id LIKE '%' || ? || '%' LIMIT 50",
         {"ref": ref},
     )
     if not raw:
         from sqlcg.server.noise_filter import NoiseFilter
 
-        nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
-        # Filter on the schema.table portion of each column id (schema.table.column)
+        nf = NoiseFilter.from_config()
         results = [r for r in results if not nf.is_noise(r["id"].rsplit(".", 1)[0])]
     _print_table(results, ["id"])
 
@@ -60,8 +57,7 @@ def find_pattern(  # noqa: B008
 ) -> None:
     """Find queries containing a SQL pattern."""
     results = run_read_routed(
-        f"MATCH (q:{NodeLabel.QUERY}) WHERE q.sql CONTAINS $pattern "
-        "RETURN q.id AS id, q.kind AS kind LIMIT 50",
+        "SELECT id, kind FROM \"SqlQuery\" WHERE sql LIKE '%' || ? || '%' LIMIT 50",
         {"pattern": pattern},
     )
     _print_table(results, ["id", "kind"])

sqlcg/cli/commands/gain.py

@@ -112,13 +112,11 @@ def gain_cmd(
             """
         )
 
-        # Section E: execute_cypher ratio
-        cypher_query = "SELECT COUNT(*) as count FROM tool_calls WHERE tool_name = 'execute_cypher'"
-        execute_cypher_count_result = metrics.execute_query(cypher_query)
-        execute_cypher_count = (
-            execute_cypher_count_result[0][0] if execute_cypher_count_result else 0
-        )
-        execute_cypher_ratio = execute_cypher_count / total_calls if total_calls > 0 else 0
+        # Section E: execute_sql ratio
+        sql_query = "SELECT COUNT(*) as count FROM tool_calls WHERE tool_name = 'execute_sql'"
+        execute_sql_count_result = metrics.execute_query(sql_query)
+        execute_sql_count = execute_sql_count_result[0][0] if execute_sql_count_result else 0
+        execute_sql_ratio = execute_sql_count / total_calls if total_calls > 0 else 0
 
         # Section F: parse quality from graph.
         # run_read_routed raises typer.Exit (Exception-derived, NOT SystemExit) on
@@ -127,8 +125,8 @@ def gain_cmd(
         parse_quality: dict[str, int] | None = None
         try:
             mode_rows = run_read_routed(
-                "MATCH (q:SqlQuery) RETURN q.parsing_mode AS mode,"
-                " COUNT(q) AS cnt ORDER BY cnt DESC",
+                'SELECT parsing_mode AS mode, count(*) AS cnt FROM "SqlQuery"'
+                " GROUP BY parsing_mode ORDER BY cnt DESC",
                 {},
             )
             if mode_rows and "mode" in mode_rows[0]:
@@ -144,7 +142,7 @@ def gain_cmd(
                 "feedback_tp": tp_count,
                 "feedback_total": fb_total,
                 "top_tools": [{"name": row[0], "count": row[1]} for row in top_tools],
-                "execute_cypher_ratio": round(execute_cypher_ratio, 2),
+                "execute_sql_ratio": round(execute_sql_ratio, 2),
             }
             if parse_quality is not None:
                 payload["parse_quality"] = parse_quality
@@ -191,14 +189,14 @@ def gain_cmd(
                     console.print(f"  {i}. {name}: {count}")
             console.print()
 
-            # Section E: execute_cypher ratio
-            console.print("[bold cyan]E. Raw Cypher Usage[/bold cyan]")
-            ratio_pct = execute_cypher_ratio * 100
-            if execute_cypher_ratio > 0.3:
-                msg = f"  [yellow]execute_cypher: {ratio_pct:.1f}% (high raw-Cypher usage)[/yellow]"
+            # Section E: execute_sql ratio
+            console.print("[bold cyan]E. Raw SQL Usage[/bold cyan]")
+            ratio_pct = execute_sql_ratio * 100
+            if execute_sql_ratio > 0.3:
+                msg = f"  [yellow]execute_sql: {ratio_pct:.1f}% (high raw-SQL usage)[/yellow]"
                 console.print(msg)
             else:
-                console.print(f"  execute_cypher: {ratio_pct:.1f}%")
+                console.print(f"  execute_sql: {ratio_pct:.1f}%")
             console.print()
 
             # Section F: parse quality from graph

sqlcg/cli/commands/git.py

@@ -33,7 +33,7 @@ _HOOKS: list[_HookSpec] = [
             '[ "$3" = "1" ] || exit 0\n'
             '{sqlcg_bin} reindex --from "$1" --to "$2"'
             ' "$(git rev-parse --show-toplevel)" --dialect auto --quiet --notify'
-            ' || echo "sqlcg: graph not updated (server busy/locked)'
+            ' || echo "sqlcg: graph not updated (reindex failed)'
             " -- run 'sqlcg mcp status'\" >&2\n"
         ),
     ),
@@ -50,10 +50,10 @@ PREV=$(git rev-parse --verify --quiet ORIG_HEAD)
 TOP=$(git rev-parse --show-toplevel)
 if [ -n "$PREV" ]; then
   {sqlcg_bin} reindex --from "$PREV" --to HEAD "$TOP" --dialect auto --quiet --notify \\
-    || echo "sqlcg: graph not updated (server busy/locked) -- run 'sqlcg mcp status'" >&2
+    || echo "sqlcg: graph not updated (reindex failed) -- run 'sqlcg mcp status'" >&2
 else
   {sqlcg_bin} reindex "$TOP" --dialect auto --quiet --notify \\
-    || echo "sqlcg: graph not updated (server busy/locked) -- run 'sqlcg mcp status'" >&2
+    || echo "sqlcg: graph not updated (reindex failed) -- run 'sqlcg mcp status'" >&2
 fi
 """,
     ),
@@ -101,7 +101,14 @@ def _install_single_hook(hooks_dir: Path, spec: _HookSpec, sqlcg_bin: str) -> No
     if hook_path.exists():
         existing_content = hook_path.read_text()
         if spec.sentinel in existing_content:
-            # Already installed — idempotent, skip silently
+            if existing_content == script:
+                # Byte-identical current template — true idempotency, silent skip.
+                return
+            # Sentinel present but content differs: sqlcg-owned but stale hook.
+            # Overwrite with the current rendered template and report the upgrade.
+            hook_path.write_text(script)
+            hook_path.chmod(0o755)
+            console.print(f"[green]Upgraded git hook:[/green] .git/hooks/{spec.filename}")
             return
         else:
             # Foreign hook without sqlcg sentinel

sqlcg/cli/commands/index.py

@@ -1,6 +1,7 @@
 """Index command for scanning and indexing SQL files."""
 
-import os
+import json
+import socket as _socket
 from pathlib import Path
 
 import typer
@@ -14,11 +15,15 @@ from rich.progress import (
     TimeRemainingColumn,
 )
 
-from sqlcg.core.config import KuzuConfig, config_file_present, get_backend, get_db_path, get_dialect
+from sqlcg.core.config import DbConfig, config_file_present, get_backend, get_db_path, get_dialect
 from sqlcg.indexer.indexer import Indexer
 
 console = Console()
 
+# Socket timeout for the index-via-server path.
+# Generous budget: full index of a large repo can take several minutes.
+_INDEX_SOCKET_TIMEOUT_S = 600
+
 
 def index_cmd(  # noqa: B008
     path: Path = typer.Argument(..., help="Directory to index"),  # noqa: B008
@@ -31,17 +36,11 @@ def index_cmd(  # noqa: B008
     timeout_per_file: int = typer.Option(  # noqa: B008
         10, "--timeout-per-file", help="Timeout per file in seconds"
     ),
-    buffer_pool_size: int = typer.Option(  # noqa: B008
-        0,
-        "--buffer-pool-size",
-        help="KuzuDB buffer pool size in MB (0 = default). "
-        "Set to 256-512 on memory-constrained machines.",
-    ),
     batch_size: int = typer.Option(  # noqa: B008
         50,
         "--batch-size",
         help=(
-            "Files per KuzuDB transaction in the upsert pass. "
+            "Files per DuckDB transaction in the upsert pass. "
             "Default 50 balances commit-overhead reduction (vs. legacy per-file commits) "
             "against per-batch memory cost. Lower values are safer for memory-constrained "
             "machines; higher values give marginal speedup at the cost of larger working sets. "
@@ -71,9 +70,24 @@ def index_cmd(  # noqa: B008
             "Marks freshness as 'indexed with working-tree changes'."
         ),
     ),
+    detach: bool = typer.Option(  # noqa: B008
+        False,
+        "--detach",
+        help=(
+            "When routing through a live server, return immediately after enqueueing "
+            "(fire-and-forget). Default is to wait for the index to complete."
+        ),
+    ),
 ) -> None:
     """Index SQL files in a directory.
 
+    When a server is live on this DB, the index is routed through the server's
+    control socket so the DB is never opened directly (avoids lock contention).
+    Use --detach to enqueue and return immediately (fire-and-forget).
+
+    With no server live, falls back to the direct-write path unchanged
+    (zero-config small-repo invariant).
+
     Schema aliases (staging schema → canonical schema) can be configured in
     .sqlcg.toml under sqlcg.schema_aliases, e.g. da_tmp = "da".
     """
@@ -85,6 +99,26 @@ def index_cmd(  # noqa: B008
     logging.getLogger("sqlcg").setLevel(level)
     logging.getLogger("sqlglot").setLevel(level)
 
+    # Resolve path early so socket routing uses the absolute path.
+    path = path.resolve()
+
+    # 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 index.
+    if dialect == "auto":
+        dialect = get_dialect(path)
+
+    # Step 3.2 — probe for a live server and route through the socket if present.
+    _routed = _try_route_index_via_server(
+        path=path,
+        dialect=dialect,
+        wait=not detach,
+        quiet=quiet,
+    )
+    if _routed:
+        return
+
     # Route parse warnings to stderr (--verbose) or to the configured log file.
     sqlcg_log = logging.getLogger("sqlcg")
 
@@ -107,20 +141,12 @@ def index_cmd(  # noqa: B008
         sqlcg_log.addHandler(_warn_handler)
         _warn_log_path = None
     else:
-        _warn_log_path = KuzuConfig.from_env().log_path
+        _warn_log_path = DbConfig.from_env().log_path
         _warn_log_path.parent.mkdir(parents=True, exist_ok=True)
         _warn_handler = logging.FileHandler(_warn_log_path)
         _warn_handler.setLevel(logging.WARNING)
         sqlcg_log.addHandler(_warn_handler)
 
-    # Set buffer pool size via env var if specified
-    if buffer_pool_size > 0:
-        os.environ["SQLCG_BUFFER_POOL_MB"] = str(buffer_pool_size)
-
-    # Resolve dialect: 'auto' reads from .sqlcg.toml, otherwise use provided value
-    if dialect == "auto":
-        dialect = get_dialect(path)
-
     if not quiet and not config_file_present(path):
         console.print(
             f"[yellow]No .sqlcg.toml found at {path}/.sqlcg.toml — "
@@ -144,7 +170,7 @@ def index_cmd(  # noqa: B008
         )
     except KeyboardInterrupt:
         # The backend context manager (inside _run_index) has already closed the
-        # KuzuDB connection and released the lock by the time we get here.
+        # DuckDB connection and released the lock by the time we get here.
         console.print("\n[yellow]Interrupted — no partial graph written. Re-run to index.[/yellow]")
         raise typer.Exit(130) from None
     finally:
@@ -172,6 +198,132 @@ def index_cmd(  # noqa: B008
         )
 
 
+def _try_route_index_via_server(
+    *,
+    path: Path,
+    dialect: str | None,
+    wait: bool,
+    quiet: bool,
+) -> bool:
+    """Probe for a live server and route the index through the socket if found.
+
+    Returns True if the index was handled via the server (caller should return).
+    Returns False if no server is live (caller should fall through to direct path).
+    """
+    from sqlcg.server.control import sock_path
+
+    sp = sock_path()
+    if not sp.exists():
+        return False
+
+    payload = {
+        "op": "index",
+        "root": str(path),
+        "dialect": dialect,
+        "wait": wait,
+        "requested_by": "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(_INDEX_SOCKET_TIMEOUT_S)
+            s.connect(str(sp))
+            s.sendall(frame)
+
+            if not wait:
+                # Fire-and-forget: read one framed acknowledgement frame.
+                f = s.makefile("rb")
+                length_line = f.readline()
+                if length_line:
+                    try:
+                        body_len = int(length_line.strip())
+                        resp_bytes = f.read(body_len)
+                        resp = json.loads(resp_bytes)
+                        if "error" in resp:
+                            err = resp["error"]
+                            if "SQLCG_DB_PATH" in err or "write lock" in err:
+                                console.print(f"[red]{err}[/red]")
+                            else:
+                                console.print(f"[red]Server error: {err}[/red]")
+                            raise typer.Exit(1)
+                        if not quiet:
+                            pos = resp.get("position", "?")
+                            console.print(f"[green]Queued via server[/green] (position {pos})")
+                    except (ValueError, json.JSONDecodeError):
+                        pass
+                return True
+
+            # wait=True: stream framed frames until done:true.
+            f = s.makefile("rb")
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                MofNCompleteColumn(),
+                TimeRemainingColumn(),
+                console=console,
+                redirect_stderr=True,
+            ) as progress:
+                task = progress.add_task("Indexing via server", total=None)
+
+                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")
+                            if "SQLCG_DB_PATH" in err or "write lock" in err:
+                                console.print(f"[red]{err}[/red]")
+                            else:
+                                console.print(f"[red]Server index error: {err}[/red]")
+                            raise typer.Exit(1)
+                        srv_summary = frame_resp.get("summary", {})
+                        if not quiet:
+                            console.print(
+                                f"[green]Indexed via server[/green] "
+                                f"{srv_summary.get('files_parsed', '?')} files — "
+                                f"{srv_summary.get('tables_found', '?')} tables, "
+                                f"{srv_summary.get('lineage_edges_created', '?')} edges"
+                            )
+                        break
+                    # Progress frame
+                    files_done = frame_resp.get("files_done", 0)
+                    files_total = frame_resp.get("files_total")
+                    if files_total:
+                        progress.update(task, completed=files_done, total=files_total)
+
+        return True
+
+    except TimeoutError:
+        import sys as _sys
+
+        print(
+            f"Server is still applying the index (timed out waiting after "
+            f"{_INDEX_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 _run_index(
     *,
     path: Path,
@@ -237,10 +389,10 @@ def _run_index(
             )
 
         # Connect files to repo
+        from sqlcg.core.queries import INDEX_REPO_FILES_QUERY
         from sqlcg.core.schema import RelType
 
-        files_query = "MATCH (f:File) WHERE f.path STARTS WITH $repo_prefix RETURN f.path AS path"
-        file_rows = backend.run_read(files_query, {"repo_prefix": abs_path})
+        file_rows = backend.run_read(INDEX_REPO_FILES_QUERY, {"repo_prefix": abs_path})
         for row in file_rows:
             backend.upsert_edge(
                 NodeLabel.FILE,