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

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

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

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

@@ -1,13 +1,13 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.12.1"
+version = "0.13.0"
 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.1",
+    "leanclient==0.5.2",
     "mcp[cli]==1.21.0",
     "orjson>=3.11.1",
 ]

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

@@ -1,5 +1,5 @@
 INSTRUCTIONS = """## General Rules
-- All line and column numbers are 1-indexed (use lean_file_contents if unsure).
+- All line and column numbers are 1-indexed.
 - 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.
@@ -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 the current proof situation.
+- lean_diagnostic_messages: Understand current proof situation (use declaration_name to focus on one proof).
 - 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.12.1 → lean_lsp_mcp-0.13.0}/src/lean_lsp_mcp/server.py

@@ -34,6 +34,7 @@ from lean_lsp_mcp.utils import (
     format_diagnostics,
     format_goal,
     format_line,
+    get_declaration_range,
     OptionalTokenVerifier,
 )
 
@@ -238,6 +239,8 @@ async def lsp_build(
 def file_contents(ctx: Context, file_path: str, annotate_lines: bool = True) -> str:
     """Get the text contents of a Lean file, optionally with line numbers.
 
+    Use sparingly (bloats context). Mainly when unsure about line numbers.
+
     Args:
         file_path (str): Abs path to Lean file
         annotate_lines (bool, optional): Annotate lines with line numbers. Defaults to True.
@@ -273,6 +276,7 @@ def diagnostic_messages(
     file_path: str,
     start_line: Optional[int] = None,
     end_line: Optional[int] = None,
+    declaration_name: Optional[str] = None,
 ) -> List[str] | str:
     """Get all diagnostic msgs (errors, warnings, infos) for a Lean file.
 
@@ -282,6 +286,9 @@ def diagnostic_messages(
         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.
+        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.
 
     Returns:
         List[str] | str: Diagnostic msgs or error msg
@@ -292,6 +299,13 @@ def diagnostic_messages(
 
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
 
+    # If declaration_name is provided, get its range and use that for filtering
+    if declaration_name:
+        decl_range = get_declaration_range(client, rel_path, declaration_name)
+        if decl_range is None:
+            return f"Declaration '{declaration_name}' not found in file. Check the name (case-sensitive) and try again."
+        start_line, end_line = decl_range
+
     # 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

{lean_lsp_mcp-0.12.1 → lean_lsp_mcp-0.13.0}/src/lean_lsp_mcp/utils.py

@@ -259,3 +259,78 @@ def filter_diagnostics_by_position(
         matches.append(diagnostic)
 
     return matches
+
+
+def search_symbols(symbols: List[Dict], target_name: str) -> Dict | None:
+    """Recursively search through symbols and their children.
+
+    Args:
+        symbols: List of LSP document symbols
+        target_name: Name of the symbol to find (case-sensitive)
+
+    Returns:
+        The matching symbol dict, or None if not found
+    """
+    for symbol in symbols:
+        if symbol.get("name") == target_name:
+            return symbol
+        # Search nested declarations (children)
+        children = symbol.get("children", [])
+        if children:
+            result = search_symbols(children, target_name)
+            if result:
+                return result
+    return None
+
+
+def get_declaration_range(
+    client, file_path: str, declaration_name: str
+) -> tuple[int, int] | None:
+    """Get the line range (1-indexed) of a declaration by name using LSP document symbols.
+
+    Args:
+        client: The Lean LSP client instance (LeanLSPClient)
+        file_path: Relative path to the Lean file
+        declaration_name: Name of the declaration to find (case-sensitive)
+
+    Returns:
+        Tuple of (start_line, end_line) as 1-indexed integers, or None if not found
+    """
+    from lean_lsp_mcp.server import logger
+
+    try:
+        # Ensure file is opened (LSP needs this to analyze the file)
+        client.open_file(file_path)
+
+        # Get document symbols from LSP
+        symbols = client.get_document_symbols(file_path)
+
+        if not symbols:
+            logger.debug(
+                "No document symbols returned for '%s' - file may not be processed yet",
+                file_path,
+            )
+            return None
+
+        matching_symbol = search_symbols(symbols, declaration_name)
+        if not matching_symbol:
+            return None
+
+        # Extract range - LSP returns 0-indexed, convert to 1-indexed
+        range_info = matching_symbol.get("range")
+        if not range_info:
+            return None
+
+        start_line = range_info["start"]["line"] + 1
+        end_line = range_info["end"]["line"] + 1
+
+        return (start_line, end_line)
+
+    except Exception as e:
+        logger.warning(
+            "Failed to get declaration range for '%s' in '%s': %s",
+            declaration_name,
+            file_path,
+            e,
+        )
+        return None

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

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

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

@@ -1,4 +1,4 @@
-leanclient==0.5.1
+leanclient==0.5.2
 mcp[cli]==1.21.0
 orjson>=3.11.1
 

lean_lsp_mcp-0.13.0/tests/test_diagnostic_line_range.py

@@ -0,0 +1,319 @@
+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 == "[]"
+        )
+
+
+@pytest.fixture()
+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"
+    content = textwrap.dedent(
+        """
+        import Mathlib
+
+        -- First theorem with a clear type error
+        theorem firstTheorem : 1 + 1 = 2 := "string instead of proof"
+
+        -- Valid definition
+        def validFunction : Nat := 42
+
+        -- Second theorem with an error in the statement type mismatch
+        theorem secondTheorem : Nat := True
+
+        -- Another valid definition
+        def anotherValidFunction : String := "hello"
+        """
+    ).strip()
+    path.write_text(content + "\n", encoding="utf-8")
+    return path
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_with_declaration_name_valid(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    declaration_diagnostic_file: Path,
+) -> None:
+    """Test filtering diagnostics by a specific declaration name."""
+    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
+        assert "string" in all_diag_text.lower() or "type" in all_diag_text.lower()
+
+        # Get diagnostics for firstTheorem only
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(declaration_diagnostic_file),
+                "declaration_name": "firstTheorem",
+            },
+        )
+        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)
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(declaration_diagnostic_file),
+                "declaration_name": "secondTheorem",
+            },
+        )
+        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)
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(declaration_diagnostic_file),
+                "declaration_name": "validFunction",
+            },
+        )
+        diag_text = result_text(diagnostics)
+
+        # Should indicate no errors or be empty
+        assert (
+            "no" in diag_text.lower()
+            or len(diag_text.strip()) == 0
+            or diag_text == "[]"
+        )
+
+
+@pytest.mark.asyncio
+async def test_diagnostic_messages_with_nonexistent_declaration(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    declaration_diagnostic_file: Path,
+) -> None:
+    """Test error handling when declaration name doesn't exist."""
+    async with mcp_client_factory() as client:
+        # Try to get diagnostics for non-existent declaration
+        result = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(declaration_diagnostic_file),
+                "declaration_name": "nonExistentTheorem",
+            },
+        )
+        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
+        diagnostics = await client.call_tool(
+            "lean_diagnostic_messages",
+            {
+                "file_path": str(declaration_diagnostic_file),
+                "declaration_name": "firstTheorem",
+                "start_line": 1,  # These should be ignored
+                "end_line": 3,  # These should be ignored
+            },
+        )
+        diag_text = result_text(diagnostics)
+
+        # Should get diagnostics for firstTheorem, not lines 1-3
+        # (which would only include imports)
+        assert len(diag_text) > 0

lean_lsp_mcp-0.12.1/tests/test_diagnostic_line_range.py

@@ -1,154 +0,0 @@
-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 == "[]"
-        )