ripple-sql 0.1.18__tar.gz → 0.1.19__tar.gz

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/CHANGELOG.md

@@ -6,6 +6,24 @@ Notable changes to Ripple. The format follows
 
 ## [Unreleased]
 
+## [0.1.19] - 2026-10-08
+
+Found by a Snowflake trial on Oct 8 2026: an analytics engineer on GitLab's 1,908-model dbt project, driving `ripple mcp` the way Claude Code or Cursor would, across twelve real setups.
+
+### Fixed
+- Ripple finds Snowflake connections wherever `snow` keeps them. It asks `snow connection list` first (it never connects) and otherwise follows snow's own rules: `SNOWFLAKE_HOME`, `~/.snowflake` only when it exists, then the platform folder (`~/Library/Application Support/snowflake` on a Mac, `~/.config/snowflake` or `XDG_CONFIG_HOME` on Linux, `%LOCALAPPDATA%\snowflake` on Windows). On a fresh Mac it used to see no connection at all. `connections.toml` replaces `config.toml`'s connections, as in snow; the default comes from `SNOWFLAKE_DEFAULT_CONNECTION_NAME`, `config.toml`, or a connection named `default`. A file snow refuses (readable by others, broken TOML) is named with the fix, for example `chmod 600 "<path>"`. Checked against real snow 3.29 on 24 setups.
+- Ripple knows a dbt project's warehouse from `profiles.yml` wherever dbt finds it: `DBT_PROFILES_DIR`, the current folder when it is inside the repo, `~/.dbt`, then folders like `profile/` in the repo. The profile and target follow dbt (`DBT_PROFILE`, `DBT_TARGET`, the `target:` key, a target named `default`, dbt Fusion's list targets). Only the adapter type, the profile and target names and the file path are kept; a password on a broken YAML line never shows up anywhere. `RIPPLE_DBT_HOME=off` skips the home folder. It used to read only a `profiles.yml` beside `dbt_project.yml`, so most Snowflake users got "warehouse unknown".
+- MCP results fit what clients accept. One budget for every tool: about 8,000 characters by default, `detail="full"` or `limit` for up to 24,000, `offset` for the next page, and a `cut` record naming what was left out and the exact call for the rest. Counts and the verdict come first, `next` last. `ingest_schema` returned 957K characters on GitLab (the whole schemas file, twice); `breaks` 126K.
+- No MCP call blocks while Ripple builds or fetches. A first call on a large project answers within 2 s with "Ripple is reading the project, 712 of 1,908 models · ask again in about 30 s", and progress notifications go out when the client asks for them. `fetch_schema`, `collect_usage` and `ingest_schema` start in the background and report through `lineage_summary` and `usage_summary`. Claude Desktop, Codex and Cursor's CLI stop a call at 60 s; the first call used to take 72 to 97 s.
+- Every MCP call stays fast after a column fetch. A status check re-read all of a project's dbt YAML several times per call (1,206 parses on GitLab's 201 sources.yml files) and fought the rebuild for Python's lock, so a call right after a fetch took 50 to 67 s. Each YAML file is now parsed once until it changes (with libyaml when installed), and the warehouse state is refreshed in the background and served with its age. On GitLab every call answers within 3 s. "Ask again in about N s" now follows the last real build time, clamped to 5 to 120 s (it once said 1,150 s).
+- `next` leads with what blocks the warehouse read and the exact fix: a connection file to chmod, which connection to pick, `DBT_TARGET` or a source database variable to add to the server's env block. When sign-in can prompt (a password with an MFA push, Okta, a browser), it tells the agent to ask the user before fetching.
+- `env_var()` in a repo's dbt files can no longer pull a secret into Ripple. Every read goes through one gate: a credential-looking name (`AWS_SECRET_ACCESS_KEY`, `GITHUB_TOKEN`, ...) is refused, a value used as a table name must look like one, and messages name the variable, never its value. A sources.yml naming `AWS_SECRET_ACCESS_KEY` put its value into the SQL sent to `snow`.
+- On Windows, a warehouse CLI no longer sees a terminal on stdin (the NUL device reports one), so it cannot wait on a prompt. CLIs are found only in absolute PATH folders, never the repo, and in the usual install folders when an app started from the Dock or Start menu has a short PATH (for example `/opt/homebrew/bin`), with a note saying so.
+
+### Changed
+- Automatic column reads run only for sign-ins that never prompt: key pair (`SNOWFLAKE_JWT`), OAuth client credentials, programmatic access tokens, workload identity. A password connection now waits for the user, because it can send an MFA push.
+- ClickHouse, SQL Server, Fabric, Synapse, Athena and other adapters parse in their own dialect instead of Snowflake with a warning (one adapter map).
+
 ## [0.1.18] - 2026-10-07
 
 ### Added
