lean-lsp-mcp 0.1.7__py3-none-any.whl → 0.11.2__py3-none-any.whl

lean_lsp_mcp/__init__.py

@@ -1,5 +1,30 @@
+import argparse
+
 from lean_lsp_mcp.server import mcp
 
 
 def main():
-    mcp.run()
+    parser = argparse.ArgumentParser(description="Lean LSP MCP Server")
+    parser.add_argument(
+        "--transport",
+        type=str,
+        choices=["stdio", "streamable-http", "sse"],
+        default="stdio",
+        help="Transport method for the server. Default is 'stdio'.",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host address for transport",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Host port for transport",
+    )
+    args = parser.parse_args()
+    mcp.settings.host = args.host
+    mcp.settings.port = args.port
+    mcp.run(transport=args.transport)

lean_lsp_mcp/client_utils.py

@@ -0,0 +1,122 @@
+import os
+from pathlib import Path
+from threading import Lock
+
+from mcp.server.fastmcp import Context
+from mcp.server.fastmcp.utilities.logging import get_logger
+from leanclient import LeanLSPClient
+
+from lean_lsp_mcp.file_utils import get_relative_file_path
+from lean_lsp_mcp.utils import OutputCapture
+
+
+logger = get_logger(__name__)
+CLIENT_LOCK = Lock()
+
+
+def startup_client(ctx: Context):
+    """Initialize the Lean LSP client if not already set up.
+
+    Args:
+        ctx (Context): Context object.
+    """
+    with CLIENT_LOCK:
+        lean_project_path = ctx.request_context.lifespan_context.lean_project_path
+        if lean_project_path is None:
+            raise ValueError("lean project path is not set.")
+
+        # Check if already correct client
+        client: LeanLSPClient | None = ctx.request_context.lifespan_context.client
+
+        if client is not None:
+            # Both are Path objects now, direct comparison works
+            if client.project_path == lean_project_path:
+                return  # Client already set up correctly - reuse it!
+            # Different project path - close old client
+            client.close()
+            ctx.request_context.lifespan_context.file_content_hashes.clear()
+
+        # Need to create a new client
+        with OutputCapture() as output:
+            try:
+                client = LeanLSPClient(lean_project_path)
+                logger.info(f"Connected to Lean language server at {lean_project_path}")
+            except Exception as e:
+                logger.warning(f"Initial connection failed, trying with build: {e}")
+                client = LeanLSPClient(lean_project_path, initial_build=True)
+                logger.info(f"Connected with initial build to {lean_project_path}")
+        build_output = output.get_output()
+        if build_output:
+            logger.debug(f"Build output: {build_output}")
+        ctx.request_context.lifespan_context.client = client
+
+
+def valid_lean_project_path(path: Path | str) -> bool:
+    """Check if the given path is a valid Lean project path (contains a lean-toolchain file).
+
+    Args:
+        path (Path | str): Absolute path to check.
+
+    Returns:
+        bool: True if valid Lean project path, False otherwise.
+    """
+    path_obj = Path(path) if isinstance(path, str) else path
+    return (path_obj / "lean-toolchain").is_file()
+
+
+def setup_client_for_file(ctx: Context, file_path: str) -> str | None:
+    """Ensure the LSP client matches the file's Lean project and return its relative path."""
+
+    lifespan = ctx.request_context.lifespan_context
+    project_cache = getattr(lifespan, "project_cache", {})
+    if not hasattr(lifespan, "project_cache"):
+        lifespan.project_cache = project_cache
+
+    abs_file_path = os.path.abspath(file_path)
+    file_dir = os.path.dirname(abs_file_path)
+
+    def activate_project(project_path: Path, cache_dirs: list[str]) -> str | None:
+        project_path_obj = project_path
+        rel = get_relative_file_path(project_path_obj, file_path)
+        if rel is None:
+            return None
+
+        project_path_obj = project_path_obj.resolve()
+        lifespan.lean_project_path = project_path_obj
+
+        cache_targets: list[str] = []
+        for directory in cache_dirs + [str(project_path_obj)]:
+            if directory and directory not in cache_targets:
+                cache_targets.append(directory)
+
+        for directory in cache_targets:
+            project_cache[directory] = project_path_obj
+
+        startup_client(ctx)
+        return rel
+
+    # Fast path: current Lean project already valid for this file
+    if lifespan.lean_project_path is not None:
+        rel_path = activate_project(lifespan.lean_project_path, [file_dir])
+        if rel_path is not None:
+            return rel_path
+
+    # Walk up from file directory to root, using cache hits or lean-toolchain
+    prev_dir = None
+    current_dir = file_dir
+    while current_dir and current_dir != prev_dir:
+        cached_root = project_cache.get(current_dir)
+        if cached_root:
+            rel_path = activate_project(Path(cached_root), [current_dir])
+            if rel_path is not None:
+                return rel_path
+        elif valid_lean_project_path(current_dir):
+            rel_path = activate_project(Path(current_dir), [current_dir])
+            if rel_path is not None:
+                return rel_path
+        else:
+            project_cache[current_dir] = ""
+        prev_dir = current_dir
+        current_dir = os.path.dirname(current_dir)
+
+    return None

