@paradigma-inc/flywheel 0.1.19 → 0.1.26

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/cli.py

@@ -0,0 +1,298 @@
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+import typer
+from rich import print as rprint
+
+from tproof.constants import (
+    LEAN_TOOLCHAIN,
+    MATHLIB_HASH,
+    OPS_AGENT_NOTES,
+    OPS_AGENT_ROLE,
+    PACKAGE_NAME,
+    PROOF_AGENT_NOTES,
+    PROOF_AGENT_ROLE,
+)
+from tproof.layout import Paths, default_paths, ensure_layout
+from tproof.leanops import (
+    ensure_toolchain_installed,
+    lake_build,
+    lake_update,
+    reindex_allproofs,
+    seed_lean_project,
+    snapshot_project,
+)
+from tproof.runstore import create_run, load_run, new_run_id, now_utc_iso, save_run
+from tproof.tasking import (
+    build_run_brief,
+    discover_project_modules,
+    find_sorry_hits,
+    read_task_prompt,
+)
+
+app = typer.Typer(no_args_is_help=True, help="Local Lean theorem proving pipeline CLI")
+
+
+def _paths() -> Paths:
+    paths = default_paths()
+    ensure_layout(paths)
+    return paths
+
+
+def _write_log(log_path: Path, text: str) -> None:
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    log_path.write_text(text, encoding="utf-8")
+
+
+def _find_forbidden_staging_artifacts(paths: Paths) -> list[str]:
+    staging_dir = paths.workspace_dir / "staging"
+    if not staging_dir.is_dir():
+        return []
+    blocked_suffixes = {".lean", ".md"}
+    hits: list[str] = []
+    for file_path in sorted(staging_dir.rglob("*")):
+        if not file_path.is_file():
+            continue
+        if file_path.name == ".gitkeep":
+            continue
+        if file_path.suffix.lower() in blocked_suffixes:
+            hits.append(str(file_path.relative_to(paths.root)))
+    return hits
+
+
+def _which(binary: str) -> str | None:
+    return shutil.which(binary)
+
+
+@app.command("doctor")
+def doctor() -> None:
+    paths = _paths()
+    lean_path = _which("lean")
+    lake_path = _which("lake")
+    elan_path = _which("elan")
+
+    if not lean_path or not lake_path or not elan_path:
+        raise RuntimeError(
+            "Missing required binaries. Ensure `lean`, `lake`, and `elan` are installed and on PATH."
+        )
+
+    from tproof.leanops import run_cmd
+
+    lean_code, lean_out = run_cmd(["lean", "--version"], cwd=paths.root)
+    lake_code, lake_out = run_cmd(["lake", "--version"], cwd=paths.root)
+    if lean_code != 0 or lake_code != 0:
+        raise RuntimeError("Unable to run `lean --version` or `lake --version`.")
+
+    rprint(f"[green]lean:[/green] {lean_path}")
+    rprint(f"[green]lake:[/green] {lake_path}")
+    rprint(f"[green]elan:[/green] {elan_path}")
+    rprint(f"[green]Pinned toolchain:[/green] {LEAN_TOOLCHAIN}")
+    rprint(f"[green]Pinned mathlib hash:[/green] {MATHLIB_HASH}")
+    rprint(f"[green]Proof worker:[/green] {PROOF_AGENT_ROLE}")
+    rprint(f"[green]Proof notes:[/green] {PROOF_AGENT_NOTES}")
+    rprint(f"[green]Ops worker:[/green] {OPS_AGENT_ROLE}")
+    rprint(f"[green]Ops notes:[/green] {OPS_AGENT_NOTES}")
+    rprint(f"[green]Lean project path:[/green] {paths.lean_project_dir}")
+    rprint(lean_out.strip())
+    rprint(lake_out.strip())
+
+
+@app.command("init")
+def init(build: bool = typer.Option(True, "--build/--no-build")) -> None:
+    paths = _paths()
+    seed_lean_project(
+        paths.lean_project_dir,
+        lean_toolchain=LEAN_TOOLCHAIN,
+        mathlib_hash=MATHLIB_HASH,
+    )
+    reindex_allproofs(paths.lean_project_dir)
+
+    install_code, install_out = ensure_toolchain_installed(LEAN_TOOLCHAIN)
+    already_installed = "already installed" in install_out.lower()
+    if install_code != 0 and not already_installed:
+        raise RuntimeError(f"elan toolchain install failed:\n{install_out}")
+
+    update_code, update_out = lake_update(paths.lean_project_dir)
+    if update_code != 0:
+        raise RuntimeError(f"lake update failed:\n{update_out}")
+
+    logs = [
+        "== elan toolchain install ==",
+        install_out,
+        "== lake update ==",
+        update_out,
+    ]
+    if build:
+        build_code, build_out = lake_build(paths.lean_project_dir)
+        if build_code != 0:
+            raise RuntimeError(f"lake build failed:\n{build_out}")
+        logs.extend(["== lake build ==", build_out])
+
+    log_name = datetime.now(timezone.utc).strftime("init_%Y%m%dT%H%M%SZ.log")
+    _write_log(paths.logs_dir / log_name, "\n".join(logs))
+    rprint(f"[green]Workspace initialized:[/green] {paths.lean_project_dir}")
+    rprint(f"[green]Toolchain:[/green] {LEAN_TOOLCHAIN}")
+    rprint(f"[green]Mathlib hash:[/green] {MATHLIB_HASH}")
+
+
+@app.command("reindex")
+def reindex(project_dir: Path | None = typer.Option(None, "--project-dir")) -> None:
+    paths = _paths()
+    target = project_dir or paths.lean_project_dir
+    all_proofs_path = reindex_allproofs(target)
+    rprint(f"[green]Reindexed:[/green] {all_proofs_path}")
+
+
+@app.command("start-run")
+def start_run(
+    prompt_file: Path | None = typer.Option(None, "--prompt-file"),
+    prompt_text: str | None = typer.Option(None, "--prompt-text"),
+    run_label: str | None = typer.Option(None, "--run-label"),
+    context_file: Path | None = typer.Option(None, "--context-file"),
+) -> None:
+    paths = _paths()
+    task_prompt = read_task_prompt(prompt_file=prompt_file, prompt_text=prompt_text)
+    context_text = context_file.read_text(encoding="utf-8") if context_file else None
+    modules = discover_project_modules(paths.lean_project_dir)
+    sorry_hits = find_sorry_hits(paths.lean_project_dir)
+
+    run_id = new_run_id(run_label)
+    run = {
+        "run_id": run_id,
+        "created_at": now_utc_iso(),
+        "updated_at": now_utc_iso(),
+        "status": "READY_FOR_PROOF",
+        "task_prompt": task_prompt,
+        "context_file": str(context_file.resolve()) if context_file else None,
+        "context_text": context_text,
+        "known_modules": modules,
+        "sorry_hits": sorry_hits,
+        "proof_agent_role": PROOF_AGENT_ROLE,
+        "proof_agent_notes": PROOF_AGENT_NOTES,
+        "ops_agent_role": OPS_AGENT_ROLE,
+        "ops_agent_notes": OPS_AGENT_NOTES,
+        "lean_project_dir": str(paths.lean_project_dir),
+    }
+    create_run(paths, run_id, run)
+
+    run_dir = paths.runs_dir / run_id
+    snapshot_project(paths.lean_project_dir, run_dir / "project_snapshot")
+    (run_dir / "task_prompt.txt").write_text(task_prompt, encoding="utf-8")
+    if context_text:
+        (run_dir / "context.txt").write_text(context_text, encoding="utf-8")
+    brief = build_run_brief(
+        run_id=run_id,
+        task_prompt=task_prompt,
+        known_modules=modules,
+        sorry_hits=sorry_hits,
+        context_text=context_text,
+    )
+    (run_dir / "run_brief.md").write_text(brief, encoding="utf-8")
+
+    rprint(f"[green]Run created:[/green] {run_id}")
+    rprint(f"[green]Run file:[/green] {run_dir / 'run.json'}")
+    rprint(f"[green]Brief file:[/green] {run_dir / 'run_brief.md'}")
+    rprint(f"[green]Outstanding sorries:[/green] {len(sorry_hits)}")
+
+
+@app.command("show-run")
+def show_run(run_id: str = typer.Argument(...)) -> None:
+    paths = _paths()
+    run = load_run(paths, run_id)
+    rprint(run)
+
+
+@app.command("set-status")
+def set_status(
+    run_id: str = typer.Argument(...),
+    status: str = typer.Argument(...),
+    note: str | None = typer.Option(None, "--note"),
+) -> None:
+    paths = _paths()
+    run = load_run(paths, run_id)
+    run["status"] = status
+    run["updated_at"] = now_utc_iso()
+    if note:
+        run["note"] = note
+    save_run(paths, run_id, run)
+    rprint(f"[green]Updated run {run_id} -> {status}[/green]")
+
+
+@app.command("verify")
+def verify(project_dir: Path | None = typer.Option(None, "--project-dir")) -> None:
+    paths = _paths()
+    target = project_dir or paths.lean_project_dir
+    code, output = lake_build(target)
+    sorry_hits = find_sorry_hits(target)
+    forbidden_staging_hits = _find_forbidden_staging_artifacts(paths)
+    log_name = datetime.now(timezone.utc).strftime("verify_%Y%m%dT%H%M%SZ.log")
+    log_path = paths.logs_dir / log_name
+    extra = ""
+    if sorry_hits:
+        extra = "\n\n== unresolved sorry locations ==\n" + "\n".join(sorry_hits)
+    if forbidden_staging_hits:
+        extra += "\n\n== forbidden artifacts under workspace/staging ==\n" + "\n".join(
+            forbidden_staging_hits
+        )
+    _write_log(log_path, output + extra)
+
+    if code != 0 or sorry_hits or forbidden_staging_hits:
+        rprint(f"[red]Verification failed.[/red] Log: {log_path}")
+        if sorry_hits:
+            rprint(f"[red]Unresolved sorries:[/red] {len(sorry_hits)}")
+        if forbidden_staging_hits:
+            rprint(
+                "[red]Forbidden staging artifacts:[/red] "
+                f"{len(forbidden_staging_hits)} (move them to ProofWorkspace/Final)"
+            )
+        raise typer.Exit(code=1)
+    rprint(f"[green]Verification passed.[/green] Log: {log_path}")
+
+
+@app.command("smoke-test")
+def smoke_test() -> None:
+    paths = _paths()
+    init(build=True)
+
+    smoke_dir = paths.lean_project_dir / PACKAGE_NAME / "Smoke"
+    smoke_dir.mkdir(parents=True, exist_ok=True)
+    smoke_file = smoke_dir / "Smoke.lean"
+    smoke_file.write_text(
+        """import Mathlib
+
+namespace ProofWorkspace.Smoke
+
+theorem smoke_add_comm (a b : Nat) : a + b = b + a := by
+  sorry
+
+end ProofWorkspace.Smoke
+""",
+        encoding="utf-8",
+    )
+    reindex_allproofs(paths.lean_project_dir)
+
+    run_id_label = "smoke"
+    start_run(
+        prompt_text="Fill all sorry placeholders while preserving theorem statements.",
+        run_label=run_id_label,
+        prompt_file=None,
+        context_file=None,
+    )
+
+    try:
+        verify(project_dir=paths.lean_project_dir)
+    except typer.Exit:
+        rprint("[green]Smoke test passed:[/green] pipeline detects unresolved `sorry` correctly.")
+        return
+    raise RuntimeError(
+        "Smoke test expected verification failure before proving, but verify passed."
+    )
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/constants.py

