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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.34.0
+Version: 1.34.2
 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.2/plan/metrics/createkind_dwh_after.json

@@ -0,0 +1,31 @@
+{"total_calls": 1231, "last_7d_calls": 1231, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 412}, 
+{"name": "trace_column_lineage", "count": 326}, {"name": 
+"list_dialects_and_repos", "count": 106}], "execute_sql_ratio": 0.33, 
+"parse_quality": {"sqlglot": 5166, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5796, "total_tables": 6581, "good_edges": 
+51326, "total_edges": 59474, "phantom_edges": 12241, "blindspot_tables": 628, 
+"good_edges_strict": 46495, "edge_health_strict_pct": 78.18, 
+"good_edges_scoped": 36842, "total_edges_scoped": 37619, 
+"edge_health_scoped_pct": 97.93, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ia_analytics.ba_wtfa_artikel_formule_dagomzet", "bad_edges": 217}, 
+{"table": "ba.wtfa_kpi_datum_klant", "bad_edges": 70}, {"table": 
+"ba.wtfs_voorraad_dagstand", "bad_edges": 55}, {"table": 
+"ba.wtfs_voorraad_zondagstand", "bad_edges": 55}, {"table": 
+"da.rtgmd_postnl_customer_usage", "bad_edges": 43}, {"table": 
+"da.rtgmd_postnl_athome_3s", "bad_edges": 33}, {"table": 
+"wtfe_kpi_voorraad_artikel_voorraadlocatie", "bad_edges": 32}, {"table": 
+"da.rtgmd_postnl_facturen", "bad_edges": 30}, {"table": "da.hthyb_pages", 
+"bad_edges": 23}, {"table": "da.rtgmd_dhb_extra_kosten", "bad_edges": 19}], 
+"blindspot_tables_for_80pct": 15, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/ckm_after.duckdb", 
+"index_timestamp": 1781457191.07209, "degraded_parse_total": 5189, 
+"degraded_parse_queries": 20, "degraded_parse_by_dir": {"etl": {"degraded": 1, 
+"total": 2776}, "ddl": {"degraded": 19, "total": 2413}}, 
+"zero_edge_write_queries": 1040, "total_write_queries": 2323, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 110257, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 35759, "transitive_col_edges": 4168, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.34.3", "running_tool_version": "1.34.3"}}

sql_code_graph-1.34.2/plan/metrics/createkind_dwh_before.json

@@ -0,0 +1,31 @@
+{"total_calls": 1231, "last_7d_calls": 1231, "index_runs": 5, "feedback_tp": 0, 
+"feedback_total": 0, "top_tools": [{"name": "execute_sql", "count": 412}, 
+{"name": "trace_column_lineage", "count": 326}, {"name": 
+"list_dialects_and_repos", "count": 106}], "execute_sql_ratio": 0.33, 
+"parse_quality": {"sqlglot": 5162, "scripting": 20, "dynamic_sql": 3}, 
+"coverage": {"catalogued_tables": 5796, "total_tables": 6572, "good_edges": 
+51235, "total_edges": 59068, "phantom_edges": 12241, "blindspot_tables": 619, 
+"good_edges_strict": 46399, "edge_health_strict_pct": 78.55, 
+"good_edges_scoped": 36748, "total_edges_scoped": 37524, 
+"edge_health_scoped_pct": 97.93, "phantom_confirmed": 11701, 
+"phantom_contradicted": 352, "phantom_unverified": 188, "top_blindspot_tables": 
+[{"table": "ia_analytics.ba_wtfa_artikel_formule_dagomzet", "bad_edges": 216}, 
+{"table": "ba.wtfa_kpi_datum_klant", "bad_edges": 70}, {"table": 
+"ba.wtfs_voorraad_dagstand", "bad_edges": 55}, {"table": 
+"ba.wtfs_voorraad_zondagstand", "bad_edges": 55}, {"table": 
+"da.rtgmd_postnl_customer_usage", "bad_edges": 43}, {"table": 
+"da.rtgmd_postnl_athome_3s", "bad_edges": 33}, {"table": 
+"wtfe_kpi_voorraad_artikel_voorraadlocatie", "bad_edges": 32}, {"table": 
+"da.rtgmd_postnl_facturen", "bad_edges": 30}, {"table": "da.hthyb_pages", 
+"bad_edges": 23}, {"table": "da.rtgmd_dhb_extra_kosten", "bad_edges": 19}], 
+"blindspot_tables_for_80pct": 15, "files_indexed": 1335, "indexed_sha": 
+"fdf1b551a34601a6cf3ce1c8b9f76e27ce2753e6", "db_path": "/tmp/ckm_before.duckdb",
+"index_timestamp": 1781456971.4233296, "degraded_parse_total": 5185, 
+"degraded_parse_queries": 20, "degraded_parse_by_dir": {"etl": {"degraded": 1, 
+"total": 2772}, "ddl": {"degraded": 19, "total": 2413}}, 
+"zero_edge_write_queries": 1069, "total_write_queries": 2351, 
+"cte_key_collisions": 0, "rescuable_unqualified_edges": 125, 
+"info_schema_has_column_rows": 110257, "cte_source_gap_writes": 0, 
+"resolvable_write_col_edges": 35351, "transitive_col_edges": 4174, 
+"qualify_failed_statements": 9, "tool_version_stale": false, 
+"indexed_tool_version": "1.34.1", "running_tool_version": "1.34.1"}}

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql-code-graph"
-version = "1.34.0"
+version = "1.34.2"
 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.2}/src/sqlcg/__init__.py

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