lean_lsp_mcp/file_utils.py

@@ -0,0 +1,100 @@
+from typing import Optional, Dict
+from pathlib import Path
+
+from mcp.server.fastmcp import Context
+from mcp.server.fastmcp.utilities.logging import get_logger
+from leanclient import LeanLSPClient
+
+
+logger = get_logger(__name__)
+
+
+def get_relative_file_path(lean_project_path: Path, file_path: str) -> Optional[str]:
+    """Convert path relative to project path.
+
+    Args:
+        lean_project_path (Path): Path to the Lean project root.
+        file_path (str): File path.
+
+    Returns:
+        str: Relative file path.
+    """
+    file_path_obj = Path(file_path)
+
+    # Check if absolute path
+    if file_path_obj.is_absolute() and file_path_obj.exists():
+        try:
+            return str(file_path_obj.relative_to(lean_project_path))
+        except ValueError:
+            # File is not in this project
+            return None
+
+    # Check if relative to project path
+    path = lean_project_path / file_path
+    if path.exists():
+        return str(path.relative_to(lean_project_path))
+
+    # Check if relative to CWD
+    cwd = Path.cwd()
+    path = cwd / file_path
+    if path.exists():
+        try:
+            return str(path.relative_to(lean_project_path))
+        except ValueError:
+            return None
+
+    return None
+
+
+def get_file_contents(abs_path: str) -> str:
+    for enc in ("utf-8", "latin-1"):
+        try:
+            with open(abs_path, "r", encoding=enc) as f:
+                return f.read()
+        except UnicodeDecodeError:
+            continue
+    with open(abs_path, "r", encoding=None) as f:
+        return f.read()
+
+
+def update_file(ctx: Context, rel_path: str) -> str:
+    """Update the file contents in the context.
+    Args:
+        ctx (Context): Context object.
+        rel_path (str): Relative file path.
+
+    Returns:
+        str: Updated file contents.
+    """
+    # Get file contents and hash
+    abs_path = ctx.request_context.lifespan_context.lean_project_path / rel_path
+    file_content = get_file_contents(str(abs_path))
+    hashed_file = hash(file_content)
+
+    # Check if file_contents have changed
+    file_content_hashes: Dict[str, str] = (
+        ctx.request_context.lifespan_context.file_content_hashes
+    )
+    if rel_path not in file_content_hashes:
+        file_content_hashes[rel_path] = hashed_file
+        return file_content
+
+    elif hashed_file == file_content_hashes[rel_path]:
+        return file_content
+
+    # Update file_contents
+    file_content_hashes[rel_path] = hashed_file
+
+    # Reload file in LSP
+    client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    try:
+        client.close_files([rel_path])
+    except FileNotFoundError as e:
+        logger.warning(
+            f"Attempted to close file {rel_path} that wasn't open in LSP client: {e}"
+        )
+    except Exception as e:
+        logger.error(
+            f"Unexpected error closing file {rel_path}: {type(e).__name__}: {e}"
+        )
+    return file_content

lean_lsp_mcp/instructions.py

@@ -0,0 +1,16 @@
+INSTRUCTIONS = """## General Rules
+- All line and column numbers are 1-indexed (use lean_file_contents if unsure).
+- 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.
+
+## Key Tools
+- 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 the 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_lsp_mcp/search_utils.py

@@ -0,0 +1,142 @@
+"""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
+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 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)
+
+    result = subprocess.run(command, capture_output=True, text=True, cwd=str(root))
+
+    matches = []
+    for line in result.stdout.splitlines():
+        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:
+            break
+
+    if result.returncode not in (0, 1) and not matches:
+        error_msg = f"ripgrep exited with code {result.returncode}"
+        if result.stderr:
+            error_msg += f"\n{result.stderr}"
+        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