dbtcopy 0.1.0__tar.gz

dbtcopy-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.9", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -v

dbtcopy-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.9", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -v
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

dbtcopy-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+.pytest_cache/
+.eggs/

dbtcopy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomiwa
+
+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.

dbtcopy-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: dbtcopy
+Version: 0.1.0
+Summary: Compile a dbt model and copy the clean SQL to your clipboard
+Project-URL: Homepage, https://github.com/tomiwa-dev/dbtcopy
+Project-URL: Repository, https://github.com/tomiwa-dev/dbtcopy
+Author: Tomiwa
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dbtcopy
+
+Compile a dbt model and copy the clean SQL to your clipboard — no log noise, no thread counts, no adapter info.
+
+`dbt compile` dumps a wall of logs to stdout, making it painful to grab just the SQL. `dbtcopy` runs the compile for you, reads the clean output from `target/compiled/`, and copies it straight to your clipboard.
+
+## Install
+
+```bash
+pip install dbtcopy
+```
+
+Requires Python 3.9+ and dbt already installed in your environment.
+
+## Usage
+
+```bash
+# Basic — compile and copy to clipboard
+dbtcopy my_model
+
+# With dbt target
+dbtcopy my_model --target=prod
+
+# With full-refresh
+dbtcopy my_model --target=prod --full-refresh
+
+# With dbt vars
+dbtcopy my_model --target=prod --vars '{"start_date": "2024-01-01"}'
+
+# Print to stdout instead of clipboard
+dbtcopy my_model --print
+
+# Copy AND print
+dbtcopy my_model --print-and-copy
+
+# Hide dbt compile output
+dbtcopy my_model --quiet
+
+# Skip compile, just grab existing compiled SQL
+dbtcopy my_model --no-compile
+
+# Specify dbt project/profiles directory
+dbtcopy my_model --project-dir /path/to/project --profiles-dir /path/to/profiles
+```
+
+All arguments after the model name are passed directly to `dbt compile`.
+
+## How it works
+
+1. Runs `dbt compile --select <model>` (output shown by default, use `--quiet` to hide)
+2. Finds `<model>.sql` in `target/compiled/` recursively
+3. Reads the file and copies the contents to your clipboard
+4. Prints a confirmation: `Copied 42 lines to clipboard (target/compiled/.../model.sql)`
+5. On compile failure, shows the actual dbt error message
+
+## Platform support
+
+Clipboard works on:
+- **macOS** — `pbcopy`
+- **Linux (X11)** — `xclip`
+- **Linux (Wayland)** — `wl-copy`
+- **WSL / Windows** — `clip.exe`
+
+If no clipboard tool is found, the SQL is printed to stdout as a fallback.
+
+## License
+
+MIT

dbtcopy-0.1.0/README.md

@@ -0,0 +1,68 @@
+# dbtcopy
+
+Compile a dbt model and copy the clean SQL to your clipboard — no log noise, no thread counts, no adapter info.
+
+`dbt compile` dumps a wall of logs to stdout, making it painful to grab just the SQL. `dbtcopy` runs the compile for you, reads the clean output from `target/compiled/`, and copies it straight to your clipboard.
+
+## Install
+
+```bash
+pip install dbtcopy
+```
+
+Requires Python 3.9+ and dbt already installed in your environment.
+
+## Usage
+
+```bash
+# Basic — compile and copy to clipboard
+dbtcopy my_model
+
+# With dbt target
+dbtcopy my_model --target=prod
+
+# With full-refresh
+dbtcopy my_model --target=prod --full-refresh
+
+# With dbt vars
+dbtcopy my_model --target=prod --vars '{"start_date": "2024-01-01"}'
+
+# Print to stdout instead of clipboard
+dbtcopy my_model --print
+
+# Copy AND print
+dbtcopy my_model --print-and-copy
+
+# Hide dbt compile output
+dbtcopy my_model --quiet
+
+# Skip compile, just grab existing compiled SQL
+dbtcopy my_model --no-compile
+
+# Specify dbt project/profiles directory
+dbtcopy my_model --project-dir /path/to/project --profiles-dir /path/to/profiles
+```
+
+All arguments after the model name are passed directly to `dbt compile`.
+
+## How it works
+
+1. Runs `dbt compile --select <model>` (output shown by default, use `--quiet` to hide)
+2. Finds `<model>.sql` in `target/compiled/` recursively
+3. Reads the file and copies the contents to your clipboard
+4. Prints a confirmation: `Copied 42 lines to clipboard (target/compiled/.../model.sql)`
+5. On compile failure, shows the actual dbt error message
+
+## Platform support
+
+Clipboard works on:
+- **macOS** — `pbcopy`
+- **Linux (X11)** — `xclip`
+- **Linux (Wayland)** — `wl-copy`
+- **WSL / Windows** — `clip.exe`
+
+If no clipboard tool is found, the SQL is printed to stdout as a fallback.
+
+## License
+
+MIT

