dbt-lineage-cli 0.15.0__tar.gz

dbt_lineage_cli-0.15.0/.dockerignore

@@ -0,0 +1,6 @@
+target
+.git
+.dbt-lineage
+assets
+tests
+docs

dbt_lineage_cli-0.15.0/.github/workflows/ci.yml

@@ -0,0 +1,62 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Test (${{ matrix.os }}, ${{ matrix.features }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        features: ["--all-features", "--no-default-features"]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test ${{ matrix.features }}
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo fmt --check
+      - run: cargo clippy --all-features -- -D warnings
+
+  docs:
+    name: Docs
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo doc --all-features --no-deps
+
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-tarpaulin
+      - run: cargo tarpaulin --all-features --out xml
+      - uses: codecov/codecov-action@v6
+        with:
+          files: cobertura.xml
+          fail_ci_if_error: false
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

dbt_lineage_cli-0.15.0/.github/workflows/metrics.yml

@@ -0,0 +1,41 @@
+name: Adoption metrics
+
+# Weekly snapshot of release downloads, crates.io downloads, stars and (with
+# a TRAFFIC_TOKEN secret: a token with push access) repo traffic, appended to
+# metrics.jsonl on the `metrics` branch. GitHub keeps traffic for 14 days only.
+on:
+  schedule:
+    - cron: "23 6 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  collect:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Check out metrics branch
+        run: |
+          if git ls-remote --exit-code origin metrics >/dev/null; then
+            git fetch --depth=1 origin metrics
+            git worktree add metrics-branch FETCH_HEAD
+          else
+            git worktree add --detach metrics-branch
+            git -C metrics-branch checkout --orphan metrics
+            git -C metrics-branch rm -rfq .
+          fi
+      - name: Collect
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TRAFFIC_TOKEN: ${{ secrets.TRAFFIC_TOKEN }}
+        run: python3 scripts/collect_metrics.py metrics-branch/metrics.jsonl
+      - name: Commit
+        working-directory: metrics-branch
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add metrics.jsonl
+          git commit -qm "metrics $(date -u +%F)"
+          git push origin HEAD:refs/heads/metrics

dbt_lineage_cli-0.15.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: Publish to crates.io
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Test before publish
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test --all-features
+
+  publish:
+    name: Publish
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      # `--allow-dirty` because cargo's own resolve step may touch Cargo.lock in
+      # the CI runner even though the file is unchanged on the committed tree.
+      - run: cargo publish --allow-dirty
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

dbt_lineage_cli-0.15.0/.github/workflows/pypi.yml

@@ -0,0 +1,68 @@
+name: Publish to PyPI
+
+# Wheels wrap the dbt-lineage binary (maturin `bindings = "bin"`), so
+# `pip install dbt-lineage-cli` / `uvx --from dbt-lineage-cli dbt-lineage` work
+# without Rust. Publishing uses PyPI trusted publishing and only runs when
+# the repository variable PYPI_PUBLISH is "true" (set it after registering the
+# publisher on PyPI: project dbt-lineage-cli, workflow pypi.yml, env pypi).
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    name: Wheel ${{ matrix.os }} ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, target: x86_64, manylinux: auto }
+          # ring needs a newer cross GCC than manylinux2014 ships for aarch64.
+          - { os: ubuntu-latest, target: aarch64, manylinux: "2_28" }
+          - { os: macos-latest, target: x86_64 }
+          - { os: macos-latest, target: aarch64 }
+          - { os: windows-latest, target: x64 }
+    steps:
+      - uses: actions/checkout@v5
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          manylinux: ${{ matrix.manylinux || 'auto' }}
+      - uses: actions/upload-artifact@v6
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.target }}
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v6
+        with:
+          name: sdist
+          path: dist
+
+  publish:
+    needs: [wheels, sdist]
+    if: vars.PYPI_PUBLISH == 'true' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

dbt_lineage_cli-0.15.0/.github/workflows/release-binaries.yml

