open-atp 0.1.0__tar.gz

open_atp-0.1.0/.env.example

@@ -0,0 +1,26 @@
+# Copy to `.env` and fill in. `.env` is gitignored and never committed.
+
+# Required only for the live Aristotle end-to-end test (`pytest -m aristotle_api`).
+ARISTOTLE_API_KEY=arstl_your_key_here
+
+# Required only for the live AgentProver test (`pytest -m agent_api`) with the
+# default claude_code harness. Generate with `claude setup-token`.
+CLAUDE_CODE_OAUTH_TOKEN=sk-ant-oat-your_token_here
+
+# Required only for the live NuminaProver test (`pytest -m numina_api`): the OAuth
+# token above plus at least GEMINI_API_KEY. Numina's helper skills call out to
+# Gemini / OpenAI / Leandex from inside the sandbox; each key is optional and the
+# corresponding skill simply degrades or skips when its key is absent.
+GEMINI_API_KEY=your_gemini_key_here
+OPENAI_API_KEY=sk-your_openai_key_here
+LEAN_LEANDEX_API_KEY=your_leandex_key_here
+
+# Required for the `agent:axprover` harness (ax-prover-base). It uses a raw provider
+# key matching the configured `model`: the default model is claude-opus-4-8, so
+# ANTHROPIC_API_KEY is needed unless you override `model` to a gpt-*/gemini-* id (then
+# OPENAI_API_KEY / GOOGLE_API_KEY instead). The harness forwards whichever is present.
+ANTHROPIC_API_KEY=sk-ant-your_key_here
+GOOGLE_API_KEY=your_google_genai_key_here
+# Optional: ax-prover's web-search tool degrades to a no-op without this, and the
+# harness does not forward it by default (see AxProverHarness.auth_spec).
+# TAVILY_API_KEY=tvly-your_key_here

open_atp-0.1.0/.github/workflows/ci-python.yml

@@ -0,0 +1,115 @@
+name: CI - Python
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "src/**"
+      - "tests/**"
+      - "pyproject.toml"
+      - "uv.lock"
+      - ".github/workflows/ci-python.yml"
+      - "codecov.yml"
+  pull_request:
+    paths:
+      - "src/**"
+      - "tests/**"
+      - "pyproject.toml"
+      - "uv.lock"
+      - ".github/workflows/ci-python.yml"
+      - "codecov.yml"
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Lint (ruff check)
+        run: uv run ruff check src tests
+
+  format:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Format check (ruff format)
+        run: uv run ruff format --check src tests
+
+  typecheck:
+    name: Type Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Type check (mypy)
+        run: uv run mypy
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Run unit tests (no docker, no modal)
+        run: uv run pytest -m 'not docker and not modal'
+
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Coverage — src
+        run: uv run pytest -m 'not docker and not modal' --cov=open_atp --cov-report=term-missing --cov-report=xml
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          flags: src
+          name: src
+          fail_ci_if_error: false

open_atp-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,69 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (e.g. v0.1.0)"
+        required: true
+
+permissions:
+  contents: write
+  id-token: write  # OIDC for PyPI Trusted Publishing
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Resolve tag
+        id: tag
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            echo "tag=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=${GITHUB_REF#refs/tags/}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Refetch annotated tag and checkout
+        run: |
+          git fetch --force --tags origin "refs/tags/${{ steps.tag.outputs.tag }}:refs/tags/${{ steps.tag.outputs.tag }}"
+          git checkout "${{ steps.tag.outputs.tag }}"
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Build distributions
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish dist/open_atp-*  # Trusted Publishing via OIDC, no token needed
+
+      - name: Create release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          TAG="${{ steps.tag.outputs.tag }}"
+          SHORT=$(git rev-parse --short "$TAG^{commit}")
+          MSG=$(git tag -l --format='%(contents:body)' "$TAG")
+          {
+            echo "$MSG"
+            echo
+            echo "open-atp release at $SHORT."
+          } > dist-notes.md
+          VERSION="${TAG#v}"
+          PRERELEASE=()
+          if [[ "${VERSION%%.*}" == "0" ]]; then
+            PRERELEASE=(--prerelease)
+          fi
+          gh release create "$TAG" \
+            dist/open_atp-* \
+            --title "$TAG" \
+            --notes-file dist-notes.md \
+            "${PRERELEASE[@]}"

open_atp-0.1.0/.gitignore

