lean-lsp-mcp 0.11.3__tar.gz → 0.12.1__tar.gz

{lean_lsp_mcp-0.11.3/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.11.3
+Version: 0.12.1
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,8 +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.4.0
-Requires-Dist: mcp[cli]==1.19.0
+Requires-Dist: leanclient==0.5.1
+Requires-Dist: mcp[cli]==1.21.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.11.3"
+version = "0.12.1"
 description = "Lean Theorem Prover MCP"
 authors = [{name="Oliver Dressler", email="hey@oli.show"}]
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
-    "leanclient==0.4.0",
-    "mcp[cli]==1.19.0",
+    "leanclient==0.5.1",
+    "mcp[cli]==1.21.0",
     "orjson>=3.11.1",
 ]
 

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1}/src/lean_lsp_mcp/client_utils.py

@@ -34,7 +34,6 @@ def startup_client(ctx: Context):
                 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:

lean_lsp_mcp-0.12.1/src/lean_lsp_mcp/file_utils.py

@@ -0,0 +1,49 @@
+from typing import Optional
+from pathlib import Path
+
+
+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)
+
+    # Absolute path under project
+    if file_path_obj.is_absolute() and file_path_obj.exists():
+        try:
+            return str(file_path_obj.relative_to(lean_project_path))
+        except ValueError:
+            return None
+
+    # Relative to project path
+    path = lean_project_path / file_path
+    if path.exists():
+        return str(path.relative_to(lean_project_path))
+
+    # Relative to CWD, but only if inside project root
+    cwd = Path.cwd()
+    path = cwd / file_path
+    if path.exists():
+        try:
+            return str(path.resolve().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()

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1}/src/lean_lsp_mcp/server.py

@@ -23,7 +23,7 @@ from lean_lsp_mcp.client_utils import (
     startup_client,
     infer_project_path,
 )