@@ -0,0 +1,10 @@
+PACKAGE_NAME = "ProofWorkspace"
+LEAN_TOOLCHAIN = "leanprover/lean4:v4.28.0"
+MATHLIB_HASH = "8f9d9cff6bd728b17a24e163c9402775d9e6a365"
+
+PROOF_AGENT_ROLE = "deep-thinking model for complex mathematics"
+PROOF_AGENT_NOTES = (
+    "Use a high-capability reasoning model from the active agent stack for theorem proving."
+)
+OPS_AGENT_ROLE = "smaller programming model for scripting/reporting"
+OPS_AGENT_NOTES = "Use a smaller coding-oriented model for automation, logs, and status reporting."

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/layout.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Paths:
+    root: Path
+    bin_dir: Path
+    scripts_dir: Path
+    src_dir: Path
+    workspace_dir: Path
+    prompts_dir: Path
+    contexts_dir: Path
+    lean_project_dir: Path
+    data_dir: Path
+    runs_dir: Path
+    logs_dir: Path
+
+
+def default_paths() -> Paths:
+    root = Path(__file__).resolve().parents[2]
+    workspace_dir = root / "workspace"
+    return Paths(
+        root=root,
+        bin_dir=root / "bin",
+        scripts_dir=root / "scripts",
+        src_dir=root / "src",
+        workspace_dir=workspace_dir,
+        prompts_dir=workspace_dir / "prompts",
+        contexts_dir=workspace_dir / "contexts",
+        lean_project_dir=workspace_dir / "lean_project",
+        data_dir=root / "data",
+        runs_dir=root / "data" / "runs",
+        logs_dir=root / "logs",
+    )
+
+
+def ensure_layout(paths: Paths) -> None:
+    for directory in (
+        paths.bin_dir,
+        paths.scripts_dir,
+        paths.src_dir,
+        paths.workspace_dir,
+        paths.prompts_dir,
+        paths.contexts_dir,
+        paths.lean_project_dir,
+        paths.data_dir,
+        paths.runs_dir,
+        paths.logs_dir,
+    ):
+        directory.mkdir(parents=True, exist_ok=True)

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/leanops.py