dbtcopy-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dbtcopy"
+version = "0.1.0"
+description = "Compile a dbt model and copy the clean SQL to your clipboard"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "Tomiwa" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+]
+dependencies = [
+    "click>=8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "build",
+    "twine",
+]
+
+[project.scripts]
+dbtcopy = "dbtcopy.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dbtcopy"]
+
+[project.urls]
+Homepage = "https://github.com/tomiwa-dev/dbtcopy"
+Repository = "https://github.com/tomiwa-dev/dbtcopy"

dbtcopy-0.1.0/src/dbtcopy/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

dbtcopy-0.1.0/src/dbtcopy/cli.py

@@ -0,0 +1,66 @@
+import sys
+
+import click
+
+from dbtcopy.clipboard import copy_to_clipboard
+from dbtcopy.compiler import (
+    CompileError,
+    DbtNotFoundError,
+    ModelNotFoundError,
+    compile_model,
+    find_compiled_sql,
+)
+
+
+@click.command(
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+@click.argument("model_name")
+@click.option("--print", "-p", "print_sql", is_flag=True, help="Print compiled SQL to stdout instead of copying.")
+@click.option("--print-and-copy", is_flag=True, help="Copy to clipboard AND print to stdout.")
+@click.option("--no-compile", is_flag=True, help="Skip dbt compile, just find existing compiled SQL.")
+@click.option("--project-dir", type=click.Path(), default=None, help="Path to dbt project directory.")
+@click.option("--profiles-dir", type=click.Path(), default=None, help="Path to dbt profiles directory.")
+@click.option("--quiet", "-q", is_flag=True, help="Hide dbt compile output.")
+@click.pass_context
+def main(ctx, model_name, print_sql, print_and_copy, no_compile, project_dir, profiles_dir, quiet):
+    """Compile a dbt model and copy the clean SQL to your clipboard.
+
+    All extra arguments after MODEL_NAME are passed directly to dbt compile.
+    """
+    extra_args = ctx.args
+
+    try:
+        if not no_compile:
+            compile_model(
+                model_name,
+                extra_args=extra_args,
+                project_dir=project_dir,
+                profiles_dir=profiles_dir,
+                quiet=quiet,
+            )
+
+        sql_path = find_compiled_sql(model_name, project_dir=project_dir)
+        sql = sql_path.read_text().strip()
+        line_count = len(sql.splitlines())
+        rel_path = sql_path
+
+        if print_sql:
+            print(sql)
+        elif print_and_copy:
+            copy_to_clipboard(sql)
+            print(sql)
+            click.echo(f"\u2713 Copied {line_count} lines to clipboard ({rel_path})", err=True)
+        else:
+            copy_to_clipboard(sql)
+            click.echo(f"\u2713 Copied {line_count} lines to clipboard ({rel_path})")
+
+    except DbtNotFoundError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except CompileError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+    except ModelNotFoundError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)

dbtcopy-0.1.0/src/dbtcopy/clipboard.py