@@ -0,0 +1,32 @@
+# Reference symlinks — for development context only, never committed.
+refs/
+
+# Integration test artifacts (agent logs, workdirs from test_agent_capabilities)
+tests/.runs/
+
+# Sphinx docs build
+docs/_build/
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+build/
+dist/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# Lean build artifacts (e.g. created by an editor opening a fixture project)
+.lake/
+
+# Env / secrets
+.env
+
+# OS
+.DS_Store
+
+# Claude Code transient state
+.claude/scheduled_tasks.lock

open_atp-0.1.0/.readthedocs.yaml

@@ -0,0 +1,20 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.12"
+
+sphinx:
+  configuration: docs/conf.py
+  fail_on_warning: true
+
+formats:
+  - htmlzip
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

open_atp-0.1.0/AGENTS.md

@@ -0,0 +1,260 @@
+# AGENTS.md
+
+Developer guide for **open-atp** (Open Automated Formal Proof Synthesis). Read this
+before making changes. The user-facing overview lives in [README.md](README.md);
+this file is the engineering reference.
+
+## What this project does
+
+Upload one or more Lean files containing `sorry`, run them through proof-synthesis
+backends, and get back **verified** completed proofs with metadata (verification
+status, cost, duration). Every prover — including the hosted Aristotle — funnels its
+output through one **shared verifier** that compiles the candidate in a Lean+Mathlib
+sandbox and checks it compiles, is sorry-free, and is axiom-clean.
+
+### Two primitives + thin generators
+
+1. **`ComputeBackend`** (`backends/`) — run a command over a working directory inside a
+   Lean+Mathlib sandbox. Two impls: `DockerBackend`, `ModalBackend`.
+2. **`Verifier`** (`verify.py`) — compile a candidate project in a backend and
+   report `verified` / `sorry_free` / `axioms`.
+
+```
+ComputeBackend (docker | modal)         ← the sandbox primitive
+        │
+        ├── Verifier  ──────────────────← shared final check (ALL provers)
+        │
+AutomatedProver (provers/base.py, base)
+ ├── AgentProver      coding-agent harness (claude/codex/opencode/axprover/vibe) + lean-lsp-mcp
+ ├── NuminaProver     configured AgentProver: claude + vendored Numina assets + round loop
+ └── AristotleProver  remote `aristotle submit --project-dir --wait` (no local generation sandbox)
+```
+
+### Input contract
+
+Submit a **full lake project** (carries `lean-toolchain` + `lake-manifest.json`). The
+verifier **rejects** projects whose toolchain doesn't match the sandbox image's pin
+(`ToolchainMismatch`) instead of failing deep in a build. The CLI can also take bare
+`.lean` files and stage them into the pinned skeleton. One Mathlib image to start
+(pinned Lean/Mathlib **v4.28.0**); `image` is a config field so more can be added.
+
+## Project structure (high-level)
+
+```
+src/open_atp/
+  api.py            Platform + prover registry — the dispatch/orchestration layer
+  __main__.py       `open-atp solve | build-image | build-modal-image` CLI
+  images/           image name + toolchain pins (DEFAULT_IMAGE, DEFAULT_TOOLCHAIN)
+  lean.py           LeanProject, ProofTask, create_project (the Lean input contract)
+  verify.py         VerificationReport, Verifier (the shared final check)
+  backends/         base.py  docker.py  modal.py            (ComputeBackend impls)
+  provers/          agent_prover.py  numina.py  numina_tracker.py  aristotle.py
+  harness/          coding-agent CLIs staged into the sandbox:
+                      base.py  claude_code.py  codex.py  opencode.py
+                      axprover.py  vibe.py  bundles.py  cost.py  _paths.py
+                    assets/  scripts/*.sh  configs/mcp.json  vibe/lean-standin.toml
+
+images/             Dockerfile (Mathlib base image) + lean/ skeleton (toolchain, lakefile)
+vendor/             vendored third-party assets, tracked to upstream SHAs (see VENDOR.md in each)
+  numina/             Numina skills + prompts (round-loop prover)
+  leanprover-skills/  host-agnostic Lean skills
+  lean4-skills/       Claude `lean4` plugin
+tests/              pytest suite (+ tests/.runs/ integration artifacts, gitignored)
+docs/               Sphinx docs (user_guide/, provers/, agent_harness/, api/)
+refs/               read-only symlinks to reference projects (NEVER modify or commit)
+```
+
+The README's `Layout` section predates the `harness/` split — trust the tree above.
+
+### Vendored code
+
+`vendor/*` is upstream third-party code pinned to a SHA (each has a `VENDOR.md`).
+Ruff is configured with `extend-exclude = ["vendor"]` — **do not reformat or lint
+vendored code**, and keep its upstream style. It ships in the wheel via
+`force-include` and is resolved at runtime by `harness/_paths.py` (wheel:
+`open_atp/vendor/<name>`; checkout: repo-root `vendor/<name>`).
+
+## Provers
+
+Names accepted by `--provers` and the `Platform` registry (`api.py`):
+
+| Name | Backing tool | Notes |
+| --- | --- | --- |
+| `aristotle` | Harmonic Aristotle (hosted) | remote API via `aristotlelib`, no local gen sandbox |
+| `agent` | Claude Code (`claude_code` harness) | default; coding agent + lean-lsp-mcp |
+| `codex` | OpenAI Codex CLI | model `gpt-5.5` |
+| `opencode` | opencode | |
+| `axprover` | ax-prover (LangGraph) | proposer→builder→reviewer loop; default model `claude-opus-4-8`, effort `high` |
+| `numina` | Numina skills/prompts on Claude Code | round-continuation loop |
+| `vibe` | Mistral Vibe `lean` scaffold | hosted model (default `magistral-medium-latest`), no GPU; `--model` configurable |
+
+Agentic harnesses share **lean-lsp-mcp** as their LSP server. The shared `Verifier`
+does the final compile/sorry/axiom check regardless of which tool generated the proof.
+
+## Tooling
+
+- **Python ≥ 3.12**, packaged with **hatchling**, deps managed by **uv** (`uv.lock`).
+- **ruff** — lint (`E,F,I,UP`) + format, line length 88, excludes `vendor`.
+- **mypy** — `strict`, `files = ["src/open_atp"]`.
+- **pytest** — `pytest-cov`, `pytest-xdist` (default `-n 5`).
+- **lefthook** — pre-commit runs ruff check, ruff format --check, and mypy on staged
+  `*.py` (with `--force-exclude` so vendored code is skipped). Install with
+  `uv run lefthook install`.
+- **Sphinx** (furo + myst) for docs; Read the Docs config in `.readthedocs.yaml`.
+- CLI entry point: `open-atp` → `open_atp.__main__:main`.
+
+## Makefile commands
+
+```
+make install         uv sync
+make test            pytest, skipping docker/modal/live-API tests (default markers)
+make test-docker     -m docker     (requires the built image)
+make test-modal      -m modal      (requires a Modal token)
+make test-aristotle  -m aristotle_api   (live, needs ARISTOTLE_API_KEY)
+make test-agent      -m agent_api       (live + billable, needs creds)
+make cov             pytest with coverage → htmlcov/, coverage.xml
+make cov-open        build + open the HTML coverage report
+make cov-clean       remove coverage artifacts
+make lint            ruff check src tests
+make format          ruff format + ruff check --fix on src tests
+make typecheck       mypy
+make check           lint + typecheck + test
+make build-image     docker build -t open-atp:latest images/
+make docs            sphinx-build -W -b html docs docs/_build/html
+make docs-serve      live-reload docs
+make docs-clean      remove built docs
+make clean           remove build + cache artifacts
+```
+
+Run `make check` before pushing.
+
+## Testing
+
+Default `addopts`: `-m 'not aristotle_api and not agent_api and not numina_api' -n 5`.
+The live/billable credentialed suites are **opt-out by default** and run only when you
+select their marker. Markers (`pyproject.toml`):
+
+- `docker` — needs the `open-atp` Docker image (opt-out: `-m 'not docker'`)
+- `modal` — launches a Modal sandbox (opt-out: `-m 'not modal'`)
+- `aristotle_api` — live Aristotle API (opt-in: `-m aristotle_api`)
+- `agent_api` — live agent CLI, billable + creds (opt-in: `-m agent_api`)
+- `numina_api` — live NuminaProver, billable + creds (opt-in: `-m numina_api`)
+
+> Project convention: when running tests (even by explicit path), exclude the
+> docker / modal / `*_api` markers by default — they are slow, billable, or need
+> external compute. `make test` already does this. Use `-n 0` to run serially when
+> debugging.
+
+Integration artifacts (agent logs, workdirs) land in `tests/.runs/` (gitignored).
+
+## Compute setup: Docker vs. Modal
+
+Both backends run the shared `Verifier` **and** the agentic provers end-to-end against
+the Mathlib image. Pick a backend with `--backend`, or split generation from the cheap
+verify with `--agent-backend`.
+
+- **Docker** (`DockerBackend`) — bind-mounts the workdir; uses `images/Dockerfile`,
+  runs as the `agent` user. Local; build the image first:
+  ```bash
+  docker build -t open-atp:latest images/      # or: make build-image / open-atp build-image
+  uv run pytest -m docker
+  ```
+- **Modal** (`ModalBackend`) — pushes/pulls the workdir around an isolated Sandbox
+  filesystem; runs as **root**, so its image is built programmatically with the same
+  toolchain installed globally. Publish the image, then run the parity suite:
+  ```bash
+  uv run open-atp build-modal-image --name open-atp --app open-atp
+  uv run pytest -m modal          # needs MODAL_TOKEN_ID / MODAL_TOKEN_SECRET
+  ```
+  `ModalBackend`'s `image` (sans `:tag`) must match the `--name` you publish under.
+
+Example splits:
+```bash
+uv run open-atp solve path/to/project --provers agent --backend modal
+uv run open-atp solve path/to/project --provers agent \
+    --agent-backend modal --backend docker   # Modal generates, Docker does cheap verify
+```
+
+## CLI quick reference
+
+```
+open-atp solve <inputs...> [options]      # lake project dir, or bare .lean files
+  --provers   comma-separated names (default: agent)
+  --instructions TEXT                       # guidance forwarded to provers
+  --targets   comma-separated files relative to project
+  --image / --toolchain                     # default to images/ pins
+  --backend {docker,modal}        default docker
+  --agent-backend {docker,modal}  separate generation backend (defaults to --backend)
+  --runs-dir DIR                  default runs/
+  --max-workers N
+  --json                          emit SolveResult as JSON
+
+open-atp build-image       [--tag TAG] [--no-cache]
+open-atp build-modal-image [--name N] [--app A] [--force]
+```
+
+Programmatic verify:
+```python
+from open_atp.lean import LeanProject
+from open_atp.verify import docker_verifier
+report = docker_verifier().verify(LeanProject("path/to/lake/project"))
+print(report.verified, report.sorry_free, report.axioms)
+```
+
+## Environment / secrets
+
+Copy `.env.example` → `.env` (gitignored, never committed). All keys are needed only
+for the corresponding **live** test or harness; absent keys make the dependent
+skill/test degrade or skip:
+
+- `ARISTOTLE_API_KEY` — `pytest -m aristotle_api`
+- `CLAUDE_CODE_OAUTH_TOKEN` — `agent_api` test with default claude_code harness
+  (`claude setup-token`)
+- `GEMINI_API_KEY` / `OPENAI_API_KEY` / `LEAN_LEANDEX_API_KEY` — Numina helper skills
+- `ANTHROPIC_API_KEY` / `GOOGLE_API_KEY` — `axprover` (raw provider key matching
+  the configured `model`); `TAVILY_API_KEY` optional (ax-prover web search)
+- `MODAL_TOKEN_ID` / `MODAL_TOKEN_SECRET` — Modal backend
+
+## Docs: API reference convention
+
+The API pages (`docs/api/*.md`) are Sphinx `autoclass` directives; **numpydoc** renders
+the class docstring's `Parameters`/`Attributes` sections, and a single
+`autodoc-skip-member` hook in `docs/conf.py` (`_skip_non_methods`) drops every class
+member that isn't a method. So the split is:
+
+- **Constructor params and attributes** (instance state + `@property`) live **only in
+  the docstring**, in `Parameters`/`Attributes` sections. The hook hides them as
+  members, so they render once, from the prose. Never re-list them with `:members:`.
+- **List each name once — `Parameters` *or* `Attributes`, never both** (the
+  numpy/scipy/sklearn convention). A constructor arg stored verbatim as an attribute is
+  documented only under `Parameters`; readers know `self.<arg>` exists without it being
+  repeated. `Attributes` is reserved for state **not** in the signature: `@property`
+  (e.g. `Harness.command`, `Verifier.image`) and derived/computed fields. If a
+  `@property` shares a name with a param (e.g. `OpenCodeHarness.provider`), document the
+  resolution in the param and leave it out of `Attributes`.
+- **Methods** are the only members `autoclass` enumerates. Document each method **once,
+  on the class that defines it.**
+- **Inheritance**: numpydoc does *not* walk the MRO, so each leaf class must
+  **re-document every constructor param it accepts, including inherited ones** (e.g.
+  `backend`/`timeout_s` from `AutomatedProver`) — otherwise they don't render. Pages do
+  **not** use `:inherited-members:`: an inherited method (e.g. `prove`) appears only on
+  its base class, not on each child.
+
+Practical rules:
+
+- **Do not** add `:exclude-members:` for attributes, params, or `name` — the hook
+  already handles them. The only legitimate `:exclude-members:` is to hide an
+  **overridden method** from a child page so it stays documented on the base only
+  (current uses: `start` on the backend impls, `stage` on the harness impls).
+- A new attribute/`@property` only shows up if you add it to the docstring `Attributes`
+  section.
+- `make docs` builds with `-W` (warnings are errors) — a broken xref or duplicate
+  fails the build.
+
+## Conventions
+
+- Commit directly to `main` unless told otherwise; warn before committing work that
+  clearly belongs on another branch.
+- Never modify or commit anything under `refs/` (read-only reference symlinks) or
+  reformat anything under `vendor/` (upstream-tracked).
+- Keep `mypy --strict` and ruff clean; run `make check` before pushing.

