lean-lsp-mcp 0.13.0__tar.gz → 0.13.2__tar.gz

{lean_lsp_mcp-0.13.0/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.13.0
+Version: 0.13.2
 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.5.2
-Requires-Dist: mcp[cli]==1.21.0
+Requires-Dist: leanclient==0.5.5
+Requires-Dist: mcp[cli]==1.21.2
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.13.0"
+version = "0.13.2"
 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.5.2",
-    "mcp[cli]==1.21.0",
+    "leanclient==0.5.5",
+    "mcp[cli]==1.21.2",
     "orjson>=3.11.1",
 ]
 

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/src/lean_lsp_mcp/client_utils.py

@@ -36,14 +36,15 @@ def startup_client(ctx: Context):
             client.close()
 
         # Need to create a new client
+        # In test environments, prevent repeated cache downloads
+        prevent_cache = bool(os.environ.get("LEAN_LSP_TEST_MODE"))
         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}")
+            client = LeanLSPClient(
+                lean_project_path, 
+                initial_build=False,
+                prevent_cache_get=prevent_cache
+            )
+            logger.info(f"Connected to Lean language server at {lean_project_path}")
         build_output = output.get_output()
         if build_output:
             logger.debug(f"Build output: {build_output}")

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/src/lean_lsp_mcp/instructions.py

@@ -7,7 +7,7 @@ INSTRUCTIONS = """## General Rules
 ## 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 current proof situation (use declaration_name to focus on one proof).
+- 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_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/src/lean_lsp_mcp/server.py

@@ -289,6 +289,7 @@ def diagnostic_messages(
         declaration_name (str, optional): Name of a specific theorem/lemma/definition.
             If provided, only returns diagnostics within that declaration.
             Takes precedence over start_line/end_line.
+            Slow, requires waiting for full file analysis.
 
     Returns:
         List[str] | str: Diagnostic msgs or error msg
@@ -314,7 +315,7 @@ def diagnostic_messages(
         rel_path,
         start_line=start_line_0,
         end_line=end_line_0,
-        inactivity_timeout=8.0,
+        inactivity_timeout=15.0,
     )
 
     return format_diagnostics(diagnostics)
@@ -672,7 +673,7 @@ def run_code(ctx: Context, code: str) -> List[str] | str:
         client.open_file(rel_path)
         opened_file = True
         diagnostics = format_diagnostics(
-            client.get_diagnostics(rel_path, inactivity_timeout=8.0)
+            client.get_diagnostics(rel_path, inactivity_timeout=15.0)
         )
     finally:
         if opened_file:

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.13.0
+Version: 0.13.2
 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.5.2
-Requires-Dist: mcp[cli]==1.21.0
+Requires-Dist: leanclient==0.5.5
+Requires-Dist: mcp[cli]==1.21.2
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,5 +1,5 @@
-leanclient==0.5.2
-mcp[cli]==1.21.0
+leanclient==0.5.5
+mcp[cli]==1.21.2
 orjson>=3.11.1
 
 [dev]

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/tests/test_diagnostic_line_range.py

@@ -10,7 +10,7 @@ import pytest
 from tests.helpers.mcp_client import MCPClient, result_text
 
 
-@pytest.fixture()
+@pytest.fixture(scope="module")
 def diagnostic_file(test_project_path: Path) -> Path:
     path = test_project_path / "DiagnosticTest.lean"
     content = textwrap.dedent(
@@ -34,46 +34,30 @@ def diagnostic_file(test_project_path: Path) -> Path:
           trivial
         """
     ).strip()
-    path.write_text(content + "\n", encoding="utf-8")
+    if not path.exists() or path.read_text(encoding="utf-8") != content + "\n":
+        path.write_text(content + "\n", encoding="utf-8")
     return path
 
 
 @pytest.mark.asyncio
-async def test_diagnostic_messages_without_line_range(
+async def test_diagnostic_messages_line_filtering(
     mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
     diagnostic_file: Path,
 ) -> None:
-    """Test getting all diagnostic messages without line range filtering."""
+    """Test all line range filtering scenarios in one client session."""
     async with mcp_client_factory() as client:
+        # Test 1: Get all diagnostic messages without line range filtering
         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)
