tff-dbt 0.2.0__tar.gz

tff_dbt-0.2.0/.gitignore

@@ -0,0 +1,10 @@
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+.cache/
+.coverage
+coverage.xml

tff_dbt-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bart Schuijt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tff_dbt-0.2.0/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: tff-dbt
+Version: 0.2.0
+Summary: dbt adapter for Transformation Fitness Functions (tff)
+Author-email: Bart Schuijt <schuijt.bart@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: tff-core
+Description-Content-Type: text/markdown
+
+# sqlmesh-ff
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlmesh-ff.svg)](https://pypi.org/project/sqlmesh-ff/)
+[![Python versions](https://img.shields.io/pypi/pyversions/sqlmesh-ff.svg)](https://pypi.org/project/sqlmesh-ff/)
+
+Configurable fitness functions plugin for [SQLMesh](https://sqlmesh.com) projects.
+
+Ships SQLMesh linter rules (classification macros, SQL complexity, metadata, naming) and architectural checks (layer integrity, custom exclusions, schema contracts, dependency graph) with a unified Rich lint report.
+
+## Installation
+
+```bash
+# Install from PyPI:
+uv add sqlmesh-ff
+
+# Or using pip:
+pip install sqlmesh-ff
+```
+
+## Quick start
+
+1. Add `fitness_functions.yaml` to your SQLMesh project root (see [Configuration](#configuration)).
+2. Add a small `config.py` bootstrap (see [Where configuration lives](#where-configuration-lives)) — SQLMesh requires the loader as a Python class and cannot load `config.py` and `config.yaml` in the same folder.
+3. Run lint:
+
+```bash
+sqlmesh-ff lint
+```
+
+## Where configuration lives
+
+There are three layers. Only the YAML/JSON files in your project are user-editable settings.
+
+| Layer | File | Role | You edit this? |
+|-------|------|------|----------------|
+| Plugin defaults | `sqlmesh_ff/config.py` (installed package) | Pydantic schema and built-in defaults (e.g. `fan_out_warn: 15`) | No — library code, never overwritten |
+| SQLMesh project | `settings.yaml` | Gateways, `linter.rules`, variables, CI/CD bot | Yes — normal SQLMesh config |
+| Fitness functions | `fitness_functions.yaml` | Thresholds, rule toggles, column naming/type rules, paths to JSON data | Yes — main FF config |
+| Loader bootstrap | `config.py` (project root) | Loads `settings.yaml` and registers `FitnessLoader` | Rarely — ~15 lines of wiring |
+| Contract data | `linter_contract_groups.json`, `linter_exclusions.json` | Repo-specific schema parity and dependency exclusions | Yes — project data |
+
+**Merge order for fitness settings:** plugin defaults → `fitness_functions.yaml` → optional `loader_kwargs` overrides in `config.py`. Your YAML always wins over plugin defaults. The project `config.py` does not hold fitness thresholds — it only points at `fitness_functions.yaml`.
+
+**Why `config.py` exists:** SQLMesh accepts `loader: FitnessLoader` only as a Python class, not as a YAML string. Because SQLMesh rejects having both `config.py` and `config.yaml` in one folder, projects use `settings.yaml` (SQLMesh settings) plus `config.py` (loader registration).
+
+Example bootstrap:
+
+```python
+from pathlib import Path
+
+from sqlmesh.core.config import Config
+from sqlmesh.utils.yaml import load as yaml_load
+from sqlmesh_ff.loader import FitnessLoader
+
+_settings = yaml_load(Path(__file__).parent / "settings.yaml")
+config = Config.parse_obj(_settings).update_with({
+    "loader": FitnessLoader,
+    "loader_kwargs": {"fitness_functions_config": "fitness_functions.yaml"},
+})
+```
+
+Enable individual SQLMesh rules in `settings.yaml` under `linter.rules` / `linter.warn_rules`.
+
+## Configuration
+
+Fitness function settings live in `fitness_functions.yaml` at the project root. Override the file path or individual keys via `loader_kwargs` in `config.py` (advanced — most projects only set `fitness_functions_config`).
+
+### Example `fitness_functions.yaml`
+
+```yaml
+contract_groups_path: linter_contract_groups.json
+exclusions_path: linter_exclusions.json
+
+layers:
+  order: [sources, derived, core, marts, export]
+
+checks:
+  layer_integrity: { enabled: true }
+  custom_exclusions: { enabled: true }
+  schema_contracts: { enabled: true }
+  dependency_graph:
+    enabled: true
+    fan_out_warn: 15
+    fan_out_fail: 25
+    fan_in_warn: 10
+
+rules:
+  classification_macros:
+    enabled: true
+    skip_layers: [sources]
+    columns:
+      product_type: "@product_type\\b|@PRODUCT_TYPE\\b"
+  sql_complexity:
+    enabled: true
+    thresholds:
+      decision_points: [15, 25]
+      cte_count: [8, 12]
+      join_count: [8, 12]
+      line_count: [250, 400]
+  mart_naming:
+    enabled: true
+    layer_name: marts
+    rule: prefix_with_subdirectory
+  column_names:
+    enabled: true
+    replacements: {}
+  column_types:
+    enabled: true
+    rules: []
+    equivalent_types:
+      text: [text, varchar]
+  metadata:
+    owner: true
+    description: true
+    grain: true
+  filename_equals_modelname:
+    enabled: true
+```
+
+### Project-specific JSON
+
+Keep repo-specific contract and exclusion data in your project:
+
+- `linter_contract_groups.json` — cross-model schema parity groups
+- `linter_exclusions.json` — blocked dependency patterns and allowed exceptions
+
+Reference their paths from `fitness_functions.yaml`. The plugin ships generic engines only; examples live in this README.
+
+### Rule name mapping
+
+SQLMesh uses lowercase class names in `linter.rules`:
+
+| Config key | SQLMesh rule name |
+|------------|-------------------|
+| `classification_macros` | `classificationmacros` |
+| `sql_complexity` | `sqlcomplexity` |
+| `mart_naming` | `martmodelnamingconvention` |
+| `column_names` | `columnnames` |
+| `column_types` | `columntypes` |
+| `metadata.owner` | `nomissingowner` |
+| `metadata.description` | `nomissingdescription` |
+| `metadata.grain` | `nomissinggrain` |
+| `filename_equals_modelname` | `filenameequalsmodelname` |
+
+## CLI
+
+```
+sqlmesh-ff lint [--project PATH] [--config PATH] [--checks CHECK,...] [--fail-level error|warning] [--group-by connascence|model]
+```
+
+- **Default:** all enabled checks plus SQLMesh linter rules
+- **`--checks layer_integrity,custom_exclusions`:** run subset (for pre-push hooks)
+- **`--fail-level warning`:** treat warnings as failures
+- **`--group-by connascence|model`:** change how violations are grouped in the report (default: `connascence`)
+
+## Integration example
+
+Example overrides. `api_request` should always be named `api_call`. `_id` columns should always be of type `text` and `is_` columns should always be of type `boolean`.
+
+```yaml
+column_names:
+  replacements:
+    api_request: api_call
+column_types:
+  rules:
+    - name: id_is_text
+      pattern: "_id$"
+      data_type: text
+    - name: boolean
+      pattern: "^is_"
+      data_type: boolean
+```
+
+## Examples
+
+A complete, runnable example project showcasing the configuration of `sqlmesh-ff` rules, exclusions, contracts, and a continuous integration workflow is located in the [examples/](file:///Users/bartschuijt/git/sqlmesh-ff/examples/) directory.
+
+To run the linter against the example project locally, run:
+```bash
+sqlmesh-ff lint --project examples/minimal-sqlmesh-project
+```
+
+See [examples/minimal-sqlmesh-project/fitness_functions.yaml](file:///Users/bartschuijt/git/sqlmesh-ff/examples/minimal-sqlmesh-project/fitness_functions.yaml) to inspect the configured rules.
+
+## Development
+
+Initialize your local environment and configure the Git pre-push hook:
+```bash
+make init
+```
+
+Run linter, tests, or check diff coverage:
+```bash
+make lint
+make test
+make coverage
+```
+
+### Releases and PR titles
+
+Releases are automated with [release-please](https://github.com/googleapis/release-please) on merges to `main`. Use [Conventional Commits](https://www.conventionalcommits.org/) in PR titles so changelog entries and semver bumps are correct.
+
+PR titles must start with a type prefix, for example:
+
+- `feat: add dependency graph fan-in check`
+- `fix: remove unused import in loader tests`
+- `docs: document fitness_functions.yaml merge order`
+- `ci: add release-please workflow`
+
+Supported types include `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, and `chore`. The PR title check in CI enforces this format.

tff_dbt-0.2.0/README.md

@@ -0,0 +1,210 @@
+# sqlmesh-ff
+
+[![PyPI version](https://img.shields.io/pypi/v/sqlmesh-ff.svg)](https://pypi.org/project/sqlmesh-ff/)
+[![Python versions](https://img.shields.io/pypi/pyversions/sqlmesh-ff.svg)](https://pypi.org/project/sqlmesh-ff/)
+
+Configurable fitness functions plugin for [SQLMesh](https://sqlmesh.com) projects.
+
+Ships SQLMesh linter rules (classification macros, SQL complexity, metadata, naming) and architectural checks (layer integrity, custom exclusions, schema contracts, dependency graph) with a unified Rich lint report.
+
+## Installation
+
+```bash
+# Install from PyPI:
+uv add sqlmesh-ff
+
+# Or using pip:
+pip install sqlmesh-ff
+```
+
+## Quick start
+
+1. Add `fitness_functions.yaml` to your SQLMesh project root (see [Configuration](#configuration)).
+2. Add a small `config.py` bootstrap (see [Where configuration lives](#where-configuration-lives)) — SQLMesh requires the loader as a Python class and cannot load `config.py` and `config.yaml` in the same folder.
+3. Run lint:
+
+```bash
+sqlmesh-ff lint
+```
+
+## Where configuration lives
+
+There are three layers. Only the YAML/JSON files in your project are user-editable settings.
+
+| Layer | File | Role | You edit this? |
+|-------|------|------|----------------|
+| Plugin defaults | `sqlmesh_ff/config.py` (installed package) | Pydantic schema and built-in defaults (e.g. `fan_out_warn: 15`) | No — library code, never overwritten |
+| SQLMesh project | `settings.yaml` | Gateways, `linter.rules`, variables, CI/CD bot | Yes — normal SQLMesh config |
+| Fitness functions | `fitness_functions.yaml` | Thresholds, rule toggles, column naming/type rules, paths to JSON data | Yes — main FF config |
+| Loader bootstrap | `config.py` (project root) | Loads `settings.yaml` and registers `FitnessLoader` | Rarely — ~15 lines of wiring |
+| Contract data | `linter_contract_groups.json`, `linter_exclusions.json` | Repo-specific schema parity and dependency exclusions | Yes — project data |
+
+**Merge order for fitness settings:** plugin defaults → `fitness_functions.yaml` → optional `loader_kwargs` overrides in `config.py`. Your YAML always wins over plugin defaults. The project `config.py` does not hold fitness thresholds — it only points at `fitness_functions.yaml`.
+
+**Why `config.py` exists:** SQLMesh accepts `loader: FitnessLoader` only as a Python class, not as a YAML string. Because SQLMesh rejects having both `config.py` and `config.yaml` in one folder, projects use `settings.yaml` (SQLMesh settings) plus `config.py` (loader registration).
+
+Example bootstrap:
+
+```python
+from pathlib import Path
+
+from sqlmesh.core.config import Config
+from sqlmesh.utils.yaml import load as yaml_load
+from sqlmesh_ff.loader import FitnessLoader
+
+_settings = yaml_load(Path(__file__).parent / "settings.yaml")
+config = Config.parse_obj(_settings).update_with({
+    "loader": FitnessLoader,
+    "loader_kwargs": {"fitness_functions_config": "fitness_functions.yaml"},
+})
+```
+
+Enable individual SQLMesh rules in `settings.yaml` under `linter.rules` / `linter.warn_rules`.
+
+## Configuration
+
+Fitness function settings live in `fitness_functions.yaml` at the project root. Override the file path or individual keys via `loader_kwargs` in `config.py` (advanced — most projects only set `fitness_functions_config`).
+
+### Example `fitness_functions.yaml`
+
+```yaml
+contract_groups_path: linter_contract_groups.json
+exclusions_path: linter_exclusions.json
+
+layers:
+  order: [sources, derived, core, marts, export]
+
+checks:
+  layer_integrity: { enabled: true }
+  custom_exclusions: { enabled: true }
+  schema_contracts: { enabled: true }
+  dependency_graph:
+    enabled: true
+    fan_out_warn: 15
+    fan_out_fail: 25
+    fan_in_warn: 10
+
+rules:
+  classification_macros:
+    enabled: true
+    skip_layers: [sources]
+    columns:
+      product_type: "@product_type\\b|@PRODUCT_TYPE\\b"
+  sql_complexity:
+    enabled: true
+    thresholds:
+      decision_points: [15, 25]
+      cte_count: [8, 12]
+      join_count: [8, 12]
+      line_count: [250, 400]
+  mart_naming:
+    enabled: true
+    layer_name: marts
+    rule: prefix_with_subdirectory
+  column_names:
+    enabled: true
+    replacements: {}
+  column_types:
+    enabled: true
+    rules: []
+    equivalent_types:
+      text: [text, varchar]
+  metadata:
+    owner: true
+    description: true
+    grain: true
+  filename_equals_modelname:
+    enabled: true
+```
+
+### Project-specific JSON
+
+Keep repo-specific contract and exclusion data in your project:
+
+- `linter_contract_groups.json` — cross-model schema parity groups
+- `linter_exclusions.json` — blocked dependency patterns and allowed exceptions
+
+Reference their paths from `fitness_functions.yaml`. The plugin ships generic engines only; examples live in this README.
+
+### Rule name mapping
+
+SQLMesh uses lowercase class names in `linter.rules`:
+
+| Config key | SQLMesh rule name |
+|------------|-------------------|
+| `classification_macros` | `classificationmacros` |
+| `sql_complexity` | `sqlcomplexity` |
+| `mart_naming` | `martmodelnamingconvention` |
+| `column_names` | `columnnames` |
+| `column_types` | `columntypes` |
+| `metadata.owner` | `nomissingowner` |
+| `metadata.description` | `nomissingdescription` |
+| `metadata.grain` | `nomissinggrain` |
+| `filename_equals_modelname` | `filenameequalsmodelname` |
+
+## CLI
+
+```
+sqlmesh-ff lint [--project PATH] [--config PATH] [--checks CHECK,...] [--fail-level error|warning] [--group-by connascence|model]
+```
+
+- **Default:** all enabled checks plus SQLMesh linter rules
+- **`--checks layer_integrity,custom_exclusions`:** run subset (for pre-push hooks)
+- **`--fail-level warning`:** treat warnings as failures
+- **`--group-by connascence|model`:** change how violations are grouped in the report (default: `connascence`)
+
+## Integration example
+
+Example overrides. `api_request` should always be named `api_call`. `_id` columns should always be of type `text` and `is_` columns should always be of type `boolean`.
+
+```yaml
+column_names:
+  replacements:
+    api_request: api_call
+column_types:
+  rules:
+    - name: id_is_text
+      pattern: "_id$"
+      data_type: text
+    - name: boolean
+      pattern: "^is_"
+      data_type: boolean
+```
+
+## Examples
+
+A complete, runnable example project showcasing the configuration of `sqlmesh-ff` rules, exclusions, contracts, and a continuous integration workflow is located in the [examples/](file:///Users/bartschuijt/git/sqlmesh-ff/examples/) directory.
+
+To run the linter against the example project locally, run:
+```bash
+sqlmesh-ff lint --project examples/minimal-sqlmesh-project
+```
+
+See [examples/minimal-sqlmesh-project/fitness_functions.yaml](file:///Users/bartschuijt/git/sqlmesh-ff/examples/minimal-sqlmesh-project/fitness_functions.yaml) to inspect the configured rules.
+
+## Development
+
+Initialize your local environment and configure the Git pre-push hook:
+```bash
+make init
+```
+
+Run linter, tests, or check diff coverage:
+```bash
+make lint
+make test
+make coverage
+```
+
+### Releases and PR titles
+
+Releases are automated with [release-please](https://github.com/googleapis/release-please) on merges to `main`. Use [Conventional Commits](https://www.conventionalcommits.org/) in PR titles so changelog entries and semver bumps are correct.
+
+PR titles must start with a type prefix, for example:
+
+- `feat: add dependency graph fan-in check`
+- `fix: remove unused import in loader tests`
+- `docs: document fitness_functions.yaml merge order`
+- `ci: add release-please workflow`
+
+Supported types include `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, and `chore`. The PR title check in CI enforces this format.

tff_dbt-0.2.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "tff-dbt"
+version = "0.2.0"
+description = "dbt adapter for Transformation Fitness Functions (tff)"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Bart Schuijt", email = "schuijt.bart@gmail.com" }
+]
+dependencies = [
+    "tff-core",
+]
+
+[project.scripts]
+tff-dbt = "tff.dbt.cli:main"
+
+[tool.uv.sources]
+tff-core = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tff"]

tff_dbt-0.2.0/src/tff/dbt/__init__.py

@@ -0,0 +1,9 @@
+"""dbt adapter for Transformation Fitness Functions (tff)."""
+
+from tff.dbt.manifest import load_dbt_models
+from tff.dbt.runner import run_all_checks
+
+__all__ = [
+    "load_dbt_models",
+    "run_all_checks",
+]

tff_dbt-0.2.0/src/tff/dbt/cli.py

@@ -0,0 +1,96 @@
+"""Command-line interface for tff-dbt."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from tff.core.config import load_fitness_config
+from tff.core.context import set_ff_config
+from tff.core.report import render_lint_report
+from tff.dbt.runner import run_all_checks
+
+
+def _parse_checks(value: str | None) -> list[str] | None:
+    if not value:
+        return None
+    return [part.strip() for part in value.split(",") if part.strip()]
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="tff-dbt",
+        description="Run dbt Transformation Fitness Function (tff) checks",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    lint_parser = subparsers.add_parser("lint", help="Run all enabled fitness checks")
+    lint_parser.add_argument(
+        "--project",
+        type=Path,
+        default=Path.cwd(),
+        help="dbt project root (default: current directory)",
+    )
+    lint_parser.add_argument(
+        "--config",
+        default="fitness_functions.yaml",
+        help="Path to fitness_functions.yaml (relative to project root)",
+    )
+    lint_parser.add_argument(
+        "--checks",
+        default=None,
+        help="Comma-separated checks to run (default: all enabled). "
+        "Use 'rules' for general linter rules only.",
+    )
+    lint_parser.add_argument(
+        "--fail-level",
+        choices=["error", "warning"],
+        default="error",
+        help="Exit non-zero when findings at or above this severity exist",
+    )
+    lint_parser.add_argument(
+        "--group-by",
+        choices=["connascence", "model"],
+        default="connascence",
+        help="How to group violations in the report (default: connascence)",
+    )
+    lint_parser.add_argument(
+        "--dialect",
+        default="bigquery",
+        help="SQL dialect of the dbt models (default: bigquery)",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.command == "lint":
+        logging.basicConfig(level=logging.ERROR)
+        project_root = args.project.resolve()
+        config = load_fitness_config(
+            project_root,
+            config_path=args.config,
+        )
+        set_ff_config(config)
+        checks = _parse_checks(args.checks)
+
+        findings, models_checked, executed_checks = run_all_checks(
+            project_root=project_root,
+            config=config,
+            checks=checks,
+            dialect=args.dialect,
+        )
+        passed = render_lint_report(
+            findings,
+            models_checked=models_checked,
+            executed_checks=executed_checks,
+            fail_level=args.fail_level,  # type: ignore[arg-type]
+            group_by=args.group_by,  # type: ignore[arg-type]
+        )
+        return 0 if passed else 1
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tff_dbt-0.2.0/src/tff/dbt/manifest.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from tff.core.model import ModelRepresentation
+
+
+def load_dbt_models(
+    project_root: Path,
+    target_dir: str = "target",
+    dialect: str = "bigquery",
+) -> dict[str, ModelRepresentation]:
+    manifest_path = project_root / target_dir / "manifest.json"
+    if not manifest_path.exists():
+        raise FileNotFoundError(
+            f"dbt manifest not found at {manifest_path}. Please run 'dbt compile' first."
+        )
+
+    with open(manifest_path, encoding="utf-8") as f:
+        manifest = json.load(f)
+
+    # 1. Collect tests by model unique ID
+    model_tests: dict[str, list[tuple[str, dict]]] = {}
+    for unique_id, node in manifest.get("nodes", {}).items():
+        if node.get("resource_type") == "test":
+            test_metadata = node.get("test_metadata", {})
+            test_name = test_metadata.get("name")
+            if not test_name:
+                continue
+
+            depends_on_nodes = node.get("depends_on", {}).get("nodes", [])
+            for dep in depends_on_nodes:
+                if dep.startswith("model.") or dep.startswith("seed."):
+                    if dep not in model_tests:
+                        model_tests[dep] = []
+                    model_tests[dep].append((test_name, test_metadata.get("kwargs", {})))
+
+    # 2. Map nodes of type 'model' and 'seed' to ModelRepresentation
+    mapped_models: dict[str, ModelRepresentation] = {}
+    for unique_id, node in manifest.get("nodes", {}).items():
+        resource_type = node.get("resource_type")
+        if resource_type not in ("model", "seed"):
+            continue
+
+        name = node.get("name", "")
+
+        # Map column types
+        columns_to_types = {}
+        for col_name, col_meta in node.get("columns", {}).items():
+            col_type = col_meta.get("data_type") or "unknown"
+            columns_to_types[col_name.lower()] = col_type.lower()
+
+        # Metadata parsing
+        meta = node.get("meta", {})
+        owner = meta.get("owner") or node.get("config", {}).get("meta", {}).get("owner")
+
+        grains_raw = meta.get("grain") or meta.get("grains") or []
+        if isinstance(grains_raw, str):
+            grains = [grains_raw]
+        elif isinstance(grains_raw, list):
+            grains = [str(g) for g in grains_raw]
+        else:
+            grains = []
+
+        # Dependencies
+        depends_on = set(node.get("depends_on", {}).get("nodes", []))
+        depends_on = {
+            dep
+            for dep in depends_on
+            if dep.startswith("model.") or dep.startswith("seed.") or dep.startswith("source.")
+        }
+
+        # Ephemeral models behave like symbolic models
+        is_symbolic = node.get("config", {}).get("materialized") == "ephemeral"
+
+        rel_path = node.get("original_file_path", "")
+        abs_path = str(project_root / rel_path)
+
+        audits = model_tests.get(unique_id, [])
+
+        mapped_models[unique_id] = ModelRepresentation(
+            name=name,
+            path=abs_path,
+            dialect=dialect,
+            is_symbolic=is_symbolic,
+            is_external=False,
+            columns_to_types=columns_to_types,
+            depends_on=depends_on,
+            description=node.get("description"),
+            owner=owner,
+            grains=grains,
+            audits=audits,
+        )
+
+    # 3. Map sources to ModelRepresentation so graph checks resolve them
+    for source_id, source in manifest.get("sources", {}).items():
+        name = source.get("name", "")
+        rel_path = source.get("original_file_path", "")
+        abs_path = str(project_root / rel_path)
+
+        mapped_models[source_id] = ModelRepresentation(
+            name=name,
+            path=abs_path,
+            dialect=dialect,
+            is_symbolic=True,
+            is_external=True,
+            columns_to_types={},
+            depends_on=set(),
+            description=source.get("description"),
+            owner=source.get("meta", {}).get("owner"),
+            grains=[],
+            audits=[],
+        )
+
+    return mapped_models

tff_dbt-0.2.0/src/tff/dbt/runner.py

@@ -0,0 +1,103 @@
+"""Orchestrator runner executing tff-core rules and checks against dbt manifest models."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from tff.core.checks.custom_exclusions import collect_custom_exclusion_findings
+from tff.core.checks.dependency_graph import collect_dependency_graph_findings
+from tff.core.checks.layer_integrity import collect_layer_integrity_findings
+from tff.core.checks.schema_contracts import collect_schema_contract_findings
+from tff.core.config import FitnessFunctionsConfig, load_fitness_config
+from tff.core.context import set_ff_config
+from tff.core.report import LintFinding
+from tff.core.rules import ALL_RULES
+from tff.core.utils.paths import model_path_relative
+from tff.core.model import ModelRepresentation
+from tff.dbt.manifest import load_dbt_models
+
+logger = logging.getLogger(__name__)
+
+CHECK_COLLECTORS = {
+    "layer_integrity": lambda models, cfg: collect_layer_integrity_findings(models, cfg),
+    "custom_exclusions": lambda models, cfg: collect_custom_exclusion_findings(models, cfg),
+    "schema_contracts": lambda _models, cfg: collect_schema_contract_findings(cfg),
+    "dependency_graph": lambda models, cfg: collect_dependency_graph_findings(models, cfg),
+}
+
+
+def collect_dbt_rules_findings(models: dict[str, ModelRepresentation]) -> list[LintFinding]:
+    findings = []
+    rules = [rule_cls() for rule_cls in ALL_RULES]
+
+    for model in models.values():
+        if model.is_external or model.is_symbolic:
+            continue
+
+        for rule in rules:
+            violation = rule.check_model(model)
+            if violation:
+                msgs = violation.violation_msg
+                if isinstance(msgs, str):
+                    msgs = [msgs]
+                for msg in msgs:
+                    # Strip model name prefix from message if the rule prepended it
+                    model_label = f"{model.name}: "
+                    clean_msg = msg.removeprefix(model_label)
+
+                    findings.append(
+                        LintFinding(
+                            check=rule.name,
+                            severity="error",
+                            model=model.name,
+                            path=model_path_relative(model),
+                            message=clean_msg,
+                        )
+                    )
+    return findings
+
+
+def _check_enabled(config: FitnessFunctionsConfig, check_name: str) -> bool:
+    check = getattr(config.checks, check_name, None)
+    return bool(getattr(check, "enabled", False))
+
+
+def run_all_checks(
+    project_root: Path | None = None,
+    config: FitnessFunctionsConfig | None = None,
+    checks: list[str] | None = None,
+    dialect: str = "bigquery",
+) -> tuple[list[LintFinding], int, list[str]]:
+    project_root = project_root or Path.cwd()
+    if config is None:
+        config = load_fitness_config(project_root)
+    set_ff_config(config)
+
+    # Parse and load manifest.json
+    models = load_dbt_models(project_root, dialect=dialect)
+
+    if checks is None:
+        selected = ["rules"] + [
+            name
+            for name in CHECK_COLLECTORS
+            if _check_enabled(config, name)
+        ]
+    else:
+        selected = checks
+
+    findings: list[LintFinding] = []
+
+    if "rules" in selected:
+        findings.extend(collect_dbt_rules_findings(models))
+
+    for check_name, collector in CHECK_COLLECTORS.items():
+        if check_name not in selected:
+            continue
+        findings.extend(collector(models, config))
+
+    models_checked = sum(
+        1 for m in models.values() if not m.is_external and not m.is_symbolic
+    )
+
+    return findings, models_checked, selected

tff_dbt-0.2.0/tests/test_dbt.py

@@ -0,0 +1,176 @@
+import json
+from pathlib import Path
+
+from tff.dbt.manifest import load_dbt_models
+from tff.dbt.runner import run_all_checks
+from tff.core.config import FitnessFunctionsConfig
+
+
+def test_load_dbt_models(tmp_path: Path):
+    target_dir = tmp_path / "target"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    manifest_file = target_dir / "manifest.json"
+
+    # Mock a simple manifest.json structure
+    manifest_data = {
+        "nodes": {
+            "model.my_project.stg_users": {
+                "resource_type": "model",
+                "name": "stg_users",
+                "original_file_path": "models/staging/stg_users.sql",
+                "columns": {
+                    "id": {"data_type": "INT"},
+                    "name": {"data_type": "VARCHAR"},
+                },
+                "config": {
+                    "materialized": "view",
+                },
+                "meta": {
+                    "owner": "data-team",
+                    "grain": "user_id", # string grain
+                },
+                "description": "Staging table for users",
+                "depends_on": {
+                    "nodes": ["source.my_project.raw_users"]
+                }
+            },
+            "model.my_project.invalid_grain": {
+                "resource_type": "model",
+                "name": "invalid_grain",
+                "original_file_path": "models/staging/invalid_grain.sql",
+                "columns": {},
+                "meta": {
+                    "grain": 123, # invalid grain type (neither list nor str)
+                },
+                "depends_on": {"nodes": []}
+            },
+            "test.my_project.not_null_stg_users_id": {
+                "resource_type": "test",
+                "name": "not_null_stg_users_id",
+                "test_metadata": {
+                    "name": "not_null",
+                    "kwargs": {"column_name": "id"}
+                },
+                "depends_on": {
+                    "nodes": ["model.my_project.stg_users"]
+                }
+            },
+            "test.my_project.no_name_test": {
+                "resource_type": "test",
+                "name": "no_name_test",
+                "test_metadata": {}, # missing name
+                "depends_on": {
+                    "nodes": ["model.my_project.stg_users"]
+                }
+            }
+        },
+        "sources": {
+            "source.my_project.raw_users": {
+                "resource_type": "source",
+                "name": "raw_users",
+                "original_file_path": "models/sources/raw_users.yml",
+                "description": "Raw users source table",
+                "meta": {"owner": "ingest-team"}
+            }
+        }
+    }
+    manifest_file.write_text(json.dumps(manifest_data), encoding="utf-8")
+
+    models = load_dbt_models(tmp_path)
+    assert "model.my_project.stg_users" in models
+    assert "source.my_project.raw_users" in models
+
+    user_model = models["model.my_project.stg_users"]
+    assert user_model.name == "stg_users"
+    assert user_model.columns_to_types == {"id": "int", "name": "varchar"}
+    assert user_model.owner == "data-team"
+    assert user_model.description == "Staging table for users"
+    assert user_model.depends_on == {"source.my_project.raw_users"}
+    assert user_model.audits == [("not_null", {"column_name": "id"})]
+    assert user_model.grains == ["user_id"]
+
+    invalid_grain_model = models["model.my_project.invalid_grain"]
+    assert invalid_grain_model.grains == []
+
+    source_node = models["source.my_project.raw_users"]
+    assert source_node.name == "raw_users"
+    assert source_node.is_external is True
+    assert source_node.owner == "ingest-team"
+
+
+def test_load_dbt_models_missing_manifest():
+    import pytest
+    with pytest.raises(FileNotFoundError):
+        load_dbt_models(Path("/non_existent_path"))
+
+
+def test_run_all_checks(tmp_path: Path):
+    target_dir = tmp_path / "target"
+    target_dir.mkdir(parents=True, exist_ok=True)
+    manifest_file = target_dir / "manifest.json"
+
+    # Mock manifest with standard model, symbolic model, and external source
+    manifest_data = {
+        "nodes": {
+            "model.my_project.stg_users": {
+                "resource_type": "model",
+                "name": "stg_users",
+                "original_file_path": "models/staging/stg_users.sql",
+                "columns": {
+                    "id": {"data_type": "INT"},
+                },
+                "config": {},
+                "meta": {"owner": "data-team"},
+                "depends_on": {"nodes": []}
+            },
+            "model.my_project.symbolic_model": {
+                "resource_type": "model",
+                "name": "symbolic_model",
+                "original_file_path": "models/staging/symbolic.sql",
+                "columns": {},
+                "config": {"materialized": "ephemeral"}, # symbolic
+                "meta": {},
+                "depends_on": {"nodes": []}
+            }
+        },
+        "sources": {}
+    }
+    manifest_file.write_text(json.dumps(manifest_data), encoding="utf-8")
+
+    # Mock SQL files
+    sql_file = tmp_path / "models/staging/stg_users.sql"
+    sql_file.parent.mkdir(parents=True, exist_ok=True)
+    sql_file.write_text("SELECT id FROM raw", encoding="utf-8")
+
+    # 1. Test passing config explicitly
+    config = FitnessFunctionsConfig()
+    config.rules.metadata.enabled = True
+    config.rules.metadata.owner = True
+    config.rules.metadata.description = True  # will violate
+
+    findings, models_checked, selected = run_all_checks(
+        project_root=tmp_path,
+        config=config,
+    )
+    assert models_checked == 1  # symbolic is skipped
+    assert len(findings) > 0
+    assert any("description" in f.check for f in findings)
+
+    # 2. Test running with config=None (auto-discovers config file)
+    yaml_file = tmp_path / "fitness_functions.yaml"
+    yaml_file.write_text("rules:\n  metadata:\n    enabled: true\n    description: true\n", encoding="utf-8")
+    findings_auto, _, _ = run_all_checks(
+        project_root=tmp_path,
+        config=None,
+    )
+    assert len(findings_auto) > 0
+
+    # 3. Test specifying checks list explicitly
+    findings_subset, _, selected_subset = run_all_checks(
+        project_root=tmp_path,
+        config=config,
+        checks=["rules"],
+    )
+    assert selected_subset == ["rules"]
+    assert len(findings_subset) > 0
+