sql-code-graph 1.34.0__tar.gz → 1.34.1__tar.gz

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.34.0
+Version: 1.34.1
 Summary: SQL code graph analyzer and lineage tracer
 Project-URL: Homepage, https://github.com/Warhorze/sql-code-graph
 Project-URL: Repository, https://github.com/Warhorze/sql-code-graph

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql-code-graph"
-version = "1.34.0"
+version = "1.34.1"
 description = "SQL code graph analyzer and lineage tracer"
 readme = "README.md"
 requires-python = ">=3.12"

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/src/sqlcg/__init__.py

@@ -1,5 +1,5 @@
 """SQL Code Graph - SQL lineage and dependency analysis tool."""
 
-__version__ = "1.34.0"
+__version__ = "1.34.1"
 
 __all__ = ["__version__"]

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/src/sqlcg/cli/commands/git.py

@@ -23,6 +23,29 @@ class _HookSpec(NamedTuple):
 # Hook script templates — use {sqlcg_bin} as the placeholder for the resolved binary.
 # The sentinel comments (e.g. "# sqlcg post-checkout hook") must stay byte-for-byte
 # unchanged so R9 idempotency is preserved: _install_single_hook matches them verbatim.
+#
+# Run-time binary resolution (#126 + #1): the hook no longer trusts the single embedded
+# absolute literal to stay valid forever (a venv rebuild or tool upgrade makes the
+# install-time path stale and the resync would then run a wrong/missing binary). Instead
+# the shared _RESOLVE_PREAMBLE resolves the binary at *run time* with a hybrid order:
+#   1. the preferred path rendered in at install time ({sqlcg_bin}, normally the stable
+#      user-base binary from _resolve_sqlcg_bin) — the fast path, used if still executable;
+#   2. `command -v sqlcg` on $PATH — covers uv-tool, user-base-on-PATH, and active-venv;
+#   3. neither resolves → print a loud stderr error and exit non-zero (never silent).
+# The shell never recomputes getuserbase() — the preferred path is rendered in by Python.
+# It exports SQLCG_BIN for the hook body to invoke.
+_RESOLVE_PREAMBLE = (
+    'if [ -x "{sqlcg_bin}" ]; then\n'
+    '  SQLCG_BIN="{sqlcg_bin}"\n'
+    "elif command -v sqlcg >/dev/null 2>&1; then\n"
+    '  SQLCG_BIN="$(command -v sqlcg)"\n'
+    "else\n"
+    "  echo \"sqlcg: cannot find the sqlcg binary (tried '{sqlcg_bin}' and \\$PATH)"
+    " -- run 'sqlcg git install-hooks' to repoint this hook\" >&2\n"
+    "  exit 1\n"
+    "fi\n"
+)
+
 _HOOKS: list[_HookSpec] = [
     _HookSpec(
         filename="post-checkout",
@@ -32,7 +55,8 @@ _HOOKS: list[_HookSpec] = [
             "# sqlcg post-checkout hook — incremental resync after branch switch\n"
             "# $3 == 1 means branch checkout (not file checkout); skip file checkouts\n"
             '[ "$3" = "1" ] || exit 0\n'
-            '{sqlcg_bin} reindex --from "$1" --to "$2"'
+            + _RESOLVE_PREAMBLE
+            + '"$SQLCG_BIN" reindex --from "$1" --to "$2"'
             ' "$(git rev-parse --show-toplevel)" --dialect auto --quiet --notify'
             ' || echo "sqlcg: graph not updated (reindex failed)'
             " -- run 'sqlcg mcp status'\" >&2\n"
@@ -41,22 +65,27 @@ _HOOKS: list[_HookSpec] = [
     _HookSpec(
         filename="post-merge",
         sentinel="# sqlcg post-merge hook",
-        script_template="""\
-#!/bin/sh
-# sqlcg post-merge hook — incremental resync after pull/merge
-# git sets ORIG_HEAD to the pre-merge HEAD; pass it as --from so --notify can route
-# through a running server (same path as post-checkout). If ORIG_HEAD is unset (e.g.
-# first-ever merge / gc'd), fall back to the standalone stored-SHA delta (direct write).
-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 (reindex failed) -- run 'sqlcg mcp status'" >&2
-else
-  {sqlcg_bin} reindex "$TOP" --dialect auto --quiet --notify \\
-    || echo "sqlcg: graph not updated (reindex failed) -- run 'sqlcg mcp status'" >&2
-fi
-""",
+        script_template=(
+            "#!/bin/sh\n"
+            "# sqlcg post-merge hook — incremental resync after pull/merge\n"
+            "# git sets ORIG_HEAD to the pre-merge HEAD; pass it as --from so --notify\n"
+            "# can route through a running server (same path as post-checkout). If\n"
+            "# ORIG_HEAD is unset (e.g. first-ever merge / gc'd), fall back to the\n"
+            "# standalone stored-SHA delta (direct write).\n"
+            + _RESOLVE_PREAMBLE
+            + "PREV=$(git rev-parse --verify --quiet ORIG_HEAD)\n"
+            "TOP=$(git rev-parse --show-toplevel)\n"
+            'if [ -n "$PREV" ]; then\n'
+            '  "$SQLCG_BIN" reindex --from "$PREV" --to HEAD "$TOP" --dialect auto'
+            " --quiet --notify \\\n"
+            '    || echo "sqlcg: graph not updated (reindex failed)'
+            " -- run 'sqlcg mcp status'\" >&2\n"
+            "else\n"
+            '  "$SQLCG_BIN" reindex "$TOP" --dialect auto --quiet --notify \\\n'
+            '    || echo "sqlcg: graph not updated (reindex failed)'
+            " -- run 'sqlcg mcp status'\" >&2\n"
+            "fi\n"
+        ),
     ),
 ]
 

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/src/sqlcg/cli/commands/reindex.py

@@ -129,6 +129,11 @@ def reindex_cmd(  # noqa: B008
     # below) and return to git immediately. The respawn guard env var prevents
     # the detached child from detaching again.
     if _is_hook_path and os.environ.get(_HOOK_DETACHED_ENV) != "1":
+        # #1 — loud foreground preflight BEFORE detaching. The detached child's
+        # schema gate (below) writes its Exit(1) to the hook-resync log, invisible
+        # to the user, so a stale-binary schema skew dies silently (exit 0 to git).
+        # Surface a real mismatch in the foreground, where git's terminal can see it.
+        _hook_preflight_schema_check()
         _spawn_detached_hook_resync(path)
         return
 
@@ -291,6 +296,66 @@ def _spawn_detached_hook_resync(path: Path) -> None:
     console.print(f"sqlcg: resyncing graph in background (log: {log_path})")
 
 
+def _hook_preflight_schema_check() -> None:
+    """Surface a stale-binary schema/version skew in the FOREGROUND hook process (#1).
+
+    On the hook path the resync is detached (#77), so the existing schema gate
+    (``reindex_cmd`` at ~:150) runs in the detached child whose stdout/stderr go to
+    ``hook-resync.log`` — its ``Exit(1)`` never reaches the user's terminal and the
+    graph silently never refreshes. This preflight runs *before* the detach and, on a
+    REAL mismatch, prints a visible, actionable stderr message and exits non-zero
+    without detaching.
+
+    Git runs post-checkout/post-merge AFTER the operation and ignores the hook exit
+    status, so the **stderr message** is the load-bearing part (not the exit code).
+
+    BOUNDED, FAIL-SOFT open (plan-review B1 — MANDATED). DuckDB takes an exclusive
+    file lock: per ``config.py`` ``get_backend`` docstring, a second process cannot
+    open the DB at all (even read-only) while another holds it — it raises
+    ``duckdb.IOException`` (#63). On rapid successive checkouts a prior detached
+    resync still holds the lock, so this open WILL contend. We therefore do a SINGLE
+    open attempt (NOT ``_open_backend_with_lock_retry``'s ~31 s retry, which would
+    stall ``git checkout`` — a #77-class regression) and, on ``IOException`` (lock
+    held ⇒ a resync is already in flight), treat it as "cannot determine — fall
+    through to the existing detach path unchanged": never block, never emit a
+    schema-mismatch error. Only a SUCCESSFUL read showing a real mismatch triggers
+    the loud exit. The backend is opened read-only and released before returning so
+    the detached child can still acquire the lock.
+    """
+    import duckdb
+
+    from sqlcg.core.config import get_backend
+    from sqlcg.core.schema import SCHEMA_VERSION
+
+    try:
+        backend = get_backend(read_only=True)
+    except duckdb.IOException:
+        # Lock held by an in-flight resync — cannot determine; fall through to detach.
+        return
+
+    try:
+        with backend:
+            stored_version = backend.get_schema_version()
+            if stored_version is None or stored_version == SCHEMA_VERSION:
+                # Matches (or no stored version yet on a fresh graph) — detach as today.
+                return
+            indexed_tool_version = backend.get_indexed_version()
+    except duckdb.IOException:
+        # Lock raced after the open (e.g. closed-then-reopened by the writer);
+        # fail soft exactly as the open-time IOException path.
+        return
+
+    skew = f" (graph last indexed by sqlcg {indexed_tool_version})" if indexed_tool_version else ""
+    print(
+        f"sqlcg: graph schema is v{stored_version} but this tool needs "
+        f"v{SCHEMA_VERSION}{skew} — the hook binary is stale. "
+        "Run 'sqlcg git install-hooks' to repoint the hook, then "
+        "'sqlcg db reset && sqlcg index <root>'.",
+        file=sys.stderr,
+    )
+    raise typer.Exit(1)
+
+
 def _open_backend_with_lock_retry() -> "GraphBackend":
     """Open the DuckDB backend, retrying with backoff if it is locked.
 

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/tests/e2e/test_git_hook_install.py

@@ -1,6 +1,7 @@
 """End-to-end tests for git hook installation and execution."""
 
 import os
+import shutil
 import subprocess
 import tempfile
 from pathlib import Path
@@ -86,8 +87,10 @@ def test_hook_runs_sqlcg_reindex_on_branch_checkout(temp_git_repo):
 
     hook_content = hook_path.read_text()
 
-    # post-checkout must call sqlcg reindex --from $1 --to $2 (incremental resync)
-    assert "sqlcg reindex" in hook_content
+    # post-checkout must call reindex via the run-time-resolved $SQLCG_BIN (#126/#1):
+    # preferred path -> command -v sqlcg -> loud error.
+    assert '"$SQLCG_BIN" reindex' in hook_content
+    assert "command -v sqlcg" in hook_content
     assert '--from "$1"' in hook_content
     assert '--to "$2"' in hook_content
     assert "--dialect auto" in hook_content
@@ -112,8 +115,8 @@ def test_idempotency_no_duplicate_hook_lines(temp_git_repo):
     assert sentinel_count == 1, f"Expected 1 sentinel, found {sentinel_count}"
 
     # All three installs should report success/idempotency
-    hook_lines = content.count("sqlcg reindex")
-    assert hook_lines == 1, f"Expected 1 sqlcg reindex line, found {hook_lines}"
+    hook_lines = content.count('"$SQLCG_BIN" reindex')
+    assert hook_lines == 1, f"Expected 1 reindex line, found {hook_lines}"
 
 
 # ---------------------------------------------------------------------------
@@ -147,7 +150,7 @@ def test_post_merge_hook_content_orig_head_guard(temp_git_repo):
     # The else branch must contain a reindex call without --from
     else_idx = content.index("else")
     fallback_section = content[else_idx:]
-    assert "sqlcg reindex" in fallback_section
+    assert '"$SQLCG_BIN" reindex' in fallback_section
 
 
 def test_post_merge_hook_idempotent(temp_git_repo):
@@ -292,3 +295,127 @@ def test_post_merge_hook_orig_head_set_routes_with_shas(temp_git_repo):
     )
     assert "--to HEAD" in argv_recorded, f"Expected --to HEAD in argv; got: {argv_recorded!r}"
     assert "--notify" in argv_recorded
+
+
+# ---------------------------------------------------------------------------
+# #126 + #1 — run-time binary resolution survives a stale preferred path
+# ---------------------------------------------------------------------------
+
+
+def _install_hook_with_preferred_bin(repo: Path, preferred_bin: Path) -> Path:
+    """Install the post-checkout hook with ``preferred_bin`` rendered as the entry."""
+    import sqlcg.cli.commands.git as _git_mod
+
+    original = _git_mod._resolve_sqlcg_bin
+    _git_mod._resolve_sqlcg_bin = lambda: str(preferred_bin)
+    try:
+        runner.invoke(app, ["git", "install-hooks", "--repo", str(repo)])
+    finally:
+        _git_mod._resolve_sqlcg_bin = original
+    return repo / ".git" / "hooks" / "post-checkout"
+
+
+def test_hook_resolves_path_binary_after_preferred_path_deleted(temp_git_repo):
+    """venv-rebuild sim: preferred path gone -> hook resolves a $PATH sqlcg, exit 0.
+
+    Models an editable .venv install whose embedded path is deleted by a venv
+    rebuild. The run-time preamble must fall back to `command -v sqlcg` and invoke
+    the working $PATH binary. Guards the git-hook binary-resolution plan
+    ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+    """
+    venv_dir = temp_git_repo / ".venv" / "bin"
+    venv_dir.mkdir(parents=True)
+    preferred = venv_dir / "sqlcg"
+    preferred.write_text("#!/bin/sh\nexit 0\n")
+    preferred.chmod(0o755)
+
+    hook_path = _install_hook_with_preferred_bin(temp_git_repo, preferred)
+    assert f'if [ -x "{preferred}"' in hook_path.read_text()
+
+    # Simulate the venv rebuild: the preferred path no longer exists.
+    preferred.unlink()
+
+    # Provide a working sqlcg on $PATH that records its invocation.
+    path_dir = temp_git_repo / "pathbin"
+    path_dir.mkdir()
+    argv_file = temp_git_repo / "argv.txt"
+    path_bin = path_dir / "sqlcg"
+    path_bin.write_text(f'#!/bin/sh\necho "$@" >> {argv_file}\nexit 0\n')
+    path_bin.chmod(0o755)
+
+    env = os.environ.copy()
+    env["PATH"] = f"{path_dir}:{env['PATH']}"
+    result = subprocess.run(
+        ["sh", str(hook_path), "abc123", "def456", "1"],
+        cwd=str(temp_git_repo),
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert argv_file.exists(), "the $PATH sqlcg binary was never invoked"
+    assert "reindex" in argv_file.read_text()
+
+
+def test_hook_loud_error_when_no_binary_resolvable_anywhere(temp_git_repo):
+    """No sqlcg anywhere -> hook exits NON-ZERO with a stderr message, never silent 0.
+
+    The exact #1 failure inversion at the hook-script layer. Guards the git-hook
+    binary-resolution plan
+    ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+    """
+    missing = temp_git_repo / "gone" / "sqlcg"  # never created
+    hook_path = _install_hook_with_preferred_bin(temp_git_repo, missing)
+
+    # Run with a PATH that has the system shell dirs (so `sh`/`command` resolve)
+    # but no sqlcg anywhere — i.e. drop the test runner's venv/user-base dirs.
+    sh_bin = shutil.which("sh") or "/bin/sh"
+    sh_dir = str(Path(sh_bin).parent)
+    empty_path_dir = temp_git_repo / "emptybin"
+    empty_path_dir.mkdir()
+    env = os.environ.copy()
+    env["PATH"] = f"{empty_path_dir}:{sh_dir}:/usr/bin:/bin"
+    assert shutil.which("sqlcg", path=env["PATH"]) is None, "test setup: sqlcg still on PATH"
+    result = subprocess.run(
+        [sh_bin, str(hook_path), "abc123", "def456", "1"],
+        cwd=str(temp_git_repo),
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode != 0, f"hook must exit non-zero when no binary resolves: {result!r}"
+    assert "cannot find the sqlcg binary" in result.stderr
+    assert "sqlcg git install-hooks" in result.stderr
+
+
+def test_reinstall_upgrades_stale_template_hook(temp_git_repo):
+    """A pre-#126 fixed-path hook is auto-upgraded to the run-time-resilient template.
+
+    The self-upgrade branch (sentinel present, body differs -> overwrite) rewrites a
+    stale v1.33.1-era hook and prints 'Upgraded git hook:'. Guards the git-hook
+    binary-resolution plan
+    ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+    """
+    hooks_dir = temp_git_repo / ".git" / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    stale = hooks_dir / "post-checkout"
+    # Old v1.33.1-era template: fixed embedded literal, no run-time preamble.
+    stale.write_text(
+        "#!/bin/sh\n"
+        "# sqlcg post-checkout hook — incremental resync after branch switch\n"
+        '[ "$3" = "1" ] || exit 0\n'
+        '/old/path/sqlcg reindex --from "$1" --to "$2" "$(git rev-parse --show-toplevel)"'
+        " --dialect auto --quiet --notify\n"
+    )
+    stale.chmod(0o755)
+
+    result = runner.invoke(app, ["git", "install-hooks", "--repo", str(temp_git_repo)])
+
+    assert result.exit_code == 0
+    assert "Upgraded git hook:" in result.output
+    upgraded = stale.read_text()
+    assert "command -v sqlcg" in upgraded
+    assert '"$SQLCG_BIN" reindex' in upgraded
+    assert "/old/path/sqlcg reindex" not in upgraded

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/tests/unit/test_git_hooks.py

@@ -55,7 +55,11 @@ def test_post_checkout_contains_reindex_with_sha_args(temp_git_repo):
     runner.invoke(app, ["git", "install-hooks", "--repo", str(temp_git_repo)])
 
     content = hook_path.read_text()
-    assert "sqlcg reindex" in content
+    # Run-time resolution (#126/#1): the binary is invoked via $SQLCG_BIN, resolved
+    # by the preamble (preferred path -> command -v sqlcg -> loud error), not a fixed
+    # embedded literal.
+    assert '"$SQLCG_BIN" reindex' in content
+    assert "command -v sqlcg" in content
     assert '--from "$1"' in content
     assert '--to "$2"' in content
     assert "--dialect auto" in content
@@ -101,7 +105,8 @@ def test_post_merge_contains_orig_head_guard(temp_git_repo):
     runner.invoke(app, ["git", "install-hooks", "--repo", str(temp_git_repo)])
 
     content = hook_path.read_text()
-    assert "sqlcg reindex" in content
+    assert '"$SQLCG_BIN" reindex' in content
+    assert "command -v sqlcg" in content
     # ORIG_HEAD guard — reads pre-merge HEAD via git rev-parse
     assert "git rev-parse --verify --quiet ORIG_HEAD" in content
     # If-branch: passes explicit SHAs to enable server routing
@@ -444,11 +449,14 @@ def test_install_hooks_fails_outside_git_repo():
 
 
 def test_install_hooks_embeds_absolute_binary_path(temp_git_repo, monkeypatch):
-    """Scenario E: when shutil.which returns an absolute path, hooks use it.
-
-    Asserts:
-    - post-checkout and post-merge command lines start with the resolved absolute path
-    - NOT bare 'sqlcg' (which would cause version skew if the installed binary differs)
+    """Scenario E: the resolved absolute path is the PREFERRED run-time entry.
+
+    Run-time resolution (#126/#1): the absolute path is no longer the literal that
+    invokes reindex. It is rendered into the preamble's preferred branch
+    (`if [ -x "<abs>" ]`); the body invokes `$SQLCG_BIN`, with `command -v sqlcg`
+    as the run-time fallback. Asserts:
+    - the resolved absolute path appears as the preferred preamble entry
+    - the body invokes "$SQLCG_BIN" reindex (not a fixed literal that can go stale)
     - sentinel comments are present (R9 idempotency preserved)
     """
     import sqlcg.cli.commands.git as _git_mod
@@ -464,18 +472,19 @@ def test_install_hooks_embeds_absolute_binary_path(temp_git_repo, monkeypatch):
     co_content = co_hook.read_text()
     pm_content = pm_hook.read_text()
 
-    # Command lines must use the absolute path
-    assert f"{abs_bin} reindex" in co_content, (
-        f"post-checkout must use absolute path. Got:\n{co_content}"
+    # The absolute path is the preferred run-time entry in the resolution preamble.
+    assert f'if [ -x "{abs_bin}" ]' in co_content, (
+        f"post-checkout must prefer the absolute path. Got:\n{co_content}"
     )
-    assert f"{abs_bin} reindex" in pm_content, (
-        f"post-merge must use absolute path. Got:\n{pm_content}"
+    assert f'if [ -x "{abs_bin}" ]' in pm_content, (
+        f"post-merge must prefer the absolute path. Got:\n{pm_content}"
     )
 
-    # Bare 'sqlcg reindex' (without the leading abs path prefix) must NOT appear
-    # as a standalone command (i.e. not preceded by a different path component)
-    assert "\nsqlcg reindex" not in co_content, "post-checkout must not use bare 'sqlcg reindex'"
-    assert "\nsqlcg reindex" not in pm_content, "post-merge must not use bare 'sqlcg reindex'"
+    # The body invokes the resolved $SQLCG_BIN, with command -v sqlcg as the fallback.
+    assert '"$SQLCG_BIN" reindex' in co_content
+    assert '"$SQLCG_BIN" reindex' in pm_content
+    assert "command -v sqlcg" in co_content
+    assert "command -v sqlcg" in pm_content
 
     # Sentinels must be unchanged (R9 idempotency)
     assert "# sqlcg post-checkout hook" in co_content
@@ -516,11 +525,15 @@ def test_install_hooks_idempotent_with_absolute_path(temp_git_repo, monkeypatch)
 
 
 def test_install_hooks_bare_fallback_when_no_binary_resolvable(temp_git_repo, monkeypatch):
-    """Scenario G: when no sqlcg binary is resolvable, falls back to bare 'sqlcg' + warning.
+    """Scenario G: no resolvable binary at install -> bare 'sqlcg' preferred entry + warning.
 
-    Asserts:
+    Run-time resolution (#126/#1): even when install-time resolution returns the bare
+    'sqlcg' literal, the rendered hook still relies on the run-time preamble — the bare
+    'sqlcg' is the preferred entry and `command -v sqlcg` is the run-time fallback, with
+    a loud error branch if neither resolves. Asserts:
     - install-hooks does NOT hard-fail
-    - the generated hooks use bare 'sqlcg reindex'
+    - the preamble renders the bare 'sqlcg' preferred entry + command -v fallback
+    - the body invokes "$SQLCG_BIN" reindex
     - a one-line warning is printed to output
     """
     import sqlcg.cli.commands.git as _git_mod
@@ -540,9 +553,13 @@ def test_install_hooks_bare_fallback_when_no_binary_resolvable(temp_git_repo, mo
     co_content = (temp_git_repo / ".git" / "hooks" / "post-checkout").read_text()
     pm_content = (temp_git_repo / ".git" / "hooks" / "post-merge").read_text()
 
-    # Must fall back to bare 'sqlcg'
-    assert "sqlcg reindex" in co_content
-    assert "sqlcg reindex" in pm_content
+    # Bare 'sqlcg' is rendered as the preferred preamble entry; run-time fallback is PATH.
+    assert 'if [ -x "sqlcg" ]' in co_content
+    assert 'if [ -x "sqlcg" ]' in pm_content
+    assert "command -v sqlcg" in co_content
+    assert "command -v sqlcg" in pm_content
+    assert '"$SQLCG_BIN" reindex' in co_content
+    assert '"$SQLCG_BIN" reindex' in pm_content
 
     # Warning must be printed
     assert "warning" in result.output.lower() or "warn" in result.output.lower(), (

{sql_code_graph-1.34.0 → sql_code_graph-1.34.1}/tests/unit/test_hook_reindex_detach.py

@@ -479,3 +479,191 @@ class TestHookResyncLogPath:
         log_path = reindex_module._hook_resync_log_path()
 
         assert log_path == db_path.parent / "hook-resync.log"
+
+
+# ---------------------------------------------------------------------------
+# #1 — loud foreground preflight on schema/version skew before detaching
+# ---------------------------------------------------------------------------
+
+
+def _seed_db_with_schema_version(db_path: Path, version: str) -> None:
+    """Create a graph whose stored SchemaVersion row has the given version.
+
+    Writes the row directly so we can simulate a *stale-binary* graph whose
+    stored schema version differs from the current build's ``SCHEMA_VERSION``.
+    """
+    from sqlcg.core.duckdb_backend import DuckDBBackend
+
+    backend = DuckDBBackend(str(db_path))
+    backend.init_schema()
+    backend._conn.execute('DELETE FROM "SchemaVersion"')
+    backend._conn.execute(
+        'INSERT INTO "SchemaVersion" (version, indexed_sha, sqlcg_version) VALUES (?, ?, ?)',
+        [version, "deadbeef", "1.25.6"],
+    )
+    backend.close()
+
+
+class TestHookPreflightSchemaSkew:
+    """A stale-binary schema skew on the hook path fails LOUDLY, never silently (#1)."""
+
+    def test_schema_mismatch_exits_nonzero_with_message_and_no_detach(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        """Stored schema != current -> non-zero exit, visible message, NO detach spawn.
+
+        Inverts the #1 silent-exit-0 failure mode: before the fix the schema gate
+        ran in the detached child (log file only); now the foreground preflight
+        surfaces it. Guards the git-hook binary-resolution plan
+        ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+        """
+        repo = _git_repo(tmp_path)
+        sha_a = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=repo, check=True, capture_output=True, text=True
+        ).stdout.strip()
+        (repo / "added.sql").write_text("CREATE TABLE ADDED (id INT);\n")
+        sha_b = _commit_all(repo, "add table")
+
+        db_path = tmp_path / "stale.db"
+        monkeypatch.setenv("SQLCG_DB_PATH", str(db_path))
+        _seed_db_with_schema_version(db_path, "8")  # stale: build needs "10"
+
+        mock_popen = _DetachPopenSpy()
+        monkeypatch.setattr(reindex_module.subprocess, "Popen", mock_popen)
+
+        result = runner.invoke(
+            app,
+            [
+                "reindex",
+                str(repo),
+                "--from",
+                sha_a,
+                "--to",
+                sha_b,
+                "--dialect",
+                "ansi",
+                "--quiet",
+                "--notify",
+            ],
+        )
+
+        assert result.exit_code != 0, result.output
+        assert "schema is v8" in result.output
+        assert "hook binary is stale" in result.output
+        assert "sqlcg git install-hooks" in result.output
+        # The whole point: it did NOT detach a doomed background resync.
+        mock_popen.assert_not_called()
+
+    def test_matching_schema_detaches_and_exits_zero(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        """Stored schema == current -> preflight is silent, detach proceeds, exit 0.
+
+        Regression guard that the preflight does not break the legitimate async
+        path. Guards the git-hook binary-resolution plan
+        ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+        """
+        from sqlcg.core.schema import SCHEMA_VERSION
+
+        repo = _git_repo(tmp_path)
+        sha_a = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=repo, check=True, capture_output=True, text=True
+        ).stdout.strip()
+        (repo / "added.sql").write_text("CREATE TABLE ADDED (id INT);\n")
+        sha_b = _commit_all(repo, "add table")
+
+        db_path = tmp_path / "current.db"
+        monkeypatch.setenv("SQLCG_DB_PATH", str(db_path))
+        _seed_db_with_schema_version(db_path, SCHEMA_VERSION)
+
+        mock_popen = _DetachPopenSpy()
+        monkeypatch.setattr(reindex_module.subprocess, "Popen", mock_popen)
+
+        result = runner.invoke(
+            app,
+            [
+                "reindex",
+                str(repo),
+                "--from",
+                sha_a,
+                "--to",
+                sha_b,
+                "--dialect",
+                "ansi",
+                "--quiet",
+                "--notify",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "hook binary is stale" not in result.output
+        mock_popen.assert_called_once()
+
+    def test_locked_db_falls_through_to_detach_without_blocking_or_false_error(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ):
+        """B1 hot-path safety: lock held -> single fast open, fall through to detach.
+
+        Simulates a concurrent resync holding the DuckDB exclusive lock: the
+        preflight's open raises IOException. It MUST NOT retry ~31 s (a #77-class
+        stall) and MUST NOT emit a false stale-schema error — it falls through to
+        the detach path unchanged. Proves we did not reintroduce #77. Guards the
+        git-hook binary-resolution plan
+        ([plan doc](plan/sprints/bugfix_githook_binary_resolution.md)).
+        """
+        repo = _git_repo(tmp_path)
+        sha_a = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=repo, check=True, capture_output=True, text=True
+        ).stdout.strip()
+        (repo / "added.sql").write_text("CREATE TABLE ADDED (id INT);\n")
+        sha_b = _commit_all(repo, "add table")
+
+        db_path = tmp_path / "locked.db"
+        monkeypatch.setenv("SQLCG_DB_PATH", str(db_path))
+
+        # Make the preflight's read-only open raise IOException (lock held), and
+        # count calls so we can assert it was a SINGLE attempt (no 31 s retry).
+        open_calls = {"n": 0}
+
+        def _always_locked(read_only: bool = False):
+            open_calls["n"] += 1
+            raise duckdb.IOException("Conflicting lock is held — another sqlcg process is running.")
+
+        import sqlcg.core.config as config_module
+
+        monkeypatch.setattr(config_module, "get_backend", _always_locked)
+        # If the preflight ever slept (retry), fail loudly — it must be a single
+        # bounded open, not the lock-retry path.
+        monkeypatch.setattr(
+            reindex_module.time,
+            "sleep",
+            lambda _s: (_ for _ in ()).throw(
+                AssertionError("preflight must not sleep/retry on a held lock")
+            ),
+        )
+
+        mock_popen = _DetachPopenSpy()
+        monkeypatch.setattr(reindex_module.subprocess, "Popen", mock_popen)
+
+        result = runner.invoke(
+            app,
+            [
+                "reindex",
+                str(repo),
+                "--from",
+                sha_a,
+                "--to",
+                sha_b,
+                "--dialect",
+                "ansi",
+                "--quiet",
+                "--notify",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        # Fell through to detach, no false stale-schema error.
+        assert "hook binary is stale" not in result.output
+        mock_popen.assert_called_once()
+        # Single bounded open — the preflight opened exactly once (not 5x retry).
+        assert open_calls["n"] == 1, f"preflight opened {open_calls['n']} times (must be 1)"