@@ -0,0 +1,39 @@
+import shutil
+import subprocess
+import sys
+
+
+def detect_clipboard_tool():
+    """Detect the available clipboard tool for the current platform.
+
+    Returns a list of command args to pipe text into, or None if no tool found.
+    """
+    tools = [
+        ("pbcopy", ["pbcopy"]),
+        ("xclip", ["xclip", "-selection", "clipboard"]),
+        ("wl-copy", ["wl-copy"]),
+        ("clip.exe", ["clip.exe"]),
+    ]
+    for name, cmd in tools:
+        if shutil.which(name):
+            return cmd
+    return None
+
+
+def copy_to_clipboard(text):
+    """Copy text to the system clipboard.
+
+    Returns True if copied successfully, False if no clipboard tool was found
+    (in which case the text is printed to stdout as a fallback).
+    """
+    cmd = detect_clipboard_tool()
+    if cmd is None:
+        print(
+            "Warning: no clipboard tool found. Printing SQL to stdout instead.",
+            file=sys.stderr,
+        )
+        print(text)
+        return False
+
+    subprocess.run(cmd, input=text.encode(), check=True)
+    return True

dbtcopy-0.1.0/src/dbtcopy/compiler.py

@@ -0,0 +1,90 @@
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+class DbtNotFoundError(Exception):
+    pass
+
+
+class CompileError(Exception):
+    pass
+
+
+class ModelNotFoundError(Exception):
+    pass
+
+
+def check_dbt_installed():
+    """Verify that dbt is available on PATH."""
+    if shutil.which("dbt") is None:
+        raise DbtNotFoundError(
+            "dbt is not installed or not on PATH. "
+            "Install it with: pip install dbt-core dbt-<adapter>"
+        )
+
+
+def compile_model(model_name, extra_args=None, project_dir=None, profiles_dir=None, quiet=False):
+    """Run dbt compile for a single model.
+
+    Stdout is suppressed by default; pass verbose=True to show full dbt output.
+    Stderr is always shown so the user sees progress.
+    """
+    check_dbt_installed()
+
+    cmd = ["dbt", "compile", "--select", model_name]
+
+    if project_dir:
+        cmd.extend(["--project-dir", str(project_dir)])
+    if profiles_dir:
+        cmd.extend(["--profiles-dir", str(profiles_dir)])
+    if extra_args:
+        cmd.extend(extra_args)
+
+    result = subprocess.run(
+        cmd,
+        stdout=subprocess.PIPE if quiet else None,
+        stderr=subprocess.PIPE,
+    )
+
+    if result.returncode != 0:
+        output = result.stdout.decode().strip() if result.stdout else ""
+        err_output = result.stderr.decode().strip() if result.stderr else ""
+        combined = "\n".join(filter(None, [output, err_output]))
+        raise CompileError(
+            f"dbt compile failed (exit code {result.returncode}):\n{combined}"
+        )
+
+
+def find_compiled_sql(model_name, project_dir=None):
+    """Find the compiled SQL file for a model in target/compiled/.
+
+    Searches recursively for <model_name>.sql under the target/compiled/ directory.
+    """
+    base = Path(project_dir) if project_dir else Path.cwd()
+    compiled_dir = base / "target" / "compiled"
+
+    if not compiled_dir.exists():
+        raise ModelNotFoundError(
+            f"Compiled directory not found: {compiled_dir}\n"
+            "Run dbt compile first, or check your --project-dir."
+        )
+
+    target_filename = f"{model_name}.sql"
+    matches = list(compiled_dir.rglob(target_filename))
+
+    if not matches:
+        raise ModelNotFoundError(
+            f"Could not find compiled SQL for model '{model_name}' "
+            f"in {compiled_dir}"
+        )
+
+    if len(matches) > 1:
+        paths = "\n  ".join(str(m) for m in matches)
+        raise ModelNotFoundError(
+            f"Found multiple compiled files for '{model_name}':\n  {paths}\n"
+            "Use a more specific model name."
+        )
+
+    return matches[0]

dbtcopy-0.1.0/tests/test_clipboard.py

