lean-lsp-mcp 0.16.1__tar.gz → 0.17.0__tar.gz

{lean_lsp_mcp-0.16.1/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.16.1
+Version: 0.17.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,9 +8,8 @@ Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: leanclient==0.6.1
-Requires-Dist: mcp[cli]==1.23.1
-Requires-Dist: mcp[cli]>=1.22.0
+Requires-Dist: leanclient==0.7.0
+Requires-Dist: mcp[cli]==1.24.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.17.0}/pyproject.toml

@@ -1,40 +1,27 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.16.1"
+version = "0.17.0"
 description = "Lean Theorem Prover MCP"
-authors = [{name="Oliver Dressler", email="hey@oli.show"}]
+authors = [{ name = "Oliver Dressler", email = "hey@oli.show" }]
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
-dependencies = [
-    "leanclient==0.6.1",
-    "mcp[cli]==1.23.1", "mcp[cli]>=1.22.0",
-    "orjson>=3.11.1",
-]
+dependencies = ["leanclient==0.7.0", "mcp[cli]==1.24.0", "orjson>=3.11.1"]
 
 [project.urls]
 Repository = "https://github.com/oOo0oOo/lean-lsp-mcp"
 
 [project.optional-dependencies]
-lint = [
-    "ruff>=0.2.0",
-]
-dev = [
-    "ruff>=0.2.0",
-    "pytest>=8.3",
-    "anyio>=4.4",
-    "pytest-asyncio>=0.23",
-]
+lint = ["ruff>=0.2.0"]
+dev = ["ruff>=0.2.0", "pytest>=8.3", "anyio>=4.4", "pytest-asyncio>=0.23"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
-markers = [
-    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
-]
+markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"]
 
 [tool.setuptools]
 packages = ["lean_lsp_mcp"]
-package-dir = {"" = "src"}
+package-dir = { "" = "src" }
 
 [build-system]
 requires = ["setuptools>=61.0"]

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.17.0}/src/lean_lsp_mcp/instructions.py

@@ -33,4 +33,7 @@ After finding a name: lean_local_search to verify, lean_hover_info for signature
 
 ## Return Formats
 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-0.16.1 → lean_lsp_mcp-0.17.0}/src/lean_lsp_mcp/loogle.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import json
 import logging
 import os
@@ -34,7 +35,7 @@ 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=20) as response:
+        with urllib.request.urlopen(req, timeout=10) as response:
             results = orjson.loads(response.read())
         if "hits" not in results:
             return "No results found."
@@ -52,18 +53,25 @@ def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
 
 
 class LoogleManager:
-    """Manages local loogle installation and async subprocess."""
+    """Manages local loogle installation and async subprocess.
+
+    Args:
+        cache_dir: Directory for loogle repo and indices (default: ~/.cache/lean-lsp-mcp/loogle)
+        project_path: Optional Lean project path to index its .lake/packages dependencies
+    """
 
     REPO_URL = "https://github.com/nomeata/loogle.git"
     READY_SIGNAL = "Loogle is ready."
 
