lean-lsp-mcp 0.14.1__py3-none-any.whl → 0.16.0__py3-none-any.whl

lean_lsp_mcp/__init__.py

@@ -1,4 +1,5 @@
 import argparse
+import os
 
 from lean_lsp_mcp.server import mcp
 
@@ -24,7 +25,25 @@ def main():
         default=8000,
         help="Host port for transport",
     )
+    parser.add_argument(
+        "--loogle-local",
+        action="store_true",
+        help="Enable local loogle (auto-installs on first run, ~5-10 min). "
+        "Avoids rate limits and network dependencies.",
+    )
+    parser.add_argument(
+        "--loogle-cache-dir",
+        type=str,
+        help="Override loogle cache location (default: ~/.cache/lean-lsp-mcp/loogle)",
+    )
     args = parser.parse_args()
+
+    # Set env vars from CLI args (CLI takes precedence over env vars)
+    if args.loogle_local:
+        os.environ["LEAN_LOOGLE_LOCAL"] = "true"
+    if args.loogle_cache_dir:
+        os.environ["LEAN_LOOGLE_CACHE_DIR"] = args.loogle_cache_dir
+
     mcp.settings.host = args.host
     mcp.settings.port = args.port
     mcp.run(transport=args.transport)

lean_lsp_mcp/instructions.py

@@ -1,17 +1,36 @@
 INSTRUCTIONS = """## General Rules
 - All line and column numbers are 1-indexed.
-- Always analyze/search context before each file edit.
-- This MCP does NOT make permanent file changes. Use other tools for editing.
-- Work iteratively: Small steps, intermediate sorries, frequent checks.
+- This MCP does NOT edit files. Use other tools for editing.
 
 ## Key Tools
-- lean_file_outline: Concise skeleton of a file (imports, docstrings, declarations). Token efficient.
-- lean_local_search: Confirm declarations (theorems/lemmas/defs/etc.) exist. VERY USEFUL AND FAST!
-- lean_goal: Check proof state. USE OFTEN!
-- lean_diagnostic_messages: Understand current proof situation.
-- lean_hover_info: Documentation about terms and lean syntax.
-- lean_leansearch: Search theorems using natural language or Lean terms.
-- lean_loogle: Search definitions and theorems by name, type, or subexpression.
-- lean_leanfinder: Semantic search for theorems using Lean Finder.
-- lean_state_search: Search theorems using goal-based search.
+- **lean_goal**: Proof state at position. Omit `column` for before/after. "no goals" = done!
+- **lean_diagnostic_messages**: Compiler errors/warnings. "no goals to be solved" = remove tactics.
+- **lean_hover_info**: Type signature + docs. Column at START of identifier.
+- **lean_completions**: IDE autocomplete on incomplete code.
+- **lean_local_search**: Fast local declaration search. Use BEFORE trying a lemma name.
+- **lean_file_outline**: Token-efficient file skeleton (slow-ish).
+- **lean_multi_attempt**: Test tactics without editing: `["simp", "ring", "omega"]`
+- **lean_declaration_file**: Get declaration source. Use sparingly (large output).
+- **lean_run_code**: Run standalone snippet. Use rarely.
+- **lean_build**: Rebuild + restart LSP. Only if needed (new imports). SLOW!
+
+## Search Tools (rate limited)
+- **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
+
+## 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
+
+After finding a name: lean_local_search to verify, lean_hover_info for signature.
+
+## Return Formats
+List tools return JSON arrays. Empty = `[]`.
 """

lean_lsp_mcp/loogle.py

