alephprover 0.0.1__tar.gz

alephprover-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,48 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: "Dry run (build only, do not upload)"
+        type: boolean
+        default: false
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-24.04
+    if: startsWith(github.ref, 'refs/tags/v') || (github.event_name == 'workflow_dispatch' && !inputs.dry_run)
+    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

alephprover-0.0.1/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+dist/
+build/
+*.egg-info/
+.idea/
+.env
+*.zip

alephprover-0.0.1/LICENSE

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

alephprover-0.0.1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: alephprover
+Version: 0.0.1
+Summary: CLI tool for submitting Lean proof requests to the Aleph Prover API
+Project-URL: Homepage, https://alephprover.logicalintelligence.com
+Project-URL: Repository, https://github.com/logiq-ai/alephprover
+Author: Logical Intelligence
+License-Expression: MIT
+License-File: LICENSE
+Keywords: formal-verification,lean,lean4,proof-assistant,theorem-proving
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# Aleph Prover CLI
+
+Prove Lean4 theorems with the [Aleph Prover](https://alephprover.logicalintelligence.com) API from your terminal or from [Claude Code](https://claude.ai/code).
+
+## Install
+
+```bash
+# Run directly with uvx (no install needed)
+uvx alephprover prove <file_path> <theorem_name>
+
+# Or install globally
+uv tool install alephprover
+
+# Or with pip
+pip install alephprover
+```
+
+## Usage
+
+```bash
+# Set your API key (get one at https://alephprover.logicalintelligence.com/account)
+export PROVER_API_KEY="sk-aleph-..."
+
+# Submit a proof request
+alephprover prove Mathlib/Algebra/Group/Basic.lean mul_left_cancel
+
+# With hints and budgets
+alephprover prove MyProject/Basic.lean my_theorem \
+  --hints "try induction on n" \
+  --time-budget 30 \
+  --cost-budget 10
+```
+
+The CLI will:
+1. Find the Lean project root (walks up to `lakefile.lean` / `lakefile.toml`)
+2. Zip the project (excluding build artifacts)
+3. Upload to the API and poll for completion
+4. Download and apply the proof diff via `git apply`
+
+## Claude Code Skill
+
+Install the `/prove` skill for [Claude Code](https://claude.ai/code):
+
+```bash
+# Install in current project
+uvx alephprover install-skill
+
+# Or install globally (available in all projects)
+uvx alephprover install-skill --global
+```
+
+Then in Claude Code:
+
+```
+/prove mul_left_cancel in Mathlib/Algebra/Group/Basic.lean
+/prove my_theorem in MyProject/Basic.lean with hint: try induction on n
+```
+
+## Configuration
+
+| Variable | Required | Default | Description |
+|---|---|---|---|
+| `PROVER_API_KEY` | Yes | — | API key (`sk-aleph-...`) from [Account Settings](https://alephprover.logicalintelligence.com/account) |
+| `PROVER_API_URL` | No | `https://alephprover.logicalintelligence.com` | API base URL |
+
+## Requirements
+
+- Python >= 3.10
+- [`uv`](https://docs.astral.sh/uv/) (for `uvx` usage) or `pip install alephprover`
+- `git` (for applying patches)
+- An Aleph Prover account with an API key

alephprover-0.0.1/README.md

@@ -0,0 +1,71 @@
+# Aleph Prover CLI
+
+Prove Lean4 theorems with the [Aleph Prover](https://alephprover.logicalintelligence.com) API from your terminal or from [Claude Code](https://claude.ai/code).
+
+## Install
+
+```bash
+# Run directly with uvx (no install needed)
+uvx alephprover prove <file_path> <theorem_name>
+
+# Or install globally
+uv tool install alephprover
+
+# Or with pip
+pip install alephprover
+```
+
+## Usage
+
+```bash
+# Set your API key (get one at https://alephprover.logicalintelligence.com/account)
+export PROVER_API_KEY="sk-aleph-..."
+
+# Submit a proof request
+alephprover prove Mathlib/Algebra/Group/Basic.lean mul_left_cancel
+
+# With hints and budgets
+alephprover prove MyProject/Basic.lean my_theorem \
+  --hints "try induction on n" \
+  --time-budget 30 \
+  --cost-budget 10
+```
+
+The CLI will:
+1. Find the Lean project root (walks up to `lakefile.lean` / `lakefile.toml`)
+2. Zip the project (excluding build artifacts)
+3. Upload to the API and poll for completion
+4. Download and apply the proof diff via `git apply`
+
+## Claude Code Skill
+
+Install the `/prove` skill for [Claude Code](https://claude.ai/code):
+
+```bash
+# Install in current project
+uvx alephprover install-skill
+
+# Or install globally (available in all projects)
+uvx alephprover install-skill --global
+```
+
+Then in Claude Code:
+
+```
+/prove mul_left_cancel in Mathlib/Algebra/Group/Basic.lean
+/prove my_theorem in MyProject/Basic.lean with hint: try induction on n
+```
+
+## Configuration
+
+| Variable | Required | Default | Description |
+|---|---|---|---|
+| `PROVER_API_KEY` | Yes | — | API key (`sk-aleph-...`) from [Account Settings](https://alephprover.logicalintelligence.com/account) |
+| `PROVER_API_URL` | No | `https://alephprover.logicalintelligence.com` | API base URL |
+
+## Requirements
+
+- Python >= 3.10
+- [`uv`](https://docs.astral.sh/uv/) (for `uvx` usage) or `pip install alephprover`
+- `git` (for applying patches)
+- An Aleph Prover account with an API key

alephprover-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "alephprover"
+version = "0.0.1"
+description = "CLI tool for submitting Lean proof requests to the Aleph Prover API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Logical Intelligence"}]
+keywords = ["lean", "lean4", "theorem-proving", "formal-verification", "proof-assistant"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "httpx>=0.27",
+    "click>=8.0",
+]
+
+[project.urls]
+Homepage = "https://alephprover.logicalintelligence.com"
+Repository = "https://github.com/logiq-ai/alephprover"
+
+[project.scripts]
+alephprover = "alephprover.cli:main"

alephprover-0.0.1/src/alephprover/__init__.py

@@ -0,0 +1,3 @@
+"""Aleph Prover CLI — submit Lean proof requests from your terminal."""
+
+__version__ = "0.0.1"

alephprover-0.0.1/src/alephprover/cli.py

@@ -0,0 +1,392 @@
+"""Aleph Prover CLI — submit Lean proof requests and apply results."""
+
+from __future__ import annotations
+
+import importlib.resources
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+
+import click
+import httpx
+
+DEFAULT_API_URL = "https://alephprover.logicalintelligence.com"
+POLL_INTERVAL = 15  # seconds
+POLL_TIMEOUT = 60 * 60  # 60 minutes
+
+# Root config files to always include in the archive
+ROOT_FILES = ("lakefile.lean", "lakefile.toml", "lean-toolchain", "lake-manifest.json")
+
+
+def find_project_root(start: Path) -> Path:
+    """Walk up from start to find directory containing lakefile.lean or lakefile.toml."""
+    current = start.resolve()
+    if current.is_file():
+        current = current.parent
+    while current != current.parent:
+        if (current / "lakefile.lean").exists() or (current / "lakefile.toml").exists():
+            return current
+        current = current.parent
+    click.echo(
+        "Error: Could not find a Lean project root (lakefile.lean or lakefile.toml).\n"
+        "Make sure you are inside a Lean project directory.",
+        err=True,
+    )
+    sys.exit(1)
+
+
+def validate_api_key() -> str:
+    """Check PROVER_API_KEY env var."""
+    key = os.environ.get("PROVER_API_KEY", "")
+    if not key:
+        click.echo(
+            "Error: PROVER_API_KEY is not set.\n"
+            "\n"
+            "To set up:\n"
+            "  1. Get an API key from https://alephprover.logicalintelligence.com/account\n"
+            '  2. export PROVER_API_KEY="sk-aleph-..."',
+            err=True,
+        )
+        sys.exit(1)
+    if not key.startswith("sk-aleph-"):
+        click.echo(
+            'Error: PROVER_API_KEY must start with "sk-aleph-".\n'
+            "Check your API key at https://alephprover.logicalintelligence.com/account",
+            err=True,
+        )
+        sys.exit(1)
+    return key
+
+
+def get_api_url() -> str:
+    return os.environ.get("PROVER_API_URL", DEFAULT_API_URL).rstrip("/")
+
+
+def get_lean_src_paths(project_root: Path) -> list[str] | None:
+    """Query Lake for source directories. Returns None if Lake is unavailable."""
+    try:
+        result = subprocess.run(
+            ["lake", "env", "printenv", "LEAN_SRC_PATH"],
+            capture_output=True,
+            text=True,
+            cwd=project_root,
+            timeout=30,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return [p for p in result.stdout.strip().split(":") if p]
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+    return None
+
+
+def zip_project(project_root: Path, verbose: bool = False, all_files: bool = False) -> Path:
+    """Create a ZIP archive with only the files needed for building.
+
+    Uses Lake to discover source directories when available. Falls back to
+    including all .lean files outside .lake/.
+    """
+    # Collect files to archive
+    files: list[Path] = []
+
+    if all_files:
+        click.echo("Warning: --all-files includes ALL project files. Archive may be large and may contain sensitive data.", err=True)
+        for p in sorted(project_root.rglob("*")):
+            if p.is_file():
+                files.append(p)
+    else:
+        src_paths = get_lean_src_paths(project_root)
+
+        # Always include root config files
+        for name in ROOT_FILES:
+            p = project_root / name
+            if p.exists():
+                files.append(p)
+
+        if src_paths is not None:
+            click.echo(f"Lake source paths: {', '.join(src_paths) or '.'}")
+            if src_paths:
+                for src in src_paths:
+                    src_dir = project_root / src
+                    if src_dir.is_dir():
+                        files.extend(sorted(src_dir.rglob("*.lean")))
+            else:
+                # Empty LEAN_SRC_PATH means project root is the source dir
+                for p in sorted(project_root.rglob("*.lean")):
+                    rel = p.relative_to(project_root).as_posix()
+                    if not rel.startswith(".lake/") and not rel.startswith("lake-packages/"):
+                        files.append(p)
+        else:
+            click.echo("Lake not available, including all .lean files")
+            for p in sorted(project_root.rglob("*.lean")):
+                rel = p.relative_to(project_root).as_posix()
+                if not rel.startswith(".lake/") and not rel.startswith("lake-packages/"):
+                    files.append(p)
+
+    # Deduplicate while preserving order
+    seen: set[Path] = set()
+    unique_files: list[Path] = []
+    for f in files:
+        if f not in seen:
+            seen.add(f)
+            unique_files.append(f)
+
+    # Create archive
+    tmp = tempfile.NamedTemporaryFile(suffix=".zip", prefix="alephprover-", delete=False)
+    tmp.close()
+    zip_path = Path(tmp.name)
+
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for path in unique_files:
+            rel = path.relative_to(project_root).as_posix()
+            if verbose:
+                click.echo(f"  {rel}")
+            zf.write(path, rel)
+
+    size_mb = zip_path.stat().st_size / (1024 * 1024)
+    click.echo(f"Archived {len(unique_files)} files ({size_mb:.1f} MB)")
+    return zip_path
+
+
+def submit(
+    api_url: str,
+    api_key: str,
+    zip_path: Path,
+    file_path: str,
+    theorem_name: str,
+    hints: str | None,
+    time_budget: int | None,
+    cost_budget: float | None,
+) -> str:
+    """Submit the archive and return the request ID."""
+    data: dict[str, str] = {
+        "file_path": file_path,
+        "theorem_name": theorem_name,
+    }
+    if hints:
+        data["hints"] = hints
+    if time_budget is not None:
+        data["time_budget_minutes"] = str(time_budget)
+    if cost_budget is not None:
+        data["cost_budget_usd"] = str(cost_budget)
+
+    with open(zip_path, "rb") as f:
+        files = {"archive": ("project.zip", f, "application/zip")}
+        response = httpx.post(
+            f"{api_url}/api/v1/requests/upload",
+            headers={"Authorization": f"Bearer {api_key}"},
+            data=data,
+            files=files,
+            timeout=120.0,
+        )
+
+    if response.status_code != 201:
+        click.echo(f"Error: Upload failed (HTTP {response.status_code})", err=True)
+        try:
+            click.echo(response.json(), err=True)
+        except Exception:
+            click.echo(response.text, err=True)
+        sys.exit(1)
+
+    request_id = response.json()["id"]
+    return request_id
+
+
+def poll_status(api_url: str, api_key: str, request_id: str) -> str:
+    """Poll until terminal status. Returns final status."""
+    headers = {"Authorization": f"Bearer {api_key}"}
+    start = time.time()
+    last_stage = None
+
+    while time.time() - start < POLL_TIMEOUT:
+        try:
+            response = httpx.get(
+                f"{api_url}/api/v1/requests/{request_id}",
+                headers=headers,
+                timeout=30.0,
+            )
+            response.raise_for_status()
+        except httpx.HTTPError as e:
+            click.echo(f"Warning: Poll request failed ({e}), retrying...", err=True)
+            time.sleep(POLL_INTERVAL)
+            continue
+
+        data = response.json()
+        status = data["status"]
+        stage = data.get("stage")
+
+        if stage and stage != last_stage:
+            click.echo(f"  Stage: {stage}")
+            last_stage = stage
+
+        if status in ("completed", "failed", "cancelled"):
+            return status
+
+        time.sleep(POLL_INTERVAL)
+
+    click.echo(
+        f"Timeout: polling exceeded {POLL_TIMEOUT // 60} minutes.\n"
+        f"Check status at: {api_url}/requests/{request_id}",
+        err=True,
+    )
+    sys.exit(1)
+
+
+def download_diff(api_url: str, api_key: str, request_id: str) -> Path | None:
+    """Download the diff patch. Returns path or None on failure."""
+    response = httpx.get(
+        f"{api_url}/api/v1/requests/{request_id}/diff",
+        headers={"Authorization": f"Bearer {api_key}"},
+        timeout=60.0,
+    )
+    if response.status_code != 200:
+        return None
+
+    patch_path = Path(tempfile.mktemp(suffix=".patch", prefix=f"proof-{request_id[:8]}-"))
+    patch_path.write_bytes(response.content)
+    return patch_path
+
+
+def apply_patch(patch_path: Path, project_root: Path) -> bool:
+    """Apply patch with git apply. Returns True on success."""
+    result = subprocess.run(
+        ["git", "apply", str(patch_path)],
+        capture_output=True,
+        text=True,
+        cwd=project_root,
+    )
+    if result.returncode == 0:
+        return True
+
+    # Try --3way fallback
+    click.echo("Standard apply failed, trying --3way...")
+    result = subprocess.run(
+        ["git", "apply", "--3way", str(patch_path)],
+        capture_output=True,
+        text=True,
+        cwd=project_root,
+    )
+    return result.returncode == 0
+
+
+@click.group()
+@click.version_option(package_name="alephprover")
+def main():
+    """Aleph Prover CLI — submit Lean proof requests."""
+
+
+@main.command()
+@click.argument("file_path")
+@click.argument("theorem_name")
+@click.option("--hints", default=None, help="Hints for the prover")
+@click.option("--time-budget", default=None, type=int, help="Time budget in minutes (default: server-side 900)")
+@click.option("--cost-budget", default=None, type=float, help="Cost budget in USD (default: server-side 50)")
+@click.option("-v", "--verbose", is_flag=True, help="List files included in the archive")
+@click.option("--all-files", is_flag=True, help="Archive ALL project files (may include sensitive data)")
+def prove(
+    file_path: str,
+    theorem_name: str,
+    hints: str | None,
+    time_budget: int | None,
+    cost_budget: float | None,
+    verbose: bool,
+    all_files: bool,
+):
+    """Submit a Lean theorem for proving.
+
+    FILE_PATH is the path to the Lean file (relative to project root).
+    THEOREM_NAME is the name of the theorem to prove.
+    """
+    api_key = validate_api_key()
+    api_url = get_api_url()
+
+    # Find project root
+    if Path(file_path).is_absolute():
+        start = Path(file_path)
+    else:
+        start = Path.cwd()
+    project_root = find_project_root(start)
+    click.echo(f"Project root: {project_root}")
+
+    # Resolve file_path relative to project root
+    abs_file = (project_root / file_path) if not Path(file_path).is_absolute() else Path(file_path)
+    if not abs_file.exists():
+        click.echo(f"Error: File not found: {abs_file}", err=True)
+        sys.exit(1)
+    rel_file = abs_file.relative_to(project_root).as_posix()
+
+    # Zip
+    click.echo("Zipping project...")
+    zip_path = zip_project(project_root, verbose=verbose, all_files=all_files)
+
+    try:
+        # Submit
+        click.echo("Submitting proof request...")
+        request_id = submit(api_url, api_key, zip_path, rel_file, theorem_name, hints, time_budget, cost_budget)
+        click.echo(f"Request ID: {request_id}")
+        click.echo(f"View at: {api_url}/requests/{request_id}")
+
+        # Poll
+        click.echo("Waiting for proof...")
+        status = poll_status(api_url, api_key, request_id)
+
+        if status != "completed":
+            click.echo(f"Proof request {status}.", err=True)
+            click.echo(f"Details: {api_url}/requests/{request_id}", err=True)
+            sys.exit(1)
+
+        click.echo("Proof completed!")
+
+        # Download diff
+        click.echo("Downloading diff...")
+        patch_path = download_diff(api_url, api_key, request_id)
+
+        if patch_path is None:
+            click.echo(
+                "Could not download diff. Check results at:\n"
+                f"  {api_url}/requests/{request_id}",
+                err=True,
+            )
+            sys.exit(1)
+
+        # Apply
+        click.echo("Applying patch...")
+        if apply_patch(patch_path, project_root):
+            click.echo("Proof applied successfully!")
+            # Show what changed
+            result = subprocess.run(["git", "diff", "--stat"], capture_output=True, text=True, cwd=project_root)
+            if result.stdout:
+                click.echo(result.stdout)
+            # Cleanup patch
+            patch_path.unlink(missing_ok=True)
+        else:
+            click.echo(
+                f"Could not apply patch automatically.\n"
+                f"Patch saved to: {patch_path}\n"
+                f"Apply manually with: git apply {patch_path}",
+                err=True,
+            )
+            sys.exit(1)
+    finally:
+        # Cleanup zip
+        Path(zip_path).unlink(missing_ok=True)
+
+
+@main.command("install-skill")
+@click.option("--global", "global_", is_flag=True, help="Install to ~/.claude/commands/ instead of project")
+def install_skill(global_: bool):
+    """Install the /prove skill for Claude Code."""
+    if global_:
+        target = Path.home() / ".claude" / "commands" / "prove.md"
+    else:
+        target = Path.cwd() / ".claude" / "commands" / "prove.md"
+
+    source = importlib.resources.files("alephprover") / "prove.md"
+    content = source.read_text(encoding="utf-8")
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8")
+    click.echo(f"Installed /prove skill to {target}")

alephprover-0.0.1/src/alephprover/prove.md

@@ -0,0 +1,41 @@
+---
+description: Submit a Lean theorem to Aleph Prover and apply the proof
+allowed-tools: Bash(uvx:*)
+---
+
+# Aleph Prover Skill
+
+Submit a Lean theorem to the Aleph Prover API using the `alephprover` CLI.
+
+## Arguments
+
+The user provides the theorem name and file path. Examples:
+- `/prove mul_left_cancel in Mathlib/Algebra/Group/Basic.lean`
+- `/prove my_theorem in MyProject/Basic.lean with hint: try induction on n`
+
+Parse the user's message to extract:
+- `theorem_name` (required): the theorem to prove
+- `file_path` (required): path to the Lean file containing the theorem
+- `hints` (optional): any hints or guidance after "with hint:" or "hint:"
+
+If the theorem name or file path is unclear, ask the user to clarify before proceeding.
+
+## Configuration
+
+**Required:** `PROVER_API_KEY` environment variable (starts with `sk-aleph-`)
+
+**Optional:** `PROVER_API_URL` environment variable (defaults to `https://alephprover.logicalintelligence.com`)
+
+## Run
+
+```bash
+uvx alephprover prove <file_path> <theorem_name> [--hints "..."] [--time-budget <minutes>] [--cost-budget <usd>] [-v]
+```
+
+Use `timeout=3700000` (just over 60 min) for the command since polling can take up to 60 minutes.
+
+## After completion
+
+1. Show whether the proof was applied successfully
+2. Show which files were modified (`git diff --stat`)
+3. Read the modified theorem from the file and show the proof to the user