langgraph-lint 0.1.0__tar.gz

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

@@ -0,0 +1,102 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+# uv's managed interpreters are "externally managed" and reject --system, so
+# every job installs into an explicit virtualenv that later steps reuse.
+env:
+  UV_PROJECT_ENVIRONMENT: .venv
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Activate the uv-managed virtualenv
+        run: |
+          uv venv .venv --allow-existing
+          echo "$PWD/.venv/bin" >> "$GITHUB_PATH"
+          echo "VIRTUAL_ENV=$PWD/.venv" >> "$GITHUB_ENV"
+
+      # The base install must stay dependency-free, so prove the package and
+      # its CLI work before any optional extra -- including langgraph itself --
+      # is present.
+      - name: Install base package only
+        run: uv pip install -e .
+      - name: Verify base install pulls in no LangChain or LangGraph
+        run: |
+          python -c "import langgraph_lint; print(langgraph_lint.__version__)"
+          langgraph-lint --version
+          python - <<'PY'
+          for name in ("langchain_core", "langgraph"):
+              try:
+                  __import__(name)
+              except ImportError:
+                  print(f"confirmed: base install pulls in no {name}")
+              else:
+                  raise SystemExit(f"base install must not depend on {name}")
+          PY
+
+      # Smoke test the CLI end to end against a graph with a real, deliberate
+      # LG003 bug, using only the base install plus langgraph itself (which a
+      # real user would already have -- this simulates their actual setup).
+      - name: Install langgraph for the smoke test
+        run: uv pip install langgraph
+      - name: CLI finds the deliberate bug in the fixture graph
+        run: |
+          cd tests/fixtures
+          if langgraph-lint buggy_graph:app --min-severity high; then
+            echo "expected langgraph-lint to find the LG003 bug and exit 1" >&2
+            exit 1
+          fi
+          echo "confirmed: CLI found the bug and exited non-zero"
+      - name: CLI is silent on a clean graph
+        run: |
+          cd tests/fixtures
+          langgraph-lint clean_graph:app
+
+      - name: Install dev and agent extras
+        run: uv pip install -e ".[dev,agent]"
+      - name: Lint
+        run: ruff check .
+      - name: Type check
+        run: mypy src
+      - name: Test
+        run: pytest -q
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      - name: Activate the uv-managed virtualenv
+        run: |
+          uv venv .venv --allow-existing
+          echo "$PWD/.venv/bin" >> "$GITHUB_PATH"
+          echo "VIRTUAL_ENV=$PWD/.venv" >> "$GITHUB_ENV"
+      - run: uv pip install build twine
+      - run: python -m build
+      - name: Validate distribution metadata
+        run: twine check --strict dist/*
+      - name: Install the built wheel in a clean environment
+        run: |
+          uv venv /tmp/fresh
+          uv pip install --python /tmp/fresh/bin/python dist/*.whl
+          /tmp/fresh/bin/langgraph-lint --version
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

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

@@ -0,0 +1,71 @@
+name: Publish
+
+# Trusted Publishing (OIDC) -- no API token is ever stored in GitHub secrets.
+# One-time setup at https://pypi.org/manage/account/publishing/ :
+#   PyPI project: langgraph-lint | owner: mathewOracle | repo: langgraph-lint
+#   workflow: publish.yml | environment: pypi
+# Repeat at https://test.pypi.org/manage/account/publishing/ for TestPyPI.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      target:
+        description: Where to publish
+        required: true
+        default: testpypi
+        type: choice
+        options: [testpypi, pypi]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      # uv's managed interpreter rejects --system, so build inside a venv.
+      - name: Activate the uv-managed virtualenv
+        run: |
+          uv venv .venv --allow-existing
+          echo "$PWD/.venv/bin" >> "$GITHUB_PATH"
+          echo "VIRTUAL_ENV=$PWD/.venv" >> "$GITHUB_ENV"
+      - run: uv pip install build twine
+      - run: python -m build
+      - run: twine check --strict dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  testpypi:
+    needs: build
+    if: github.event_name == 'workflow_dispatch' && inputs.target == 'testpypi'
+    runs-on: ubuntu-latest
+    environment: testpypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  pypi:
+    needs: build
+    if: github.event_name == 'release' || inputs.target == 'pypi'
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

langgraph_lint-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+env/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.DS_Store
+.idea/
+.vscode/
+*.log
+.env

langgraph_lint-0.1.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.1.0
+
+Initial release.
+
+- `LG000` — graph fails to `compile()` at all.
+- `LG001` — a node with no path from `START` (dead code). Downgraded to
+  informational when the node is referenced by a `Send(...)` call, to avoid
+  false-positiving on map-reduce fan-out.
+- `LG003` — a conditional router's declared return type includes a value
+  missing from its `path_map`. This is the flagship rule: LangGraph compiles
+  this without error and it only crashes, with `KeyError`, on whichever input
+  first takes the untested branch. Verified against a real reproduction.
+- `LG005` — the mirror image of `LG003`: a `path_map` branch the router's own
+  return type can never produce (dead routing code).
+- CLI (`langgraph-lint module.path:attribute`), library API (`lint()`), and
+  an optional LangChain/LangGraph agent tool (`langgraph-lint[agent]`).
+- Zero required dependencies, verified in a clean virtualenv.
+
+Two rules considered for this release — "no path to `END`" and "duplicate
+edge" — were cut before shipping. Both turned out to be structurally
+undetectable: LangGraph auto-inserts an implicit edge to `END` on nearly
+every node (confirmed even inside a genuine unbreakable cycle), and plain
+edges are deduplicated into a `set` before `get_graph()` ever sees them.

langgraph_lint-0.1.0/LICENSE

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

langgraph_lint-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.5
+Name: langgraph-lint
+Version: 0.1.0
+Summary: Find LangGraph wiring bugs before they become a runtime KeyError.
+Project-URL: Homepage, https://github.com/mathewOracle/langgraph-lint
+Project-URL: Repository, https://github.com/mathewOracle/langgraph-lint
+Project-URL: Issues, https://github.com/mathewOracle/langgraph-lint/issues
+Author: mathewOracle
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,ai,code-quality,graph,langchain,langgraph,linter,static-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: agent
+Requires-Dist: langchain-core>=0.3; extra == 'agent'
+Requires-Dist: langchain>=1.0; extra == 'agent'
+Requires-Dist: langgraph>=0.2; extra == 'agent'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: langgraph>=0.2; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# langgraph-lint
+
+**Find LangGraph wiring bugs before they become a runtime `KeyError`.**
+
+LangGraph validates some things at `compile()` time — an edge to a node that doesn't exist, for instance, fails immediately and loudly. But a lot of real wiring bugs compile perfectly fine and only surface the first time a specific input takes a specific untested branch, weeks later, in production.
+
+```console
+$ langgraph-lint myapp.graph:app
+
+  [HIGH] LG003 (route_after_search): router can return 'maybe', which has no
+  matching entry in the path_map (['no', 'yes']) -- this raises KeyError at
+  runtime the first time this branch is taken
+
+  [HIGH] LG001 (validate_output): 'validate_output' has no incoming edge and
+  no path from START; it can never run
+
+2 finding(s) in myapp.graph:app.
+```
+
+That first finding is real, reproducible, and proven — not a guess:
+
+```python
+def router(state) -> Literal["yes", "no", "maybe"]:
+    ...
+
+graph.add_conditional_edges("a", router, {"yes": "b", "no": "c"})  # no "maybe"!
+
+compiled = graph.compile()      # succeeds. no warning. nothing.
+compiled.invoke({"x": 2})       # fine
+compiled.invoke({"x": 3})       # fine
+compiled.invoke({"x": 101})     # KeyError: 'maybe'  <- only now
+```
+
+`langgraph-lint` catches this the moment you write it, by checking the router's own `Literal[...]` return type against the `path_map` you gave `add_conditional_edges`. No invocation needed.
+
+## Install
+
+```console
+pip install langgraph-lint                # zero dependencies
+pip install "langgraph-lint[agent]"       # + a LangChain/LangGraph agent tool
+```
+
+## Use it as a CLI
+
+```console
+langgraph-lint myapp.graph:app             # module.path:attribute, like uvicorn
+langgraph-lint myapp.graph:app --min-severity high
+langgraph-lint myapp.graph:app --format json
+langgraph-lint myapp.graph:app --format github   # Actions annotations
+```
+
+`target` accepts a compiled graph, an uncompiled `StateGraph` builder, or any object with `.get_graph()` — so it also works on plain LangChain LCEL runnables, just with a smaller rule set (the conditional-branch check is LangGraph-specific). Exit code `1` on findings, `0` clean, `2` on error.
+
+## Use it as a library
+
+```python
+from langgraph_lint import lint
+
+for finding in lint(app):
+    print(finding)
+```
+
+## Use it in an agent
+
+```python
+from langgraph_lint.integrations import build_graph
+
+auditor = build_graph("anthropic:claude-sonnet-4-5")
+auditor.invoke({
+    "messages": [{"role": "user", "content": "Check myapp.graph:app for wiring bugs."}]
+})
+```
+
+Or `get_tools()` to bind `check_langgraph_graph` to your own agent.
+
+## Rules
+
+| Code | Catches | LangGraph catches it today? |
+|---|---|---|
+| `LG000` | Graph fails to `compile()` at all | Raises, but as a stack trace, not a lint finding |
+| `LG001` | A node with no path from `START` (dead code) | No |
+| `LG003` | A router's `Literal[...]` return type has a value missing from its `path_map` | **No — silent until that branch runs** |
+| `LG005` | A `path_map` branch the router's own return type can never produce (dead routing code, the mirror image of LG003) | No |
+
+Two rules that seemed obviously useful up front — "node with no path to `END`" and "duplicate edge" — got cut before release. Both turned out to be structurally undetectable: LangGraph auto-inserts an implicit escape-hatch edge to `END` on essentially every node (even inside a genuine, unbreakable cycle — verified), and plain edges are deduplicated into a `set` before `get_graph()` ever sees them. A rule that can never fire is worse than no rule; better to ship four honest ones than six decorative ones.
+
+## On false positives
+
+Every rule here has a real counter-pattern, and this tool knows about the big one: **`Send()`-based map-reduce fan-out creates zero static edges** to its target node. A node reached only via `Send("worker", ...)` has no incoming edge in the graph's structure at all — indistinguishable, by structure alone, from a typo'd dead node. `langgraph-lint` scans node and router source for `Send("literal_name", ...)` calls and downgrades those findings to informational rather than screaming at correct, idiomatic code.
+
+Similarly:
+- `LG005`'s check on unreachable `path_map` branches only trusts a `Literal[...]` type annotation, never the AST heuristic, since a false claim of "this can never happen" is worse than staying silent.
+- `LG003`'s AST-based fallback (used when a router has no `Literal[...]` annotation) is a heuristic, not a guarantee — it scans `return "..."` statements and can miss dynamically computed values. Those findings are `MEDIUM`, not `HIGH`, and say so explicitly.
+
+Every `Finding` carries a `caveat` field for exactly this reason. `LG003` findings backed by an actual type annotation carry an empty caveat, because there's nothing to hedge — that's about as close to certain as static analysis gets.
+
+## Compatibility
+
+Built and tested against `langgraph==1.2.11`. The `LG003`/`LG005` branch checks read `StateGraph.branches` and `BranchSpec.path`/`.ends` -- internal, non-public attributes, not a documented API. They've been stable across recent LangGraph releases, but a future LangGraph refactor could rename them; if that happens, `langgraph-lint` degrades to `LG001`-only (dead-node detection, which only needs the public `get_graph()`), not a crash -- worth knowing if you pin an unusually old or new LangGraph version.
+
+## Development
+
+```console
+uv venv && uv pip install -e ".[dev]"
+pytest
+ruff check . && mypy src
+```
+
+The test suite builds real `langgraph.StateGraph` objects rather than mocks. The flagship test doesn't just assert a finding fires — it then actually invokes the compiled graph and confirms the predicted `KeyError` really happens, so the rule's claim is proven, not just plausible.
+
+## License
+
+MIT

langgraph_lint-0.1.0/README.md

@@ -0,0 +1,113 @@
+# langgraph-lint
+
+**Find LangGraph wiring bugs before they become a runtime `KeyError`.**
+
+LangGraph validates some things at `compile()` time — an edge to a node that doesn't exist, for instance, fails immediately and loudly. But a lot of real wiring bugs compile perfectly fine and only surface the first time a specific input takes a specific untested branch, weeks later, in production.
+
+```console
+$ langgraph-lint myapp.graph:app
+
+  [HIGH] LG003 (route_after_search): router can return 'maybe', which has no
+  matching entry in the path_map (['no', 'yes']) -- this raises KeyError at
+  runtime the first time this branch is taken
+
+  [HIGH] LG001 (validate_output): 'validate_output' has no incoming edge and
+  no path from START; it can never run
+
+2 finding(s) in myapp.graph:app.
+```
+
+That first finding is real, reproducible, and proven — not a guess:
+
+```python
+def router(state) -> Literal["yes", "no", "maybe"]:
+    ...
+
+graph.add_conditional_edges("a", router, {"yes": "b", "no": "c"})  # no "maybe"!
+
+compiled = graph.compile()      # succeeds. no warning. nothing.
+compiled.invoke({"x": 2})       # fine
+compiled.invoke({"x": 3})       # fine
+compiled.invoke({"x": 101})     # KeyError: 'maybe'  <- only now
+```
+
+`langgraph-lint` catches this the moment you write it, by checking the router's own `Literal[...]` return type against the `path_map` you gave `add_conditional_edges`. No invocation needed.
+
+## Install
+
+```console
+pip install langgraph-lint                # zero dependencies
+pip install "langgraph-lint[agent]"       # + a LangChain/LangGraph agent tool
+```
+
+## Use it as a CLI
+
+```console
+langgraph-lint myapp.graph:app             # module.path:attribute, like uvicorn
+langgraph-lint myapp.graph:app --min-severity high
+langgraph-lint myapp.graph:app --format json
+langgraph-lint myapp.graph:app --format github   # Actions annotations
+```
+
+`target` accepts a compiled graph, an uncompiled `StateGraph` builder, or any object with `.get_graph()` — so it also works on plain LangChain LCEL runnables, just with a smaller rule set (the conditional-branch check is LangGraph-specific). Exit code `1` on findings, `0` clean, `2` on error.
+
+## Use it as a library
+
+```python
+from langgraph_lint import lint
+
+for finding in lint(app):
+    print(finding)
+```
+
+## Use it in an agent
+
+```python
+from langgraph_lint.integrations import build_graph
+
+auditor = build_graph("anthropic:claude-sonnet-4-5")
+auditor.invoke({
+    "messages": [{"role": "user", "content": "Check myapp.graph:app for wiring bugs."}]
+})
+```
+
+Or `get_tools()` to bind `check_langgraph_graph` to your own agent.
+
+## Rules
+
+| Code | Catches | LangGraph catches it today? |
+|---|---|---|
+| `LG000` | Graph fails to `compile()` at all | Raises, but as a stack trace, not a lint finding |
+| `LG001` | A node with no path from `START` (dead code) | No |
+| `LG003` | A router's `Literal[...]` return type has a value missing from its `path_map` | **No — silent until that branch runs** |
+| `LG005` | A `path_map` branch the router's own return type can never produce (dead routing code, the mirror image of LG003) | No |
+
+Two rules that seemed obviously useful up front — "node with no path to `END`" and "duplicate edge" — got cut before release. Both turned out to be structurally undetectable: LangGraph auto-inserts an implicit escape-hatch edge to `END` on essentially every node (even inside a genuine, unbreakable cycle — verified), and plain edges are deduplicated into a `set` before `get_graph()` ever sees them. A rule that can never fire is worse than no rule; better to ship four honest ones than six decorative ones.
+
+## On false positives
+
+Every rule here has a real counter-pattern, and this tool knows about the big one: **`Send()`-based map-reduce fan-out creates zero static edges** to its target node. A node reached only via `Send("worker", ...)` has no incoming edge in the graph's structure at all — indistinguishable, by structure alone, from a typo'd dead node. `langgraph-lint` scans node and router source for `Send("literal_name", ...)` calls and downgrades those findings to informational rather than screaming at correct, idiomatic code.
+
+Similarly:
+- `LG005`'s check on unreachable `path_map` branches only trusts a `Literal[...]` type annotation, never the AST heuristic, since a false claim of "this can never happen" is worse than staying silent.
+- `LG003`'s AST-based fallback (used when a router has no `Literal[...]` annotation) is a heuristic, not a guarantee — it scans `return "..."` statements and can miss dynamically computed values. Those findings are `MEDIUM`, not `HIGH`, and say so explicitly.
+
+Every `Finding` carries a `caveat` field for exactly this reason. `LG003` findings backed by an actual type annotation carry an empty caveat, because there's nothing to hedge — that's about as close to certain as static analysis gets.
+
+## Compatibility
+
+Built and tested against `langgraph==1.2.11`. The `LG003`/`LG005` branch checks read `StateGraph.branches` and `BranchSpec.path`/`.ends` -- internal, non-public attributes, not a documented API. They've been stable across recent LangGraph releases, but a future LangGraph refactor could rename them; if that happens, `langgraph-lint` degrades to `LG001`-only (dead-node detection, which only needs the public `get_graph()`), not a crash -- worth knowing if you pin an unusually old or new LangGraph version.
+
+## Development
+
+```console
+uv venv && uv pip install -e ".[dev]"
+pytest
+ruff check . && mypy src
+```
+
+The test suite builds real `langgraph.StateGraph` objects rather than mocks. The flagship test doesn't just assert a finding fires — it then actually invokes the compiled graph and confirms the predicted `KeyError` really happens, so the rule's claim is proven, not just plausible.
+
+## License
+
+MIT

langgraph_lint-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langgraph-lint"
+version = "0.1.0"
+description = "Find LangGraph wiring bugs before they become a runtime KeyError."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "mathewOracle" }]
+keywords = [
+    "langgraph",
+    "langchain",
+    "static-analysis",
+    "linter",
+    "graph",
+    "agent",
+    "ai",
+    "code-quality",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+agent = ["langchain>=1.0", "langchain-core>=0.3", "langgraph>=0.2"]
+dev = ["pytest>=8", "ruff>=0.6", "mypy>=1.11", "build>=1.2", "langgraph>=0.2"]
+
+[project.scripts]
+langgraph-lint = "langgraph_lint.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/mathewOracle/langgraph-lint"
+Repository = "https://github.com/mathewOracle/langgraph-lint"
+Issues = "https://github.com/mathewOracle/langgraph-lint/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/langgraph_lint"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+
+[[tool.mypy.overrides]]
+module = "langgraph_lint.integrations"
+disallow_untyped_decorators = false
+
+[[tool.mypy.overrides]]
+module = ["langchain.*", "langchain_core.*", "langgraph.*"]
+ignore_missing_imports = true

langgraph_lint-0.1.0/src/langgraph_lint/__init__.py

@@ -0,0 +1,13 @@
+"""Public API.
+
+Find LangGraph wiring bugs LangGraph itself won't catch until runtime.
+"""
+
+from __future__ import annotations
+
+from langgraph_lint.core import lint
+from langgraph_lint.models import Finding, Severity
+
+__version__ = "0.1.0"
+
+__all__ = ["Finding", "Severity", "__version__", "lint"]