@@ -354,7 +372,8 @@ First public release.
 ### Removed
 - The dark whole-graph canvas that `ripple serve` used to open (`static/index.html`). Every surface now draws one answer.
 
-[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.18...HEAD
+[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.19...HEAD
+[0.1.19]: https://github.com/bteh/ripple/compare/v0.1.18...v0.1.19
 [0.1.18]: https://github.com/bteh/ripple/compare/v0.1.17...v0.1.18
 [0.1.17]: https://github.com/bteh/ripple/compare/v0.1.16...v0.1.17
 [0.1.16]: https://github.com/bteh/ripple/releases/tag/v0.1.16

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ripple-sql
-Version: 0.1.18
+Version: 0.1.19
 Summary: Offline column-level SQL lineage. See what breaks before you merge.
 Project-URL: Homepage, https://github.com/bteh/ripple
 Project-URL: Repository, https://github.com/bteh/ripple
@@ -137,6 +137,34 @@ default_tools_approval_mode = "approve"
 Then ask: *"what breaks if I change `orders.amount` to cents?"* If the client
 lists ripple but the tools do nothing, `ripple doctor` tells you why.
 
+On a big project a full answer can run to hundreds of thousands of
+characters, and clients cut or spill results long before that (Cline keeps
+8,000 characters, Codex cuts the middle at about 10,000 tokens, Claude Code
+writes anything over 50,000 to a file). So every tool result stays under
+8,000 characters by default. The counts, the verdict and `next` are never
+cut; long lists are, nearest hops or worst blockers first, and the result's
+`cut` field says how many it showed out of how many, with the exact call for
+the rest. `breaks`, `trace`, `check_file`, `model_columns`,
+`unresolved_tables`, `usage_summary` and `lineage_summary` take three extra
+arguments: `offset` (skip that many rows), `limit` (rows per page) and
+`detail` (`summary`, the default, or `full`). Asked for more, a result still
+stops at 24,000 characters. `page=true` on `breaks` and `trace` is the HTML
+answer page for a person, not paging.
+
+No tool call waits more than about 2 seconds. Claude Desktop, Codex and the
+Cursor CLI give up on a call after 60 seconds, and reading a 2,000-model
+project the first time takes longer than that. So the server starts reading
+the project the moment it starts, and a call that arrives before it is done
+answers at once with `building: true`, how many models are read, and when to
+ask again ("Ripple is reading the project, 712 of 1,908 models · ask again in
+about 30 s"). The disk cache makes a restart instant. `fetch_schema` and
+`ingest_schema` work the same way: a slow warehouse or rebuild answers
+"started" and the result lands in `lineage_summary` (`warehouse.fetching`,
+`warehouse.rebuilding`, then `warehouse.last_fetch` with what was saved and
+how many more models are fully analyzed). A client that sends a
+`progressToken` also gets progress notifications while a call waits.
+`RIPPLE_MCP_WAIT_S` changes the wait.
+
 ## Is it actually right?
 
 Most SQL lineage tools are confidently wrong, so Ripple ships a benchmark you can rerun instead of a claim you have to trust. Real public dbt projects, hand-verified column lineage, every tool scored by the same function. The corpus and the harness are both in this repo.
@@ -241,6 +269,10 @@ Your SQL probably reads tables defined outside the repo, and without their colum
 
 Ripple never stores, prompts for, or sends a credential, and never opens a connection of its own: it runs the CLI you already signed in to, with the connection you marked default (or the only one). It starts on its own only when signing in needs no browser; otherwise the page shows one button, "Fetch from Snowflake · prod". Several connections and no default: the page asks once and remembers the name in your cache, not in the repo. `RIPPLE_WAREHOUSE=off` turns it off.
 
+For a dbt project, Ripple learns the warehouse from `profiles.yml` the way dbt finds it: `DBT_PROFILES_DIR`, then your working directory, the project folder, `~/.dbt`, and folders like `profile/` in the repo. It picks the target from `DBT_TARGET` or the profile's `target:`, and reads only each target's `type`, never a password or token. An MCP server started by a desktop app does not see your shell's exports, so put `DBT_TARGET` or `DBT_PROFILES_DIR` in the server's `env` block when you need them, and any variable your sources read with `env_var()` (GitLab's sources name their database with `SNOWFLAKE_LOAD_DATABASE`, so its block carries `"SNOWFLAKE_LOAD_DATABASE": "RAW"`). Restart the server after changing it. `RIPPLE_DBT_HOME=off` stops it reading `~/.dbt`, and `--dialect` overrides all of it.
+
+What Ripple reports about your profile, in the CLI, the answer page and to an MCP client: the adapter type, the profile and target names, the other targets of that profile with their adapter types (so it can say "set DBT_TARGET=prod"), and the path of the one file it used (or, when it found none, the places it looked). It never reports other profile files on your machine. A `{{ env_var('X') }}` in `type`, `target` or `profile` is read only for `DBT_*` names and names ending in `_TARGET`, `_PROFILE`, `_TYPE`, `_ENV` and the like, never for a name that looks like a credential (`TOKEN`, `KEY`, `SECRET`, `PASSWORD`). A value from the environment is kept only when it names a known adapter, a target of that profile, or a profile a file has; otherwise Ripple names the variable and not its value.
+
 The columns land in `.ripple/schemas.json` with where they came from and when, which you can commit so the whole team gets the coverage. From a terminal:
 
 ```bash
@@ -249,7 +281,7 @@ ripple unresolved                 # which tables still block coverage, worst fir
 ripple ingest-schema cols.csv     # no CLI? an information_schema.columns export works too
 ```
 
-An agent connected over MCP is told all of this when it connects: it calls `fetch_schema`, or, when Ripple cannot read the warehouse and the agent can, queries `information_schema.columns` itself and hands the names to `ingest_schema`.
+An agent connected over MCP is told all of this when it connects: it calls `fetch_schema` (on its own only when the sign-in cannot prompt; otherwise it asks you first), or, when Ripple cannot read the warehouse and the agent can, queries `information_schema.columns` itself and hands the names to `ingest_schema`.
 
 ## A file arrives from another team
 

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/README.md

@@ -96,6 +96,34 @@ default_tools_approval_mode = "approve"
 Then ask: *"what breaks if I change `orders.amount` to cents?"* If the client
 lists ripple but the tools do nothing, `ripple doctor` tells you why.
 
+On a big project a full answer can run to hundreds of thousands of
+characters, and clients cut or spill results long before that (Cline keeps
+8,000 characters, Codex cuts the middle at about 10,000 tokens, Claude Code
+writes anything over 50,000 to a file). So every tool result stays under
+8,000 characters by default. The counts, the verdict and `next` are never
+cut; long lists are, nearest hops or worst blockers first, and the result's
+`cut` field says how many it showed out of how many, with the exact call for
+the rest. `breaks`, `trace`, `check_file`, `model_columns`,
+`unresolved_tables`, `usage_summary` and `lineage_summary` take three extra
+arguments: `offset` (skip that many rows), `limit` (rows per page) and
+`detail` (`summary`, the default, or `full`). Asked for more, a result still
+stops at 24,000 characters. `page=true` on `breaks` and `trace` is the HTML
+answer page for a person, not paging.
+
+No tool call waits more than about 2 seconds. Claude Desktop, Codex and the
+Cursor CLI give up on a call after 60 seconds, and reading a 2,000-model
+project the first time takes longer than that. So the server starts reading
+the project the moment it starts, and a call that arrives before it is done
+answers at once with `building: true`, how many models are read, and when to
+ask again ("Ripple is reading the project, 712 of 1,908 models · ask again in
+about 30 s"). The disk cache makes a restart instant. `fetch_schema` and
+`ingest_schema` work the same way: a slow warehouse or rebuild answers
+"started" and the result lands in `lineage_summary` (`warehouse.fetching`,
+`warehouse.rebuilding`, then `warehouse.last_fetch` with what was saved and
+how many more models are fully analyzed). A client that sends a
+`progressToken` also gets progress notifications while a call waits.
+`RIPPLE_MCP_WAIT_S` changes the wait.
+
 ## Is it actually right?
 
 Most SQL lineage tools are confidently wrong, so Ripple ships a benchmark you can rerun instead of a claim you have to trust. Real public dbt projects, hand-verified column lineage, every tool scored by the same function. The corpus and the harness are both in this repo.
@@ -200,6 +228,10 @@ Your SQL probably reads tables defined outside the repo, and without their colum
 
 Ripple never stores, prompts for, or sends a credential, and never opens a connection of its own: it runs the CLI you already signed in to, with the connection you marked default (or the only one). It starts on its own only when signing in needs no browser; otherwise the page shows one button, "Fetch from Snowflake · prod". Several connections and no default: the page asks once and remembers the name in your cache, not in the repo. `RIPPLE_WAREHOUSE=off` turns it off.
 
+For a dbt project, Ripple learns the warehouse from `profiles.yml` the way dbt finds it: `DBT_PROFILES_DIR`, then your working directory, the project folder, `~/.dbt`, and folders like `profile/` in the repo. It picks the target from `DBT_TARGET` or the profile's `target:`, and reads only each target's `type`, never a password or token. An MCP server started by a desktop app does not see your shell's exports, so put `DBT_TARGET` or `DBT_PROFILES_DIR` in the server's `env` block when you need them, and any variable your sources read with `env_var()` (GitLab's sources name their database with `SNOWFLAKE_LOAD_DATABASE`, so its block carries `"SNOWFLAKE_LOAD_DATABASE": "RAW"`). Restart the server after changing it. `RIPPLE_DBT_HOME=off` stops it reading `~/.dbt`, and `--dialect` overrides all of it.
+
+What Ripple reports about your profile, in the CLI, the answer page and to an MCP client: the adapter type, the profile and target names, the other targets of that profile with their adapter types (so it can say "set DBT_TARGET=prod"), and the path of the one file it used (or, when it found none, the places it looked). It never reports other profile files on your machine. A `{{ env_var('X') }}` in `type`, `target` or `profile` is read only for `DBT_*` names and names ending in `_TARGET`, `_PROFILE`, `_TYPE`, `_ENV` and the like, never for a name that looks like a credential (`TOKEN`, `KEY`, `SECRET`, `PASSWORD`). A value from the environment is kept only when it names a known adapter, a target of that profile, or a profile a file has; otherwise Ripple names the variable and not its value.
+
 The columns land in `.ripple/schemas.json` with where they came from and when, which you can commit so the whole team gets the coverage. From a terminal:
 
 ```bash
@@ -208,7 +240,7 @@ ripple unresolved                 # which tables still block coverage, worst fir
 ripple ingest-schema cols.csv     # no CLI? an information_schema.columns export works too
 ```
 
-An agent connected over MCP is told all of this when it connects: it calls `fetch_schema`, or, when Ripple cannot read the warehouse and the agent can, queries `information_schema.columns` itself and hands the names to `ingest_schema`.
+An agent connected over MCP is told all of this when it connects: it calls `fetch_schema` (on its own only when the sign-in cannot prompt; otherwise it asks you first), or, when Ripple cannot read the warehouse and the agent can, queries `information_schema.columns` itself and hands the names to `ingest_schema`.
 
 ## A file arrives from another team
 

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ripple-sql"
-version = "0.1.18"
+version = "0.1.19"
 description = "Offline column-level SQL lineage. See what breaks before you merge."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -70,6 +70,9 @@ testpaths = ["tests"]
 # a hung test fails with its stack instead of running until the CI job limit
 timeout = 180
 timeout_method = "thread"
+markers = [
+    "asks_snow: lets the test run `snow connection list` (a fake on PATH, or the real one)",
+]
 
 [tool.ruff]
 line-length = 100

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/src/ripple/cache.py

@@ -16,7 +16,7 @@ import os
 import pickle
 from pathlib import Path
 
-from ripple.sourcefiles import stamp
+from ripple.sourcefiles import source_files, stamp
 
 logger = logging.getLogger(__name__)
 
@@ -44,10 +44,26 @@ def _fingerprint(root: Path, dialect: str | None) -> str:
             digest.update(f"{src.name}|{src.stat().st_mtime_ns}".encode())
     except OSError:
         pass
-    digest.update(stamp(root).encode())
+    digest.update(inputs_stamp(root, dialect).encode())
     return digest.hexdigest()
 
 
+def inputs_stamp(root: Path, dialect: str | None, skip: Path | None = None) -> str:
+    """What a graph was built from right now. The disk cache and the live
+    server both use it, so a change either notices, the other does too.
+    skip leaves one file out, to ask whether anything else changed."""
+    files = [f for f in source_files(root) if f != skip]
+    out = stamp(root, files)
+    if dialect is None:
+        # the dialect may come from ~/.dbt or DBT_TARGET, which no repo
+        # file stamps; --dialect users skip this so their key is unchanged
+        from ripple.loaders.dbt_profile import selection_key
+
+        keys = [selection_key(f.parent) for f in files if f.name == "dbt_project.yml"]
+        out += "|" + "|".join(keys)
+    return out
+
+
 def load(root: Path, dialect: str | None):
     path = _cache_dir() / f"graph-{_fingerprint(root, dialect)}.pickle"
     if not path.exists():

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/src/ripple/check_file/declared.py

@@ -11,6 +11,7 @@ import copy
 from pathlib import Path
 
 from ripple.check_file.readers import CannotCheck
+from ripple.loaders.yaml_text import safe_load
 
 # roots tuple -> (signature, declarations), one entry per roots tuple
 _CACHE: dict[tuple, tuple[tuple, list]] = {}
@@ -89,7 +90,7 @@ def _read(roots: list[Path]):
         own = root / "ripple.yml"
         if own.is_file():
             try:
-                parsed = yaml.safe_load(own.read_text(encoding="utf-8", errors="replace")) or {}
+                parsed = safe_load(own.read_text(encoding="utf-8", errors="replace")) or {}
             except yaml.YAMLError as e:
                 raise BrokenRippleYml(
                     f"ripple.yml is not valid yaml ({str(e).splitlines()[0]})"

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/src/ripple/graph.py

@@ -1319,11 +1319,13 @@ class LineageGraph:
 
     # ---- export ----
 
-    def stats(self) -> dict:
+    def failure_reasons(self) -> dict[str, str]:
+        """Every model that failed, fell back or timed out, with its error.
+        stats() keeps the first 20 for the CLI; MCP pages the whole list."""
         by_status = defaultdict(list)
         for report in self.reports.values():
             by_status[report.status].append(report.name)
-        failed = {
+        return {
             name: self.reports[name].error
             for name in [
                 *by_status.get("failed", []),
@@ -1331,6 +1333,12 @@ class LineageGraph:
                 *by_status.get("timed_out", []),
             ]
         }
+
+    def stats(self) -> dict:
+        by_status = defaultdict(list)
+        for report in self.reports.values():
+            by_status[report.status].append(report.name)
+        failed = self.failure_reasons()
         return {
             "mode": self.project.mode,
             "dialect": self.project.dialect,

{ripple_sql-0.1.18 → ripple_sql-0.1.19}/src/ripple/loaders/dbt.py

@@ -19,6 +19,13 @@ from ripple.loaders.dbt_config import (
     _project_vars,
     _seed_dirs,
 )
+from ripple.loaders.dbt_info_schema import (  # noqa: F401  tests and the cache import these from here
+    INFO_SCHEMA,
+    _manifest_from_info_schema,
+    _source_parts,
+    info_schema_files,
+)
+from ripple.loaders.dbt_profile import resolve_profile
 from ripple.loaders.types import (
     _REF_RE,
     _SOURCE_RE,
@@ -34,57 +41,6 @@ from ripple.loaders.types import (
 logger = logging.getLogger(__name__)
 
 
-def _profile_adapter(root: Path) -> str | None:
-    """The adapter dbt is configured to use, from profiles.yml beside the project.
-
-    dbt names the profile in dbt_project.yml and defines it in profiles.yml. That
-    is the project telling us its warehouse, and it was never read: every raw dbt
-    project was called snowflake regardless, so ClickHouse/dbt-clickhouse
-    reported snowflake without a word.
-
-    Only the project-local profiles.yml is read. ~/.dbt/profiles.yml belongs to
-    whoever is running the command, not to the repo, and reading a developer's
-    home directory to analyze a checkout would be a surprise.
-    """
-    path = root / "profiles.yml"
-    if not path.is_file():
-        return None
-    try:
-        import yaml
-
-        doc = yaml.safe_load(path.read_text(errors="replace", encoding="utf-8")) or {}
-    except Exception:
-        return None
-    if not isinstance(doc, dict):
-        return None
-    wanted = _project_profile_name(root)
-    for name, profile in doc.items():
-        if not isinstance(profile, dict) or (wanted and name != wanted):
-            continue
-        outputs = profile.get("outputs")
-        if not isinstance(outputs, dict) or not outputs:
-            continue
-        target = profile.get("target")
-        chosen = outputs.get(target) if target in outputs else next(iter(outputs.values()))
-        if isinstance(chosen, dict) and chosen.get("type"):
-            return str(chosen["type"]).lower()
-    return None
-
-
-def _project_profile_name(root: Path) -> str | None:
-    path = root / "dbt_project.yml"
-    if not path.is_file():
-        return None
-    try:
-        import yaml
-
-        doc = yaml.safe_load(path.read_text(errors="replace", encoding="utf-8")) or {}
-    except Exception:
-        return None
-    profile = doc.get("profile") if isinstance(doc, dict) else None
-    return str(profile) if profile else None
-
-
 def resolve_dbt_dialect(
     root: Path, dialect: str | None, sample: str = ""
 ) -> tuple[str, str | None]:
@@ -95,17 +51,30 @@ def resolve_dbt_dialect(
     does not say it guessed is the failure this exists to prevent: a wrong one
     costs whole models, and the reader has no way to know that is why.
     """
+    resolved, note, _ = _resolve_with_source(root, dialect, sample)
+    return resolved, note
+
+
+def _resolve_with_source(
+    root: Path, dialect: str | None, sample: str = ""
+) -> tuple[str, str | None, dict]:
+    """resolve_dbt_dialect plus where the answer came from (dbt_profile's
+    ProfileResolution as a dict), which the warehouse fetch reports."""
     if dialect:
-        return dialect, None
-    adapter = _profile_adapter(root)
+        return dialect, None, {"kind": "flag", "platform": dialect}
+    found = resolve_profile(root)
+    source = found.as_dict()
+    adapter = found.platform
     if adapter and adapter in ADAPTER_TO_DIALECT:
-        return ADAPTER_TO_DIALECT[adapter], None
+        return ADAPTER_TO_DIALECT[adapter], None, source
     if adapter:
         return (
             DEFAULT_DIALECT,
             f"dbt profile declares '{adapter}', which Ripple cannot parse; "
             f"guessed {DEFAULT_DIALECT}. Pass --dialect to override.",
+            source,
         )
+    why = f" ({found.reason})" if found.kind == "unusable" and found.reason else ""
     if sample:
         from ripple.engine.sql_script import sniff_dialect
 
@@ -113,13 +82,15 @@ def resolve_dbt_dialect(
         if sniffed:
             return (
                 sniffed,
-                f"No dbt profile or manifest declares a warehouse; the SQL reads as "
+                f"No dbt profile or manifest declares a warehouse{why}; the SQL reads as "
                 f"{sniffed}. Pass --dialect to override.",
+                source,
             )
     return (
         DEFAULT_DIALECT,
-        f"No dbt profile or manifest declares a warehouse; guessed "
+        f"No dbt profile or manifest declares a warehouse{why}; guessed "
         f"{DEFAULT_DIALECT}. Pass --dialect to override.",
+        source,
     )
 
 
@@ -162,135 +133,6 @@ def _load_one_dbt(project_dir: Path, dialect: str | None) -> Project:
     return project
 
 
-INFO_SCHEMA = Path("target") / "info_schema" / "v1"
-# dbt 2's Parquet tables that hold SQL nodes, and the resource type each row is
-NODE_TABLES = {"models": "model", "seeds": "seed", "snapshots": "snapshot"}
-SQL_PARENTS = ("model.", "source.", "seed.", "snapshot.")
-SQL_CHILDREN = ("model.", "snapshot.", "seed.")
-# the columns the reader uses, so a large project's raw and compiled SQL is
-# the only heavy thing read, once, and nothing else is materialised
-NODE_COLUMNS = (
-    "unique_id",
-    "name",
-    "resource_type",
-    "package_name",
-    "original_file_path",
-    "alias",
-    "raw_code",
-    "compiled_code",
-    "compiled_path",
-    "database_name",
-    "schema_name",
-    "relation_name",
-    "identifier",
-    "enabled",
-)
-EDGE_COLUMNS = ("parent_unique_id", "child_unique_id")
-PROJECT_COLUMNS = ("adapter_type", "dbt_version")
-INFO_SCHEMA_FILES = tuple(f"dbt.{t}.parquet" for t in (*NODE_TABLES, "sources", "edges", "project"))
-
-
-def info_schema_files(root: Path) -> list[Path]:
-    """The Parquet files the reader consumes, for whoever fingerprints the
-    project: a change to them must invalidate a cached graph."""
-    folder = root / INFO_SCHEMA
-    return [folder / name for name in INFO_SCHEMA_FILES if (folder / name).is_file()]
-
-
-def _source_parts(uid: str, package: str | None, name: str | None) -> tuple[str, str]:
-    """(source_name, table_name) from a source unique_id, which is
-    source.<package>.<source_name>.<table>. A source or table name may hold
-    a dot, so the table is taken from the row's own name and the source is
-    what sits between the package and it, never a fixed position."""
-    parts = uid.split(".")
-    if len(parts) < 4 or parts[0] != "source":
-        return "", ""
-    prefix = f"source.{package}." if package else ""
-    rest = uid[len(prefix) :] if prefix and uid.startswith(prefix) else ".".join(parts[2:])
-    if name and rest.endswith(f".{name}") and len(rest) > len(name) + 1:
-        return rest[: -len(name) - 1], name
-    return parts[-2], name or parts[-1]
-
-
-def _manifest_from_info_schema(root: Path) -> tuple[dict | None, str | None]:
-    """dbt 2's Parquet information schema (target/info_schema/v1/, written by
-    --generate-info-schema) folded into the manifest shape the manifest
-    reader takes, so one reader serves both artifacts. A team that turns
-    manifest.json off with --no-write-json still gets compiled lineage.
-    (manifest, note): the note says why the folder could not be used."""
-    folder = root / INFO_SCHEMA
-    node_files = [folder / f"dbt.{t}.parquet" for t in (*NODE_TABLES, "sources")]
-    if not any(f.is_file() for f in node_files):
-        return None, None
-    try:
-        import pyarrow.parquet as pq
-    except ImportError:
-        return None, (
-            "target/info_schema found (dbt 2's Parquet artifacts) but pyarrow is not installed; "
-            "pip install pyarrow to read it. Reading raw model SQL instead."
-        )
-
-    def rows(name: str, wanted: tuple[str, ...]) -> list[dict]:
-        path = folder / f"dbt.{name}.parquet"
-        if not path.is_file():
-            return []
-        have = set(pq.read_schema(path).names)
-        return pq.read_table(path, columns=[c for c in wanted if c in have]).to_pylist()
-
-    try:
-        project = (rows("project", PROJECT_COLUMNS) or [{}])[0]
-        parents: dict[str, list[str]] = {}
-        for edge in rows("edges", EDGE_COLUMNS):
-            parent, child = edge.get("parent_unique_id") or "", edge.get("child_unique_id") or ""
-            if child.startswith(SQL_CHILDREN) and parent.startswith(SQL_PARENTS):
-                parents.setdefault(child, []).append(parent)
-        nodes: dict[str, dict] = {}
-        for table, kind in NODE_TABLES.items():
-            for row in rows(table, NODE_COLUMNS):
-                uid = row.get("unique_id") or ""
-                if not uid or str(row.get("enabled", "True")).lower() == "false":
-                    continue
-                nodes[uid] = {
-                    "resource_type": row.get("resource_type") or kind,
-                    "name": row.get("name") or uid,
-                    "alias": row.get("alias"),
-                    "compiled_code": row.get("compiled_code") or "",
-                    "compiled_path": row.get("compiled_path") or "",
-                    "raw_code": row.get("raw_code") or "",
-                    "database": row.get("database_name"),
-                    "schema": row.get("schema_name"),
-                    "relation_name": row.get("relation_name"),
-                    "original_file_path": row.get("original_file_path") or "",
-                    "package_name": row.get("package_name"),
-                    "depends_on": {"nodes": parents.get(uid, [])},
-                }
-        sources: dict[str, dict] = {}
-        for row in rows("sources", NODE_COLUMNS):
-            uid = row.get("unique_id") or ""
-            source_name, table_name = _source_parts(uid, row.get("package_name"), row.get("name"))
-            if not source_name:
-                continue
-            sources[uid] = {
-                "source_name": source_name,
-                "name": table_name,
-                "database": row.get("database_name"),
-                "schema": row.get("schema_name"),
-                "identifier": row.get("identifier"),
-                "relation_name": row.get("relation_name"),
-            }
-    except (
-        Exception
-    ) as e:  # pyarrow raises its own hierarchy; a broken artifact is a note, not a crash
-        return None, f"target/info_schema could not be read ({e}); reading raw model SQL instead."
-    metadata = {
-        "adapter_type": project.get("adapter_type"),
-        "dbt_version": project.get("dbt_version"),
-        "dbt_schema_version": "https://schemas.getdbt.com/dbt/info_schema/v1",
-        "artifact": "info_schema",
-    }
-    return {"metadata": metadata, "nodes": nodes, "sources": sources}, None
-
-
 def _find_manifest(root: Path) -> dict | None:
     candidate = root / "target" / "manifest.json"
     if not candidate.exists():
@@ -364,12 +206,15 @@ def _compiled_on_disk(root: Path, node: dict, inputs_mtime: float) -> str:
 def _load_from_manifest(root: Path, manifest: dict, dialect: str | None) -> Project:
     metadata = manifest.get("metadata", {})
     adapter = (metadata.get("adapter_type") or "").lower()
-    resolved_dialect = dialect or ADAPTER_TO_DIALECT.get(adapter, "snowflake")
+    resolved_dialect = dialect or ADAPTER_TO_DIALECT.get(adapter, DEFAULT_DIALECT)
     warnings: list[str] = []
-    if not dialect and adapter not in ADAPTER_TO_DIALECT:
+    assumed = not dialect and adapter not in ADAPTER_TO_DIALECT
+    if assumed:
         warnings.append(
-            f"Unknown adapter '{adapter}', assuming snowflake. Pass --dialect to override."
+            f"Unknown adapter '{adapter}', assuming {DEFAULT_DIALECT}. Pass --dialect to override."
         )
+    source = {"kind": "flag", "platform": dialect} if dialect else {"kind": "manifest"}
+    source.setdefault("platform", adapter or None)
 
     models: list[Model] = []
     inputs_mtime: float | None = None  # the macro walk runs once, and only when a row needs it
@@ -436,6 +281,8 @@ def _load_from_manifest(root: Path, manifest: dict, dialect: str | None) -> Proj
         models=models,
         sources=sources,
         warnings=warnings,
+        dialect_assumed=assumed,
+        dialect_source=source,
         jinja_vars=_project_vars(root),
     )
 
@@ -453,9 +300,11 @@ def _load_dbt_raw(root: Path, dialect: str | None) -> Project:
     sample = "\n".join(p.read_text(errors="replace", encoding="utf-8")[:4000] for _, p in pairs)[
         :200000
     ]
-    resolved_dialect, dialect_note = resolve_dbt_dialect(root, dialect, sample)
+    resolved_dialect, dialect_note, dialect_source = _resolve_with_source(root, dialect, sample)
     if dialect_note:
         warnings.append(dialect_note)
+    if dialect_source.get("note"):
+        warnings.append(dialect_source["note"])
     project_vars = _project_vars(root)
     enabled_rules = _enabled_overrides(root, resolved_dialect, project_vars)
     models: list[Model] = []
@@ -541,6 +390,7 @@ def _load_dbt_raw(root: Path, dialect: str | None) -> Project:
         dialect=resolved_dialect,
         mode="dbt-raw",
         dialect_assumed=dialect_note is not None,
+        dialect_source=dialect_source,
         models=models,
         sources=sources,
         warnings=warnings,