sql-code-graph 1.0.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

{sql_code_graph-1.0.1.dist-info → sql_code_graph-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.0.1
+Version: 1.1.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
@@ -219,7 +219,7 @@ After indexing, `sqlcg db info` shows non-zero `STAR_EXPANSION lineage edges`, a
 | **Search & meta** | |
 | `search_sql_pattern(query)` | Full-text search across indexed SQL |
 | `list_dialects_and_repos()` | List indexed repos and dialects (catalogue) |
-| `db_info()` | Graph health, node counts, parse quality breakdown, warnings |
+| `db_info()` | Graph health, node counts, parse quality breakdown, warnings, freshness (indexed SHA vs HEAD) |
 | `execute_cypher(query)` | Raw Cypher query against the graph |
 | `submit_feedback(...)` | Report a false positive/negative to improve metrics |
 
@@ -228,6 +228,12 @@ After indexing, `sqlcg db info` shows non-zero `STAR_EXPANSION lineage edges`, a
 > `table.column`. Each returned node carries both `name` (the bare column) and
 > `table` (the owning `schema.table`), so results are navigable without a second lookup.
 
+> **Provenance fields**: lineage edges now carry `file`, `line`, and `expression`
+> (where the lineage was derived from), a `confidence` of `1.0` for plainly-parsed
+> facts (lower for inferred edges, with a `reason`), and a `table_kind`
+> (`table` / `cte` / `derived` / `external`) so CTE and derived aliases are
+> distinguishable from real tables.
+
 > **LLM agent tip**: call `db_info()` before lineage queries to check that
 > `SqlColumn > 0` and `warnings` is empty. If `parse_quality["scripting_block"]`
 > is high, column lineage will be limited for those files — use table-level tools
@@ -243,16 +249,21 @@ sqlcg db init                          # initialise graph database
 sqlcg index <path> --dialect snowflake # index SQL files (snowflake is the tested dialect)
 sqlcg index <path> --dialect auto      # read dialect from .sqlcg.toml
 sqlcg index <path> --profile           # index + print per-stage timing and slowest files
+sqlcg index <path> --include-working-tree  # also index uncommitted changes (marks graph dirty)
 sqlcg reindex <path> --from <sha> --to <sha>  # incremental resync of only changed files
 sqlcg analyze unused                   # tables with no query references
 sqlcg analyze upstream/downstream      # trace lineage from the CLI
 sqlcg find table/column/pattern        # search the graph
 sqlcg watch <path>                     # watch for file changes
+sqlcg db info                          # graph stats + freshness (indexed SHA vs HEAD)
 sqlcg git install-hooks                # install post-checkout + post-merge resync hooks
 sqlcg gain                             # show usage metrics
 sqlcg report                           # generate FP/error report
 sqlcg mcp best-practices               # print the fact/heuristic boundary for the MCP tools
 sqlcg mcp start                        # start MCP server manually
+sqlcg mcp status                       # server status JSON (via control socket)
+sqlcg mcp stop                         # stop the running MCP server gracefully
+sqlcg mcp restart                      # stop the server (client must respawn it)
 sqlcg version                          # show installed version
 ```
 

sql_code_graph-1.1.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+sqlcg/__init__.py,sha256=CWoJX8Awg5Tf6p2E5lT66EFE8kd-Aru8aujKizglgdo,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/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
+sqlcg/cli/commands/analyze.py,sha256=qtvM_TeqYzaLClZksM_o5hAdksZ9sqLM9HGDtLDrXwY,12646
+sqlcg/cli/commands/db.py,sha256=Q3VEdNJzhrs26KtskI5j9B3C0vBTZe4VN2sZXZG_6BY,7434
+sqlcg/cli/commands/find.py,sha256=5MbGavA-QS75zwm35dYK-0H1bJ1Zd_gJHgQ_lXnpMDU,3126
+sqlcg/cli/commands/gain.py,sha256=bOvia7CVla_fESrDEdftYze8Mm0xDio3SpCzIyoXg7A,8925
+sqlcg/cli/commands/git.py,sha256=yMgWOuoTCTBr2P1QgmghRi5ikmUYHuxDUVyBDYerErw,5728
+sqlcg/cli/commands/index.py,sha256=xMnxKDiUt5LH_3lKAotoRctL4VSOvcw7Gq--idLPtm0,11091
+sqlcg/cli/commands/install.py,sha256=KNABvrLbamPyYnmnVdCaM_MNezbDc-pr6IkignCWI8k,9186
+sqlcg/cli/commands/mcp.py,sha256=2gDsNvtj1Ql7PkjX9dHWAzOK0uCPRR5DGdBAzJa8PIU,6005
+sqlcg/cli/commands/reindex.py,sha256=n1mQTYAZshtCKPgpR12S6ZMCqO3cSUtpCXjzb1PuZxU,11857
+sqlcg/cli/commands/report.py,sha256=JU0qjyMxwOukE7bN3XvvIzOI7zMg_Gsnvk_8F6pKNpA,4915
+sqlcg/cli/commands/uninstall.py,sha256=IYwQaqnMmmzW0Nlls40wD-L3tVkMgKIMRXUkcXPMUc4,9398
+sqlcg/cli/commands/watch.py,sha256=7N6c-QuvxAEGHzDZ0C3CU2BkHSraZW9YtgoFnz7SaQo,2373
+sqlcg/core/__init__.py,sha256=uNsJCrCMVWVT80sHPtI_f39BYqIf5N0i6LSq8x8HsyI,283
+sqlcg/core/config.py,sha256=8QtFNRnrzLK1Zw93AKX37h6bSASDLv-42FzDQ7zxTtI,13079
+sqlcg/core/freshness.py,sha256=gRb8pRPw5SdIUxAYkMXIJ00DTdQ6CegRZPAvWnv0rU0,4575
+sqlcg/core/graph_db.py,sha256=Aa85wPFg26H-Ud9SrZyxCHH-99iitAI5S3X9T_62Yyw,7957
+sqlcg/core/jobs.py,sha256=Je-fCdSKRgiSsv1W8SgNAlp36a7t7-pJZ-qKPbka9OE,3298
+sqlcg/core/kuzu_backend.py,sha256=ziHt-AB9sEZY7qB8whseWFicbTfOZaNOxcNVKhjii5Y,16587
+sqlcg/core/neo4j_backend.py,sha256=AM1TncP9GBGph-rSHwalZPmGUV2kFILzaJP-PSB0UYw,8437
+sqlcg/core/queries.cypher,sha256=91Pb10-ekSi0812wuHJTdXcMY4sT53_5o-oHhfSP_DQ,4967
+sqlcg/core/queries.py,sha256=JLgV4MIgP7KVIQ0xpGj3_-MBhBfY_9XPoCdcI2mO-TM,2148
+sqlcg/core/schema.cypher,sha256=rK5QMhSrzZhuj73NeNXGX6oM-rPPPvxFjex0fEyUvkQ,2859
+sqlcg/core/schema.py,sha256=JO5rkspYKjL9AEl5mt0VIJKn-IPOH3kJV_fVmAMuFCI,1467
+sqlcg/indexer/__init__.py,sha256=Wh20Unz2OHs1oIyWLrpurPAasF0BET2g4iXtNk7mh2U,56
+sqlcg/indexer/dbt_adapter.py,sha256=EB5x1WU5Z9d-I97ADDj88S_hG1C4z4nbrv8JUCzXfy8,686
+sqlcg/indexer/error_classify.py,sha256=MYjPVprwT-ARPjBCyCzu2F9DSrZfnTVtVIoBgm8s4H8,5329
+sqlcg/indexer/git_delta.py,sha256=P-QM4vnVURT2KLiE6u3cQynRUF-mTH13cbB4I20YHPQ,4468
+sqlcg/indexer/indexer.py,sha256=DYdUr59hRKCjJTRiQUWOC72JUQ9TgBrH0W4UOYNwqx8,60913
+sqlcg/indexer/pool.py,sha256=BTYx-pBe6zwUG89MHh0X7nzGNVlsHN-GjovYKanVI1s,18553
+sqlcg/indexer/walker.py,sha256=umNaqDbuerr75VYG1TEOv0ATsbI40O3SIw35f7XJcDE,1931
+sqlcg/indexer/watcher.py,sha256=mJQq1LASRLKKwhz0WhCUWPLLqyPR2_-FD_8efYU6gE8,8442
+sqlcg/lineage/__init__.py,sha256=Da1DlYwtK13WHv_RnHjAtNkHTOuFbhxqCjT1Le7DsWM,46
+sqlcg/lineage/aggregator.py,sha256=G1xsTjf981EVSgN1yIHcC_ecDvcTcSPvEp6Kb2HPXkY,4943
+sqlcg/lineage/schema_resolver.py,sha256=iXt6LYF6UVWsGUpcfbmjmGn9wCgXl721lTGf_8AaWcc,7320
+sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
+sqlcg/metrics/store.py,sha256=BaMf7QYTmYMlX_Jzi1GNU8R2sMVkWdn07f-ZSndtcNk,8879
+sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
+sqlcg/parsers/ansi_parser.py,sha256=tu1MWWaSYmpefKjgk2PPyGStIFjV47Z_1WjyBh5Zi2c,17180
+sqlcg/parsers/base.py,sha256=uL0W22zpbIz_9eq-i-4LSlonxy2J1yChuISMLSYgvRU,49345
+sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
+sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
+sqlcg/parsers/registry.py,sha256=LXy1F6rqQI6VdxpRvZg_tNpoEucW3mXZHYBMlMONbX4,1496
+sqlcg/parsers/snowflake_parser.py,sha256=fovMyqfhWD2wmtEyiwTC0aoP4QWP-3XQZ8WYkXvs9hg,15511
+sqlcg/parsers/tsql_parser.py,sha256=RRj1pACtAk2tLTDaFWRYF67a0IDvaf5A1YQXWIz0bpQ,956
+sqlcg/server/__init__.py,sha256=n4wuNE7xyJIJxJZBtmtdccCMQfvTdF-IqIaZVbC4FC4,35
+sqlcg/server/control.py,sha256=v-r21npODiHlHnJHuo_6KWrKclQKq_E1QyrzIWjqgtY,4508
+sqlcg/server/exceptions.py,sha256=EONw34icOByCTpppSQrvQBW6asc4hfqaGDCAFjv96II,469
+sqlcg/server/models.py,sha256=l7ORy6sbtzBW1y3qVaeLwEukbyAgBkz9S5VIm2q4b24,19378
+sqlcg/server/noise_filter.py,sha256=idSBGgdKWWccJdpOo9qgbM2350Oew-2l5W6Yc9GYQqY,6337
+sqlcg/server/server.py,sha256=gzeO5WbSNfGxgIKte01uy0VjO1_basI2ChSuAwr0dBc,14844
+sqlcg/server/skill.py,sha256=GE8eeimk6yiGGJ74erGypqYAviur5peSR6_2a4QQWVM,12828
+sqlcg/server/tools.py,sha256=JvijDC0h5uHjZyZUIZq9sztNG3W5sr-Yy5rHwOVuJec,66642
+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.1.0.dist-info/METADATA,sha256=blW1eYNjfy6P61747uUtc22qm5MDETMcVYImXPa762g,13615
+sql_code_graph-1.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sql_code_graph-1.1.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.1.0.dist-info/RECORD,,

sqlcg/__init__.py

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

sqlcg/cli/commands/analyze.py

@@ -1,12 +1,20 @@
 """Analyze command for lineage analysis."""
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import typer
 from rich.console import Console
 from rich.table import Table
 
 from sqlcg.core.config import get_backend
+from sqlcg.core.queries import GET_TABLE_EXTERNAL_CONSUMERS_QUERY
 from sqlcg.core.schema import NodeLabel, RelType
 
+if TYPE_CHECKING:
+    from sqlcg.server.noise_filter import NoiseFilter
+
 app = typer.Typer(help="Lineage analysis")
 console = Console()
 
@@ -15,6 +23,10 @@ console = Console()
 def upstream(  # noqa: B008
     ref: str = typer.Argument(..., help="Column reference"),  # noqa: B008
     depth: int = typer.Option(5, "--depth", help="Maximum traversal depth"),  # noqa: B008
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
+    include_intermediate: bool = typer.Option(  # noqa: B008
+        False, "--include-intermediate", help="Include CTE/derived intermediate nodes"
+    ),
 ) -> None:
     """Trace upstream column lineage."""
     # Bounds check for depth to prevent performance DoS
@@ -22,20 +34,60 @@ def upstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
+    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them
+    kind_filter = (
+        ""
+        if include_intermediate
+        else "MATCH (t:SqlTable {qualified: src.table_qualified}) "
+        "WHERE t.kind IN ['table', 'external'] "
+    )
+
     with get_backend() as backend:
         results = backend.run_read(
-            f"MATCH p=(c:{NodeLabel.COLUMN} {{id: $ref}})"
-            f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src) "
-            "RETURN src.id AS id LIMIT 100",
+            f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+            f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src:{NodeLabel.COLUMN}) "
+            f"{kind_filter}"
+            f"OPTIONAL MATCH (src)-[direct:{RelType.COLUMN_LINEAGE}]->(c) "
+            "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
+            "RETURN src.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
             {"ref": ref},
         )
-        _print_table(results, ["id"])
+        if not results and len(ref.split(".")) >= 3:
+            bare = _bare_ref(ref)
+            fallback_results = backend.run_read(
+                f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
+                f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src:{NodeLabel.COLUMN}) "
+                f"{kind_filter}"
+                f"OPTIONAL MATCH (src)-[direct:{RelType.COLUMN_LINEAGE}]->(c) "
+                "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
+                "RETURN src.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
+                {"bare": bare},
+            )
+            if fallback_results:
+                console.print(
+                    f"[yellow]Hint:[/yellow] No results for '{ref}'. "
+                    f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
+                    "The INSERT target may have been indexed without a schema prefix. "
+                    "Multiple tables with the same unqualified name in different schemas "
+                    "would all match — re-index with an explicit schema for precise results."
+                )
+                results = fallback_results
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+            results = _filter_column_results(results, nf)
+        _print_table(_add_file_line_col(results), ["id", "file:line"])
 
 
 @app.command("downstream")
 def downstream(  # noqa: B008
     ref: str = typer.Argument(..., help="Column reference"),  # noqa: B008
     depth: int = typer.Option(5, "--depth", help="Maximum traversal depth"),  # noqa: B008
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
+    include_intermediate: bool = typer.Option(  # noqa: B008
+        False, "--include-intermediate", help="Include CTE/derived intermediate nodes"
+    ),
 ) -> None:
     """Trace downstream column lineage."""
     # Bounds check for depth to prevent performance DoS
@@ -43,40 +95,114 @@ def downstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
+    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them
+    kind_filter = (
+        ""
+        if include_intermediate
+        else "MATCH (t:SqlTable {qualified: dst.table_qualified}) "
+        "WHERE t.kind IN ['table', 'external'] "
+    )
+
     with get_backend() as backend:
         results = backend.run_read(
-            f"MATCH p=(c:{NodeLabel.COLUMN} {{id: $ref}})"
-            f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst) "
-            "RETURN dst.id AS id LIMIT 100",
+            f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+            f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst:{NodeLabel.COLUMN}) "
+            f"{kind_filter}"
+            f"OPTIONAL MATCH (c)-[direct:{RelType.COLUMN_LINEAGE}]->(dst) "
+            "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
+            "RETURN dst.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
             {"ref": ref},
         )
-        _print_table(results, ["id"])
+        if not results and len(ref.split(".")) >= 3:
+            bare = _bare_ref(ref)
+            fallback_results = backend.run_read(
+                f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
+                f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst:{NodeLabel.COLUMN}) "
+                f"{kind_filter}"
+                f"OPTIONAL MATCH (c)-[direct:{RelType.COLUMN_LINEAGE}]->(dst) "
+                "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
+                "RETURN dst.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
+                {"bare": bare},
+            )
+            if fallback_results:
+                console.print(
+                    f"[yellow]Hint:[/yellow] No results for '{ref}'. "
+                    f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
+                    "The INSERT target may have been indexed without a schema prefix. "
+                    "Multiple tables with the same unqualified name in different schemas "
+                    "would all match — re-index with an explicit schema for precise results."
+                )
+                results = fallback_results
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+            results = _filter_column_results(results, nf)
+        _print_table(_add_file_line_col(results), ["id", "file:line"])
+
+        # Append external consumer rows for terminal tables (scalar query, one per terminal).
+        # Resolve terminal tables from the column results; fall back to the root column's table.
+        terminal_tables: set[str] = set()
+        for r in results:
+            tbl = _col_id_to_table(r["id"])
+            if tbl:
+                terminal_tables.add(tbl)
+        # Also check the root column's table (in case no downstream columns were found).
+        root_parts = ref.rsplit(".", 1)
+        if len(root_parts) == 2:
+            terminal_tables.add(root_parts[0])
+        consumer_rows: list[dict] = []
+        for tbl in sorted(terminal_tables):
+            rows_ec = backend.run_read(
+                GET_TABLE_EXTERNAL_CONSUMERS_QUERY,
+                {"table_qualified": tbl},
+            )
+            for ec in rows_ec:
+                consumer_rows.append(
+                    {"id": f"[external] {ec['name']} ({ec['consumer_type']})", "file:line": ""}
+                )
+        if consumer_rows:
+            _print_table(consumer_rows, ["id", "file:line"])
 
 
 @app.command("impact")
 def impact(  # noqa: B008
     table: str = typer.Argument(..., help="Table name to analyze"),  # noqa: B008
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Show all queries impacted by a table."""
     with get_backend() as backend:
         results = backend.run_read(
             f"MATCH (t:{NodeLabel.TABLE} {{qualified: $t}})"
             f"<-[:{RelType.SELECTS_FROM}]-(q:{NodeLabel.QUERY}) "
-            "RETURN q.id AS id, q.kind AS kind LIMIT 100",
+            "RETURN DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target LIMIT 100",
             {"t": table},
         )
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()
+            results = [r for r in results if not nf.is_noise(r.get("target", ""))]
         _print_table(results, ["id", "kind"])
 
 
 @app.command("failures")
 def failures(
     cause: str | None = typer.Option(  # noqa: B008
-        None, "--cause", help="Filter by E-code bucket (e.g. E5, timeout)"
+        None,
+        "--cause",
+        help=(
+            "Filter by E-code bucket. Valid values: "
+            "timeout, E8, E3, E2, E5, E1, qualify_failed, func_fallback, pure_ddl_skip"
+        ),
     ),
     limit: int = typer.Option(100, "--limit", help="Maximum rows to return"),  # noqa: B008
 ) -> None:
     """List files that failed to parse, with their dominant cause (E-code bucket).
 
+    Valid --cause buckets (from highest to lowest severity):
+    timeout, E8, E3, E2, E5, E1, qualify_failed, func_fallback, pure_ddl_skip.
+
     Requires a graph indexed with sqlcg >= v3 (schema version 3). Re-index
     with 'sqlcg db reset && sqlcg index <path>' if the graph was built with
     an earlier version.
@@ -95,17 +221,79 @@ def failures(
 @app.command("unused")
 def unused(
     threshold: int = typer.Option(0, "--threshold", help="Minimum reference count threshold"),
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Find tables with no query references."""
     with get_backend() as backend:
         results = backend.run_read(
             f"MATCH (t:{NodeLabel.TABLE}) WHERE NOT (t)<-[:{RelType.SELECTS_FROM}]-() "
-            "RETURN t.qualified AS qualified LIMIT 100",
+            "RETURN DISTINCT t.qualified AS qualified LIMIT 100",
             {},
         )
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()
+            results = [r for r in results if not nf.is_noise(r["qualified"])]
         _print_table(results, ["qualified"])
 
 
+def _bare_ref(ref: str) -> str:
+    """Strip schema prefix from a ref string, keeping table.column.
+
+    For a 3-part ref ("mart.fact_t.amount") this returns "fact_t.amount".
+    For a 2-part ref ("fact_t.amount") this returns the ref unchanged.
+    Never uses rsplit — that would yield only the column name for 3-part refs.
+    """
+    parts = ref.split(".")
+    if len(parts) >= 3:
+        return ".".join(parts[1:])  # drop schema, keep table.column
+    return ref  # already bare (no schema prefix)
+
+
+def _col_id_to_table(col_id: str) -> str:
+    """Extract the table-qualified part from a column ID (schema.table.col → schema.table).
+
+    Column IDs follow the format: schema.table.column or table.column.
+    The table part is everything except the last component.
+
+    Args:
+        col_id: A column ID string from the graph.
+
+    Returns:
+        The table-qualified portion (all but the last dotted component).
+    """
+    parts = col_id.rsplit(".", 1)
+    return parts[0] if len(parts) == 2 else col_id
+
+
+def _filter_column_results(
+    results: list[dict],
+    nf: NoiseFilter,  # type: ignore[name-defined]
+) -> list[dict]:
+    """Filter column-ID result rows by NoiseFilter, dropping rows whose table is noise."""
+    return [r for r in results if not nf.is_noise(_col_id_to_table(r["id"]))]
+
+
+def _add_file_line_col(rows: list[dict]) -> list[dict]:
+    """Add a 'file:line' composite column from 'file' and 'line' fields.
+
+    Formats as 'path/to/file.sql:N' when both are present, or '?' when either
+    is absent (multi-hop upstream where file/line is not available).
+    """
+    result = []
+    for row in rows:
+        new_row = dict(row)
+        file = row.get("file")
+        line = row.get("line")
+        if file and line:
+            new_row["file:line"] = f"{file}:{line}"
+        else:
+            new_row["file:line"] = "?"
+        result.append(new_row)
+    return result
+
+
 def _print_table(rows: list[dict], columns: list[str]) -> None:
     """Print results as a Rich table."""
     if not rows:

sqlcg/cli/commands/db.py

@@ -2,11 +2,13 @@
 
 import os
 import shutil
+from pathlib import Path
 
 import typer
 from rich.console import Console
 
 from sqlcg.core.config import get_backend, get_db_path
+from sqlcg.core.freshness import compute_freshness, render_freshness_line
 from sqlcg.core.schema import NodeLabel
 from sqlcg.utils.logging import getLogger
 
@@ -77,6 +79,21 @@ def db_info() -> None:
         version = backend.get_schema_version() or "unknown"
         console.print(f"Schema version: {version}")
 
+        # Freshness block — only shown when the DB has been indexed from a git repo
+        try:
+            indexed_sha = backend.get_indexed_sha()
+            repo_rows = backend.run_read("MATCH (r:Repo) RETURN r.path AS path LIMIT 1", {})
+            if repo_rows and indexed_sha is not None and repo_rows[0].get("path"):
+                repo_root = Path(repo_rows[0]["path"])
+                f = compute_freshness(repo_root, indexed_sha)
+                console.print(render_freshness_line(f))
+        except NotImplementedError:
+            # Neo4j backend raises NotImplementedError for get_indexed_sha — skip silently
+            pass
+        except Exception as e:
+            # Any unexpected error in the freshness block must not crash db info
+            logger.debug(f"Freshness check skipped: {e}")
+
         # Show node counts for all labels
         for label in NodeLabel:
             try:

sqlcg/cli/commands/find.py

@@ -14,27 +14,45 @@ console = Console()
 @app.command("table")
 def find_table(  # noqa: B008
     name: str = typer.Argument(..., help="Table name to search for"),  # noqa: B008
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Find a table by name."""
+    name = name.lower()  # graph keys are lowercased at index time (C2 normalization)
     with get_backend() as backend:
         results = backend.run_read(
             f"MATCH (t:{NodeLabel.TABLE}) WHERE t.qualified CONTAINS $name "
             "RETURN t.qualified AS qualified, t.kind AS kind LIMIT 50",
             {"name": name},
         )
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+            ids = [r["qualified"] for r in results]
+            kept, _ = nf.filter_nodes(ids)
+            kept_set = set(kept)
+            results = [r for r in results if r["qualified"] in kept_set]
         _print_table(results, ["qualified", "kind"])
 
 
 @app.command("column")
 def find_column(  # noqa: B008
     ref: str = typer.Argument(..., help="Column reference (table.column)"),  # noqa: B008
+    raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Find a column by table.column reference."""
+    ref = ref.lower()  # graph keys are lowercased at index time (C2 normalization)
     with get_backend() as backend:
         results = backend.run_read(
             f"MATCH (c:{NodeLabel.COLUMN}) WHERE c.id CONTAINS $ref RETURN c.id AS id LIMIT 50",
             {"ref": ref},
         )
+        if not raw:
+            from sqlcg.server.noise_filter import NoiseFilter
+
+            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+            # Filter on the schema.table portion of each column id (schema.table.column)
+            results = [r for r in results if not nf.is_noise(r["id"].rsplit(".", 1)[0])]
         _print_table(results, ["id"])
 
 

sqlcg/cli/commands/git.py

@@ -1,5 +1,7 @@
 """Git integration commands for sqlcg."""
 
+import shutil
+import sys
 from pathlib import Path
 from typing import NamedTuple
 
@@ -14,36 +16,79 @@ app = typer.Typer(name="git", help="Git integration commands")
 class _HookSpec(NamedTuple):
     filename: str
     sentinel: str
-    script: str
+    script_template: str
 
 
+# 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.
 _HOOKS: list[_HookSpec] = [
     _HookSpec(
         filename="post-checkout",
         sentinel="# sqlcg post-checkout hook",
-        script=(
+        script_template=(
             "#!/bin/sh\n"
             "# 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 reindex --from "$1" --to "$2"'
-            ' "$(git rev-parse --show-toplevel)" --dialect auto --quiet || true\n'
+            '{sqlcg_bin} reindex --from "$1" --to "$2"'
+            ' "$(git rev-parse --show-toplevel)" --dialect auto --quiet --notify'
+            ' || echo "sqlcg: graph not updated (server busy/locked)'
+            " -- run 'sqlcg mcp status'\" >&2\n"
         ),
     ),
     _HookSpec(
         filename="post-merge",
         sentinel="# sqlcg post-merge hook",
-        script="""\
+        script_template="""\
 #!/bin/sh
 # sqlcg post-merge hook — incremental resync after pull/merge
-# post-merge receives only $1 (squash flag), no old/new SHA; use stored-SHA delta
-sqlcg reindex "$(git rev-parse --show-toplevel)" --dialect auto --quiet || true
+# 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 (server busy/locked) -- run 'sqlcg mcp status'" >&2
+else
+  {sqlcg_bin} reindex "$TOP" --dialect auto --quiet --notify \\
+    || echo "sqlcg: graph not updated (server busy/locked) -- run 'sqlcg mcp status'" >&2
+fi
 """,
     ),
 ]
 
 
-def _install_single_hook(hooks_dir: Path, spec: _HookSpec) -> None:
+def _resolve_sqlcg_bin() -> str:
+    """Resolve the absolute path of the installing sqlcg binary.
+
+    Resolution order:
+    1. shutil.which("sqlcg") — the binary on the installer's $PATH.
+    2. sys.argv[0] resolved via Path(...).resolve() if it ends in "sqlcg" and is executable.
+    3. Bare "sqlcg" fallback (current behaviour) — prints a warning so the user knows.
+
+    Returns the resolved path string (absolute when resolvable, bare "sqlcg" otherwise).
+    """
+    # 1. Try $PATH first — the binary the user means
+    which_result = shutil.which("sqlcg")
+    if which_result:
+        return which_result
+
+    # 2. Try sys.argv[0] for python -m / editable-install invocations
+    argv0 = Path(sys.argv[0]).resolve()
+    if argv0.name == "sqlcg" and argv0.is_file() and argv0.stat().st_mode & 0o111:
+        return str(argv0)
+
+    # 3. Bare fallback — still functional but relies on $PATH at hook-run time
+    console.print(
+        "[yellow]Warning: could not resolve the sqlcg binary path; the generated hooks "
+        "will use bare 'sqlcg' and rely on $PATH at hook-run time.[/yellow]"
+    )
+    return "sqlcg"
+
+
+def _install_single_hook(hooks_dir: Path, spec: _HookSpec, sqlcg_bin: str) -> None:
     """Install one git hook idempotently.
 
     If the hook file already contains the sentinel, it is already installed — skip silently.
@@ -51,6 +96,7 @@ def _install_single_hook(hooks_dir: Path, spec: _HookSpec) -> None:
     Otherwise, write the hook file and set 0o755.
     """
     hook_path = hooks_dir / spec.filename
+    script = spec.script_template.format(sqlcg_bin=sqlcg_bin)
 
     if hook_path.exists():
         existing_content = hook_path.read_text()
@@ -68,10 +114,10 @@ def _install_single_hook(hooks_dir: Path, spec: _HookSpec) -> None:
                 f".git/hooks/{spec.filename}:[/yellow]"
             )
             console.print("")
-            console.print("[cyan]" + spec.script.rstrip() + "[/cyan]")
+            console.print("[cyan]" + script.rstrip() + "[/cyan]")
             return
 
-    hook_path.write_text(spec.script)
+    hook_path.write_text(script)
     hook_path.chmod(0o755)
     console.print(f"[green]Installed git hook:[/green] .git/hooks/{spec.filename}")
 
@@ -87,6 +133,8 @@ def install_hooks(
     Writes a post-checkout hook that triggers incremental resync after branch switches
     and a post-merge hook that triggers resync after pulls/merges.
     Idempotent: running multiple times produces one hook entry per hook.
+    The hooks embed the absolute path of the installing sqlcg binary so version skew
+    between the installed binary and the hook command is avoided.
     """
     if repo is None:
         repo = Path.cwd()
@@ -100,5 +148,7 @@ def install_hooks(
 
     hooks_dir.mkdir(parents=True, exist_ok=True)
 
+    sqlcg_bin = _resolve_sqlcg_bin()
+
     for spec in _HOOKS:
-        _install_single_hook(hooks_dir, spec)
+        _install_single_hook(hooks_dir, spec, sqlcg_bin)