-from lean_lsp_mcp.file_utils import get_file_contents, update_file
+from lean_lsp_mcp.file_utils import get_file_contents
 from lean_lsp_mcp.instructions import INSTRUCTIONS
 from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
 from lean_lsp_mcp.utils import (
@@ -51,7 +51,6 @@ _RG_AVAILABLE, _RG_MESSAGE = check_ripgrep_status()
 class AppContext:
     lean_project_path: Path | None
     client: LeanLSPClient | None
-    file_content_hashes: Dict[str, str]
     rate_limit: Dict[str, List[int]]
     lean_search_available: bool
 
@@ -68,7 +67,6 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         context = AppContext(
             lean_project_path=lean_project_path,
             client=None,
-            file_content_hashes={},
             rate_limit={
                 "leansearch": [],
                 "loogle": [],
@@ -166,7 +164,6 @@ async def lsp_build(
         if client:
             ctx.request_context.lifespan_context.client = None
             client.close()
-            ctx.request_context.lifespan_context.file_content_hashes.clear()
 
         if clean:
             subprocess.run(["lake", "clean"], cwd=lean_project_path_obj, check=False)
@@ -271,13 +268,20 @@ def file_contents(ctx: Context, file_path: str, annotate_lines: bool = True) ->
 
 
 @mcp.tool("lean_diagnostic_messages")
-def diagnostic_messages(ctx: Context, file_path: str) -> List[str] | str:
+def diagnostic_messages(
+    ctx: Context,
+    file_path: str,
+    start_line: Optional[int] = None,
+    end_line: Optional[int] = None,
+) -> List[str] | str:
     """Get all diagnostic msgs (errors, warnings, infos) for a Lean file.
 
     "no goals to be solved" means code may need removal.
 
     Args:
         file_path (str): Abs path to Lean file
+        start_line (int, optional): Start line (1-indexed). Filters from this line.
+        end_line (int, optional): End line (1-indexed). Filters to this line.
 
     Returns:
         List[str] | str: Diagnostic msgs or error msg
@@ -286,10 +290,19 @@ def diagnostic_messages(ctx: Context, file_path: str) -> List[str] | str:
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    update_file(ctx, rel_path)
-
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
-    diagnostics = client.get_diagnostics(rel_path)
+
+    # Convert 1-indexed to 0-indexed for leanclient
+    start_line_0 = (start_line - 1) if start_line is not None else None
+    end_line_0 = (end_line - 1) if end_line is not None else None
+
+    diagnostics = client.get_diagnostics(
+        rel_path,
+        start_line=start_line_0,
+        end_line=end_line_0,
+        inactivity_timeout=8.0,
+    )
+
     return format_diagnostics(diagnostics)
 
 
@@ -314,8 +327,9 @@ def goal(ctx: Context, file_path: str, line: int, column: Optional[int] = None)
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    content = update_file(ctx, rel_path)
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    content = client.get_file_content(rel_path)
 
     if column is None:
         lines = content.splitlines()
@@ -360,14 +374,15 @@ def term_goal(
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    content = update_file(ctx, rel_path)
+    client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    content = client.get_file_content(rel_path)
     if column is None:
         lines = content.splitlines()
         if line < 1 or line > len(lines):
             return "Line number out of range. Try elsewhere?"
         column = len(content.splitlines()[line - 1])
 
-    client: LeanLSPClient = ctx.request_context.lifespan_context.client
     term_goal = client.get_term_goal(rel_path, line - 1, column - 1)
     f_line = format_line(content, line, column)
     if term_goal is None:
@@ -394,8 +409,9 @@ def hover(ctx: Context, file_path: str, line: int, column: int) -> str:
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    file_content = update_file(ctx, rel_path)
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    file_content = client.get_file_content(rel_path)
     hover_info = client.get_hover(rel_path, line - 1, column - 1)
     if hover_info is None:
         f_line = format_line(file_content, line, column)
@@ -440,9 +456,10 @@ def completions(
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
-    content = update_file(ctx, rel_path)
 
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    content = client.get_file_content(rel_path)
     completions = client.get_completions(rel_path, line - 1, column - 1)
     formatted = [c["label"] for c in completions if "label" in c]
     f_line = format_line(content, line, column)
@@ -502,14 +519,16 @@ def declaration_file(ctx: Context, file_path: str, symbol: str) -> str:
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
-    orig_file_content = update_file(ctx, rel_path)
+
+    client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    orig_file_content = client.get_file_content(rel_path)
 
     # Find the first occurence of the symbol (line and column) in the file,
     position = find_start_position(orig_file_content, symbol)
     if not position:
         return f"Symbol `{symbol}` (case sensitive) not found in file `{rel_path}`. Add it first, then try again."
 
-    client: LeanLSPClient = ctx.request_context.lifespan_context.client
     declaration = client.get_declarations(
         rel_path, position["line"], position["column"]
     )
@@ -557,8 +576,9 @@ def multi_attempt(
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
-    update_file(ctx, rel_path)
+
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
 
     try:
         client.open_file(rel_path)
@@ -637,7 +657,9 @@ def run_code(ctx: Context, code: str) -> List[str] | str:
         assert client is not None  # startup_client guarantees an initialized client
         client.open_file(rel_path)
         opened_file = True
-        diagnostics = format_diagnostics(client.get_diagnostics(rel_path))
+        diagnostics = format_diagnostics(
+            client.get_diagnostics(rel_path, inactivity_timeout=8.0)
+        )
     finally:
         if opened_file:
             try:
@@ -858,8 +880,9 @@ def state_search(
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    file_contents = update_file(ctx, rel_path)
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    file_contents = client.get_file_content(rel_path)
     goal = client.get_goal(rel_path, line - 1, column - 1)
 
     f_line = format_line(file_contents, line, column)
@@ -908,8 +931,9 @@ def hammer_premise(
     if not rel_path:
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
-    file_contents = update_file(ctx, rel_path)
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
+    file_contents = client.get_file_content(rel_path)
     goal = client.get_goal(rel_path, line - 1, column - 1)
 
     f_line = format_line(file_contents, line, column)

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.11.3
+Version: 0.12.1
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,8 +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.4.0
-Requires-Dist: mcp[cli]==1.19.0
+Requires-Dist: leanclient==0.5.1
+Requires-Dist: mcp[cli]==1.21.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1}/src/lean_lsp_mcp.egg-info/SOURCES.txt

@@ -15,7 +15,9 @@ src/lean_lsp_mcp.egg-info/dependency_links.txt
 src/lean_lsp_mcp.egg-info/entry_points.txt
 src/lean_lsp_mcp.egg-info/requires.txt
 src/lean_lsp_mcp.egg-info/top_level.txt
+tests/test_diagnostic_line_range.py
 tests/test_editor_tools.py
+tests/test_file_caching.py
 tests/test_logging.py
 tests/test_misc_tools.py
 tests/test_project_tools.py

{lean_lsp_mcp-0.11.3 → lean_lsp_mcp-0.12.1}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,5 +1,5 @@
-leanclient==0.4.0
-mcp[cli]==1.19.0
+leanclient==0.5.1
+mcp[cli]==1.21.0
 orjson>=3.11.1
 
 [dev]

lean_lsp_mcp-0.12.1/tests/test_diagnostic_line_range.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import textwrap
+from collections.abc import Callable
+from pathlib import Path
+from typing import AsyncContextManager
+
+import pytest
+
+from tests.helpers.mcp_client import MCPClient, result_text
+
+
+@pytest.fixture()
+def diagnostic_file(test_project_path: Path) -> Path:
+    path = test_project_path / "DiagnosticTest.lean"
+    content = textwrap.dedent(
+        """
+        import Mathlib
+
+        -- Line 3: Valid definition
+        def validDef : Nat := 42
+
+        -- Line 6: Error on this line
+        def errorDef : Nat := "string"
+
+        -- Line 9: Another valid definition
+        def anotherValidDef : Nat := 100
+
+        -- Line 12: Another error
+        def anotherError : String := 123
+
+        -- Line 15: Valid theorem
+        theorem validTheorem : True := by
+          trivial
+        """
+    ).strip()
+    path.write_text(content + "\n", encoding="utf-8")
+    return path
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_without_line_range(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    diagnostic_file: Path,
+) -> None:
+    """Test getting all diagnostic messages without line range filtering."""
+    async with mcp_client_factory() as client:
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {"file_path": str(diagnostic_file)},
+        )
+        diag_text = result_text(diagnostics)
+
+        # Should contain both errors
+        assert "string" in diag_text.lower() or "error" in diag_text.lower()
+        # Check that multiple diagnostics are returned (at least the two errors we created)
+        assert diag_text.count("severity") >= 2
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_with_start_line(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    diagnostic_file: Path,
+) -> None:
+    """Test getting diagnostic messages starting from a specific line."""
+    async with mcp_client_factory() as client:
+        # First get all diagnostics to see what we have
+        all_diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(diagnostic_file),
+            },
+        )
+        all_diag_text = result_text(all_diagnostics)
+
+        # Get diagnostics starting from line 10 (should only include the second error)
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(diagnostic_file),
+                "start_line": 10,
+            },
+        )
+        diag_text = result_text(diagnostics)
+
+        # Should contain the second error (line 13: anotherError)
+        assert "123" in diag_text or "error" in diag_text.lower()
+        # Should have fewer diagnostics than all_diagnostics
+        assert len(diag_text) < len(all_diag_text)
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_with_line_range(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    diagnostic_file: Path,
+) -> None:
+    """Test getting diagnostic messages for a specific line range."""
+    async with mcp_client_factory() as client:
+        # First, get all diagnostics to see what lines they're actually on
+        all_diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {"file_path": str(diagnostic_file)},
+        )
+        all_diag_text = result_text(all_diagnostics)
+
+        # Extract line numbers from the diagnostics (format: "l7c23-l7c31")
+        import re
+
+        line_matches = re.findall(r"l(\d+)c", all_diag_text)
+        if line_matches:
+            first_error_line = int(line_matches[0])
+
+            # Get diagnostics only up to that error line
+            diagnostics = await client.call_tool(
+                "lean_diagnostic_messages",
+                {
+                    "file_path": str(diagnostic_file),
+                    "start_line": 1,
+                    "end_line": first_error_line,
+                },
+            )
+            diag_text = result_text(diagnostics)
+
+            # Should contain the first error
+            assert "string" in diag_text.lower() or len(diag_text) > 0
+            # Should be fewer diagnostics than all
+            assert len(diag_text) < len(all_diag_text)
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_with_no_errors_in_range(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    diagnostic_file: Path,
+) -> None:
+    """Test getting diagnostic messages for a range with no errors."""
+    async with mcp_client_factory() as client:
+        # Get diagnostics only for lines 14-17 (valid theorem, should have no errors)
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(diagnostic_file),
+                "start_line": 14,
+                "end_line": 17,
+            },
+        )
+        diag_text = result_text(diagnostics)
+
+        # Should indicate no errors or be empty
+        # The exact format depends on how the tool formats an empty result
+        assert (
+            "no" in diag_text.lower()
+            or len(diag_text.strip()) == 0
+            or diag_text == "[]"
+        )

lean_lsp_mcp-0.12.1/tests/test_file_caching.py

@@ -0,0 +1,80 @@
+"""Test file caching optimization."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import AsyncContextManager
+
+import pytest
+
+from tests.helpers.mcp_client import MCPClient, result_text
+
+
+@pytest.fixture()
+def cache_test_file(test_project_path: Path) -> Path:
+    path = test_project_path / "CacheTest.lean"
+    content = """import Mathlib
+
+def cachedValue : Nat := 42
+
+theorem cachedTheorem : cachedValue = 42 := by rfl
+"""
+    path.write_text(content, encoding="utf-8")
+    return path
+
+
+@pytest.mark.asyncio
+async def test_disk_changes_detected(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    cache_test_file: Path,
+) -> None:
+    """Disk changes must be detected and reprocessed correctly."""
+
+    async with mcp_client_factory() as client:
+        goal1 = await client.call_tool(
+            "lean_goal", {"file_path": str(cache_test_file), "line": 5}
+        )
+        result1 = result_text(goal1)
+        assert "no goals" in result1.lower()
+
+        cache_test_file.write_text(
+            """import Mathlib
+
+def cachedValue : Nat := 42
+
+theorem cachedTheorem : cachedValue = 42 := by sorry
+""",
+            encoding="utf-8",
+        )
+
+        goal2 = await client.call_tool(
+            "lean_goal", {"file_path": str(cache_test_file), "line": 5}
+        )
+        result2 = result_text(goal2)
+
+        assert "cachedValue = 42" in result2, (
+            f"Should show goal at sorry, got: {result2}"
+        )
+
+
+@pytest.mark.asyncio
+async def test_multiple_tools_share_file(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    cache_test_file: Path,
+) -> None:
+    """Different tools must reuse cached file state correctly."""
+
+    async with mcp_client_factory() as client:
+        await client.call_tool(
+            "lean_diagnostic_messages", {"file_path": str(cache_test_file)}
+        )
+        await client.call_tool(
+            "lean_goal", {"file_path": str(cache_test_file), "line": 5}
+        )
+        hover = await client.call_tool(
+            "lean_hover_info",
+            {"file_path": str(cache_test_file), "line": 3, "column": 5},
+        )
+
+        assert "cachedValue" in result_text(hover)

lean_lsp_mcp-0.11.3/src/lean_lsp_mcp/file_utils.py

@@ -1,100 +0,0 @@
-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