@@ -0,0 +1,116 @@
+import shutil
+import subprocess
+from pathlib import Path
+
+from tproof.constants import PACKAGE_NAME
+
+
+def run_cmd(command: list[str], cwd: Path) -> tuple[int, str]:
+    proc = subprocess.run(
+        command,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    output = (proc.stdout or "") + (proc.stderr or "")
+    return proc.returncode, output
+
+
+def ensure_toolchain_installed(toolchain: str) -> tuple[int, str]:
+    return run_cmd(["elan", "toolchain", "install", toolchain], cwd=Path.cwd())
+
+
+def lake_update(project_dir: Path) -> tuple[int, str]:
+    return run_cmd(["lake", "update"], cwd=project_dir)
+
+
+def lake_build(project_dir: Path) -> tuple[int, str]:
+    return run_cmd(["lake", "build"], cwd=project_dir)
+
+
+def seed_lean_project(project_dir: Path, lean_toolchain: str, mathlib_hash: str) -> None:
+    project_dir.mkdir(parents=True, exist_ok=True)
+    package_dir = project_dir / PACKAGE_NAME
+    package_dir.mkdir(parents=True, exist_ok=True)
+    (package_dir / "Demo").mkdir(parents=True, exist_ok=True)
+    (package_dir / "Final").mkdir(parents=True, exist_ok=True)
+    (project_dir / "lean-toolchain").write_text(f"{lean_toolchain}\n", encoding="utf-8")
+    (project_dir / "lakefile.lean").write_text(
+        f"""import Lake
+open Lake DSL
+
+package "{PACKAGE_NAME}"
+
+require mathlib from git
+  "https://github.com/leanprover-community/mathlib4.git" @ "{mathlib_hash}"
+
+@[default_target]
+lean_lib "{PACKAGE_NAME}" where
+""",
+        encoding="utf-8",
+    )
+    (project_dir / f"{PACKAGE_NAME}.lean").write_text(
+        f"""import {PACKAGE_NAME}.AllProofs
+""",
+        encoding="utf-8",
+    )
+    all_proofs = project_dir / PACKAGE_NAME / "AllProofs.lean"
+    if not all_proofs.is_file():
+        all_proofs.write_text(
+            """/-
+Auto-generated import index for proof modules.
+Regenerate with: tproof reindex
+-/
+""",
+            encoding="utf-8",
+        )
+
+    placeholder = project_dir / PACKAGE_NAME / "Demo" / "Placeholder.lean"
+    if not placeholder.is_file():
+        placeholder.write_text(
+            f"""namespace {PACKAGE_NAME}.Demo
+
+theorem placeholder : True := by
+  trivial
+
+end {PACKAGE_NAME}.Demo
+""",
+            encoding="utf-8",
+        )
+
+
+def reindex_allproofs(project_dir: Path) -> Path:
+    package_dir = project_dir / PACKAGE_NAME
+    modules: list[str] = []
+    if package_dir.is_dir():
+        for lean_file in sorted(package_dir.rglob("*.lean")):
+            rel = lean_file.relative_to(project_dir).with_suffix("")
+            module_name = ".".join(rel.parts)
+            if module_name.endswith(".AllProofs"):
+                continue
+            modules.append(module_name)
+
+    all_proofs_path = package_dir / "AllProofs.lean"
+    lines = [
+        "/-",
+        "Auto-generated import index for proof modules.",
+        "Regenerate with: tproof reindex",
+        "-/",
+        "",
+    ]
+    for module in modules:
+        lines.append(f"import {module}")
+    lines.append("")
+    all_proofs_path.write_text("\n".join(lines), encoding="utf-8")
+    return all_proofs_path
+
+
+def snapshot_project(source_project_dir: Path, destination_dir: Path) -> None:
+    if destination_dir.exists():
+        shutil.rmtree(destination_dir)
+    shutil.copytree(
+        source_project_dir,
+        destination_dir,
+        ignore=shutil.ignore_patterns(".lake", "build", "__pycache__", "*.olean", "*.ilean"),
+    )

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/runstore.py

@@ -0,0 +1,58 @@
+import json
+import re
+import secrets
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from tproof.layout import Paths
+
+
+def now_utc_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _sanitize_label(label: str) -> str:
+    cleaned = re.sub(r"[^a-zA-Z0-9_-]+", "-", label.strip()).strip("-")
+    return cleaned[:40] if cleaned else "run"
+
+
+def new_run_id(label: str | None = None) -> str:
+    prefix = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    token = secrets.token_hex(2)
+    if label:
+        return f"{prefix}_{_sanitize_label(label)}_{token}"
+    return f"{prefix}_{token}"
+
+
+def run_dir(paths: Paths, run_id: str) -> Path:
+    return paths.runs_dir / run_id
+
+
+def run_file(paths: Paths, run_id: str) -> Path:
+    return run_dir(paths, run_id) / "run.json"
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def create_run(paths: Paths, run_id: str, payload: dict[str, Any]) -> None:
+    run_dir(paths, run_id).mkdir(parents=True, exist_ok=True)
+    write_json(run_file(paths, run_id), payload)
+
+
+def load_run(paths: Paths, run_id: str) -> dict[str, Any]:
+    path = run_file(paths, run_id)
+    if not path.is_file():
+        raise FileNotFoundError(f"Unknown run id '{run_id}'. Missing file: {path}")
+    return read_json(path)
+
+
+def save_run(paths: Paths, run_id: str, payload: dict[str, Any]) -> None:
+    write_json(run_file(paths, run_id), payload)

package/skills/flywheel-prove/assets/pipeline_template/src/tproof/tasking.py

@@ -0,0 +1,94 @@
+import re
+from pathlib import Path
+
+from tproof.constants import (
+    OPS_AGENT_NOTES,
+    OPS_AGENT_ROLE,
+    PACKAGE_NAME,
+    PROOF_AGENT_NOTES,
+    PROOF_AGENT_ROLE,
+)
+
+
+def read_task_prompt(prompt_file: Path | None, prompt_text: str | None) -> str:
+    if prompt_file and prompt_text:
+        raise ValueError("Pass either --prompt-file or --prompt-text, not both.")
+    if prompt_file:
+        return prompt_file.read_text(encoding="utf-8").strip()
+    if prompt_text:
+        return prompt_text.strip()
+    raise ValueError("Pass one of --prompt-file or --prompt-text.")
+
+
+def discover_project_modules(project_dir: Path) -> list[str]:
+    package_dir = project_dir / PACKAGE_NAME
+    if not package_dir.is_dir():
+        return []
+
+    modules: list[str] = []
+    for lean_file in sorted(package_dir.rglob("*.lean")):
+        rel = lean_file.relative_to(project_dir).with_suffix("")
+        module_name = ".".join(rel.parts)
+        if module_name.endswith(".AllProofs"):
+            continue
+        modules.append(module_name)
+    return modules
+
+
+def find_sorry_hits(project_dir: Path) -> list[str]:
+    word = re.compile(r"\bsorry\b")
+    hits: list[str] = []
+    package_dir = project_dir / PACKAGE_NAME
+    if not package_dir.is_dir():
+        return hits
+
+    for lean_file in sorted(package_dir.rglob("*.lean")):
+        rel = lean_file.relative_to(project_dir)
+        lines = lean_file.read_text(encoding="utf-8").splitlines()
+        for line_number, line in enumerate(lines, start=1):
+            if word.search(line):
+                hits.append(f"{rel}:{line_number}")
+    return hits
+
+
+def build_run_brief(
+    *,
+    run_id: str,
+    task_prompt: str,
+    known_modules: list[str],
+    sorry_hits: list[str],
+    context_text: str | None,
+) -> str:
+    module_block = "\n".join(f"- {module}" for module in known_modules) or "- (none)"
+    sorry_block = "\n".join(f"- {hit}" for hit in sorry_hits) or "- (none)"
+    context_block = context_text.strip() if context_text else "(none)"
+
+    return f"""# Run Brief: {run_id}
+
+## Task
+{task_prompt}
+
+## Context
+{context_block}
+
+## Known Modules
+{module_block}
+
+## Outstanding `sorry` Locations
+{sorry_block}
+
+## Model Routing (Required)
+1. Mathematical proving worker:
+   - Profile: `{PROOF_AGENT_ROLE}`
+   - Guidance: {PROOF_AGENT_NOTES}
+   - Scope: theorem proving, proof search, lemma decomposition, difficult Lean terms.
+2. Programming/ops/reporting worker:
+   - Profile: `{OPS_AGENT_ROLE}`
+   - Guidance: {OPS_AGENT_NOTES}
+   - Scope: scripts, repo hygiene, status summaries, verification logs, run metadata updates.
+
+## Execution Pattern
+1. Ask the proving worker to edit files under `workspace/lean_project/`.
+2. Ask the ops worker to run `uv run -m tproof.cli verify` and summarize failures.
+3. Iterate until verification passes with no `sorry`.
+"""

package/skills/flywheel-prove/assets/pipeline_template/workspace/prompts/fill_sorries.txt

@@ -0,0 +1,3 @@
+Fill all sorry placeholders in this Lean project.
+Keep theorem statements unchanged.
+Prefer using existing lemmas from this project and Mathlib.