lean-lsp-mcp 0.15.0__tar.gz → 0.16.0__tar.gz

{lean_lsp_mcp-0.15.0/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.15.0
+Version: 0.16.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -10,6 +10,7 @@ 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: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.15.0 → lean_lsp_mcp-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.15.0"
+version = "0.16.0"
 description = "Lean Theorem Prover MCP"
 authors = [{name="Oliver Dressler", email="hey@oli.show"}]
 readme = "README.md"
@@ -8,7 +8,7 @@ requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
     "leanclient==0.6.1",
-    "mcp[cli]==1.23.1",
+    "mcp[cli]==1.23.1", "mcp[cli]>=1.22.0",
     "orjson>=3.11.1",
 ]
 

lean_lsp_mcp-0.16.0/src/lean_lsp_mcp/instructions.py

@@ -0,0 +1,36 @@
+INSTRUCTIONS = """## General Rules
+- All line and column numbers are 1-indexed.
+- This MCP does NOT edit files. Use other tools for editing.
+
+## Key Tools
+- **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-0.15.0 → lean_lsp_mcp-0.16.0}/src/lean_lsp_mcp/loogle.py

@@ -15,6 +15,8 @@ from typing import Any
 
 import orjson
 
+from lean_lsp_mcp.models import LoogleResult
+
 logger = logging.getLogger(__name__)
 
 
@@ -25,7 +27,7 @@ def get_cache_dir() -> Path:
     return Path(xdg) / "lean-lsp-mcp" / "loogle"
 
 
-def loogle_remote(query: str, num_results: int) -> list[dict] | str:
+def loogle_remote(query: str, num_results: int) -> list[LoogleResult] | str:
     """Query the remote loogle API."""
     try:
         req = urllib.request.Request(
@@ -36,10 +38,15 @@ def loogle_remote(query: str, num_results: int) -> list[dict] | str:
             results = orjson.loads(response.read())
         if "hits" not in results:
             return "No results found."
-        results = results["hits"][:num_results]
-        for r in results:
-            r.pop("doc", None)
-        return results
+        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}"
 
@@ -141,6 +148,39 @@ class LoogleManager:
             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"
 
@@ -190,7 +230,9 @@ class LoogleManager:
     async def start(self) -> bool:
         if self.process is not None and self.process.returncode is None:
             return self._ready
-        if not self.is_installed:
+        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():
@@ -201,14 +243,25 @@ class LoogleManager:
                 *cmd,
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.PIPE,
                 cwd=self.repo_dir,
             )
             line = await asyncio.wait_for(self.process.stdout.readline(), timeout=120)
-            if self.READY_SIGNAL in line.decode():
+            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")

lean_lsp_mcp-0.16.0/src/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")

{lean_lsp_mcp-0.15.0 → lean_lsp_mcp-0.16.0}/src/lean_lsp_mcp/outline_utils.py

@@ -3,6 +3,8 @@ from typing import Dict, List, Optional, Tuple
 from leanclient import LeanLSPClient
 from leanclient.utils import DocumentContentChange
 
+from lean_lsp_mcp.models import FileOutline, OutlineEntry
+
 
 METHOD_KIND = {6, "method"}
 KIND_TAGS = {"namespace": "Ns"}
@@ -181,6 +183,97 @@ def _format_symbol(sym: Dict, type_sigs: Dict, fields_map: Dict, indent: int) ->
     return result + "\n"
 
 
+def _build_outline_entry(
+    sym: Dict, type_sigs: Dict, fields_map: Dict, indent: int
+) -> Optional[OutlineEntry]:
+    """Build a structured outline entry for a symbol."""
+    name = sym["name"]
+    type_sig = sym.get("_type") or type_sigs.get(name, "")
+    fields = fields_map.get(name, [])
+
+    tag = _detect_tag(
+        name, sym.get("kind", ""), type_sig, bool(fields), sym.get("_keyword")
+    )
+    start = sym["range"]["start"]["line"] + 1
+    end = sym["range"]["end"]["line"] + 1
+
+    # Add fields as children for structs/classes
+    children = [
+        OutlineEntry(
+            name=fname,
+            kind="field",
+            start_line=start,
+            end_line=start,
+            type_signature=ftype,
+            children=[],
+        )
+        for fname, ftype in fields
+    ]
+
+    return OutlineEntry(
+        name=name,
+        kind=tag,
+        start_line=start,
+        end_line=end,
+        type_signature=type_sig if type_sig else None,
+        children=children,
+    )
+
+
+def generate_outline_data(client: LeanLSPClient, path: str) -> FileOutline:
+    """Generate structured outline data for a Lean file."""
+    client.open_file(path)
+    content = client.get_file_content(path)
+
+    # Extract imports
+    imports = [
+        line.strip()[7:]
+        for line in content.splitlines()
+        if line.strip().startswith("import ")
+    ]
+
+    symbols = client.get_document_symbols(path)
+    if not symbols and not imports:
+        return FileOutline(imports=[], declarations=[])
+
+    # Flatten symbol tree and extract namespace declarations
+    all_symbols = _flatten_symbols(symbols, content=content)
+
+    # Get info trees only for LSP symbols (not extracted declarations)
+    lsp_methods = [
+        s
+        for s, _ in all_symbols
+        if s.get("kind") in METHOD_KIND and "_keyword" not in s
+    ]
+    info_trees = _get_info_trees(client, path, lsp_methods)
+
+    # Extract type signatures and fields from info trees
+    type_sigs = {
+        name: sig
+        for name, info in info_trees.items()
+        if (sig := _extract_type(info, name))
+    }
+    fields_map = {
+        name: fields
+        for name, info in info_trees.items()
+        if (fields := _extract_fields(info, name))
+    }
+
+    # Build declarations list
+    declarations = []
+    for sym, indent in all_symbols:
+        if (
+            sym.get("kind") in METHOD_KIND
+            or sym.get("_keyword")
+            or sym.get("kind") == "namespace"
+        ):
+            entry = _build_outline_entry(sym, type_sigs, fields_map, indent)
+            if entry:
+                declarations.append(entry)
+
+    return FileOutline(imports=imports, declarations=declarations)
+
+
 def generate_outline(client: LeanLSPClient, path: str) -> str:
     """Generate a concise outline of a Lean file showing structure and signatures."""
     client.open_file(path)