+        all_diag_text = diag_text
+        
+        # Test 2: Get diagnostics starting from line 10
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -82,35 +66,15 @@ async def test_diagnostic_messages_with_start_line(
             },
         )
         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")
+        
+        # Test 3: Get diagnostics for specific line range
         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",
                 {
@@ -120,21 +84,10 @@ async def test_diagnostic_messages_with_line_range(
                 },
             )
             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)
+        
+        # Test 4: Get diagnostics for range with no errors (lines 14-17)
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -144,9 +97,6 @@ async def test_diagnostic_messages_with_no_errors_in_range(
             },
         )
         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
@@ -154,7 +104,7 @@ async def test_diagnostic_messages_with_no_errors_in_range(
         )
 
 
-@pytest.fixture()
+@pytest.fixture(scope="module")
 def declaration_diagnostic_file(test_project_path: Path) -> Path:
     """Create a test file with multiple declarations, some with errors."""
     path = test_project_path / "DeclarationDiagnosticTest.lean"
@@ -175,29 +125,28 @@ def declaration_diagnostic_file(test_project_path: Path) -> Path:
         def anotherValidFunction : String := "hello"
         """
     ).strip()
-    path.write_text(content + "\n", encoding="utf-8")
+    if not path.exists() or path.read_text(encoding="utf-8") != content + "\n":
+        path.write_text(content + "\n", encoding="utf-8")
     return path
 
 
 @pytest.mark.asyncio
-async def test_diagnostic_messages_with_declaration_name_valid(
+async def test_diagnostic_messages_declaration_filtering(
     mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
     declaration_diagnostic_file: Path,
 ) -> None:
-    """Test filtering diagnostics by a specific declaration name."""
+    """Test all declaration-based filtering scenarios in one client session."""
     async with mcp_client_factory() as client:
-        # Get all diagnostics first to verify file has errors
+        # Test 1: Get all diagnostics first to verify file has errors
         all_diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {"file_path": str(declaration_diagnostic_file)},
         )
         all_diag_text = result_text(all_diagnostics)
-
-        # File should have diagnostics (contains intentional errors)
         assert len(all_diag_text) > 0
         assert "string" in all_diag_text.lower() or "type" in all_diag_text.lower()
 
-        # Get diagnostics for firstTheorem only
+        # Test 2: Get diagnostics for firstTheorem only
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -206,33 +155,10 @@ async def test_diagnostic_messages_with_declaration_name_valid(
             },
         )
         diag_text = result_text(diagnostics)
-
-        # Should contain error from firstTheorem
-        # The exact error message may vary, but should reference the theorem
         assert len(diag_text) > 0
-
-        # Filtered diagnostics should be shorter than or equal to all diagnostics
         assert len(diag_text) <= len(all_diag_text)
 
-
-@pytest.mark.asyncio
-async def test_diagnostic_messages_with_declaration_name_with_errors(
-    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
-    declaration_diagnostic_file: Path,
-) -> None:
-    """Test filtering by declaration that has type errors."""
-    async with mcp_client_factory() as client:
-        # Get all diagnostics first to verify file has errors
-        all_diagnostics = await client.call_tool(
-            "lean_diagnostic_messages",
-            {"file_path": str(declaration_diagnostic_file)},
-        )
-        all_diag_text = result_text(all_diagnostics)
-
-        # File should have diagnostics (contains intentional errors)
-        assert len(all_diag_text) > 0
-
-        # Get diagnostics for secondTheorem (has type error in statement)
+        # Test 3: Get diagnostics for secondTheorem (has type error in statement)
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -241,20 +167,10 @@ async def test_diagnostic_messages_with_declaration_name_with_errors(
             },
         )
         diag_text = result_text(diagnostics)
-
-        # secondTheorem has type errors, should have diagnostics
         assert len(diag_text) > 0
         assert isinstance(diag_text, str)
 
-
-@pytest.mark.asyncio
-async def test_diagnostic_messages_with_declaration_name_no_errors(
-    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
-    declaration_diagnostic_file: Path,
-) -> None:
-    """Test filtering by declaration that has no errors."""
-    async with mcp_client_factory() as client:
-        # Get diagnostics for validFunction (no errors)
+        # Test 4: Get diagnostics for validFunction (no errors)
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -263,8 +179,6 @@ async def test_diagnostic_messages_with_declaration_name_no_errors(
             },
         )
         diag_text = result_text(diagnostics)
-
-        # Should indicate no errors or be empty
         assert (
             "no" in diag_text.lower()
             or len(diag_text.strip()) == 0
@@ -273,13 +187,13 @@ async def test_diagnostic_messages_with_declaration_name_no_errors(
 
 
 @pytest.mark.asyncio
-async def test_diagnostic_messages_with_nonexistent_declaration(
+async def test_diagnostic_messages_declaration_edge_cases(
     mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
     declaration_diagnostic_file: Path,
 ) -> None:
-    """Test error handling when declaration name doesn't exist."""
+    """Test edge cases for declaration-based filtering."""
     async with mcp_client_factory() as client:
-        # Try to get diagnostics for non-existent declaration
+        # Test 1: Non-existent declaration
         result = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -288,21 +202,10 @@ async def test_diagnostic_messages_with_nonexistent_declaration(
             },
         )
         result_str = result_text(result)
-
-        # Should return error message about declaration not found
         assert "not found" in result_str.lower()
         assert "nonExistentTheorem" in result_str
 
-
-@pytest.mark.asyncio
-async def test_diagnostic_messages_declaration_name_takes_precedence(
-    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
-    declaration_diagnostic_file: Path,
-) -> None:
-    """Test that declaration_name takes precedence over start_line/end_line."""
-    async with mcp_client_factory() as client:
-        # Use declaration_name with conflicting start_line/end_line
-        # declaration_name should take precedence
+        # Test 2: declaration_name takes precedence over start_line/end_line
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -313,7 +216,44 @@ async def test_diagnostic_messages_declaration_name_takes_precedence(
             },
         )
         diag_text = result_text(diagnostics)
-
         # Should get diagnostics for firstTheorem, not lines 1-3
-        # (which would only include imports)
         assert len(diag_text) > 0
+
+
+@pytest.fixture(scope="module")
+def kernel_error_file(test_project_path: Path) -> Path:
+    """File with kernel error as first error (issue #63)."""
+    path = test_project_path / "KernelErrorTest.lean"
+    content = textwrap.dedent(
+        """
+        import Mathlib.Data.Real.Basic
+
+        structure test where
+          x : ℝ
+          deriving Repr
+
+        lemma test_lemma : False := by rfl
+        """
+    ).strip()
+    if not path.exists() or path.read_text(encoding="utf-8") != content + "\n":
+        path.write_text(content + "\n", encoding="utf-8")
+    return path
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_detects_kernel_errors(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    kernel_error_file: Path,
+) -> None:
+    """Test kernel errors detected when first in file (issue #63)."""
+    async with mcp_client_factory() as client:
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {"file_path": str(kernel_error_file)},
+        )
+        diag_text = result_text(diagnostics)
+
+        # Detect kernel error and regular error
+        assert "kernel" in diag_text.lower() or "unsafe" in diag_text.lower()
+        assert "rfl" in diag_text.lower() or "failed" in diag_text.lower()
+        assert diag_text.count("severity") >= 2

{lean_lsp_mcp-0.13.0 → lean_lsp_mcp-0.13.2}/tests/test_file_caching.py

@@ -25,19 +25,34 @@ theorem cachedTheorem : cachedValue = 42 := by rfl
 
 
 @pytest.mark.asyncio
-async def test_disk_changes_detected(
+async def test_file_caching(
     mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
     cache_test_file: Path,
 ) -> None:
-    """Disk changes must be detected and reprocessed correctly."""
+    """Test file caching: disk changes detected and tools share state correctly."""
 
     async with mcp_client_factory() as client:
+        # Test 1: Multiple tools share file state correctly
+        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)
+
+        # Test 2: Disk changes are detected and reprocessed correctly
         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()
 
+        # Modify file on disk
         cache_test_file.write_text(
             """import Mathlib
 
@@ -48,6 +63,7 @@ theorem cachedTheorem : cachedValue = 42 := by sorry
             encoding="utf-8",
         )
 
+        # Verify change is detected
         goal2 = await client.call_tool(
             "lean_goal", {"file_path": str(cache_test_file), "line": 5}
         )
@@ -56,25 +72,3 @@ theorem cachedTheorem : cachedValue = 42 := by sorry
         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)