sql-code-graph 1.34.3__tar.gz → 1.35.0__tar.gz

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.34.3
+Version: 1.35.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.34.3 → sql_code_graph-1.35.0}/docs/cli.md

@@ -17,6 +17,7 @@ bash scripts/generate_cli_docs.sh
 | `watch` | Watch a directory and re-index on SQL file changes. |
 | `gain` | Show metrics and feedback analytics. |
 | `report` | Generate a metrics report with FP clusters and parse error patterns. |
+| `viz` | Generate a self-contained graph-explorer HTML from the live graph. |
 | `install` | Register sqlcg as an MCP server in Claude Code. |
 | `uninstall` | Uninstall sqlcg from Claude Code and optionally clean up resources. |
 | `version` | Show version. |
@@ -187,6 +188,33 @@ If no metrics database exists, prints a message and exits 0.
 | --stdout | BOOLEAN | No | No | False | Print to stdout instead of file |
 | --output, -o | PATH | No | No |  | Output file path |
 
+## `sqlcg viz`
+
+```bash
+sqlcg viz [OPTIONS]
+```
+
+Generate a self-contained graph-explorer HTML from the live graph.
+
+Reads the graph via the server-aware routed-read path (never a direct DB
+open). The emitted file inlines the force-graph library plus the baked node/
+edge/adjacency data and the tag/job facets — no external resources — so it
+opens by double-click on Windows.
+
+The client-side filter composes schema ∩ kind ∩ tag (multi-select per facet,
+union within a facet, intersection across) plus a job dropdown; an edge
+renders only when both endpoints are visible. Node kinds table/view/temp are
+ON by default, cte/derived OFF (switchable).
+
+### Options
+
+| Option | Type | Required | Repeatable | Default | Description |
+| --- | --- | --- | --- | --- | --- |
+| --tags | PATH | No | No |  | BYO tags CSV (pattern,label[,color]; header required). The 'tag' facet drives the legend swatches (color + filter). Patterns are fnmatch globs (*, ?, [seq]) matched case-insensitively against the qualified table name. Many-to-many. Omit to hide the tag legend. |
+| --jobs | PATH | No | No |  | BYO jobs CSV, same shape as --tags. The 'job' facet drives the job dropdown (filter only). Omit to leave the dropdown empty. |
+| --out | PATH | No | No |  | Output HTML path (default: table_graph.html in the current directory). |
+| --config-dir | PATH | No | No | . | Directory searched for .sqlcg.toml ([sqlcg.viz] schemas). |
+
 ## `sqlcg install`
 
 ```bash
@@ -438,6 +466,13 @@ sqlcg analyze impact [OPTIONS] TABLE
 
 Show all queries impacted by a table.
 
+One-hop "who reads this table" — the union of direct SELECTS_FROM consumers
+and consumers that read the table only via COLUMN_LINEAGE / STAR_SOURCE
+(CTE-wrapped / promoted-intermediate reads, e.g. the live DWH node
+``ba.all_rows_in_selection``). Bug #6 fix: brings ``impact`` to the same
+one-hop consumer completeness ``find_table_usages`` already has. Stays
+one-hop (NOT transitive — that is ``downstream``'s job).
+
 ### Options
 
 | Option | Type | Required | Repeatable | Default | Description |

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/pyproject.toml

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

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/__init__.py

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

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/cli/commands/analyze.py

@@ -8,7 +8,10 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from sqlcg.core.queries import GET_TABLE_EXTERNAL_CONSUMERS_QUERY
+from sqlcg.core.queries import (
+    GET_TABLE_EXTERNAL_CONSUMERS_QUERY,
+    IMPACT_CONSUMERS_VIA_LINEAGE_QUERY,
+)
 from sqlcg.server.read_client import resolved_repo_root, run_read_routed
 
 if TYPE_CHECKING:
@@ -312,8 +315,16 @@ 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."""
-    results = run_read_routed(
+    """Show all queries impacted by a table.
+
+    One-hop "who reads this table" — the union of direct SELECTS_FROM consumers
+    and consumers that read the table only via COLUMN_LINEAGE / STAR_SOURCE
+    (CTE-wrapped / promoted-intermediate reads, e.g. the live DWH node
+    ``ba.all_rows_in_selection``). Bug #6 fix: brings ``impact`` to the same
+    one-hop consumer completeness ``find_table_usages`` already has. Stays
+    one-hop (NOT transitive — that is ``downstream``'s job).
+    """
+    direct = run_read_routed(
         "SELECT DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target"
         ' FROM "SqlTable" t'
         ' JOIN "SELECTS_FROM" sf ON sf.dst_key = t.qualified'
@@ -321,6 +332,17 @@ def impact(  # noqa: B008
         " WHERE t.qualified = ? LIMIT 100",
         {"t": table},
     )
+    # Consumers reachable only via COLUMN_LINEAGE / STAR_SOURCE. Two "?" both
+    # bound to the qualified table name: _params_list returns list(values()) in
+    # insertion order, so the ordered dict {"t":..., "t2":...} binds correctly.
+    via = run_read_routed(
+        IMPACT_CONSUMERS_VIA_LINEAGE_QUERY,
+        {"t": table, "t2": table},
+    )
+    seen = {r["id"] for r in direct}
+    results = direct + [r for r in via if r["id"] not in seen]
+    # Preserve the existing 100-row bound on the merged consumer set.
+    results = results[:100]
     if not raw:
         from sqlcg.server.noise_filter import NoiseFilter
 

sql_code_graph-1.35.0/src/sqlcg/cli/commands/viz.py

@@ -0,0 +1,102 @@
+"""The sqlcg viz command — generate a self-contained graph-explorer HTML.
+
+Plan: plan/sprints/feature_graph_viz.md §"CLI signature".
+
+Queries the live graph (via the server-aware ``run_read_routed`` seam),
+attaches per-table label facets (tags/jobs) from BYO CSVs, and writes ONE
+self-contained ``.html`` with the force-graph library inlined — openable on
+Windows via ``file://``. Touches no parser/indexer/lineage code.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from sqlcg.core.config import get_viz_schemas
+from sqlcg.utils.logging import getLogger
+from sqlcg.viz.data import build_viz_data
+from sqlcg.viz.render import DEFAULT_VIZ_OUT, render_html
+from sqlcg.viz.tags import FacetMap, load_facet, resolve_labels
+
+logger = getLogger(__name__)
+console = Console()
+
+
+def _facet_payload(facet: FacetMap) -> dict:
+    """Shape a FacetMap for baking: ``{labels, colors}``."""
+    return {"labels": facet.labels, "colors": facet.colors}
+
+
+def viz_cmd(
+    tags: Path | None = typer.Option(  # noqa: B008
+        None,
+        "--tags",
+        help=(
+            "BYO tags CSV (pattern,label[,color]; header required). The 'tag' "
+            "facet drives the legend swatches (color + filter). Patterns are "
+            "fnmatch globs (*, ?, [seq]) matched case-insensitively against the "
+            "qualified table name. Many-to-many. Omit to hide the tag legend."
+        ),
+    ),
+    jobs: Path | None = typer.Option(  # noqa: B008
+        None,
+        "--jobs",
+        help=(
+            "BYO jobs CSV, same shape as --tags. The 'job' facet drives the job "
+            "dropdown (filter only). Omit to leave the dropdown empty."
+        ),
+    ),
+    out: Path | None = typer.Option(  # noqa: B008
+        None,
+        "--out",
+        help=f"Output HTML path (default: {DEFAULT_VIZ_OUT} in the current directory).",
+    ),
+    config_dir: Path = typer.Option(  # noqa: B008
+        Path("."),
+        "--config-dir",
+        help="Directory searched for .sqlcg.toml ([sqlcg.viz] schemas).",
+    ),
+) -> None:
+    """Generate a self-contained graph-explorer HTML from the live graph.
+
+    Reads the graph via the server-aware routed-read path (never a direct DB
+    open). The emitted file inlines the force-graph library plus the baked node/
+    edge/adjacency data and the tag/job facets — no external resources — so it
+    opens by double-click on Windows.
+
+    The client-side filter composes schema ∩ kind ∩ tag (multi-select per facet,
+    union within a facet, intersection across) plus a job dropdown; an edge
+    renders only when both endpoints are visible. Node kinds table/view/temp are
+    ON by default, cte/derived OFF (switchable).
+    """
+    out_path = out if out is not None else Path(DEFAULT_VIZ_OUT)
+
+    schemas = get_viz_schemas(config_dir)
+
+    data = build_viz_data()
+
+    tag_facet = load_facet(tags, "tag") if tags is not None else FacetMap(name="tag")
+    job_facet = load_facet(jobs, "job") if jobs is not None else FacetMap(name="job")
+
+    # Attach resolved facet labels to every node (m2m glob resolution).
+    for node in data["nodes"]:
+        node["tags"] = resolve_labels(node["id"], tag_facet)
+        node["jobs"] = resolve_labels(node["id"], job_facet)
+
+    html = render_html(
+        data,
+        _facet_payload(tag_facet),
+        _facet_payload(job_facet),
+        schemas,
+    )
+    out_path.write_text(html, encoding="utf-8")
+
+    schema_count = len(schemas) if schemas else len({n["schema"] for n in data["nodes"]})
+    console.print(
+        f"Wrote {out_path} — {len(data['nodes'])} nodes, "
+        f"{len(data['links'])} edges, {len(tag_facet.labels)} tags, "
+        f"{len(job_facet.labels)} jobs, {schema_count} schemas."
+    )

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/cli/main.py

@@ -16,6 +16,7 @@ from sqlcg.cli.commands import (
     reindex,
     report,
     uninstall,
+    viz,
     watch,
 )
 
@@ -84,6 +85,7 @@ app.command("reindex")(reindex.reindex_cmd)
 app.command("watch")(watch.watch_cmd)
 app.command("gain")(gain.gain_cmd)
 app.command("report")(report.report_cmd)
+app.command("viz")(viz.viz_cmd)
 app.command("install")(install.install_cmd)
 app.command("uninstall")(uninstall.uninstall_cmd)
 

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/core/config.py

@@ -151,6 +151,44 @@ def get_noise_filter_patterns(path: Path) -> list[str]:
     return default_patterns
 
 
+def get_viz_schemas(path: Path) -> list[str]:
+    """Get the curated viz schema list from .sqlcg.toml.
+
+    Reads [sqlcg.viz] -> schemas (a list of schema-name strings) from
+    .sqlcg.toml. Used by ``sqlcg viz`` to decide which schemas get a distinct
+    hue / appear as multi-select facets. When the block/key is absent or not a
+    list, returns ``[]`` and the generator falls back to **data-derived**
+    schemas (every distinct schema present in the graph), preserving the
+    zero-config small-repo path::
+
+        [sqlcg.viz]
+        schemas = ["ba", "da", "ia_analytics"]
+
+    This reader mirrors ``get_schema_aliases`` / ``get_noise_filter_patterns``
+    exactly (same .sqlcg.toml open, same ``except Exception: pass`` guard, same
+    fallback shape). It is presentation-only config; it never touches indexing
+    or lineage.
+
+    Args:
+        path: Root directory to search for .sqlcg.toml
+
+    Returns:
+        List of configured schema names. ``[]`` when the key is absent or
+        malformed (caller derives schemas from the data).
+    """
+    config_file = Path(path) / ".sqlcg.toml"
+    if config_file.exists():
+        try:
+            with open(config_file, "rb") as f:
+                config = tomllib.load(f)
+            raw = config.get("sqlcg", {}).get("viz", {}).get("schemas")
+            if isinstance(raw, list):
+                return [s for s in raw if isinstance(s, str)]
+        except Exception:
+            pass
+    return []
+
+
 def get_ignored_tables(path: Path) -> list[str]:
     """Get explicitly-ignored qualified table names from .sqlcg.toml.
 

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/core/queries.py

@@ -72,3 +72,4 @@ GET_TABLES_EXTERNAL_CONSUMERS_BATCH_QUERY = _Q["GET_TABLES_EXTERNAL_CONSUMERS_BA
 COUNT_EXTERNAL_CONSUMERS_QUERY = _Q["COUNT_EXTERNAL_CONSUMERS"]
 GET_TABLE_READS_ADJACENCY_QUERY = _Q["GET_TABLE_READS_ADJACENCY"]
 GET_PRODUCER_TABLES_QUERY = _Q["GET_PRODUCER_TABLES"]
+IMPACT_CONSUMERS_VIA_LINEAGE_QUERY = _Q["IMPACT_CONSUMERS_VIA_LINEAGE"]

{sql_code_graph-1.34.3 → sql_code_graph-1.35.0}/src/sqlcg/core/queries.sql

@@ -413,3 +413,26 @@ WHERE t.name = ?
 SELECT DISTINCT target_table AS producer_table
 FROM "SqlQuery"
 WHERE target_table <> '' AND target_table IS NOT NULL
+
+-- IMPACT_CONSUMERS_VIA_LINEAGE
+-- Bug #6: consumers that read a table only via COLUMN_LINEAGE or STAR_SOURCE
+-- (CTE-wrapped / promoted-intermediate reads that emit no top-level SELECTS_FROM
+-- edge, e.g. the live DWH cross-file-promoted node ba.all_rows_in_selection:
+-- kind='table', non-namespaced, 0 SELECTS_FROM in-edges, 55 COLUMN_LINEAGE
+-- out-edges). Returns the same (id, kind, target) shape as the SELECTS_FROM-only
+-- impact query in analyze.py:impact() so the two result sets merge + dedup on q.id.
+-- Both branches key on the QUALIFIED table name (impact() keys on t.qualified):
+-- COLUMN_LINEAGE branch -> src.table_qualified; STAR_SOURCE branch -> ss.dst_key.
+-- The STAR_SOURCE branch closes the STAR-only-consumer gap (FIND_TABLE_USAGES
+-- itself still lacks it — out of scope, separate follow-up).
+-- params: [table_qualified, table_qualified]  (same value bound to BOTH ?)
+SELECT DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target
+FROM "SqlColumn" src
+JOIN "COLUMN_LINEAGE" cl ON cl.src_key = src.id
+JOIN "SqlQuery" q ON q.id = cl.query_id
+WHERE src.table_qualified = ?
+UNION
+SELECT DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target
+FROM "STAR_SOURCE" ss
+JOIN "SqlQuery" q ON q.id = ss.src_key
+WHERE ss.dst_key = ?

sql_code_graph-1.35.0/src/sqlcg/viz/__init__.py

@@ -0,0 +1,10 @@
+"""Self-contained graph-visualization generator for ``sqlcg viz``.
+
+Plan: plan/sprints/feature_graph_viz.md
+
+A pure read + render feature: queries the live DuckDB graph (via the
+server-aware ``run_read_routed`` seam), resolves query-anchored edges to
+table->table links, attaches per-table label facets (tags/jobs) from a BYO
+CSV, and emits ONE self-contained HTML file with the force-graph library
+inlined. No parser/indexer/lineage code is touched.
+"""