lean-lsp-mcp 0.19.1__py3-none-any.whl → 0.20.0__py3-none-any.whl

lean_lsp_mcp/__init__.py

@@ -36,6 +36,16 @@ def main():
         type=str,
         help="Override loogle cache location (default: ~/.cache/lean-lsp-mcp/loogle)",
     )
+    parser.add_argument(
+        "--repl",
+        action="store_true",
+        help="Enable fast REPL-based multi-attempt (~5x faster). Requires Lean REPL.",
+    )
+    parser.add_argument(
+        "--repl-timeout",
+        type=int,
+        help="REPL command timeout in seconds (default: 60)",
+    )
     args = parser.parse_args()
 
     # Set env vars from CLI args (CLI takes precedence over env vars)
@@ -43,6 +53,10 @@ def main():
         os.environ["LEAN_LOOGLE_LOCAL"] = "true"
     if args.loogle_cache_dir:
         os.environ["LEAN_LOOGLE_CACHE_DIR"] = args.loogle_cache_dir
+    if args.repl:
+        os.environ["LEAN_REPL"] = "true"
+    if args.repl_timeout:
+        os.environ["LEAN_REPL_TIMEOUT"] = str(args.repl_timeout)
 
     mcp.settings.host = args.host
     mcp.settings.port = args.port

lean_lsp_mcp/instructions.py

@@ -16,19 +16,19 @@ INSTRUCTIONS = """## General Rules
 - **lean_profile_proof**: Profile a theorem for performance. Shows tactic hotspots. SLOW!
 
 ## Search Tools (rate limited)
-- **lean_leansearch** (3/30s): Natural language → mathlib
-- **lean_loogle** (3/30s): Type pattern → mathlib
+- **lean_leansearch** (3/30s): Natural language -> mathlib
+- **lean_loogle** (3/30s): Type pattern -> mathlib
 - **lean_leanfinder** (10/30s): Semantic/conceptual search
-- **lean_state_search** (3/30s): Goal → closing lemmas
-- **lean_hammer_premise** (3/30s): Goal → premises for simp/aesop
+- **lean_state_search** (3/30s): Goal -> closing lemmas
+- **lean_hammer_premise** (3/30s): Goal -> premises for simp/aesop
 
 ## Search Decision Tree
-1. "Does X exist locally?" → lean_local_search
-2. "I need a lemma that says X" → lean_leansearch
-3. "Find lemma with type pattern" → lean_loogle
-4. "What's the Lean name for concept X?" → lean_leanfinder
-5. "What closes this goal?" → lean_state_search
-6. "What to feed simp?" → lean_hammer_premise
+1. "Does X exist locally?" -> lean_local_search
+2. "I need a lemma that says X" -> lean_leansearch
+3. "Find lemma with type pattern" -> lean_loogle
+4. "What's the Lean name for concept X?" -> lean_leanfinder
+5. "What closes this goal?" -> lean_state_search
+6. "What to feed simp?" -> lean_hammer_premise
 
 After finding a name: lean_local_search to verify, lean_hover_info for signature.
 
@@ -37,4 +37,5 @@ List tools return JSON arrays. Empty = `[]`.
 
 ## Error Handling
 Check `isError` in responses: `true` means failure (timeout/LSP error), while `[]` with `isError: false` means no results found.
+
 """

lean_lsp_mcp/loogle.py

@@ -8,12 +8,14 @@ import json
 import logging
 import os
 import shutil
+import ssl
 import subprocess
 import urllib.parse
 import urllib.request
 from pathlib import Path
 from typing import Any
 
+import certifi
 import orjson
 
 from lean_lsp_mcp.models import LoogleResult
@@ -35,7 +37,8 @@ def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
             f"https://loogle.lean-lang.org/json?q={urllib.parse.quote(query)}",
             headers={"User-Agent": "lean-lsp-mcp/0.1"},
         )
-        with urllib.request.urlopen(req, timeout=10) as response:
+        ssl_ctx = ssl.create_default_context(cafile=certifi.where())
+        with urllib.request.urlopen(req, timeout=10, context=ssl_ctx) as response:
             results = orjson.loads(response.read())
         if "hits" not in results:
             return "No results found."