@@ -0,0 +1,62 @@
+from unittest.mock import patch, MagicMock
+
+from dbtcopy.clipboard import copy_to_clipboard, detect_clipboard_tool
+
+
+class TestDetectClipboardTool:
+    def test_detects_pbcopy(self):
+        with patch("dbtcopy.clipboard.shutil.which") as mock_which:
+            mock_which.side_effect = lambda name: "/usr/bin/pbcopy" if name == "pbcopy" else None
+            result = detect_clipboard_tool()
+            assert result == ["pbcopy"]
+
+    def test_detects_xclip(self):
+        with patch("dbtcopy.clipboard.shutil.which") as mock_which:
+            mock_which.side_effect = lambda name: "/usr/bin/xclip" if name == "xclip" else None
+            result = detect_clipboard_tool()
+            assert result == ["xclip", "-selection", "clipboard"]
+
+    def test_detects_wl_copy(self):
+        with patch("dbtcopy.clipboard.shutil.which") as mock_which:
+            mock_which.side_effect = lambda name: "/usr/bin/wl-copy" if name == "wl-copy" else None
+            result = detect_clipboard_tool()
+            assert result == ["wl-copy"]
+
+    def test_detects_clip_exe(self):
+        with patch("dbtcopy.clipboard.shutil.which") as mock_which:
+            mock_which.side_effect = lambda name: "/mnt/c/Windows/system32/clip.exe" if name == "clip.exe" else None
+            result = detect_clipboard_tool()
+            assert result == ["clip.exe"]
+
+    def test_returns_none_when_no_tool(self):
+        with patch("dbtcopy.clipboard.shutil.which", return_value=None):
+            result = detect_clipboard_tool()
+            assert result is None
+
+    def test_priority_order(self):
+        """pbcopy should be detected first even if other tools exist."""
+        with patch("dbtcopy.clipboard.shutil.which") as mock_which:
+            mock_which.side_effect = lambda name: f"/usr/bin/{name}"
+            result = detect_clipboard_tool()
+            assert result == ["pbcopy"]
+
+
+class TestCopyToClipboard:
+    def test_copies_text_successfully(self):
+        with patch("dbtcopy.clipboard.detect_clipboard_tool", return_value=["pbcopy"]):
+            with patch("dbtcopy.clipboard.subprocess.run") as mock_run:
+                result = copy_to_clipboard("SELECT 1")
+                assert result is True
+                mock_run.assert_called_once_with(
+                    ["pbcopy"],
+                    input=b"SELECT 1",
+                    check=True,
+                )
+
+    def test_falls_back_to_stdout_when_no_tool(self, capsys):
+        with patch("dbtcopy.clipboard.detect_clipboard_tool", return_value=None):
+            result = copy_to_clipboard("SELECT 1")
+            assert result is False
+            captured = capsys.readouterr()
+            assert "SELECT 1" in captured.out
+            assert "Warning" in captured.err

dbtcopy-0.1.0/tests/test_compiler.py