-    def __init__(self, cache_dir: Path | None = None):
+    def __init__(self, cache_dir: Path | None = None, project_path: 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.project_path = project_path
         self.process: asyncio.subprocess.Process | None = None
         self._ready = False
         self._lock = asyncio.Lock()
+        self._extra_paths: list[Path] = []
 
     @property
     def binary_path(self) -> Path:
@@ -181,21 +189,54 @@ class LoogleManager:
             return False, err
         return True, ""
 
+    def _discover_project_paths(self) -> list[Path]:
+        """Find .lake/packages lib paths from the user's project."""
+        if not self.project_path:
+            return []
+        paths = []
+        # Check packages directory
+        lake_packages = self.project_path / ".lake" / "packages"
+        if lake_packages.exists():
+            for pkg_dir in lake_packages.iterdir():
+                if not pkg_dir.is_dir():
+                    continue
+                lib_path = pkg_dir / ".lake" / "build" / "lib" / "lean"
+                if lib_path.exists():
+                    paths.append(lib_path)
+        # Also add the project's own build output
+        project_lib = self.project_path / ".lake" / "build" / "lib" / "lean"
+        if project_lib.exists():
+            paths.append(project_lib)
+        return sorted(paths)
+
     def _get_index_path(self) -> Path:
-        return self.index_dir / f"mathlib-{self._get_mathlib_version()}.idx"
+        base = f"mathlib-{self._get_mathlib_version()}"
+        if self._extra_paths:
+            # Include hash of extra paths for project-specific index
+            paths_str = ":".join(str(p) for p in sorted(self._extra_paths))
+            path_hash = hashlib.sha256(paths_str.encode()).hexdigest()[:8]
+            return self.index_dir / f"{base}-{path_hash}.idx"
+        return self.index_dir / f"{base}.idx"
 
     def _cleanup_old_indices(self) -> None:
-        """Remove old index files from previous mathlib versions."""
+        """Remove old index files from previous mathlib versions.
+
+        Cleans up both mathlib-only indexes (mathlib-<version>.idx) and
+        project-specific indexes (mathlib-<version>-<hash>.idx) that don't
+        match the current mathlib version.
+        """
         if not self.index_dir.exists():
             return
-        current = self._get_index_path()
+        current_mathlib = f"mathlib-{self._get_mathlib_version()}"
         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
+            # Keep indexes with current mathlib version (both base and project-specific)
+            if idx.name.startswith(current_mathlib):
+                continue
+            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()
@@ -205,17 +246,37 @@ class LoogleManager:
             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,
+
+        # Build command with extra paths
+        cmd = [str(self.binary_path), "--write-index", str(index_path), "--json"]
+        for path in self._extra_paths:
+            cmd.extend(["--path", str(path)])
+        cmd.append("")  # Empty query for index building
+
+        if self._extra_paths:
+            logger.info(
+                f"Building search index with {len(self._extra_paths)} extra paths..."
             )
+        else:
+            logger.info("Building search index...")
+        try:
+            self._run(cmd, 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 set_project_path(self, project_path: Path | None) -> bool:
+        """Update project path and rediscover extra paths. Returns True if paths changed."""
+        self.project_path = project_path
+        new_paths = self._discover_project_paths()
+        if new_paths != self._extra_paths:
+            self._extra_paths = new_paths
+            if new_paths:
+                logger.info(f"Discovered {len(new_paths)} project library paths")
+            return True
+        return False
+
     def ensure_installed(self) -> bool:
         ok, err = self._check_prerequisites()
         if not ok:
@@ -223,6 +284,10 @@ class LoogleManager:
             return False
         if not self._clone_repo() or not self._build_loogle():
             return False
+        # Discover project paths before building index
+        self._extra_paths = self._discover_project_paths()
+        if self._extra_paths:
+            logger.info(f"Indexing {len(self._extra_paths)} project library paths")
         if not self._build_index():
             logger.warning("Index build failed, loogle will build on startup")
         return self.is_installed
@@ -234,10 +299,26 @@ class LoogleManager:
         if not ok:
             logger.error(f"Loogle environment check failed: {err}")
             return False
+
+        # Check if project paths changed and we need to rebuild index
+        if self.project_path:
+            new_paths = self._discover_project_paths()
+            if new_paths != self._extra_paths:
+                self._extra_paths = new_paths
+                # Build new index if paths changed
+                self._build_index()
+
         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...")
+        # Add extra paths for runtime search (in case not all are indexed)
+        for path in self._extra_paths:
+            cmd.extend(["--path", str(path)])
+
+        if self._extra_paths:
+            logger.info(f"Starting loogle with {len(self._extra_paths)} extra paths...")
+        else:
+            logger.info("Starting loogle subprocess...")
         try:
             self.process = await asyncio.create_subprocess_exec(
                 *cmd,

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.17.0}/src/lean_lsp_mcp/models.py

@@ -46,7 +46,15 @@ class DiagnosticMessage(BaseModel):
 
 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)")
+    goals: Optional[List[str]] = Field(
+        None, description="Goal list at specified column position"
+    )
+    goals_before: Optional[List[str]] = Field(
+        None, description="Goals at line start (when column omitted)"
+    )
+    goals_after: Optional[List[str]] = Field(
+        None, description="Goals at line end (when column omitted)"
+    )
 
 
 class CompletionItem(BaseModel):
@@ -94,8 +102,8 @@ class FileOutline(BaseModel):
 
 class AttemptResult(BaseModel):
     snippet: str = Field(description="Code snippet that was tried")
-    goal_state: Optional[str] = Field(
-        None, description="Goal state after applying snippet"
+    goals: List[str] = Field(
+        default_factory=list, description="Goal list after applying snippet"
     )
     diagnostics: List[DiagnosticMessage] = Field(
         default_factory=list, description="Diagnostics for this attempt"
@@ -118,3 +126,80 @@ class RunResult(BaseModel):
 class DeclarationInfo(BaseModel):
     file_path: str = Field(description="Path to declaration file")
     content: str = Field(description="File content")
+
+
+# Wrapper models for list-returning tools
+# FastMCP flattens bare lists into separate TextContent blocks, causing serialization issues.
+# Wrapping in a model ensures proper JSON serialization.
+
+
+class DiagnosticsResult(BaseModel):
+    """Wrapper for diagnostic messages list."""
+
+    items: List[DiagnosticMessage] = Field(
+        default_factory=list, description="List of diagnostic messages"
+    )
+
+
+class CompletionsResult(BaseModel):
+    """Wrapper for completions list."""
+
+    items: List[CompletionItem] = Field(
+        default_factory=list, description="List of completion items"
+    )
+
+
+class MultiAttemptResult(BaseModel):
+    """Wrapper for multi-attempt results list."""
+
+    items: List[AttemptResult] = Field(
+        default_factory=list, description="List of attempt results"
+    )
+
+
+class LocalSearchResults(BaseModel):
+    """Wrapper for local search results list."""
+
+    items: List[LocalSearchResult] = Field(
+        default_factory=list, description="List of local search results"
+    )
+
+
+class LeanSearchResults(BaseModel):
+    """Wrapper for LeanSearch results list."""
+
+    items: List[LeanSearchResult] = Field(
+        default_factory=list, description="List of LeanSearch results"
+    )
+
+
+class LoogleResults(BaseModel):
+    """Wrapper for Loogle results list."""
+
+    items: List[LoogleResult] = Field(
+        default_factory=list, description="List of Loogle results"
+    )
+
+
+class LeanFinderResults(BaseModel):
+    """Wrapper for Lean Finder results list."""
+
+    items: List[LeanFinderResult] = Field(
+        default_factory=list, description="List of Lean Finder results"
+    )
+
+
+class StateSearchResults(BaseModel):
+    """Wrapper for state search results list."""
+
+    items: List[StateSearchResult] = Field(
+        default_factory=list, description="List of state search results"
+    )
+
+
+class PremiseResults(BaseModel):
+    """Wrapper for premise results list."""
+
+    items: List[PremiseResult] = Field(
+        default_factory=list, description="List of premise results"
+    )

lean_lsp_mcp-0.17.0/src/lean_lsp_mcp/search_utils.py

@@ -0,0 +1,236 @@
+"""Utilities for Lean search tools."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from functools import lru_cache
+import platform
+import re
+import shutil
+import subprocess
+import threading
+from orjson import loads as _json_loads
+from pathlib import Path
+
+
+INSTALL_URL = "https://github.com/BurntSushi/ripgrep#installation"
+
+_PLATFORM_INSTRUCTIONS: dict[str, Iterable[str]] = {
+    "Windows": (
+        "winget install BurntSushi.ripgrep.MSVC",
+        "choco install ripgrep",
+    ),
+    "Darwin": ("brew install ripgrep",),
+    "Linux": (
+        "sudo apt-get install ripgrep",
+        "sudo dnf install ripgrep",
+    ),
+}
+
+
+def _create_ripgrep_process(command: list[str], *, cwd: str) -> subprocess.Popen[str]:
+    """Spawn ripgrep and return a process with line-streaming stdout.
+
+    Separated for test monkeypatching and to allow early termination once we
+    have enough matches.
+    """
+    return subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        cwd=cwd,
+    )
+
+
+def check_ripgrep_status() -> tuple[bool, str]:
+    """Check whether ``rg`` is available on PATH and return status + message."""
+
+    if shutil.which("rg"):
+        return True, ""
+
+    system = platform.system()
+    platform_instructions = _PLATFORM_INSTRUCTIONS.get(
+        system, ("Check alternative installation methods.",)
+    )
+
+    lines = [
+        "ripgrep (rg) was not found on your PATH. The lean_local_search tool uses ripgrep for fast declaration search.",
+        "",
+        "Installation options:",
+        *(f"  - {item}" for item in platform_instructions),
+        f"More installation options: {INSTALL_URL}",
+    ]
+
+    return False, "\n".join(lines)
+
+
+def lean_local_search(
+    query: str,
+    limit: int = 32,
+    project_root: Path | None = None,
+) -> list[dict[str, str]]:
+    """Search Lean declarations matching ``query`` using ripgrep; results include theorems, lemmas, defs, classes, instances, structures, inductives, abbrevs, and opaque decls."""
+    root = (project_root or Path.cwd()).resolve()
+
+    pattern = (
+        rf"^\s*(?:theorem|lemma|def|axiom|class|instance|structure|inductive|abbrev|opaque)\s+"
+        rf"(?:[A-Za-z0-9_'.]+\.)*{re.escape(query)}[A-Za-z0-9_'.]*(?:\s|:)"
+    )
+
+    command = [
+        "rg",
+        "--json",
+        "--no-ignore",
+        "--smart-case",
+        "--hidden",
+        "--color",
+        "never",
+        "--no-messages",
+        "-g",
+        "*.lean",
+        "-g",
+        "!.git/**",
+        "-g",
+        "!.lake/build/**",
+        pattern,
+        str(root),
+    ]
+
+    if lean_src := _get_lean_src_search_path():
+        command.append(lean_src)
+
+    process = _create_ripgrep_process(command, cwd=str(root))
+
+    matches: list[dict[str, str]] = []
+    stderr_text = ""
+    terminated_early = False
+    stderr_chunks: list[str] = []
+    stderr_chars = 0
+    stderr_truncated = False
+    max_stderr_chars = 100_000
+
+    def _drain_stderr(pipe) -> None:
+        nonlocal stderr_chars, stderr_truncated
+        try:
+            for err_line in pipe:
+                if stderr_chars < max_stderr_chars:
+                    stderr_chunks.append(err_line)
+                    stderr_chars += len(err_line)
+                else:
+                    stderr_truncated = True
+        except Exception:
+            return
+
+    stderr_thread: threading.Thread | None = None
+    if process.stderr is not None:
+        stderr_thread = threading.Thread(
+            target=_drain_stderr,
+            args=(process.stderr,),
+            name="lean-local-search-rg-stderr",
+            daemon=True,
+        )
+        stderr_thread.start()
+
+    try:
+        stdout = process.stdout
+        if stdout is None:
+            raise RuntimeError("ripgrep did not provide stdout pipe")
+
+        for line in stdout:
+            if not line or (event := _json_loads(line)).get("type") != "match":
+                continue
+
+            data = event["data"]
+            parts = data["lines"]["text"].lstrip().split(maxsplit=2)
+            if len(parts) < 2:
+                continue
+
+            decl_kind, decl_name = parts[0], parts[1].rstrip(":")
+            file_path = Path(data["path"]["text"])
+            abs_path = (
+                file_path if file_path.is_absolute() else (root / file_path).resolve()
+            )
+
+            try:
+                display_path = str(abs_path.relative_to(root))
+            except ValueError:
+                display_path = str(file_path)
+
+            matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
+
+            if len(matches) >= limit:
+                terminated_early = True
+                try:
+                    process.terminate()
+                except Exception:
+                    pass
+                break
+
+        try:
+            if terminated_early:
+                process.wait(timeout=5)
+            else:
+                process.wait()
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+    finally:
+        if process.returncode is None:
+            try:
+                process.terminate()
+            except Exception:
+                pass
+            try:
+                process.wait(timeout=5)
+            except Exception:
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+                try:
+                    process.wait(timeout=5)
+                except Exception:
+                    pass
+        if stderr_thread is not None:
+            stderr_thread.join(timeout=1)
+        if process.stdout is not None:
+            process.stdout.close()
+        if process.stderr is not None:
+            process.stderr.close()
+
+    if stderr_chunks:
+        stderr_text = "".join(stderr_chunks)
+        if stderr_truncated:
+            stderr_text += "\n[stderr truncated]"
+
+    returncode = process.returncode if process.returncode is not None else 0
+
+    if returncode not in (0, 1) and not matches:
+        error_msg = f"ripgrep exited with code {returncode}"
+        if stderr_text:
+            error_msg += f"\n{stderr_text}"
+        raise RuntimeError(error_msg)
+
+    return matches
+
+
+@lru_cache(maxsize=1)
+def _get_lean_src_search_path() -> str | None:
+    """Return the Lean stdlib directory, if available (cache once)."""
+    try:
+        completed = subprocess.run(
+            ["lean", "--print-prefix"], capture_output=True, text=True
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return None
+
+    prefix = completed.stdout.strip()
+    if not prefix:
+        return None
+
+    candidate = Path(prefix).expanduser().resolve() / "src"
+    if candidate.exists():
+        return str(candidate)
+
+    return None