sql-code-graph 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

{sql_code_graph-1.4.1.dist-info → sql_code_graph-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.4.1
+Version: 1.5.0
 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.4.1.dist-info → sql_code_graph-1.5.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-sqlcg/__init__.py,sha256=Q9RK3IHj_JNrfASKHyNaH76PD2u74uMssIwE5Mi7F7Q,115
+sqlcg/__init__.py,sha256=umkxJTfZmp0-L1q_ge27nl61dPsJtPJKnGORGDpbJKY,115
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
-sqlcg/cli/main.py,sha256=WmdTjsOlz1ozi2Y3Aq4ezR_FCRl-Lc1YOKw3_d48dlY,1650
+sqlcg/cli/main.py,sha256=oiZ0e_blUCnlmmXNSCLYnifleDv6ixm9dF7GEDGe0dQ,2429
 sqlcg/cli/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
 sqlcg/cli/commands/analyze.py,sha256=_aC5ML3w7YdLi7DL3TFS9OiCEIipuNZxWR6S4peTcn4,12154
 sqlcg/cli/commands/db.py,sha256=TMhPCHRWSo8YmlNnSxmGxrR0_1r3K4e0Bn8unZTkvU4,7248
@@ -9,8 +9,8 @@ sqlcg/cli/commands/find.py,sha256=p5Vyyx-VBk8YDWYQN16UhECh7PIeMaEyCPEcUFcRFlM,25
 sqlcg/cli/commands/gain.py,sha256=SJU1c51a7MgNbZItqQnaBfOWGnV5xpXQctbew5Dr9BE,9062
 sqlcg/cli/commands/git.py,sha256=9a8T2FVxcAHq1H6Cslaq34t10w9fBGf4T2reiLk33t8,6135
 sqlcg/cli/commands/index.py,sha256=RPEpT9aXmK0rixRuHgMcmAn9FLR4JtIbZ1LM4RLkMvY,17050
-sqlcg/cli/commands/install.py,sha256=KNABvrLbamPyYnmnVdCaM_MNezbDc-pr6IkignCWI8k,9186
-sqlcg/cli/commands/mcp.py,sha256=QYaupf69lLpYzIoqsPJoCPiAggLVkYBzwpuOLRzxJDU,9140
+sqlcg/cli/commands/install.py,sha256=VdfZnC41WE3Lx6CcGSd2Xyi-XNNOLP1YQrnXmqo7x3c,10023
+sqlcg/cli/commands/mcp.py,sha256=CA24kRfBltanKuSMkRVRf42GW8cTgG8YQrMruxB3vSQ,11592
 sqlcg/cli/commands/reindex.py,sha256=FqXxvQ0UrxwDS0q2V3gzYgarN3NPh9muaIZ3rgvTmHs,13810
 sqlcg/cli/commands/report.py,sha256=JU0qjyMxwOukE7bN3XvvIzOI7zMg_Gsnvk_8F6pKNpA,4915
 sqlcg/cli/commands/uninstall.py,sha256=WrA1FnINxnd6mmE4-_QBK0aHBnibstJeAT8swnQKG4M,8962
@@ -22,8 +22,8 @@ sqlcg/core/freshness.py,sha256=F9jWn2cbFs60jA9ta8KrT6MghD0mzI7SqqKs_Op9AeU,4577
 sqlcg/core/graph_db.py,sha256=eLYdmiqPWrZHtKLFcKgD2aiWZHFU3wrwz6Y0A3d9NcE,8633
 sqlcg/core/jobs.py,sha256=Je-fCdSKRgiSsv1W8SgNAlp36a7t7-pJZ-qKPbka9OE,3298
 sqlcg/core/queries.cypher,sha256=cvPOVe5GUOzJN4bxUvDxNI--xIIP8gm42TR-gUnea4U,4685
-sqlcg/core/queries.py,sha256=jtZR6caLpF0WqqkjncYTlf5L1GN6DZweoM5dNOAB8OY,3043
-sqlcg/core/queries.sql,sha256=75EHoHA5hKz-Xs8g-CCtDXbf3lYFEw_fxghjYU48gUM,7794
+sqlcg/core/queries.py,sha256=DeGrpsh-N8CczapKW5Iw_CPBMOxtWZfusMOhpN4Qn_c,3319
+sqlcg/core/queries.sql,sha256=yRITKvjnWY0e1Sa8me0yFe_FkkIBsk3BQn2l0iqOJ7Q,10768
 sqlcg/core/schema.cypher,sha256=rK5QMhSrzZhuj73NeNXGX6oM-rPPPvxFjex0fEyUvkQ,2859
 sqlcg/core/schema.py,sha256=7fKf314ueIV7-tIkQQUS4O6H-OhlFKFVFFvGFqw_5Xk,1476
 sqlcg/indexer/__init__.py,sha256=Wh20Unz2OHs1oIyWLrpurPAasF0BET2g4iXtNk7mh2U,56
@@ -40,7 +40,7 @@ sqlcg/lineage/schema_resolver.py,sha256=iXt6LYF6UVWsGUpcfbmjmGn9wCgXl721lTGf_8Aa
 sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
 sqlcg/metrics/store.py,sha256=KuDtxvyAgug9_KtiSCpvgKM2VZM7VSaI3D11uMLjJJk,10604
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
-sqlcg/parsers/ansi_parser.py,sha256=mGZvijMOMQ4i1BybpwU29a8jnIGViefhy9fxzkSpsRM,17193
+sqlcg/parsers/ansi_parser.py,sha256=UNousZcTgHmgDzbvqF77hPf8RmTqwz4oo1rk9OMGWz4,17570
 sqlcg/parsers/base.py,sha256=N6uqQWHO2lpzTIWgPqzewAXmij0ikZdNmNVJkIQ8Mr0,54889
 sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
 sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
@@ -50,18 +50,18 @@ sqlcg/parsers/tsql_parser.py,sha256=RRj1pACtAk2tLTDaFWRYF67a0IDvaf5A1YQXWIz0bpQ,
 sqlcg/server/__init__.py,sha256=n4wuNE7xyJIJxJZBtmtdccCMQfvTdF-IqIaZVbC4FC4,35
 sqlcg/server/control.py,sha256=qUcztb_aDhL-_X_Nq4q6uGx17cUlbLnI6vUpoZsEjbo,4506
 sqlcg/server/exceptions.py,sha256=EONw34icOByCTpppSQrvQBW6asc4hfqaGDCAFjv96II,469
-sqlcg/server/models.py,sha256=l7ORy6sbtzBW1y3qVaeLwEukbyAgBkz9S5VIm2q4b24,19378
+sqlcg/server/models.py,sha256=4c4ula195cHEqZycO6ZaSNohSLsodB-Du1FP94JKSdc,19810
 sqlcg/server/noise_filter.py,sha256=Ats2FFzmzFKqvQPWvlUzK8mY9pzlUhL4m1s8P_HNnvI,6335
 sqlcg/server/read_client.py,sha256=4v1OOl12HCHp6J14HrcWQApSixvJ0wwE8UIIZ0pzLyw,7808
-sqlcg/server/server.py,sha256=A1soT-hYnAX78X5j97nIjw9oIZCxBejjV6p_tRDIK38,24335
+sqlcg/server/server.py,sha256=1RiUmjWLgtN636kRQO6-4rH8amC-m9BKsIMO0aDRqes,24838
 sqlcg/server/skill.py,sha256=EDvmEgl-LQwCxZ9Lca4lt8zCtkk2cCgh9GLYlGgDA64,12828
-sqlcg/server/tools.py,sha256=Rdl5SXAuePydk8Z12JVx-lNQeAqm3k9R-z0Q4DstCkw,69743
+sqlcg/server/tools.py,sha256=SyxPbnFmsR1w2Hi2ENmD_mynCdI9JHhTgv1byXFIKoY,77191
 sqlcg/server/writer.py,sha256=HH8pW6k1c2pbY4b6g2N87Tx4gNCezYqTLNTlAmsHg2Y,18522
 sqlcg/utils/__init__.py,sha256=--iqt5ThTXmT8Wz7da8hs3n0zDfYPl8P-z5OgRJ_77E,154
 sqlcg/utils/hashing.py,sha256=H25-sYfxHKb3_IERFnHyAIYNiXN470Oqo5sJT_D3YOA,438
 sqlcg/utils/ignore.py,sha256=wJjwa0mjnQ_xJExOUxk25y00g065XmmzJapqV3ifD5o,1151
 sqlcg/utils/logging.py,sha256=u0fCmYsLj9o81vawm3xZTHaw68GQYVm7JxG-gP81u8A,840
-sql_code_graph-1.4.1.dist-info/METADATA,sha256=7psrSu1Vh3GiZ7PK7FED45QzazeUrHrltrRla4twAVQ,14085
-sql_code_graph-1.4.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.4.1.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.4.1.dist-info/RECORD,,
+sql_code_graph-1.5.0.dist-info/METADATA,sha256=LWYY4WQliA5p-YOMnci4GcEGjKkJGy8sRBWPj8a30n8,14085
+sql_code_graph-1.5.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.5.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.5.0.dist-info/RECORD,,

sqlcg/__init__.py

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

sqlcg/cli/commands/install.py

@@ -20,6 +20,8 @@ from pathlib import Path
 import typer
 from rich.console import Console
 
+from sqlcg.cli.commands.mcp import stop_server
+
 console = Console()
 
 _SERVER_KEY = "sql-code-graph"
@@ -70,10 +72,12 @@ def install_cmd(
             claude_json = Path.home() / ".claude.json"
             console.print("[dim]--dry-run: would write to ~/.claude.json:[/dim]")
             _preview_claude_json(claude_json, entry)
+        console.print("[dim]--dry-run: would stop running MCP server[/dim]")
         _provision_skill(resolved_scope, repo, dry_run=True)
         return
 
     # --- Try official claude CLI first ---
+    configured_via_claude_cli = False
     claude_bin = shutil.which("claude")
     if claude_bin:
         proc = subprocess.run(
@@ -84,56 +88,65 @@ def install_cmd(
         if proc.returncode == 0:
             console.print(f"[green]Configured:[/green] {_SERVER_KEY} via `claude mcp add`")
             console.print("\nRestart Claude Code to pick up the new MCP server.")
-            _provision_skill(resolved_scope, repo, dry_run=False)
-            return
-        # Non-zero: log and fall through to ~/.claude.json fallback
-        console.print(
-            f"[yellow]Warning:[/yellow] `claude mcp add` returned rc={proc.returncode}; "
-            "falling back to ~/.claude.json write."
-        )
-        if proc.stderr:
-            console.print(f"[dim]{proc.stderr.strip()}[/dim]")
-
-    # --- Fallback: write ~/.claude.json directly ---
-    claude_json = Path.home() / ".claude.json"
-    if claude_json.exists():
-        try:
-            data: dict = json.loads(claude_json.read_text())
-        except (json.JSONDecodeError, OSError, TypeError):
+            configured_via_claude_cli = True
+        else:
+            # Non-zero: log and fall through to ~/.claude.json fallback
             console.print(
-                f"[yellow]Warning:[/yellow] {claude_json} contains invalid JSON — "
-                "mcpServers key will be added"
+                f"[yellow]Warning:[/yellow] `claude mcp add` returned rc={proc.returncode}; "
+                "falling back to ~/.claude.json write."
             )
+            if proc.stderr:
+                console.print(f"[dim]{proc.stderr.strip()}[/dim]")
+
+    if not configured_via_claude_cli:
+        # --- Fallback: write ~/.claude.json directly ---
+        claude_json = Path.home() / ".claude.json"
+        if claude_json.exists():
+            try:
+                data: dict = json.loads(claude_json.read_text())
+            except (json.JSONDecodeError, OSError, TypeError):
+                console.print(
+                    f"[yellow]Warning:[/yellow] {claude_json} contains invalid JSON — "
+                    "mcpServers key will be added"
+                )
+                data = {}
+        else:
             data = {}
-    else:
-        data = {}
 
-    existing = data.get("mcpServers", {}).get("user", {}).get(_SERVER_KEY)
-    if existing == entry:
-        console.print(f"[green]Already configured:[/green] {_SERVER_KEY} (in ~/.claude.json)")
-        _provision_skill(resolved_scope, repo, dry_run=False)
-        return
+        existing = data.get("mcpServers", {}).get("user", {}).get(_SERVER_KEY)
+        if existing == entry:
+            console.print(f"[green]Already configured:[/green] {_SERVER_KEY} (in ~/.claude.json)")
+        else:
+            data.setdefault("mcpServers", {}).setdefault("user", {})[_SERVER_KEY] = entry
 
-    data.setdefault("mcpServers", {}).setdefault("user", {})[_SERVER_KEY] = entry
+            try:
+                tmp = claude_json.with_suffix(".tmp")
+                tmp.write_text(json.dumps(data, indent=2) + "\n")
+                os.replace(tmp, claude_json)
+            except (OSError, TypeError, AttributeError):
+                pass  # Ignore file I/O errors in testing
 
-    try:
-        tmp = claude_json.with_suffix(".tmp")
-        tmp.write_text(json.dumps(data, indent=2) + "\n")
-        os.replace(tmp, claude_json)
-    except (OSError, TypeError, AttributeError):
-        pass  # Ignore file I/O errors in testing
-
-    cmd_str = " ".join(cmd_parts)
-    console.print(f"[green]Configured:[/green] {_SERVER_KEY} → {cmd_str}")
-    console.print(f"[dim]Written to {claude_json}[/dim]")
-
-    if entry.get("command") == "uvx":
-        console.print(
-            "[yellow]Note:[/yellow] First startup downloads dependencies (~30s). "
-            "Subsequent restarts use cache (~1s)."
-        )
+            cmd_str = " ".join(cmd_parts)
+            console.print(f"[green]Configured:[/green] {_SERVER_KEY} → {cmd_str}")
+            console.print(f"[dim]Written to {claude_json}[/dim]")
+
+            if entry.get("command") == "uvx":
+                console.print(
+                    "[yellow]Note:[/yellow] First startup downloads dependencies (~30s). "
+                    "Subsequent restarts use cache (~1s)."
+                )
 
-    console.print("\nRestart Claude Code to pick up the new MCP server.")
+            console.print("\nRestart Claude Code to pick up the new MCP server.")
+
+    # --- Single non-dry-run tail: all three success branches converge here. ---
+    # The config may not have changed (e.g. "Already configured"), but the
+    # binary on disk did — so the stale running server still must be stopped
+    # so the editor respawns the freshly-installed build.
+    stopped = stop_server()
+    if stopped:
+        console.print("Stopped running MCP server; your editor will respawn it on the new build.")
+    else:
+        console.print("No running MCP server to refresh.")
     _provision_skill(resolved_scope, repo, dry_run=False)
 
 

sqlcg/cli/commands/mcp.py

@@ -77,9 +77,19 @@ def mcp_best_practices() -> None:
 def mcp_status() -> None:
     """Print server status JSON (connects to control socket).
 
-    Returns JSON with fields: running, pid, db_path, indexed_sha, head_sha,
-    stale_by_commits, connected_clients, uptime, writer_queue when a server
-    is live.
+    Returns JSON with fields: running, version, pid, db_path, indexed_sha,
+    head_sha, stale_by_commits, connected_clients, uptime, writer_queue,
+    stale_by_version when a server is live.
+
+    `version` is the *running* server's reported sqlcg.__version__ (read live
+    over the control socket — the build the editor is currently talking to).
+    `stale_by_version` compares it against the *installed* sqlcg.__version__
+    (the CLI process you just invoked): true when they differ, false when they
+    match, null when the running version cannot be determined (degraded mode).
+    When stale, a warning is printed telling you to restart the MCP server via
+    your editor or run `sqlcg install` (which stops the stale server for you).
+    This is distinct from `stale_by_commits` (graph-vs-repo freshness, not
+    package-vs-binary drift).
 
     The status response is length-prefixed framed (v1.3.0, B3) so large
     writer_queue payloads are received in full — the client uses the
@@ -87,7 +97,8 @@ def mcp_status() -> None:
 
     When no server is found: {"running": false}.
     When the PID file exists with a live process but the socket is unavailable:
-    {"running": true, "degraded": "socket unavailable", ...}.
+    {"running": true, "degraded": "socket unavailable", "stale_by_version": null, ...}
+    (the running version cannot be read without a live socket).
 
     R3 (stale socket): if the socket file exists but the server is not
     responding (ConnectionRefusedError / FileNotFoundError), falls through
@@ -119,9 +130,25 @@ def mcp_status() -> None:
 
         status = json.loads(data.decode())
 
+        # Drift detection: compare the *running* server's reported version (read
+        # over the socket, from the live process) against the *installed*
+        # sqlcg.__version__ (the version of the CLI process you just invoked).
+        from sqlcg import __version__
+
+        running_version = status.get("version")
+        stale = running_version is not None and running_version != __version__
+        status = {**status, "version": running_version, "stale_by_version": stale}
+
         # Pretty-print the base fields.
         console.print_json(json.dumps({k: v for k, v in status.items() if k != "writer_queue"}))
 
+        if stale:
+            console.print(
+                f"[yellow]Warning:[/yellow] running MCP server is v{running_version}, "
+                f"installed sqlcg is v{__version__} — restart the MCP server via your "
+                "editor (or run `sqlcg install`, which stops the stale server for you)."
+            )
+
         # Render the writer_queue block separately for readability.
         wq = status.get("writer_queue")
         if wq:
@@ -178,6 +205,10 @@ def mcp_status() -> None:
                         "degraded": "socket unavailable",
                         "pid": rec["pid"],
                         "db_path": rec["db_path"],
+                        # Cannot read the running version without a live socket —
+                        # omit `version` and report drift as unknown (None → JSON
+                        # null), never guess.
+                        "stale_by_version": None,
                     }
                 )
             )
@@ -185,16 +216,20 @@ def mcp_status() -> None:
             console.print_json(json.dumps({"running": False}))
 
 
-@app.command("stop")
-def mcp_stop() -> None:
-    """Stop the running MCP server gracefully.
+def stop_server() -> bool:
+    """Stop a running MCP server gracefully (best-effort). Returns True if stopped.
 
     Sends a ``stop`` op via the control socket; waits up to 5 s for the
     socket file to disappear (confirming clean exit).  Falls back to SIGTERM
     on the PID-file PID if the socket is unavailable.
 
     R3 (stale socket): ``ConnectionRefusedError`` / ``FileNotFoundError`` are
-    caught — never hangs on a dead socket.
+    caught — never hangs on a dead socket; a socket error here must not abort
+    the caller (``mcp_stop`` and ``install_cmd`` both rely on this).
+
+    Returns:
+        True if a running server was found and stopped (via socket or SIGTERM
+        fallback); False if no running server was found.
     """
     import socket as _socket
     import time
@@ -214,6 +249,7 @@ def mcp_stop() -> None:
                 break
             time.sleep(0.5)
         console.print("[green]Server stopped.[/green]")
+        return True
     except (FileNotFoundError, ConnectionRefusedError, OSError):
         # Socket unavailable — fall back to SIGTERM via PID file
         import signal
@@ -222,8 +258,20 @@ def mcp_stop() -> None:
         if rec and is_pid_alive(rec["pid"]):
             os.kill(rec["pid"], signal.SIGTERM)
             console.print(f"[yellow]Socket unavailable — sent SIGTERM to PID {rec['pid']}[/yellow]")
-        else:
-            console.print("[yellow]No server found to stop.[/yellow]")
+            return True
+        return False
+
+
+@app.command("stop")
+def mcp_stop() -> None:
+    """Stop the running MCP server gracefully.
+
+    Delegates to ``stop_server()`` (shared with ``sqlcg install``) and prints
+    a final message based on whether a server was found.
+    """
+    stopped = stop_server()
+    if not stopped:
+        console.print("[yellow]No server found to stop.[/yellow]")
 
 
 @app.command("restart")

sqlcg/cli/main.py

@@ -34,8 +34,41 @@ USING THE MCP TOOLS:
 Note: Binary is `sqlcg`; PyPI package is `sql-code-graph`.
 """
 
+
+def _version_string() -> str:
+    from sqlcg import __version__
+
+    return f"sqlcg version {__version__}"
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(_version_string())
+        raise typer.Exit()
+
+
 app = typer.Typer(name="sqlcg", help=help_text)
 
+
+@app.callback(invoke_without_command=True)
+def _root(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Show version and exit.",
+        is_eager=True,
+        callback=_version_callback,
+    ),
+) -> None:
+    """SQL code graph analyzer."""
+    # The eager --version callback exits before we get here when --version is
+    # passed. Otherwise: if no subcommand was given, show help (matching the
+    # pre-callback behaviour) instead of silently exiting 0.
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
 # Register subcommand groups
 app.add_typer(db.app, name="db")
 app.add_typer(find.app, name="find")
@@ -56,9 +89,7 @@ app.command("uninstall")(uninstall.uninstall_cmd)
 @app.command()
 def version() -> None:
     """Show version."""
-    from sqlcg import __version__
-
-    typer.echo(f"sqlcg version {__version__}")
+    typer.echo(_version_string())
 
 
 def main() -> None:

sqlcg/core/queries.py

@@ -54,9 +54,13 @@ COUNT_STAR_SOURCES_QUERY = _Q["COUNT_STAR_SOURCES"]
 COUNT_STAR_EXPANSIONS_QUERY = _Q["COUNT_STAR_EXPANSIONS"]
 FIND_DEFINITION_QUERY = _Q["FIND_DEFINITION"]
 GET_TABLE_DEFINING_FILES_QUERY = _Q["GET_TABLE_DEFINING_FILES"]
+GET_PRODUCER_FILES_FOR_TABLE_QUERY = _Q["GET_PRODUCER_FILES_FOR_TABLE"]
 GET_TABLE_DIRECT_UPSTREAMS_QUERY = _Q["GET_TABLE_DIRECT_UPSTREAMS"]
 GET_COLUMNS_FOR_TABLE_QUERY = _Q["GET_COLUMNS_FOR_TABLE"]
 GET_TABLES_DEFINED_IN_FILE_QUERY = _Q["GET_TABLES_DEFINED_IN_FILE"]
+GET_TARGET_TABLES_FOR_FILE_QUERY = _Q["GET_TARGET_TABLES_FOR_FILE"]
+GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY = _Q["GET_TABLE_ADJACENCY_FOR_COLUMNS"]
+GET_TABLE_KINDS_BATCH_QUERY = _Q["GET_TABLE_KINDS_BATCH"]
 ANALYZE_UNUSED_TABLES_QUERY = _Q["ANALYZE_UNUSED_TABLES"]
 HUB_RANKING_QUERY = _Q["HUB_RANKING"]
 DEPENDENT_FILES_OF_TABLES_QUERY = _Q["DEPENDENT_FILES_OF_TABLES"]

sqlcg/core/queries.sql

@@ -172,6 +172,19 @@ JOIN "DEFINED_IN" di ON di.src_key = t.qualified
 JOIN "File" f ON f.path = di.dst_key
 WHERE t.qualified = ?
 
+-- GET_PRODUCER_FILES_FOR_TABLE
+-- ETL INSERT...SELECT producers populate a table without a DEFINED_IN edge
+-- (that edge is DDL-only). Resolve SqlQuery.target_table -> QUERY_DEFINED_IN -> File
+-- so get_definition / get_change_scope can also surface "populated here" producer
+-- files, not just "defined here" DDL files (mirror of GET_TARGET_TABLES_FOR_FILE,
+-- the reverse-direction lookup). table_qualified is stored lowercase.
+-- params: [table_qualified]
+SELECT DISTINCT f.path AS file_path
+FROM "SqlQuery" q
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+JOIN "File" f ON f.path = qdi.dst_key
+WHERE q.target_table = ?
+
 -- GET_TABLE_DIRECT_UPSTREAMS
 -- params: [table_qualified, table_qualified]
 SELECT DISTINCT src.qualified AS upstream_table, f.path AS in_file
@@ -198,6 +211,53 @@ FROM "SqlTable" t
 JOIN "DEFINED_IN" di ON di.src_key = t.qualified
 WHERE di.dst_key = ?
 
+-- GET_TARGET_TABLES_FOR_FILE
+-- ETL INSERT...SELECT producers populate a table without a DEFINED_IN edge
+-- (that edge is DDL-only). Resolve query->file QUERY_DEFINED_IN -> SqlQuery.target_table
+-- so diff_impact can also see "populated here" producers, not just "defined here" DDL.
+-- params: [file_path]
+SELECT DISTINCT q.target_table AS table_qualified
+FROM "SqlQuery" q
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+WHERE qdi.dst_key = ?
+  AND q.target_table <> ''
+
+-- GET_TABLE_ADJACENCY_FOR_COLUMNS
+-- Aggregate table-level producer->consumer adjacency derived from COLUMN_LINEAGE,
+-- restricted to a closure's column-id set (Option A — issue #38 backfill fix).
+-- Replaces the N x GET_TABLE_DIRECT_UPSTREAMS loop with a single query: CTE-wrapped
+-- INSERT...SELECT statements emit no SELECTS_FROM adjacency at all (the real source
+-- table is nested in the CTE child scope and never surfaces into the statement's
+-- top-level sources). The raw COLUMN_LINEAGE topology bridges producer -> consumer
+-- via a TWO-HOP path through the synthetic cte/derived node (producer -> cte ->
+-- consumer, not a parallel direct edge) — this query returns ALL rolled-up table
+-- pairs (including synthetic endpoints); the caller contracts synthetic-node hops
+-- into direct real-table adjacency in one pass over this small edge set (still
+-- ONCE per closure, never per-table/per-column). Also returns each endpoint's
+-- SqlTable.kind so the caller can identify synthetic nodes without a second query.
+-- params: [col_ids, col_ids]
+SELECT DISTINCT
+  src.table_qualified AS upstream_table,
+  ut.kind AS upstream_kind,
+  dst.table_qualified AS downstream_table,
+  dt.kind AS downstream_kind
+FROM "COLUMN_LINEAGE" cl
+JOIN "SqlColumn" src ON src.id = cl.src_key
+JOIN "SqlColumn" dst ON dst.id = cl.dst_key
+LEFT JOIN "SqlTable" ut ON ut.qualified = src.table_qualified
+LEFT JOIN "SqlTable" dt ON dt.qualified = dst.table_qualified
+WHERE cl.src_key = ANY(?)
+  AND cl.dst_key = ANY(?)
+  AND src.table_qualified <> dst.table_qualified
+
+-- GET_TABLE_KINDS_BATCH
+-- Batch lookup of SqlTable.kind for a set of qualified names — the authoritative
+-- marker for synthetic cte/derived nodes (issue #38 synthetic-node-leak fix).
+-- params: [table_qualifieds]
+SELECT t.qualified AS table_qualified, t.kind AS kind
+FROM "SqlTable" t
+WHERE t.qualified = ANY(?)
+
 -- ANALYZE_UNUSED_TABLES
 -- params: []
 SELECT t.qualified AS table_qualified

sqlcg/parsers/ansi_parser.py

@@ -404,14 +404,19 @@ class AnsiParser(SqlParser):
             create_stmt: CREATE expression (must be a TABLE create)
 
         Returns:
-            List of column names in source order (as they appear in the SQL)
+            List of column names in source order (as they appear in the SQL),
+            normalized to lowercase with surrounding double-quotes stripped —
+            identical to ColumnRef.__post_init__ — so DDL columns share node
+            identity with lowercase ETL lineage columns (issue #38 Phase 5).
         """
         columns: list[str] = []
         # Find all ColumnDef nodes in the CREATE statement
         for col_def in create_stmt.find_all(exp.ColumnDef):
             col_name = col_def.this.name if col_def.this else None
             if col_name:
-                columns.append(col_name)
+                if len(col_name) >= 2 and col_name[0] == '"' and col_name[-1] == '"':
+                    col_name = col_name[1:-1]
+                columns.append(col_name.lower())
         return columns
 
     @staticmethod

sqlcg/server/models.py

@@ -190,6 +190,9 @@ class DialectRepoResult(BaseModel):
 class DbInfoResult(BaseModel):
     """Result of db_info tool — graph health and parse quality diagnostics."""
 
+    sqlcg_version: str = Field(
+        ..., description="Installed sqlcg package version (sqlcg.__version__)"
+    )
     schema_version: str = Field(..., description="Graph schema version")
     node_counts: dict[str, int] = Field(
         default_factory=dict,
@@ -242,6 +245,12 @@ class DefinitionResult(BaseModel):
     duplicate_ddl: bool = Field(
         False, description="True when the same table is defined in more than one file."
     )
+    producer_files: list[str] = Field(
+        default_factory=list,
+        description="Files whose INSERT...SELECT populates this table (via "
+        "QUERY_DEFINED_IN -> SqlQuery.target_table). Often the more useful answer "
+        "to 'where do I change this table's logic?' than the DDL file alone.",
+    )
     noise_excluded: list[str] = Field(
         default_factory=list,
         description="Definition file paths that were flagged as backup/noise.",

sqlcg/server/server.py

@@ -27,6 +27,7 @@ _real_stdout_buffer = os.fdopen(os.dup(1), "wb", buffering=0)
 from dotenv import load_dotenv  # noqa: E402
 from mcp.server import FastMCP  # noqa: E402
 
+from sqlcg import __version__  # noqa: E402
 from sqlcg.utils.logging import getLogger  # noqa: E402
 
 logger = getLogger(__name__)
@@ -35,6 +36,13 @@ logger = getLogger(__name__)
 # This is safe because _real_stdout_buffer has already captured fd 1 above.
 mcp = FastMCP("SQL Code Graph")
 
+# FastMCP.__init__ does not accept a `version` kwarg (verified signature); the
+# underlying mcp.server.lowlevel.Server.__init__(self, name, version=None, ...)
+# does. Set it post-construction so the `initialize` handshake reports
+# serverInfo.version == sqlcg.__version__ instead of None. Deliberate, pinned
+# private-attr write — see tests/unit/test_version_parity.py.
+mcp._mcp_server.version = __version__
+
 
 def _configure_mcp_logging() -> None:
     """Redirect sys.stdout to sys.stderr and configure logging to stderr.
@@ -219,6 +227,7 @@ async def _control_socket_task(
 
                     resp: dict = {
                         "running": True,
+                        "version": __version__,
                         "pid": os.getpid(),
                         "db_path": str(db_path or _get_db_path()),
                         "indexed_sha": indexed_sha,

sqlcg/server/tools.py

@@ -21,10 +21,14 @@ from sqlcg.core.queries import (
     FIND_TABLE_USAGES_QUERY,
     GET_COLUMNS_FOR_TABLE_QUERY,
     GET_DOWNSTREAM_DEPENDENCIES_QUERY,
+    GET_PRODUCER_FILES_FOR_TABLE_QUERY,
+    GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY,
     GET_TABLE_DEFINING_FILES_QUERY,
     GET_TABLE_DIRECT_UPSTREAMS_QUERY,
+    GET_TABLE_KINDS_BATCH_QUERY,
     GET_TABLES_DEFINED_IN_FILE_QUERY,
     GET_TABLES_EXTERNAL_CONSUMERS_BATCH_QUERY,
+    GET_TARGET_TABLES_FOR_FILE_QUERY,
     GET_UPSTREAM_DEPENDENCIES_QUERY,
     HUB_RANKING_QUERY,
     INDEX_REPO_FILES_QUERY,
@@ -396,6 +400,51 @@ def _rollup_to_tables(col_ids: list[str]) -> list[str]:
     return tables
 
 
+# Synthetic SqlTable.kind values that must never surface as rebuildable tables —
+# the authoritative marker per indexer.py (kind="cte" / kind="derived"); see
+# _exclude_synthetic_tables. Keying on kind (not the alias string) avoids dropping
+# a real table that happens to share a name with a CTE alias.
+_SYNTHETIC_TABLE_KINDS = frozenset({"cte", "derived"})
+
+
+def _exclude_synthetic_tables(db: GraphBackend, tables: list[str]) -> tuple[list[str], list[str]]:
+    """Split *tables* into (real, synthetic) using the authoritative SqlTable.kind.
+
+    Synthetic CTE/derived nodes (``kind in {"cte", "derived"}``) are emitted into
+    the graph for lineage-tracing purposes but must never surface as rebuildable
+    tables in get_change_scope / get_backfill_order / diff_impact / scope_change
+    (issue #38 synthetic-node leak). Exclusion is keyed on ``kind`` — the
+    authoritative marker set in indexer.py — never on the alias string, so a real
+    table that happens to share a name with a CTE alias is never dropped.
+
+    Args:
+        db: Graph backend.
+        tables: Candidate table_qualified strings (already noise-filtered).
+
+    Returns:
+        (real_tables, synthetic_excluded) — both order-preserving, deduplicated.
+    """
+    if not tables:
+        return [], []
+
+    rows = db.run_read(GET_TABLE_KINDS_BATCH_QUERY, {"table_qualifieds": tables})
+    synthetic_ids = {
+        row["table_qualified"] for row in rows if row["kind"] in _SYNTHETIC_TABLE_KINDS
+    }
+
+    if not synthetic_ids:
+        return tables, []
+
+    real: list[str] = []
+    synthetic: list[str] = []
+    for t in tables:
+        if t in synthetic_ids:
+            synthetic.append(t)
+        else:
+            real.append(t)
+    return real, synthetic
+
+
 def _dedup_preserve_order(items: list[str]) -> list[str]:
     """Deduplicate a list while preserving first-seen order."""
     out: list[str] = []
@@ -421,30 +470,84 @@ def _risk_label(affected_table_count: int) -> str:
     return "high"
 
 
-def _kahn_topological_sort(affected_tables: list[str], db: GraphBackend) -> tuple[list[str], bool]:
+def _kahn_topological_sort(
+    affected_tables: list[str], db: GraphBackend, closure_col_ids: list[str]
+) -> tuple[list[str], bool]:
     """Order affected tables so producers come before consumers (rebuild order).
 
-    Builds an adjacency list from SELECTS_FROM edges *within* the affected set
-    (a table's producing query selecting from another affected table is an edge
-    producer -> consumer) and runs Kahn's algorithm. Returns
-    (ordered_tables, had_cycle). On a cycle the acyclic prefix is emitted in
-    topological order and the remaining cyclic tables are appended in input
-    order — no exception is raised.
+    Builds adjacency from the **COLUMN_LINEAGE closure** (Option A — issue #38),
+    not from ``SELECTS_FROM``: CTE-wrapped ``INSERT ... WITH cte AS (...) SELECT
+    ... FROM cte`` statements emit no ``SELECTS_FROM`` adjacency at all (the real
+    source table is nested in the CTE's child scope and never surfaces into the
+    statement's top-level ``sources``), which previously left every table at
+    indegree 0 and degraded ordering to alphabetical.
+
+    ``COLUMN_LINEAGE`` *does* carry the producer -> consumer connectivity, but —
+    contrary to an earlier (unreproduced) assumption of a parallel direct edge —
+    it bridges producer and consumer via a **two-hop path through the synthetic
+    cte/derived node** (``producer -> cte -> consumer``), not a parallel direct
+    edge bypassing it. Rolling the raw closure up to table level therefore yields
+    edges *to and from* synthetic nodes, not real producer -> consumer adjacency
+    directly. This function **contracts** those synthetic-node hops in one pass
+    over the (small) rolled-up edge set — ``real -> synthetic -> ... -> real``
+    collapses to ``real -> real`` — yielding the true causal adjacency. Still
+    **one** aggregate query + one contraction pass per closure (never
+    per-table/per-column; replaces the old N x GET_TABLE_DIRECT_UPSTREAMS loop).
+
+    Runs Kahn's algorithm over the contracted adjacency. Returns (ordered_tables,
+    had_cycle). On a cycle the acyclic prefix is emitted in topological order
+    and the remaining cyclic tables are appended in input order — no exception
+    is raised.
+
+    Args:
+        affected_tables: Noise-filtered, synthetic-excluded table set to order.
+        db: Graph backend.
+        closure_col_ids: Full column-id set of the closure (start columns plus
+            their transitive downstream columns) — both endpoints of every
+            producer -> consumer hop (including synthetic bridges) must be
+            present here for the adjacency query to find the connecting path.
     """
     table_set = set(affected_tables)
     successors: dict[str, set[str]] = {t: set() for t in affected_tables}
     indegree: dict[str, int] = {t: 0 for t in affected_tables}
 
-    for table in affected_tables:
+    if closure_col_ids:
         rows = db.run_read(
-            GET_TABLE_DIRECT_UPSTREAMS_QUERY,
-            {"table_qualified": table, "table_qualified2": table},
+            GET_TABLE_ADJACENCY_FOR_COLUMNS_QUERY,
+            {"col_ids": closure_col_ids, "col_ids2": closure_col_ids},
         )
+        # Raw rolled-up adjacency, including synthetic (cte/derived) endpoints.
+        raw_successors: dict[str, set[str]] = {}
+        synthetic_nodes: set[str] = set()
         for row in rows:
-            src = row["upstream_table"]
-            if src in table_set and src != table and table not in successors[src]:
-                successors[src].add(table)
-                indegree[table] += 1
+            src, dst = row["upstream_table"], row["downstream_table"]
+            if src == dst:
+                continue
+            raw_successors.setdefault(src, set()).add(dst)
+            if row["upstream_kind"] in _SYNTHETIC_TABLE_KINDS:
+                synthetic_nodes.add(src)
+            if row["downstream_kind"] in _SYNTHETIC_TABLE_KINDS:
+                synthetic_nodes.add(dst)
+
+        # Contract synthetic-node hops: from each real producer, BFS through
+        # any chain of synthetic nodes to find the real consumers it reaches —
+        # `real -> synthetic [-> synthetic ...] -> real` collapses to `real -> real`.
+        for src in table_set:
+            seen_chain: set[str] = set()
+            frontier = deque(raw_successors.get(src, ()))
+            while frontier:
+                node = frontier.popleft()
+                if node in seen_chain:
+                    continue
+                seen_chain.add(node)
+                if node in table_set:
+                    if node != src and node not in successors[src]:
+                        successors[src].add(node)
+                        indegree[node] += 1
+                elif node in synthetic_nodes:
+                    frontier.extend(raw_successors.get(node, ()))
+                # Real nodes outside table_set (e.g. noise-filtered) are dead ends —
+                # do not traverse through them; only synthetic bridges are contracted.
 
     # Sort the zero-indegree frontier for deterministic output.
     ready: deque[str] = deque(sorted(t for t in affected_tables if indegree[t] == 0))
@@ -842,7 +945,10 @@ def find_definition(table_qualified: str) -> DefinitionResult:
     with _open_backend() as db:
         _assert_indexed(db)
 
-        rows = db.run_read(FIND_DEFINITION_QUERY, {"table_qualified": table_qualified.lower()})
+        target = table_qualified.lower()
+        rows = db.run_read(FIND_DEFINITION_QUERY, {"table_qualified": target})
+        producer_rows = db.run_read(GET_PRODUCER_FILES_FOR_TABLE_QUERY, {"table_qualified": target})
+        producer_files = _dedup_preserve_order([r["file_path"] for r in producer_rows])
         noise_filter = NoiseFilter.from_config()
 
         duplicate_ddl = len(rows) > 1
@@ -874,6 +980,7 @@ def find_definition(table_qualified: str) -> DefinitionResult:
             table_qualified=table_qualified,
             definitions=definitions,
             duplicate_ddl=duplicate_ddl,
+            producer_files=producer_files,
             noise_excluded=noise_excluded,
             hint=hint,
         )
@@ -905,7 +1012,10 @@ def get_change_scope(table_qualified: str) -> ChangeScopeResult:
         noise_filter = NoiseFilter.from_config()
 
         def_rows = db.run_read(GET_TABLE_DEFINING_FILES_QUERY, {"table_qualified": target})
-        defining_files = _dedup_preserve_order([r["file_path"] for r in def_rows])
+        producer_rows = db.run_read(GET_PRODUCER_FILES_FOR_TABLE_QUERY, {"table_qualified": target})
+        defining_files = _dedup_preserve_order(
+            [r["file_path"] for r in def_rows] + [r["file_path"] for r in producer_rows]
+        )
 
         up_rows = db.run_read(
             GET_TABLE_DIRECT_UPSTREAMS_QUERY,
@@ -921,7 +1031,13 @@ def get_change_scope(table_qualified: str) -> ChangeScopeResult:
         affected_cols, _depth, truncated = _affected_columns_closure(db, start_cols, max_depth=None)
 
         affected_tables_all = [t for t in _rollup_to_tables(affected_cols) if t != target]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         kept_tables = set(affected_tables)
         affected_columns = [c for c in affected_cols if c.rsplit(".", 1)[0] in kept_tables]
 
@@ -985,11 +1101,21 @@ def get_backfill_order(table_qualified: str) -> BackfillOrderResult:
         affected_cols, _depth, truncated = _affected_columns_closure(db, start_cols, max_depth=None)
 
         affected_tables_all = [t for t in _rollup_to_tables(affected_cols) if t != target]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         kept_tables = set(affected_tables)
         affected_columns = [c for c in affected_cols if c.rsplit(".", 1)[0] in kept_tables]
 
-        order, had_cycle = _kahn_topological_sort(affected_tables, db)
+        # Option A (issue #38): adjacency is derived from the same COLUMN_LINEAGE
+        # closure as membership — pass the full id set (start + affected) so the
+        # direct producer->consumer edge endpoints are both present.
+        closure_col_ids = _dedup_preserve_order([*start_cols, *affected_cols])
+        order, had_cycle = _kahn_topological_sort(affected_tables, db, closure_col_ids)
 
         hint = None
         if had_cycle:
@@ -1044,19 +1170,26 @@ def diff_impact(changed_files: list[str]) -> DiffImpactResult:
             fp = Path(file_path)
             if not fp.is_absolute():
                 fp = root / fp
-            rows = db.run_read(GET_TABLES_DEFINED_IN_FILE_QUERY, {"file_path": str(fp)})
-            for row in rows:
-                tq = row["table_qualified"]
-                if tq not in seen_changed:
-                    seen_changed.add(tq)
-                    changed_tables.append(tq)
+            for query in (GET_TABLES_DEFINED_IN_FILE_QUERY, GET_TARGET_TABLES_FOR_FILE_QUERY):
+                rows = db.run_read(query, {"file_path": str(fp)})
+                for row in rows:
+                    tq = row["table_qualified"]
+                    if tq and tq not in seen_changed:
+                        seen_changed.add(tq)
+                        changed_tables.append(tq)
 
         all_affected_cols: list[str] = []
         affected_seen: set[str] = set()
+        all_start_cols: list[str] = []
+        start_seen: set[str] = set()
         truncated = False
         for tq in changed_tables:
             col_rows = db.run_read(GET_COLUMNS_FOR_TABLE_QUERY, {"table_qualified": tq})
             start_cols = [r["col_id"] for r in col_rows]
+            for col in start_cols:
+                if col not in start_seen:
+                    start_seen.add(col)
+                    all_start_cols.append(col)
             cols, _depth, tr = _affected_columns_closure(db, start_cols, max_depth=None)
             truncated = truncated or tr
             for col in cols:
@@ -1067,9 +1200,18 @@ def diff_impact(changed_files: list[str]) -> DiffImpactResult:
         affected_tables_all = [
             t for t in _rollup_to_tables(all_affected_cols) if t not in seen_changed
         ]
-        affected_tables, noise_excluded = noise_filter.filter_nodes(affected_tables_all)
+        affected_tables_noise_filtered, noise_excluded = noise_filter.filter_nodes(
+            affected_tables_all
+        )
+        affected_tables, synthetic_excluded = _exclude_synthetic_tables(
+            db, affected_tables_noise_filtered
+        )
+        noise_excluded = [*noise_excluded, *synthetic_excluded]
         presentation_facing = [t for t in affected_tables if any(t.startswith(p) for p in prefixes)]
-        order, had_cycle = _kahn_topological_sort(affected_tables, db)
+        # Option A (issue #38): same closure-derived adjacency as get_backfill_order —
+        # union of every changed table's start columns plus the unioned affected set.
+        closure_col_ids = _dedup_preserve_order([*all_start_cols, *all_affected_cols])
+        order, had_cycle = _kahn_topological_sort(affected_tables, db, closure_col_ids)
 
         # Resolve external consumers for the blast radius in a single BATCH query (not per-table).
         external_consumers: list[str] = []
@@ -1530,13 +1672,22 @@ def db_info() -> DbInfoResult:
       those files. Table-level lineage is still available.
     - `warnings` list — empty means the graph is healthy.
 
+    `sqlcg_version` is the installed *package* build (sqlcg.__version__) — use
+    it to self-check you are talking to the build you expect (the MCP protocol
+    `serverInfo.version` is not reliably visible to the agent persona). This is
+    a different axis from `schema_version`, which tracks the graph schema, not
+    the package: do not conflate the two.
+
     Parse quality legend (parsing_mode per SqlQuery node):
       sqlglot          — standard path; column lineage available if extracted
       scripting_block  — tokenizer fallback; column lineage unavailable
 
     Returns:
-        DbInfoResult with schema version, node counts, parse quality, and warnings
+        DbInfoResult with sqlcg/schema versions, node counts, parse quality,
+        and warnings
     """
+    from sqlcg import __version__
+
     db = _get_backend()
 
     schema_version = db.get_schema_version() or "unknown"
@@ -1603,6 +1754,7 @@ def db_info() -> DbInfoResult:
         pass
 
     return DbInfoResult(
+        sqlcg_version=__version__,
         schema_version=schema_version,
         node_counts=node_counts,
         column_lineage_edges=column_lineage_edges,