@@ -0,0 +1,228 @@
+name: Release binaries
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+
+env:
+  CARGO_TERM_COLOR: always
+  BIN_NAME: dbt-lineage
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    name: Build ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-latest
+            archive: tar.gz
+          - target: aarch64-unknown-linux-gnu
+            os: ubuntu-latest
+            archive: tar.gz
+            cross: true
+          - target: x86_64-apple-darwin
+            os: macos-latest
+            archive: tar.gz
+          - target: aarch64-apple-darwin
+            os: macos-latest
+            archive: tar.gz
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
+            archive: zip
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
+
+      # `cross` provides a Docker-based toolchain for aarch64 Linux without
+      # needing the system to have a cross-compiler installed.
+      - name: Install cross (Linux aarch64 only)
+        if: matrix.cross == true
+        run: cargo install cross --locked
+
+      - name: Build release binary
+        shell: bash
+        run: |
+          if [ "${{ matrix.cross }}" = "true" ]; then
+            cross build --release --target ${{ matrix.target }}
+          else
+            cargo build --release --target ${{ matrix.target }}
+          fi
+
+      - name: Package archive
+        shell: bash
+        run: |
+          set -euxo pipefail
+          version="${GITHUB_REF#refs/tags/}"
+          stage="${BIN_NAME}-${version}-${{ matrix.target }}"
+          mkdir -p "dist/${stage}"
+          # Copy the binary.
+          if [ "${{ matrix.os }}" = "windows-latest" ]; then
+            cp "target/${{ matrix.target }}/release/${BIN_NAME}.exe" "dist/${stage}/"
+          else
+            cp "target/${{ matrix.target }}/release/${BIN_NAME}" "dist/${stage}/"
+          fi
+          # Bundle docs.
+          cp README.md LICENSE BENCHMARKS.md "dist/${stage}/" 2>/dev/null || true
+          # Archive.
+          cd dist
+          if [ "${{ matrix.archive }}" = "zip" ]; then
+            7z a "${stage}.zip" "${stage}"
+            sha256sum "${stage}.zip" > "${stage}.zip.sha256" || shasum -a 256 "${stage}.zip" > "${stage}.zip.sha256"
+          else
+            tar czf "${stage}.tar.gz" "${stage}"
+            shasum -a 256 "${stage}.tar.gz" > "${stage}.tar.gz.sha256" 2>/dev/null || sha256sum "${stage}.tar.gz" > "${stage}.tar.gz.sha256"
+          fi
+          ls -la
+
+      - name: Upload as artifact (for the release step)
+        uses: actions/upload-artifact@v6
+        with:
+          name: ${{ matrix.target }}
+          path: |
+            dist/${{ env.BIN_NAME }}-*-${{ matrix.target }}.tar.gz
+            dist/${{ env.BIN_NAME }}-*-${{ matrix.target }}.zip
+            dist/${{ env.BIN_NAME }}-*-${{ matrix.target }}.*.sha256
+          if-no-files-found: error
+          retention-days: 1
+
+  attach:
+    name: Attach to release
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Release notes from CHANGELOG
+        run: python3 scripts/release_notes.py "$GITHUB_REF_NAME" > release-notes.md
+
+      - uses: actions/download-artifact@v7
+        with:
+          path: dist
+          merge-multiple: true
+
+      - name: List downloaded artifacts
+        run: ls -la dist
+
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          body_path: release-notes.md
+          files: |
+            dist/*.tar.gz
+            dist/*.zip
+            dist/*.sha256
+          fail_on_unmatched_files: true
+
+  major-tag:
+    name: Move floating major tag (e.g. v0)
+    needs: attach
+    runs-on: ubuntu-latest
+    # Pre-releases (v1.2.3-rc.1) don't move the floating tag.
+    if: ${{ !contains(github.ref_name, '-') }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Force-update major tag
+        run: |
+          set -euo pipefail
+          major="${GITHUB_REF_NAME%%.*}"   # v0.9.1 -> v0
+          git tag -f "$major" "$GITHUB_SHA"
+          git push -f origin "refs/tags/$major"
+
+  docker:
+    name: Publish container image (ghcr.io)
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: docker/setup-qemu-action@v4
+      - uses: docker/setup-buildx-action@v4
+      - uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Compute tags
+        id: tags
+        run: |
+          set -euo pipefail
+          image="ghcr.io/${GITHUB_REPOSITORY_OWNER,,}/dbt-lineage"
+          version="${GITHUB_REF_NAME#v}"          # 0.10.0 or 0.10.0-rc.1
+          tags="$image:$version"
+          if [[ "$version" != *-* ]]; then
+            major="${version%%.*}"
+            minor="${version#*.}"; minor="${minor%%.*}"
+            tags="$tags,$image:$major.$minor,$image:v$major,$image:latest"
+          fi
+          echo "tags=$tags" >> "$GITHUB_OUTPUT"
+      - uses: docker/build-push-action@v7
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.tags.outputs.tags }}
+          labels: |
+            org.opencontainers.image.source=https://github.com/${{ github.repository }}
+            org.opencontainers.image.description=PR-time dbt lineage, impact analysis and rebuild plans
+            org.opencontainers.image.licenses=MIT
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  bitbucket-pipe:
+    name: Publish Bitbucket Pipe image (ghcr.io)
+    needs: docker
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: docker/setup-qemu-action@v4
+      - uses: docker/setup-buildx-action@v4
+      - uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Compute tags
+        id: tags
+        run: |
+          set -euo pipefail
+          owner="${GITHUB_REPOSITORY_OWNER,,}"
+          image="ghcr.io/$owner/dbt-lineage-pipe"
+          version="${GITHUB_REF_NAME#v}"
+          tags="$image:$version"
+          if [[ "$version" != *-* ]]; then
+            major="${version%%.*}"
+            minor="${version#*.}"; minor="${minor%%.*}"
+            tags="$tags,$image:$major.$minor,$image:v$major,$image:latest"
+          fi
+          echo "tags=$tags" >> "$GITHUB_OUTPUT"
+          echo "base=ghcr.io/$owner/dbt-lineage:$version" >> "$GITHUB_OUTPUT"
+      - uses: docker/build-push-action@v7
+        with:
+          context: integrations/bitbucket
+          platforms: linux/amd64,linux/arm64
+          push: true
+          build-args: BASE_IMAGE=${{ steps.tags.outputs.base }}
+          tags: ${{ steps.tags.outputs.tags }}
+          labels: |
+            org.opencontainers.image.source=https://github.com/${{ github.repository }}
+            org.opencontainers.image.description=dbt-lineage Bitbucket Pipe
+            org.opencontainers.image.licenses=MIT

dbt_lineage_cli-0.15.0/.gitignore

@@ -0,0 +1,8 @@
+/target
+demo.tape
+# Per-project parse cache (created automatically when dbt-lineage runs against
+# a project). Safe to delete; see docs/CACHE.md.
+.dbt-lineage/
+
+# Claude Code agent worktrees
+.claude/worktrees/

dbt_lineage_cli-0.15.0/.pre-commit-hooks.yaml

@@ -0,0 +1,24 @@
+# pre-commit hooks for dbt projects. Usage in a dbt repo's .pre-commit-config.yaml:
+#
+#   - repo: https://github.com/sipemu/dbt-lineage-viewer
+#     rev: v0.10.0
+#     hooks:
+#       - id: dbt-lineage-lint
+#       - id: dbt-lineage-check-manifest
+#
+# Pass `args: [-p, path/to/dbt]` when the dbt project is not at the repo root.
+- id: dbt-lineage-lint
+  name: dbt-lineage lint
+  description: Structural lint of the dbt DAG (dead ends, undefined refs, unused sources, missing docs).
+  entry: dbt-lineage lint
+  language: rust
+  pass_filenames: false
+  files: \.(sql|py|ya?ml|csv)$
+
+- id: dbt-lineage-check-manifest
+  name: dbt-lineage check-manifest
+  description: Fail if target/manifest.json is out of sync with the SQL files (requires a compiled manifest).
+  entry: dbt-lineage check-manifest
+  language: rust
+  pass_filenames: false
+  files: \.(sql|py|ya?ml)$

dbt_lineage_cli-0.15.0/BENCHMARKS.md

@@ -0,0 +1,56 @@
+# Benchmarks
+
+Baseline numbers for the SQL-parse-mode graph builder. Generated by
+`cargo bench --bench builder_bench`. Numbers below are from a single
+machine (Linux, AMD64, Rust stable). Use them as relative references,
+not absolute targets.
+
+## Fixture
+
+`benches/builder_bench.rs` generates a synthetic 500-model dbt project
+into a temp directory on first invocation:
+
+- 200 staging models, each ~6 lines of SQL with one source reference.
+- 300 mart models, each ~8 lines of SQL with two ref calls (one via a
+  detected wrapper macro to exercise #13).
+- One `schema.yml` per layer with model descriptions.
+- One macro file defining a simple `ref()` wrapper.
+
+Total: 500 nodes, 500 `ref()` calls, 200 `source()` calls.
+
+## Baseline (0.5.1)
+
+| Target | Time | Notes |
+|---|---|---|
+| `build_graph_cold` (no cache) | **~17 ms** | Parses every file from scratch. Rayon parallelization across cores. |
+| `build_graph_warm` (cache hit) | **~4.3 ms** | Cache populated by a prior cold run. Walks dirs + hashes files + serves cached parse. |
+| `compute_summary` | **~114 µs** | Aggregation only — no I/O. |
+| `compute_impact` | **~1.3 µs** | BFS from a deep-fan-in staging model. |
+
+**Warm vs cold ratio: ~4×.** The warm path skips the lexer + regex
+parsing entirely, just walks dirs and hashes file contents. The ratio
+grows on real projects where model files are larger and parsing is
+proportionally heavier.
+
+### Lexer overhead (#25)
+
+Cold parse went from ~14.4ms (0.5.0, regex-only) to ~17ms (0.5.1, with
+Jinja+SQL lexer in the path). The ~15% extra buys correctness — false
+positives from `ref(` inside string literals and comments are now
+eliminated. Worth it.
+
+## Reading the numbers
+
+For context: 14.4 ms cold means a 500-model project rebuilds the full
+graph in well under a frame on a developer laptop. 5.2 ms warm is
+sub-frame, effectively instant. The cache earns its keep most on
+projects where:
+
+- Models are large (heavy Jinja, many lines of SQL).
+- The user runs `dbt-lineage` repeatedly (TUI dev loop, CI watch).
+
+## Regression policy
+
+When changes to the parser, builder, or cache affect these numbers,
+update this file in the same commit. CI doesn't gate on bench
+performance yet — these are reference numbers for humans.