@@ -0,0 +1,329 @@
+"""Loogle search - local subprocess and remote API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+import subprocess
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import orjson
+
+from lean_lsp_mcp.models import LoogleResult
+
+logger = logging.getLogger(__name__)
+
+
+def get_cache_dir() -> Path:
+    if d := os.environ.get("LEAN_LOOGLE_CACHE_DIR"):
+        return Path(d)
+    xdg = os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")
+    return Path(xdg) / "lean-lsp-mcp" / "loogle"
+
+
+def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
+    """Query the remote loogle API."""
+    try:
+        req = urllib.request.Request(
+            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=20) as response:
+            results = orjson.loads(response.read())
+        if "hits" not in results:
+            return "No results found."
+        hits = results["hits"][:num_results]
+        return [
+            LoogleResult(
+                name=r.get("name", ""),
+                type=r.get("type", ""),
+                module=r.get("module", ""),
+            )
+            for r in hits
+        ]
+    except Exception as e:
+        return f"loogle error:\n{e}"
+
+
+class LoogleManager:
+    """Manages local loogle installation and async subprocess."""
+
+    REPO_URL = "https://github.com/nomeata/loogle.git"
+    READY_SIGNAL = "Loogle is ready."
+
+    def __init__(self, cache_dir: Path | None = None):
+        self.cache_dir = cache_dir or get_cache_dir()
+        self.repo_dir = self.cache_dir / "repo"
+        self.index_dir = self.cache_dir / "index"
+        self.process: asyncio.subprocess.Process | None = None
+        self._ready = False
+        self._lock = asyncio.Lock()
+
+    @property
+    def binary_path(self) -> Path:
+        return self.repo_dir / ".lake" / "build" / "bin" / "loogle"
+
+    @property
+    def is_installed(self) -> bool:
+        return self.binary_path.exists()
+
+    @property
+    def is_running(self) -> bool:
+        return (
+            self._ready and self.process is not None and self.process.returncode is None
+        )
+
+    def _check_prerequisites(self) -> tuple[bool, str]:
+        if not shutil.which("git"):
+            return False, "git not found in PATH"
+        if not shutil.which("lake"):
+            return (
+                False,
+                "lake not found (install elan: https://github.com/leanprover/elan)",
+            )
+        return True, ""
+
+    def _run(
+        self, cmd: list[str], timeout: int = 300, cwd: Path | None = None
+    ) -> subprocess.CompletedProcess:
+        env = os.environ.copy()
+        env["LAKE_ARTIFACT_CACHE"] = "false"
+        return subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=cwd or self.repo_dir,
+            env=env,
+        )
+
+    def _clone_repo(self) -> bool:
+        if self.repo_dir.exists():
+            return True
+        logger.info(f"Cloning loogle to {self.repo_dir}...")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            r = self._run(
+                ["git", "clone", "--depth", "1", self.REPO_URL, str(self.repo_dir)],
+                cwd=self.cache_dir,
+            )
+            if r.returncode != 0:
+                logger.error(f"Clone failed: {r.stderr}")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Clone error: {e}")
+            return False
+
+    def _build_loogle(self) -> bool:
+        if self.is_installed:
+            return True
+        if not self.repo_dir.exists():
+            return False
+        logger.info("Downloading mathlib cache...")
+        try:
+            self._run(["lake", "exe", "cache", "get"], timeout=600)
+        except Exception as e:
+            logger.warning(f"Cache download: {e}")
+        logger.info("Building loogle...")
+        try:
+            return self._run(["lake", "build"], timeout=900).returncode == 0
+        except Exception as e:
+            logger.error(f"Build error: {e}")
+            return False
+
+    def _get_mathlib_version(self) -> str:
+        try:
+            manifest = json.loads((self.repo_dir / "lake-manifest.json").read_text())
+            for pkg in manifest.get("packages", []):
+                if pkg.get("name") == "mathlib":
+                    return pkg.get("rev", "unknown")[:12]
+        except Exception:
+            pass
+        return "unknown"
+
+    def _get_toolchain_version(self) -> str | None:
+        """Get the Lean toolchain version from lean-toolchain file."""
+        try:
+            return (self.repo_dir / "lean-toolchain").read_text().strip()
+        except Exception:
+            return None
+
+    def _check_toolchain_installed(self) -> tuple[bool, str]:
+        """Check if the required Lean toolchain is installed."""
+        tc = self._get_toolchain_version()
+        if not tc:
+            return True, ""  # Can't check without lean-toolchain file
+        # Convert lean-toolchain format to elan directory name
+        # e.g., "leanprover/lean4:v4.25.0-rc1" -> "leanprover--lean4---v4.25.0-rc1"
+        tc_dir_name = tc.replace("/", "--").replace(":", "---")
+        elan_home = Path(os.environ.get("ELAN_HOME", Path.home() / ".elan"))
+        tc_path = elan_home / "toolchains" / tc_dir_name
+        if not tc_path.exists():
+            return False, (
+                f"Toolchain '{tc}' not installed. "
+                f"Run: cd {self.repo_dir} && lake update"
+            )
+        return True, ""
+
+    def check_environment(self) -> tuple[bool, str]:
+        """Check if the loogle environment is valid. Returns (ok, error_msg)."""
+        if not self.is_installed:
+            return False, "Loogle binary not found"
+        ok, err = self._check_toolchain_installed()
+        if not ok:
+            return False, err
+        return True, ""
+
+    def _get_index_path(self) -> Path:
+        return self.index_dir / f"mathlib-{self._get_mathlib_version()}.idx"
+
+    def _cleanup_old_indices(self) -> None:
+        """Remove old index files from previous mathlib versions."""
+        if not self.index_dir.exists():
+            return
+        current = self._get_index_path()
+        for idx in self.index_dir.glob("*.idx"):
+            if idx != current:
+                try:
+                    idx.unlink()
+                    logger.info(f"Removed old index: {idx.name}")
+                except Exception:
+                    pass
+
+    def _build_index(self) -> Path | None:
+        index_path = self._get_index_path()
+        if index_path.exists():
+            return index_path
+        if not self.is_installed:
+            return None
+        self.index_dir.mkdir(parents=True, exist_ok=True)
+        self._cleanup_old_indices()
+        logger.info("Building search index...")
+        try:
+            self._run(
+                [str(self.binary_path), "--write-index", str(index_path), "--json", ""],
+                timeout=600,
+            )
+            return index_path if index_path.exists() else None
+        except Exception as e:
+            logger.error(f"Index build error: {e}")
+            return None
+
+    def ensure_installed(self) -> bool:
+        ok, err = self._check_prerequisites()
+        if not ok:
+            logger.warning(f"Prerequisites: {err}")
+            return False
+        if not self._clone_repo() or not self._build_loogle():
+            return False
+        if not self._build_index():
+            logger.warning("Index build failed, loogle will build on startup")
+        return self.is_installed
+
+    async def start(self) -> bool:
+        if self.process is not None and self.process.returncode is None:
+            return self._ready
+        ok, err = self.check_environment()
+        if not ok:
+            logger.error(f"Loogle environment check failed: {err}")
+            return False
+        cmd = [str(self.binary_path), "--json", "--interactive"]
+        if (idx := self._get_index_path()).exists():
+            cmd.extend(["--read-index", str(idx)])
+        logger.info("Starting loogle subprocess...")
+        try:
+            self.process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=self.repo_dir,
+            )
+            line = await asyncio.wait_for(self.process.stdout.readline(), timeout=120)
+            decoded = line.decode()
+            if self.READY_SIGNAL in decoded:
+                self._ready = True
+                logger.info("Loogle ready")
+                return True
+            # Check stderr for error messages
+            try:
+                stderr_data = await asyncio.wait_for(
+                    self.process.stderr.read(), timeout=1
+                )
+                if stderr_data:
+                    logger.error(f"Loogle stderr: {stderr_data.decode().strip()}")
+            except asyncio.TimeoutError:
+                pass
+            logger.error(f"Loogle failed to start. stdout: {decoded.strip()}")
+            return False
+        except asyncio.TimeoutError:
+            logger.error("Loogle startup timeout")
+            return False
+        except Exception as e:
+            logger.error(f"Start failed: {e}")
+            return False
+
+    async def query(self, q: str, num_results: int = 8) -> list[dict[str, Any]]:
+        async with self._lock:
+            # Try up to 2 attempts (initial + one restart)
+            for attempt in range(2):
+                if (
+                    not self._ready
+                    or self.process is None
+                    or self.process.returncode is not None
+                ):
+                    if attempt > 0:
+                        raise RuntimeError("Loogle subprocess not ready")
+                    self._ready = False
+                    if not await self.start():
+                        raise RuntimeError("Failed to start loogle")
+                    continue
+
+                try:
+                    self.process.stdin.write(f"{q}\n".encode())
+                    await self.process.stdin.drain()
+                    line = await asyncio.wait_for(
+                        self.process.stdout.readline(), timeout=30
+                    )
+                    response = json.loads(line.decode())
+                    if err := response.get("error"):
+                        logger.warning(f"Query error: {err}")
+                        return []
+                    return [
+                        {
+                            "name": h.get("name", ""),
+                            "type": h.get("type", ""),
+                            "module": h.get("module", ""),
+                            "doc": h.get("doc"),
+                        }
+                        for h in response.get("hits", [])[:num_results]
+                    ]
+                except asyncio.TimeoutError:
+                    raise RuntimeError("Query timeout") from None
+                except json.JSONDecodeError as e:
+                    raise RuntimeError(f"Invalid response: {e}") from e
+
+            raise RuntimeError("Loogle subprocess not ready")
+
+    async def stop(self) -> None:
+        if self.process:
+            try:
+                self.process.terminate()
+                await asyncio.wait_for(self.process.wait(), timeout=5)
+            except asyncio.TimeoutError:
+                self.process.kill()
+                try:
+                    await asyncio.wait_for(self.process.wait(), timeout=2)
+                except asyncio.TimeoutError:
+                    pass
+            except Exception:
+                pass
+            self.process = None
+            self._ready = False

lean_lsp_mcp/models.py

@@ -0,0 +1,120 @@
+"""Pydantic models for MCP tool structured outputs."""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class LocalSearchResult(BaseModel):
+    name: str = Field(description="Declaration name")
+    kind: str = Field(description="Declaration kind (theorem, def, class, etc.)")
+    file: str = Field(description="Relative file path")
+
+
+class LeanSearchResult(BaseModel):
+    name: str = Field(description="Full qualified name")
+    module_name: str = Field(description="Module where declared")
+    kind: Optional[str] = Field(None, description="Declaration kind")
+    type: Optional[str] = Field(None, description="Type signature")
+
+
+class LoogleResult(BaseModel):
+    name: str = Field(description="Declaration name")
+    type: str = Field(description="Type signature")
+    module: str = Field(description="Module where declared")
+
+
+class LeanFinderResult(BaseModel):
+    full_name: str = Field(description="Full qualified name")
+    formal_statement: str = Field(description="Lean type signature")
+    informal_statement: str = Field(description="Natural language description")
+
+
+class StateSearchResult(BaseModel):
+    name: str = Field(description="Theorem/lemma name")
+
+
+class PremiseResult(BaseModel):
+    name: str = Field(description="Premise name for simp/omega/aesop")
+
+
+class DiagnosticMessage(BaseModel):
+    severity: str = Field(description="error, warning, info, or hint")
+    message: str = Field(description="Diagnostic message text")
+    line: int = Field(description="Line (1-indexed)")
+    column: int = Field(description="Column (1-indexed)")
+
+
+class GoalState(BaseModel):
+    line_context: str = Field(description="Source line where goals were queried")
+    goals: str = Field(description="Goal state (before→after if column omitted)")
+
+
+class CompletionItem(BaseModel):
+    label: str = Field(description="Completion text to insert")
+    kind: Optional[str] = Field(
+        None, description="Completion kind (function, variable, etc.)"
+    )
+    detail: Optional[str] = Field(None, description="Additional detail")
+
+
+class HoverInfo(BaseModel):
+    symbol: str = Field(description="The symbol being hovered")
+    info: str = Field(description="Type signature and documentation")
+    diagnostics: List[DiagnosticMessage] = Field(
+        default_factory=list, description="Diagnostics at this position"
+    )
+
+
+class TermGoalState(BaseModel):
+    line_context: str = Field(description="Source line where term goal was queried")
+    expected_type: Optional[str] = Field(
+        None, description="Expected type at this position"
+    )
+
+
+class OutlineEntry(BaseModel):
+    name: str = Field(description="Declaration name")
+    kind: str = Field(description="Declaration kind (Thm, Def, Class, Struct, Ns, Ex)")
+    start_line: int = Field(description="Start line (1-indexed)")
+    end_line: int = Field(description="End line (1-indexed)")
+    type_signature: Optional[str] = Field(
+        None, description="Type signature if available"
+    )
+    children: List["OutlineEntry"] = Field(
+        default_factory=list, description="Nested declarations"
+    )
+
+
+class FileOutline(BaseModel):
+    imports: List[str] = Field(default_factory=list, description="Import statements")
+    declarations: List[OutlineEntry] = Field(
+        default_factory=list, description="Top-level declarations"
+    )
+
+
+class AttemptResult(BaseModel):
+    snippet: str = Field(description="Code snippet that was tried")
+    goal_state: Optional[str] = Field(
+        None, description="Goal state after applying snippet"
+    )
+    diagnostics: List[DiagnosticMessage] = Field(
+        default_factory=list, description="Diagnostics for this attempt"
+    )
+
+
+class BuildResult(BaseModel):
+    success: bool = Field(description="Whether build succeeded")
+    output: str = Field(description="Build output")
+    errors: List[str] = Field(default_factory=list, description="Build errors if any")
+
+
+class RunResult(BaseModel):
+    success: bool = Field(description="Whether code compiled successfully")
+    diagnostics: List[DiagnosticMessage] = Field(
+        default_factory=list, description="Compiler diagnostics"
+    )
+
+
+class DeclarationInfo(BaseModel):
+    file_path: str = Field(description="Path to declaration file")
+    content: str = Field(description="File content")