open_atp-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

open_atp-0.1.0/LICENSE

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

open_atp-0.1.0/Makefile

@@ -0,0 +1,87 @@
+# Common dev commands for the open-atp package.
+
+.PHONY: help install test test-docker test-modal test-aristotle test-agent cov cov-open cov-clean lint format typecheck check build build-image docs docs-serve docs-clean clean
+
+help:
+	@echo "Targets:"
+	@echo "  install         Sync deps with uv"
+	@echo "  test            Run pytest, skipping docker/modal/live-API tests"
+	@echo "  test-docker     Run docker-marked tests (requires the built image)"
+	@echo "  test-modal      Run modal-marked tests (requires a Modal token)"
+	@echo "  test-aristotle  Run the live Aristotle API test (needs ARISTOTLE_API_KEY)"
+	@echo "  test-agent      Run the live agent CLI test (billable + needs creds)"
+	@echo "  cov             Run pytest with coverage; HTML to htmlcov/, XML to coverage.xml"
+	@echo "  cov-open        Open the HTML coverage report"
+	@echo "  cov-clean       Remove coverage artifacts"
+	@echo "  lint            Run ruff check"
+	@echo "  format          Run ruff format + ruff check --fix"
+	@echo "  typecheck       Run mypy"
+	@echo "  check           Run lint + typecheck + test"
+	@echo "  build           Build the sdist + wheel into dist/"
+	@echo "  build-image     Build the open-atp:latest Docker image"
+	@echo "  docs            Build the Sphinx docs once"
+	@echo "  docs-serve      Live-reload docs in browser"
+	@echo "  docs-clean      Remove built docs"
+	@echo "  clean           Remove build + cache artifacts"
+
+install:
+	uv sync
+
+test:
+	uv run pytest
+
+test-docker:
+	uv run pytest -m 'docker'
+
+test-modal:
+	uv run pytest -m 'modal'
+
+test-aristotle:
+	uv run pytest -m 'aristotle_api'
+
+test-agent:
+	uv run pytest -m 'agent_api'
+
+cov:
+	uv run pytest \
+		--cov=open_atp \
+		--cov-report=term-missing \
+		--cov-report=html \
+		--cov-report=xml
+
+cov-open: cov
+	@python -c "import os, webbrowser; webbrowser.open('file://' + os.path.abspath('htmlcov/index.html'))"
+
+cov-clean:
+	rm -rf htmlcov coverage.xml .coverage
+
+lint:
+	uv run ruff check src tests
+
+format:
+	uv run ruff format src tests
+	uv run ruff check --fix src tests
+
+typecheck:
+	uv run mypy
+
+check: lint typecheck test
+
+build:
+	uv build
+
+build-image:
+	docker build -t open-atp:latest images/
+
+docs:
+	uv run --extra docs sphinx-build -W -b html docs docs/_build/html
+
+docs-serve:
+	uv run --extra docs sphinx-autobuild --watch src docs docs/_build/html
+
+docs-clean:
+	rm -rf docs/_build
+
+clean: docs-clean cov-clean
+	rm -rf build dist .pytest_cache .mypy_cache .ruff_cache
+	find . -type d -name __pycache__ -exec rm -rf {} +

open_atp-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: open-atp
+Version: 0.1.0
+Summary: Open Automated Formal Proof Synthesis: upload Lean files with sorrys, get verified completed proofs across multiple proving backends.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: anthropic>=0.75.0
+Requires-Dist: aristotlelib
+Requires-Dist: google-genai>=1.44.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: lean-explore>=1.2.1
+Requires-Dist: modal>=1.5
+Requires-Dist: openai>=2.7.1
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.5; extra == 'dev'
+Requires-Dist: python-dotenv; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: furo; extra == 'docs'
+Requires-Dist: myst-parser>=3; extra == 'docs'
+Requires-Dist: numpydoc; extra == 'docs'
+Requires-Dist: sphinx-autobuild; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
+Requires-Dist: sphinx-design; extra == 'docs'
+Requires-Dist: sphinx>=7; extra == 'docs'