@@ -139,9 +142,12 @@ class LoogleManager:
             self._run(["lake", "exe", "cache", "get"], timeout=600)
         except Exception as e:
             logger.warning(f"Cache download: {e}")
-        logger.info("Building loogle...")
+        logger.info("Building loogle (this may a few minutes)...")
         try:
-            return self._run(["lake", "build"], timeout=900).returncode == 0
+            result = self._run(["lake", "build"], timeout=900)
+            if result.returncode != 0:
+                logger.error(f"Build failed: {result.stderr[:1000]}")
+            return result.returncode == 0
         except Exception as e:
             logger.error(f"Build error: {e}")
             return False

lean_lsp_mcp/repl.py

@@ -0,0 +1,260 @@
+"""Lean REPL for fast multi-attempt tactic execution using tactic mode."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import platform
+from dataclasses import dataclass, field
+from typing import Any
+
+if platform.system() != "Windows":
+    import resource
+
+
+class ReplError(Exception):
+    pass
+
+
+@dataclass
+class SnippetResult:
+    goals: list[str] = field(default_factory=list)
+    messages: list[dict[str, Any]] = field(default_factory=list)
+    proof_status: str | None = None
+    error: str | None = None
+
+
+def repl_enabled() -> bool:
+    return os.environ.get("LEAN_REPL", "").lower() in ("1", "true", "yes")
+
+
+def find_repl_binary(project_dir: str | None = None) -> str | None:
+    """Find REPL binary: env var > .lake/packages > PATH."""
+    import shutil
+    from pathlib import Path
+
+    # 1. Explicit env var
+    if path := os.environ.get("LEAN_REPL_PATH"):
+        return path if Path(path).exists() or shutil.which(path) else None
+
+    # 2. Auto-detect from .lake/packages (common location after `lake build`)
+    if project_dir:
+        candidates = [
+            Path(project_dir)
+            / ".lake"
+            / "packages"
+            / "repl"
+            / ".lake"
+            / "build"
+            / "bin"
+            / "repl",
+            Path(project_dir) / ".lake" / "build" / "bin" / "repl",
+        ]
+        for p in candidates:
+            if p.exists():
+                return str(p)
+
+    # 3. Fall back to PATH
+    if found := shutil.which("repl"):
+        return found
+
+    return None
+
+
+def _split_imports(code: str) -> tuple[str, str]:
+    """Split code into (header with imports, body)."""
+    lines = code.splitlines()
+    i = 0
+    while i < len(lines) and (not lines[i].strip() or lines[i].startswith("import ")):
+        i += 1
+
+    # Deduplicate imports while preserving order
+    imports = [ln.strip() for ln in lines[:i] if ln.startswith("import ")]
+    header = "\n".join(dict.fromkeys(imports))
+    return header, "\n".join(lines[i:])
+
+
+class Repl:
+    """Lean REPL using tactic mode for fast multi-attempt."""
+
+    def __init__(self, project_dir: str, repl_path: str | None = None):
+        self.project_dir = project_dir
+        self.repl_path = repl_path or find_repl_binary(project_dir) or "repl"
+        self.timeout = int(os.environ.get("LEAN_REPL_TIMEOUT", "60"))
+        self.mem_mb = int(os.environ.get("LEAN_REPL_MEM_MB", "8192"))
+        self._proc: asyncio.subprocess.Process | None = None
+        self._header: str | None = None
+        self._header_env: int | None = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        """Start REPL subprocess."""
+        kwargs: dict[str, Any] = {
+            "cwd": self.project_dir,
+            "stdin": asyncio.subprocess.PIPE,
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+        }
+        if platform.system() != "Windows":
+            kwargs["start_new_session"] = True
+            # Memory limit on Unix systems
+            if platform.system() == "Linux":
+                limit = resource.RLIMIT_AS  # Virtual memory
+            else:  # macOS
+                limit = resource.RLIMIT_RSS  # Resident set size
+            mem = self.mem_mb * 1024 * 1024
+            kwargs["preexec_fn"] = lambda: resource.setrlimit(limit, (mem, mem))
+        self._proc = await asyncio.create_subprocess_exec(
+            "lake", "env", self.repl_path, **kwargs
+        )
+
+    async def _send(self, cmd: dict[str, Any]) -> dict[str, Any]:
+        """Send command and return response."""
+        if not self._proc or not self._proc.stdin or not self._proc.stdout:
+            raise ReplError("REPL not running")
+
+        self._proc.stdin.write((json.dumps(cmd) + "\n\n").encode())
+        await self._proc.stdin.drain()
+
+        lines = []
+        while True:
+            line = await self._proc.stdout.readline()
+            if not line or not line.strip():
+                break
+            lines.append(line)
+
+        if not lines:
+            raise ReplError("No response from REPL")
+        return json.loads(b"".join(lines))
+
+    async def _send_cmd(self, code: str, env: int | None = None) -> dict[str, Any]:
+        """Send a command (code) to the REPL."""
+        cmd: dict[str, Any] = {"cmd": code}
+        if env is not None:
+            cmd["env"] = env
+        return await self._send(cmd)
+
+    async def _send_tactic(self, tactic: str, proof_state: int) -> dict[str, Any]:
+        """Send a tactic to run in a proof state."""
+        return await self._send({"tactic": tactic, "proofState": proof_state})
+
+    async def _ensure_header(self, header: str) -> int | None:
+        """Ensure REPL is running with given header, return header env."""
+        if self._header != header:
+            await self.close()
+            self._header = header
+            self._header_env = None
+
+        if not self._proc or self._proc.returncode is not None:
+            await self._start()
+            if header:
+                resp = await self._send_cmd(header, env=None)
+                if "error" in resp:
+                    raise ReplError(f"Failed to load imports: {resp['error']}")
+                self._header_env = resp.get("env")
+
+        return self._header_env
+
+    async def run_snippets(
+        self, base_code: str, snippets: list[str]
+    ) -> list[SnippetResult]:
+        """Run multiple tactic snippets using tactic mode.
+
+        1. Load header (imports) - cached across calls
+        2. Send body + sorry to get proofState
+        3. Run each tactic via tactic mode (very fast)
+        """
+        header, body = _split_imports(base_code)
+
+        async with self._lock:
+            try:
+                # Load imports (cached)
+                header_env = await asyncio.wait_for(
+                    self._ensure_header(header), timeout=self.timeout
+                )
+
+                # Send body with sorry to get proof state
+                if not body.strip():
+                    return [SnippetResult(error="No proof body") for _ in snippets]
+
+                # Ensure proper whitespace before sorry
+                body_with_sorry = body.rstrip() + "\n  sorry"
+                resp = await asyncio.wait_for(
+                    self._send_cmd(body_with_sorry, env=header_env),
+                    timeout=self.timeout,
+                )
+
+                if "error" in resp:
+                    return [SnippetResult(error=resp["error"]) for _ in snippets]
+
+                # Get proof state from the sorry
+                sorries = resp.get("sorries", [])
+                if not sorries:
+                    # No sorry = no proof goal, check messages for errors
+                    msgs = resp.get("messages", [])
+                    err = "; ".join(
+                        m.get("data", "") for m in msgs if m.get("severity") == "error"
+                    )
+                    return [
+                        SnippetResult(error=err or "No proof goal found")
+                        for _ in snippets
+                    ]
+
+                proof_state = sorries[0].get("proofState")
+                if proof_state is None:
+                    return [
+                        SnippetResult(error="No proofState returned") for _ in snippets
+                    ]
+
+                # Run each tactic in tactic mode
+                results = []
+                for snippet in snippets:
+                    try:
+                        resp = await asyncio.wait_for(
+                            self._send_tactic(snippet.strip(), proof_state),
+                            timeout=self.timeout,
+                        )
+
+                        if "error" in resp:
+                            # Lean error (tactic failed)
+                            results.append(SnippetResult(error=resp["error"]))
+                        else:
+                            goals = resp.get("goals", [])
+                            messages = resp.get("messages", [])
+                            proof_status = resp.get("proofStatus")
+                            results.append(
+                                SnippetResult(
+                                    goals=goals,
+                                    messages=messages,
+                                    proof_status=proof_status,
+                                )
+                            )
+                    except Exception as e:
+                        results.append(SnippetResult(error=str(e)))
+
+                return results
+
+            except Exception as e:
+                await self.close()
+                raise ReplError(str(e)) from e
+
+    async def close(self) -> None:
+        if not self._proc:
+            return
+        proc, self._proc = self._proc, None
+        self._header = None
+        self._header_env = None
+        try:
+            if platform.system() != "Windows":
+                os.killpg(os.getpgid(proc.pid), 9)
+            else:
+                proc.kill()
+        except (ProcessLookupError, OSError):
+            pass
+        try:
+            await asyncio.wait_for(proc.wait(), timeout=1.0)
+        except asyncio.TimeoutError:
+            pass
+        if hasattr(proc, "_transport") and proc._transport:
+            proc._transport.close()

lean_lsp_mcp/server.py

@@ -1,7 +1,9 @@
 import asyncio
 import functools
+import logging.config
 import os
 import re
+import ssl
 import time
 import urllib
 import uuid
@@ -11,6 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated, Dict, List, Optional
 
+import certifi
 import orjson
 from leanclient import DocumentContentChange, LeanLSPClient
 from mcp.server.auth.settings import AuthSettings
@@ -27,6 +30,7 @@ from lean_lsp_mcp.client_utils import (
 from lean_lsp_mcp.file_utils import get_file_contents
 from lean_lsp_mcp.instructions import INSTRUCTIONS
 from lean_lsp_mcp.loogle import LoogleManager, loogle_remote
+from lean_lsp_mcp.repl import Repl, repl_enabled
 from lean_lsp_mcp.models import (
     AttemptResult,
     BuildResult,
@@ -56,6 +60,9 @@ from lean_lsp_mcp.models import (
     StateSearchResults,
     TermGoalState,
 )
+
+# REPL models not imported - low-level REPL tools not exposed to keep API simple.
+# The model uses lean_multi_attempt which handles REPL internally.
 from lean_lsp_mcp.outline_utils import generate_outline_data
 from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
 from lean_lsp_mcp.utils import (
@@ -80,9 +87,10 @@ DIAGNOSTIC_SEVERITY: Dict[int, str] = {1: "error", 2: "warning", 3: "info", 4: "
 
 async def _urlopen_json(req: urllib.request.Request, timeout: float):
     """Run urllib.request.urlopen in a worker thread to avoid blocking the event loop."""
+    ssl_ctx = ssl.create_default_context(cafile=certifi.where())
 
     def _do_request():
-        with urllib.request.urlopen(req, timeout=timeout) as response:
+        with urllib.request.urlopen(req, timeout=timeout, context=ssl_ctx) as response:
             return orjson.loads(response.read())
 
     return await asyncio.to_thread(_do_request)
@@ -97,8 +105,36 @@ async def _safe_report_progress(
         return
 
 
+_LOG_FILE_CONFIG = os.environ.get("LEAN_LOG_FILE_CONFIG", None)
 _LOG_LEVEL = os.environ.get("LEAN_LOG_LEVEL", "INFO")
-configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
+if _LOG_FILE_CONFIG:
+    try:
+        if _LOG_FILE_CONFIG.endswith((".yaml", ".yml")):
+            import yaml
+
+            with open(_LOG_FILE_CONFIG, "r", encoding="utf-8") as f:
+                cfg = yaml.safe_load(f)
+            logging.config.dictConfig(cfg)
+        elif _LOG_FILE_CONFIG.endswith(".json"):
+            with open(_LOG_FILE_CONFIG, "r", encoding="utf-8") as f:
+                cfg = orjson.loads(f.read())
+            logging.config.dictConfig(cfg)
+        else:
+            # .ini / fileConfig
+            logging.config.fileConfig(_LOG_FILE_CONFIG, disable_existing_loggers=False)
+    except Exception as e:
+        # fallback to LEAN_LOG_LEVEL so server still runs
+        # use the existing configure_logging helper to set level
+        configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
+        logger = get_logger(__name__)  # temporary to emit the warning
+        logger.warning(
+            "Failed to load logging config %s: %s. Falling back to LEAN_LOG_LEVEL.",
+            _LOG_FILE_CONFIG,
+            e,
+        )
+else:
+    configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
+
 logger = get_logger(__name__)
 
 
@@ -113,12 +149,17 @@ class AppContext:
     lean_search_available: bool
     loogle_manager: LoogleManager | None = None
     loogle_local_available: bool = False
+    # REPL for efficient multi-attempt execution
+    repl: Repl | None = None
+    repl_enabled: bool = False
 
 
 @asynccontextmanager
 async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
     loogle_manager: LoogleManager | None = None
     loogle_local_available = False
+    repl: Repl | None = None
+    repl_on = False
 
     try:
         lean_project_path_str = os.environ.get("LEAN_PROJECT_PATH", "").strip()
@@ -140,6 +181,26 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
             else:
                 logger.warning("Local loogle installation failed, will use remote API")
 
+        # Initialize REPL if enabled
+        if repl_enabled():
+            if lean_project_path:
+                from lean_lsp_mcp.repl import find_repl_binary
+
+                repl_bin = find_repl_binary(str(lean_project_path))
+                if repl_bin:
+                    logger.info("REPL enabled, using: %s", repl_bin)
+                    repl = Repl(project_dir=str(lean_project_path), repl_path=repl_bin)
+                    repl_on = True
+                    logger.info("REPL initialized: timeout=%ds", repl.timeout)
+                else:
+                    logger.warning(
+                        "REPL enabled but binary not found. "
+                        'Add `require repl from git "https://github.com/leanprover-community/repl"` '
+                        "to lakefile and run `lake build repl`. Falling back to LSP."
+                    )
+            else:
+                logger.warning("REPL requires LEAN_PROJECT_PATH to be set")
+
         context = AppContext(
             lean_project_path=lean_project_path,
             client=None,
@@ -153,6 +214,8 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
             lean_search_available=_RG_AVAILABLE,
             loogle_manager=loogle_manager,
             loogle_local_available=loogle_local_available,
+            repl=repl,
+            repl_enabled=repl_on,
         )
         yield context
     finally:
@@ -164,6 +227,9 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         if loogle_manager:
             await loogle_manager.stop()
 
+        if repl:
+            await repl.close()
+
 
 mcp_kwargs = dict(
     name="Lean LSP",
@@ -823,24 +889,65 @@ def declaration_file(
     return DeclarationInfo(file_path=str(abs_path), content=file_content)
 
 
-@mcp.tool(
-    "lean_multi_attempt",
-    annotations=ToolAnnotations(
-        title="Multi-Attempt",
-        readOnlyHint=True,
-        idempotentHint=True,
-        openWorldHint=False,
-    ),
-)
-def multi_attempt(
+async def _multi_attempt_repl(
     ctx: Context,
-    file_path: Annotated[str, Field(description="Absolute path to Lean file")],
-    line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
-    snippets: Annotated[
-        List[str], Field(description="Tactics to try (3+ recommended)")
-    ],
+    file_path: str,
+    line: int,
+    snippets: List[str],
+) -> MultiAttemptResult | None:
+    """Try tactics using REPL (fast path)."""
+    app_ctx: AppContext = ctx.request_context.lifespan_context
+    if not app_ctx.repl_enabled or not app_ctx.repl:
+        return None
+
+    try:
+        content = get_file_contents(file_path)
+        if content is None:
+            return None
+        lines = content.splitlines()
+        if line > len(lines):
+            return None
+
+        base_code = "\n".join(lines[: line - 1])
+        repl_results = await app_ctx.repl.run_snippets(base_code, snippets)
+
+        results = []
+        for snippet, pr in zip(snippets, repl_results):
+            diagnostics = [
+                DiagnosticMessage(
+                    severity=m.get("severity", "info"),
+                    message=m.get("data", ""),
+                    line=m.get("pos", {}).get("line", 0),
+                    column=m.get("pos", {}).get("column", 0),
+                )
+                for m in (pr.messages or [])
+            ]
+            if pr.error:
+                diagnostics.append(
+                    DiagnosticMessage(
+                        severity="error", message=pr.error, line=0, column=0
+                    )
+                )
+            results.append(
+                AttemptResult(
+                    snippet=snippet.rstrip("\n"),
+                    goals=pr.goals or [],
+                    diagnostics=diagnostics,
+                )
+            )
+        return MultiAttemptResult(items=results)
+    except Exception as e:
+        logger.debug(f"REPL multi_attempt failed: {e}")
+        return None
+
+
+def _multi_attempt_lsp(
+    ctx: Context,
+    file_path: str,
+    line: int,
+    snippets: List[str],
 ) -> MultiAttemptResult:
-    """Try multiple tactics without modifying file. Returns goal state for each."""
+    """Try tactics using LSP file modifications (fallback)."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
         raise LeanToolError(
@@ -849,25 +956,22 @@ def multi_attempt(
 
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
     client.open_file(rel_path)
+    original_content = get_file_contents(file_path)
 
     try:
         results: List[AttemptResult] = []
-        # Avoid mutating caller-provided snippets; normalize locally per attempt
         for snippet in snippets:
             snippet_str = snippet.rstrip("\n")
             payload = f"{snippet_str}\n"
-            # Create a DocumentContentChange for the snippet
             change = DocumentContentChange(
                 payload,
                 [line - 1, 0],
                 [line, 0],
             )
-            # Apply the change to the file, capture diagnostics and goal state
             client.update_file(rel_path, [change])
             diag = client.get_diagnostics(rel_path)
             check_lsp_response(diag, "get_diagnostics")
             filtered_diag = filter_diagnostics_by_position(diag, line - 1, None)
-            # Use the snippet text length without any trailing newline for the column
             goal_result = client.get_goal(rel_path, line - 1, len(snippet_str))
             goals = extract_goals_list(goal_result)
             results.append(
@@ -880,12 +984,41 @@ def multi_attempt(
 
         return MultiAttemptResult(items=results)
     finally:
-        try:
-            client.close_files([rel_path])
-        except Exception as exc:  # pragma: no cover - close failures only logged
-            logger.warning(
-                "Failed to close `%s` after multi_attempt: %s", rel_path, exc
-            )
+        if original_content is not None:
+            try:
+                client.update_file_content(rel_path, original_content)
+            except Exception as exc:
+                logger.warning(
+                    "Failed to restore `%s` after multi_attempt: %s", rel_path, exc
+                )
+
+
+@mcp.tool(
+    "lean_multi_attempt",
+    annotations=ToolAnnotations(
+        title="Multi-Attempt",
+        readOnlyHint=True,
+        idempotentHint=True,
+        openWorldHint=False,
+    ),
+)
+async def multi_attempt(
+    ctx: Context,
+    file_path: Annotated[str, Field(description="Absolute path to Lean file")],
+    line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
+    snippets: Annotated[
+        List[str],
+        Field(description="Tactics to try (3+ recommended)"),
+    ],
+) -> MultiAttemptResult:
+    """Try multiple tactics without modifying file. Returns goal state for each."""
+    # Priority 1: REPL
+    result = await _multi_attempt_repl(ctx, file_path, line, snippets)
+    if result is not None:
+        return result
+
+    # Priority 2: LSP approach (fallback)
+    return _multi_attempt_lsp(ctx, file_path, line, snippets)
 
 
 @mcp.tool(

{lean_lsp_mcp-0.19.1.dist-info → lean_lsp_mcp-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.19.1
+Version: 0.20.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -11,6 +11,9 @@ License-File: LICENSE
 Requires-Dist: leanclient==0.9.2
 Requires-Dist: mcp[cli]==1.25.0
 Requires-Dist: orjson>=3.11.1
+Requires-Dist: certifi>=2024.0.0
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6.0; extra == "yaml"
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"
 Provides-Extra: dev
@@ -266,8 +269,10 @@ l1c1-l1c6, severity: 3
 
 #### lean_multi_attempt
 
-Attempt multiple lean code snippets on a line and return goal state and diagnostics for each snippet.
-This tool is useful to screen different proof attempts before using the most promising one.
+Attempt multiple tactics on a line and return goal state and diagnostics for each.
+Useful to screen different proof attempts before committing to one.
+
+When `LEAN_REPL=true`, uses the REPL tactic mode for up to 5x faster execution (see [Environment Variables](#environment-variables)).
 
 <details>
 <summary>Example output (attempting `rw [Nat.pow_sub (Fintype.card_pos_of_nonempty S)]` and `by_contra h_neq`)</summary>
@@ -483,7 +488,12 @@ This MCP server works out-of-the-box without any configuration. However, a few o
 ### Environment Variables
 
 - `LEAN_LOG_LEVEL`: Log level for the server. Options are "INFO", "WARNING", "ERROR", "NONE". Defaults to "INFO".
+- `LEAN_LOG_FILE_CONFIG`: Config file path for logging, with priority over `LEAN_LOG_LEVEL`. If not set, logs are printed to stdout.
 - `LEAN_PROJECT_PATH`: Path to your Lean project root. Set this if the server cannot automatically detect your project.
+- `LEAN_REPL`: Set to `true`, `1`, or `yes` to enable fast REPL-based `lean_multi_attempt` (~5x faster, see [REPL Setup](#repl-setup)).
+- `LEAN_REPL_PATH`: Path to the `repl` binary. Auto-detected from `.lake/packages/repl/` if not set.
+- `LEAN_REPL_TIMEOUT`: Per-command timeout in seconds (default: 60).
+- `LEAN_REPL_MEM_MB`: Max memory per REPL in MB (default: 8192). Only enforced on Linux/macOS.
 - `LEAN_LSP_MCP_TOKEN`: Secret token for bearer authentication when using `streamable-http` or `sse` transport.
 - `LEAN_STATE_SEARCH_URL`: URL for a self-hosted [premise-search.com](https://premise-search.com) instance.
 - `LEAN_HAMMER_URL`: URL for a self-hosted [Lean Hammer Premise Search](https://github.com/hanwenzhu/lean-premise-server) instance.
@@ -544,6 +554,36 @@ uvx lean-lsp-mcp --transport streamable-http
 
 Clients should then include the token in the `Authorization` header.
 
+### REPL Setup
+
+Enable fast REPL-based `lean_multi_attempt` (~5x faster). Uses [leanprover-community/repl](https://github.com/leanprover-community/repl) tactic mode.
+
+**1. Add REPL to your Lean project's `lakefile.toml`:**
+
+```toml
+[[require]]
+name = "repl"
+git = "https://github.com/leanprover-community/repl"
+rev = "v4.25.0"  # Match your Lean version
+```
+
+**2. Build it:**
+
+```bash
+lake build repl
+```
+
+**3. Enable via CLI or environment variable:**
+
+```bash
+uvx lean-lsp-mcp --repl
+
+# Or via environment variable
+export LEAN_REPL=true
+```
+
+The REPL binary is auto-detected from `.lake/packages/repl/`. Falls back to LSP if not found.
+
 ### Local Loogle
 
 Run loogle locally to avoid the remote API's rate limit (3 req/30s). First run takes ~5-10 minutes to build; subsequent runs start in seconds.
@@ -590,9 +630,15 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
-## Publications using lean-lsp-mcp
+## Publications and Formalization Projects using lean-lsp-mcp
 
 - Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+- Numina-Lean-Agent: An Open and General Agentic Reasoning System for Formal Mathematics [arxiv](https://arxiv.org/abs/2601.14027) [github](https://github.com/project-numina/numina-lean-agent)
+- A Group-Theoretic Approach to Shannon Capacity of Graphs and a Limit Theorem from Lattice Packings [github](https://github.com/jzuiddam/GroupTheoreticShannonCapacity/)
+
+## Talks
+
+lean-lsp-mcp: Tools for agentic interaction with Lean (Lean Together 2026) [youtube](https://www.youtube.com/watch?v=uttbYaTaF-E)
 
 ## Related Projects
 

lean_lsp_mcp-0.20.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+lean_lsp_mcp/__init__.py,sha256=0D0XJqzMsM_4EFOrfXQsRhn_F5n3z_Dzc7_5urTwehs,1855
+lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
+lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
+lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
+lean_lsp_mcp/instructions.py,sha256=pAmgg-Lr3-t0f377SQP4ahtfsHAmAbfZ7dXfcQQv-Zg,1985
+lean_lsp_mcp/loogle.py,sha256=PJ_z9InIk-3yJsWmkhVctPOYIbovD7Z9A3vrGuC1Em0,15774
+lean_lsp_mcp/models.py,sha256=dyjM6m36PscEtBiLjGxDxeM5b0ELpRTw1SUayYDeOwA,7549
+lean_lsp_mcp/outline_utils.py,sha256=i7xL27UO2rTT48IdKXkoMq5FVJNxyA3tPuQREOBf_gU,11105
+lean_lsp_mcp/profile_utils.py,sha256=LwtBmgwrywPiNhWS6xK-_QF-FTy0uWkW6NCK5l5rCQI,8144
+lean_lsp_mcp/repl.py,sha256=5a3JrfwU6lvZaPfsCzdCqTm2LrbGoXOdh9ov6RVkf84,9259
+lean_lsp_mcp/search_utils.py,sha256=MLqKGe4bhEvyfFLIBCmiDxkbcH4O5J3vl9mWnRSb_v0,6801
+lean_lsp_mcp/server.py,sha256=kXzKrmfuoaLwZy8SHQoILhaXbf2e2OoyEJi1G5lswzM,50051
+lean_lsp_mcp/utils.py,sha256=dGv84a4E-szOkQVYtSE-q9GbawpiVk47qvrkTN-Clts,13478
+lean_lsp_mcp-0.20.0.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
+lean_lsp_mcp-0.20.0.dist-info/METADATA,sha256=apVisDrqIP-TAGv0bJKnssn4gikRt9la2Pcq_-A7Tzg,23168
+lean_lsp_mcp-0.20.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lean_lsp_mcp-0.20.0.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
+lean_lsp_mcp-0.20.0.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
+lean_lsp_mcp-0.20.0.dist-info/RECORD,,

{lean_lsp_mcp-0.19.1.dist-info → lean_lsp_mcp-0.20.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lean_lsp_mcp-0.19.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-lean_lsp_mcp/__init__.py,sha256=MN_bNFyb5-p33JWWGbrlUYBd1UUMQKtZYGC9KCh2mtM,1403
-lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
-lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
-lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
-lean_lsp_mcp/instructions.py,sha256=HgENbIe1nwIzKXqf_yYC44f7YQ8j47zJgKBYmmaD_UI,1994
-lean_lsp_mcp/loogle.py,sha256=zUgnDWoTIqa4G6GXStAIxxJUR545YbU8Z-8KMjddKV0,15500
-lean_lsp_mcp/models.py,sha256=dyjM6m36PscEtBiLjGxDxeM5b0ELpRTw1SUayYDeOwA,7549
-lean_lsp_mcp/outline_utils.py,sha256=i7xL27UO2rTT48IdKXkoMq5FVJNxyA3tPuQREOBf_gU,11105
-lean_lsp_mcp/profile_utils.py,sha256=LwtBmgwrywPiNhWS6xK-_QF-FTy0uWkW6NCK5l5rCQI,8144
-lean_lsp_mcp/search_utils.py,sha256=MLqKGe4bhEvyfFLIBCmiDxkbcH4O5J3vl9mWnRSb_v0,6801
-lean_lsp_mcp/server.py,sha256=VFdyRxHJsBM0sehHyvEkdG17HQl78MYgBgH8usBkpUU,45430
-lean_lsp_mcp/utils.py,sha256=dGv84a4E-szOkQVYtSE-q9GbawpiVk47qvrkTN-Clts,13478
-lean_lsp_mcp-0.19.1.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
-lean_lsp_mcp-0.19.1.dist-info/METADATA,sha256=D2CgfgVE_jKV0Lnz3TDlbCgOdywCk48WXP1Bp9xLZNs,21274
-lean_lsp_mcp-0.19.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lean_lsp_mcp-0.19.1.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
-lean_lsp_mcp-0.19.1.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
-lean_lsp_mcp-0.19.1.dist-info/RECORD,,