{sql_code_graph-1.34.0 → sql_code_graph-1.34.2}/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.2}/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.2}/src/sqlcg/parsers/base.py

@@ -591,7 +591,8 @@ class SqlParser(ABC):
                     case "PROCEDURE" | "FUNCTION":
                         return QueryKind.CREATE_PROC
                     case _:
-                        return QueryKind.CREATE_TABLE  # Default to table
+                        # non-table CREATE (sequence/stage/file format/schema/index/etc.)
+                        return QueryKind.OTHER
             case exp.Merge():
                 return QueryKind.MERGE
             case _:

{sql_code_graph-1.34.0 → sql_code_graph-1.34.2}/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.2/tests/integration/test_non_table_create_coverage_no_regression.py

@@ -0,0 +1,88 @@
+"""Coverage no-regression: non-table CREATE DDL is excluded from write-kind metrics.
+
+Pins blast-radius item #7 of the create-kind mislabel bugfix
+([plan doc](plan/sprints/bugfix_create_kind_mislabel.md), AC4).
+
+``_WRITE_KINDS = ("INSERT", "MERGE", "CREATE_TABLE", "UPDATE")`` drives
+``total_write_queries`` and ``zero_edge_write_queries``. Before the fix a
+``CREATE SEQUENCE`` was stored as ``CREATE_TABLE`` and so inflated both counters
+(it carries no COLUMN_LINEAGE, so it counted as a "zero-edge write" — a false
+unresolved-write gap). After the fix it classifies as ``OTHER`` and drops out of
+the write population. This is an honest-accounting correction, not a regression.
+
+Observable oracle: ``collect_coverage`` routed to the in-memory graph returns the
+write counts that exclude the sequence; an independent kind census on the same
+graph confirms the sequence is stored as ``OTHER``.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from sqlcg.cli.coverage import collect_coverage
+from sqlcg.core.duckdb_backend import DuckDBBackend
+from sqlcg.indexer.indexer import Indexer
+
+
+@pytest.fixture
+def indexed_db(tmp_path):
+    """Index a repo with one resolvable INSERT, one CREATE TABLE, one CREATE SEQUENCE.
+
+    Expected write population (kind IN _WRITE_KINDS):
+      * ba.src — CREATE TABLE (zero COLUMN_LINEAGE → a zero-edge write)
+      * ba.dst — INSERT … SELECT (has COLUMN_LINEAGE)
+    The CREATE SEQUENCE classifies as OTHER → NOT in the write population.
+    """
+    db = DuckDBBackend(":memory:")
+    db.init_schema()
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "src.sql").write_text("CREATE TABLE ba.src (a INT);\n")
+    (repo / "ins.sql").write_text("INSERT INTO ba.dst SELECT a FROM ba.src;\n")
+    (repo / "seq.sql").write_text("CREATE SEQUENCE ba.s START 1;\n")
+    Indexer().index_repo(repo, dialect="snowflake", db=db, use_git=False)
+    yield db
+    db.close()
+
+
+def _collect(db: DuckDBBackend):
+    def _routed(query: str, params: dict):
+        return db.run_read(query, params)
+
+    with patch("sqlcg.cli.coverage.run_read_routed", side_effect=_routed):
+        return collect_coverage()
+
+
+def test_sequence_excluded_from_total_write_queries(indexed_db):
+    """total_write_queries counts only INSERT + CREATE TABLE, not the CREATE SEQUENCE."""
+    stats = _collect(indexed_db)
+    assert stats is not None
+    assert stats.total_write_queries == 2, (
+        "total_write_queries must count only the INSERT and the CREATE TABLE "
+        f"(the CREATE SEQUENCE is OTHER, excluded); got {stats.total_write_queries}. "
+        "A value of 3 means the sequence was mislabeled CREATE_TABLE again."
+    )
+
+
+def test_sequence_does_not_inflate_zero_edge_write_queries(indexed_db):
+    """zero_edge_write_queries reflects only the genuine zero-edge CREATE TABLE.
+
+    The CREATE SEQUENCE has zero COLUMN_LINEAGE; before the fix it would have
+    counted here as a false unresolved-write. Expected = 1 (the CREATE TABLE
+    'ba.src' DDL with no SELECT body), not 2.
+    """
+    stats = _collect(indexed_db)
+    assert stats is not None
+    assert stats.zero_edge_write_queries == 1, (
+        "zero_edge_write_queries must be 1 (the CREATE TABLE DDL only); "
+        f"got {stats.zero_edge_write_queries}. A value of 2 means the sequence "
+        "was counted as a zero-edge write (the inflation this fix removes)."
+    )
+
+
+def test_sequence_stored_as_other_kind(indexed_db):
+    """Independent oracle: the sequence statement is stored as kind=OTHER."""
+    rows = indexed_db.run_read('SELECT kind FROM "SqlQuery" WHERE id LIKE ?', {"id": "%seq.sql:0"})
+    assert rows and rows[0]["kind"] == "OTHER", f"sequence must be stored as OTHER; got {rows}"