@@ -0,0 +1,171 @@
+import os
+import subprocess
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+import pytest
+from click.testing import CliRunner
+
+from dbtcopy.compiler import (
+    CompileError,
+    DbtNotFoundError,
+    ModelNotFoundError,
+    check_dbt_installed,
+    compile_model,
+    find_compiled_sql,
+)
+from dbtcopy.cli import main
+
+
+class TestCheckDbtInstalled:
+    def test_raises_when_dbt_not_found(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value=None):
+            with pytest.raises(DbtNotFoundError):
+                check_dbt_installed()
+
+    def test_passes_when_dbt_found(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            check_dbt_installed()
+
+
+class TestCompileModel:
+    def test_runs_dbt_compile(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0)
+                compile_model("my_model")
+                args = mock_run.call_args[0][0]
+                assert args[:4] == ["dbt", "compile", "--select", "my_model"]
+
+    def test_passes_extra_args(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0)
+                compile_model("my_model", extra_args=["--target=prod", "--full-refresh"])
+                args = mock_run.call_args[0][0]
+                assert "--target=prod" in args
+                assert "--full-refresh" in args
+
+    def test_passes_project_dir(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0)
+                compile_model("my_model", project_dir="/some/path")
+                args = mock_run.call_args[0][0]
+                assert "--project-dir" in args
+                assert "/some/path" in args
+
+    def test_default_shows_stdout(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0)
+                compile_model("my_model")
+                assert mock_run.call_args[1]["stdout"] is None
+
+    def test_quiet_suppresses_stdout(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(returncode=0)
+                compile_model("my_model", quiet=True)
+                assert mock_run.call_args[1]["stdout"] == subprocess.PIPE
+
+    def test_raises_on_compile_failure(self):
+        with patch("dbtcopy.compiler.shutil.which", return_value="/usr/local/bin/dbt"):
+            with patch("dbtcopy.compiler.subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(
+                    returncode=1,
+                    stdout=b"Compilation Error: something went wrong",
+                    stderr=b"",
+                )
+                with pytest.raises(CompileError, match="something went wrong"):
+                    compile_model("my_model")
+
+
+class TestFindCompiledSql:
+    def test_finds_sql_file(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled" / "project" / "models"
+        compiled_dir.mkdir(parents=True)
+        sql_file = compiled_dir / "my_model.sql"
+        sql_file.write_text("SELECT 1")
+
+        result = find_compiled_sql("my_model", project_dir=str(tmp_path))
+        assert result == sql_file
+
+    def test_finds_nested_sql_file(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled" / "project" / "models" / "staging"
+        compiled_dir.mkdir(parents=True)
+        sql_file = compiled_dir / "my_model.sql"
+        sql_file.write_text("SELECT 1")
+
+        result = find_compiled_sql("my_model", project_dir=str(tmp_path))
+        assert result == sql_file
+
+    def test_raises_when_compiled_dir_missing(self, tmp_path):
+        with pytest.raises(ModelNotFoundError, match="Compiled directory not found"):
+            find_compiled_sql("my_model", project_dir=str(tmp_path))
+
+    def test_raises_when_model_not_found(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled"
+        compiled_dir.mkdir(parents=True)
+
+        with pytest.raises(ModelNotFoundError, match="Could not find"):
+            find_compiled_sql("my_model", project_dir=str(tmp_path))
+
+    def test_raises_on_multiple_matches(self, tmp_path):
+        for subdir in ["models", "snapshots"]:
+            d = tmp_path / "target" / "compiled" / "project" / subdir
+            d.mkdir(parents=True)
+            (d / "my_model.sql").write_text("SELECT 1")
+
+        with pytest.raises(ModelNotFoundError, match="multiple"):
+            find_compiled_sql("my_model", project_dir=str(tmp_path))
+
+
+class TestCli:
+    def test_help(self):
+        runner = CliRunner()
+        result = runner.invoke(main, ["--help"])
+        assert result.exit_code == 0
+        assert "MODEL_NAME" in result.output
+
+    def test_no_compile_and_print(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled" / "project" / "models"
+        compiled_dir.mkdir(parents=True)
+        sql_file = compiled_dir / "my_model.sql"
+        sql_file.write_text("SELECT 1\nFROM table")
+
+        runner = CliRunner()
+        result = runner.invoke(
+            main,
+            ["my_model", "--no-compile", "--print", f"--project-dir={tmp_path}"],
+        )
+        assert result.exit_code == 0
+        assert "SELECT 1" in result.output
+
+    def test_no_compile_copies_to_clipboard(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled" / "project" / "models"
+        compiled_dir.mkdir(parents=True)
+        sql_file = compiled_dir / "my_model.sql"
+        sql_file.write_text("SELECT 1\nFROM table")
+
+        runner = CliRunner()
+        with patch("dbtcopy.cli.copy_to_clipboard", return_value=True) as mock_copy:
+            result = runner.invoke(
+                main,
+                ["my_model", "--no-compile", f"--project-dir={tmp_path}"],
+            )
+            assert result.exit_code == 0
+            mock_copy.assert_called_once()
+            assert "Copied 2 lines" in result.output
+
+    def test_error_when_model_not_found(self, tmp_path):
+        compiled_dir = tmp_path / "target" / "compiled"
+        compiled_dir.mkdir(parents=True)
+
+        runner = CliRunner()
+        result = runner.invoke(
+            main,
+            ["nonexistent", "--no-compile", f"--project-dir={tmp_path}"],
+        )
+        assert result.exit_code == 1
+        assert "Could not find" in result.output