lean-lsp-mcp 0.13.1__tar.gz → 0.14.0__tar.gz

{lean_lsp_mcp-0.13.1/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.13.1
+Version: 0.14.0
 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.3
-Requires-Dist: mcp[cli]==1.21.1
+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"
@@ -66,7 +66,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ### 3. Configure your IDE/Setup
 
 <details>
-<summary><b>VSCode</b></summary>
+<summary><b>VSCode (Click to expand)</b></summary>
 One-click config setup:
 
 [![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=lean-lsp&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22lean-lsp-mcp%22%5D%7D)
@@ -118,7 +118,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Cursor</b></summary>
+<summary><b>Cursor (Click to expand)</b></summary>
 1. Open MCP Settings (File > Preferences > Cursor Settings > MCP)
 
 2. "+ Add a new global MCP Server" > ("Create File")
@@ -138,7 +138,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Claude Code</b></summary>
+<summary><b>Claude Code (Click to expand)</b></summary>
 Run one of these commands in the root directory of your Lean project (where `lakefile.toml` is located):
 
 ```bash
@@ -166,7 +166,11 @@ For the local search tool `lean_local_search`, install [ripgrep](https://github.
 
 ### File interactions (LSP)
 
-#### lean_file_contents
+#### lean_file_outline
+
+Get a concise outline of a Lean file showing imports and declarations with type signatures (theorems, definitions, classes, structures).
+
+#### lean_file_contents (DEPRECATED)
 
 Get the contents of a Lean file, optionally with line number annotations.
 

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/README.md

@@ -44,7 +44,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ### 3. Configure your IDE/Setup
 
 <details>
-<summary><b>VSCode</b></summary>
+<summary><b>VSCode (Click to expand)</b></summary>
 One-click config setup:
 
 [![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=lean-lsp&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22lean-lsp-mcp%22%5D%7D)
@@ -96,7 +96,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Cursor</b></summary>
+<summary><b>Cursor (Click to expand)</b></summary>
 1. Open MCP Settings (File > Preferences > Cursor Settings > MCP)
 
 2. "+ Add a new global MCP Server" > ("Create File")
@@ -116,7 +116,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Claude Code</b></summary>
+<summary><b>Claude Code (Click to expand)</b></summary>
 Run one of these commands in the root directory of your Lean project (where `lakefile.toml` is located):
 
 ```bash
@@ -144,7 +144,11 @@ For the local search tool `lean_local_search`, install [ripgrep](https://github.
 
 ### File interactions (LSP)
 
-#### lean_file_contents
+#### lean_file_outline
+
+Get a concise outline of a Lean file showing imports and declarations with type signatures (theorems, definitions, classes, structures).
+
+#### lean_file_contents (DEPRECATED)
 
 Get the contents of a Lean file, optionally with line number annotations.
 

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.13.1"
+version = "0.14.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.3",
-    "mcp[cli]==1.21.1",
+    "leanclient==0.5.5",
+    "mcp[cli]==1.21.2",
     "orjson>=3.11.1",
 ]
 

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp/client_utils.py

@@ -36,14 +36,13 @@ 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.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp/instructions.py

@@ -5,6 +5,7 @@ INSTRUCTIONS = """## General Rules
 - Work iteratively: Small steps, intermediate sorries, frequent checks.
 
 ## Key Tools
+- lean_file_outline: Concise skeleton of a file (imports, docstrings, declarations). Token efficient.
 - 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.

lean_lsp_mcp-0.14.0/src/lean_lsp_mcp/outline_utils.py

@@ -0,0 +1,200 @@
+import re
+from typing import Dict, List, Optional, Tuple
+from leanclient import LeanLSPClient
+from leanclient.utils import DocumentContentChange
+
+
+METHOD_KIND = {6, "method"}
+KIND_TAGS = {"namespace": "Ns"}
+
+
+def _get_info_trees(client: LeanLSPClient, path: str, symbols: List[Dict]) -> Dict[str, str]:
+    """Insert #info_trees commands, collect diagnostics, then revert changes."""
+    if not symbols:
+        return {}
+
+    symbol_by_line = {}
+    changes = []
+    for i, sym in enumerate(sorted(symbols, key=lambda s: s['range']['start']['line'])):
+        line = sym['range']['start']['line'] + i
+        symbol_by_line[line] = sym['name']
+        changes.append(DocumentContentChange("#info_trees in\n", [line, 0], [line, 0]))
+
+    client.update_file(path, changes)
+    diagnostics = client.get_diagnostics(path)
+
+    info_trees = {
+        symbol_by_line[diag['range']['start']['line']]: diag['message']
+        for diag in diagnostics
+        if diag['severity'] == 3 and diag['range']['start']['line'] in symbol_by_line
+    }
+
+    # Revert in reverse order
+    client.update_file(path, [
+        DocumentContentChange("", [line, 0], [line + 1, 0])
+        for line in sorted(symbol_by_line.keys(), reverse=True)
+    ])
+    return info_trees
+
+
+def _extract_type(info: str, name: str) -> Optional[str]:
+    """Extract type signature from info tree message."""
+    if m := re.search(rf'  • \[Term\] {re.escape(name)} \(isBinder := true\) : ([^@]+) @', info):
+        return m.group(1).strip()
+    return None
+
+
+def _extract_fields(info: str, name: str) -> List[Tuple[str, str]]:
+    """Extract structure/class fields from info tree message."""
+    fields = []
+    for pattern in [rf'{re.escape(name)}\.(\w+)', rf'@{re.escape(name)}\.(\w+)']:
+        for m in re.finditer(rf'  • \[Term\] {pattern} \(isBinder := true\) : (.+?) @', info):
+            field_name, full_type = m.groups()
+            # Clean up the type signature
+            if ']' in full_type:
+                field_type = full_type[full_type.rfind(']')+1:].lstrip('→ ').strip()
+            elif ' → ' in full_type:
+                field_type = full_type.split(' → ')[-1].strip()
+            else:
+                field_type = full_type.strip()
+            fields.append((field_name, field_type))
+    return fields
+
+
+def _extract_declarations(content: str, start: int, end: int) -> List[Dict]:
+    """Extract theorem/lemma/def declarations from file content."""
+    lines = content.splitlines()
+    decls, i = [], start
+
+    while i < min(end, len(lines)):
+        line = lines[i].strip()
+        for keyword in ['theorem', 'lemma', 'def']:
+            if line.startswith(f"{keyword} "):
+                name = line[len(keyword):].strip().split()[0]
+                if name and not name.startswith('_'):
+                    # Collect until :=
+                    decl_lines = [line]
+                    j = i + 1
+                    while j < min(end, len(lines)) and ':=' not in ' '.join(decl_lines):
+                        if (next_line := lines[j].strip()) and not next_line.startswith('--'):
+                            decl_lines.append(next_line)
+                        j += 1
+
+                    # Extract signature (everything before :=, minus keyword and name)
+                    full_decl = ' '.join(decl_lines)
+                    type_sig = None
+                    if ':=' in full_decl:
+                        sig_part = full_decl.split(':=', 1)[0].strip()[len(keyword):].strip()
+                        if sig_part.startswith(name):
+                            type_sig = sig_part[len(name):].strip()
+
+                    decls.append({
+                        'name': name,
+                        'kind': 'method',
+                        'range': {'start': {'line': i, 'character': 0}, 
+                                 'end': {'line': i, 'character': len(lines[i])}},
+                        '_keyword': keyword,
+                        '_type': type_sig
+                    })
+                break
+        i += 1
+    return decls
+
+
+def _flatten_symbols(symbols: List[Dict], indent: int = 0, content: str = "") -> List[Tuple[Dict, int]]:
+    """Recursively flatten symbol hierarchy, extracting declarations from namespaces."""
+    result = []
+    for sym in symbols:
+        result.append((sym, indent))
+        children = sym.get('children', [])
+
+        # Extract theorem/lemma/def from namespace bodies
+        if content and sym.get('kind') == 'namespace':
+            ns_range = sym['range']
+            ns_start = ns_range['start']['line']
+            ns_end = ns_range['end']['line']
+            children = children + _extract_declarations(content, ns_start, ns_end)
+
+        if children:
+            result.extend(_flatten_symbols(children, indent + 1, content))
+    return result
+
+
+def _detect_tag(name: str, kind: str, type_sig: str, has_fields: bool, keyword: Optional[str]) -> str:
+    """Determine the appropriate tag for a symbol."""
+    if has_fields:
+        return "Class" if '→' in type_sig else "Struct"
+    if name == "example":
+        return "Ex"
+    if keyword in {'theorem', 'lemma'}:
+        return "Thm"
+    if type_sig and any(marker in type_sig for marker in ['∀', '=']):
+        return "Thm"
+    if type_sig and '→' in type_sig.replace(' → ', '', 1):  # More than one arrow
+        return "Thm"
+    return KIND_TAGS.get(kind, "Def")
+
+
+def _format_symbol(sym: Dict, type_sigs: Dict, fields_map: Dict, indent: int) -> str:
+    """Format a single symbol with its type signature and fields."""
+    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'))
+    prefix = "\t" * indent
+
+    start = sym['range']['start']['line'] + 1
+    end = sym['range']['end']['line'] + 1
+    line_info = f"L{start}" if start == end else f"L{start}-{end}"
+
+    result = f"{prefix}[{tag}: {line_info}] {name}"
+    if type_sig:
+        result += f" : {type_sig}"
+
+    for fname, ftype in fields:
+        result += f"\n{prefix}\t{fname} : {ftype}"
+
+    return result + "\n"
+
+
+def generate_outline(client: LeanLSPClient, path: str) -> str:
+    """Generate a concise outline of a Lean file showing structure and signatures."""
+    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 f"# {path}\n\n*No symbols or imports found*\n"
+
+    # 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 output
+    parts = []
+    if imports:
+        parts.append("## Imports\n" + "\n".join(imports))
+
+    if symbols:
+        declarations = [
+            _format_symbol(sym, type_sigs, fields_map, indent)
+            for sym, indent in all_symbols
+            if sym.get('kind') in METHOD_KIND or sym.get('_keyword') or sym.get('kind') == 'namespace'
+        ]
+        parts.append("## Declarations\n" + "".join(declarations).rstrip())
+
+    return "\n\n".join(parts) + "\n"

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp/server.py

@@ -26,8 +26,10 @@ from lean_lsp_mcp.client_utils import (
 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.outline_utils import generate_outline
 from lean_lsp_mcp.utils import (
     OutputCapture,
+    deprecated,
     extract_range,
     filter_diagnostics_by_position,
     find_start_position,
@@ -236,6 +238,7 @@ async def lsp_build(
 
 # File level tools
 @mcp.tool("lean_file_contents")
+@deprecated
 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.
 
@@ -270,6 +273,26 @@ def file_contents(ctx: Context, file_path: str, annotate_lines: bool = True) ->
         return data
 
 
+@mcp.tool("lean_file_outline")
+def file_outline(ctx: Context, file_path: str) -> str:
+    """Get a concise outline showing imports and declarations with type signatures (theorems, defs, classes, structures).
+
+    Highly useful and token-efficient. Slow-ish.
+
+    Args:
+        file_path (str): Abs path to Lean file
+
+    Returns:
+        str: Markdown formatted outline or error msg
+    """
+    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"
+
+    client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    return generate_outline(client, rel_path)
+
+
 @mcp.tool("lean_diagnostic_messages")
 def diagnostic_messages(
     ctx: Context,
@@ -706,7 +729,7 @@ def run_code(ctx: Context, code: str) -> List[str] | str:
 
 @mcp.tool("lean_local_search")
 def local_search(
-    ctx: Context, query: str, limit: int = 10
+    ctx: Context, query: str, limit: int = 10, project_root: str | None = None
 ) -> List[Dict[str, str]] | str:
     """Confirm declarations exist in the current workspace to prevent hallucinating APIs.
 
@@ -724,11 +747,29 @@ def local_search(
     if not _RG_AVAILABLE:
         return _RG_MESSAGE
 
-    stored_root = ctx.request_context.lifespan_context.lean_project_path
-    if stored_root is None:
+    lifespan = ctx.request_context.lifespan_context
+    stored_root = lifespan.lean_project_path
+
+    if project_root:
+        try:
+            resolved_root = Path(project_root).expanduser().resolve()
+        except OSError as exc:  # pragma: no cover - defensive path handling
+            return f"Invalid project root '{project_root}': {exc}"
+        if not resolved_root.exists():
+            return f"Project root '{project_root}' does not exist."
+        lifespan.lean_project_path = resolved_root
+    else:
+        resolved_root = stored_root
+
+    if resolved_root is None:
         return "Lean project path not set. Call a file-based tool (like lean_file_contents) first to set the project path."
 
-    return lean_local_search(query=query.strip(), limit=limit, project_root=stored_root)
+    try:
+        return lean_local_search(
+            query=query.strip(), limit=limit, project_root=resolved_root
+        )
+    except RuntimeError as exc:
+        return f"lean_local_search error:\n{exc}"
 
 
 @mcp.tool("lean_leansearch")

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp/utils.py

@@ -2,7 +2,7 @@ import os
 import secrets
 import sys
 import tempfile
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Callable
 
 from mcp.server.auth.provider import AccessToken, TokenVerifier
 
@@ -334,3 +334,22 @@ def get_declaration_range(
             e,
         )
         return None
+
+
+def deprecated(func_or_msg: str | Callable | None = None) -> Callable:
+    """Mark a tool as deprecated. Can be used as @deprecated or @deprecated("msg")."""
+    msg = "Will be removed soon."
+
+    def _decorator(func: Callable) -> Callable:
+        doc = func.__doc__ or ""
+        func.__doc__ = f"DEPRECATED: {msg}\n\n{doc}"
+        return func
+
+    if isinstance(func_or_msg, str):
+        msg = func_or_msg
+        return _decorator
+
+    if func_or_msg is None:
+        return _decorator
+
+    return _decorator(func_or_msg)

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.13.1
+Version: 0.14.0
 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.3
-Requires-Dist: mcp[cli]==1.21.1
+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"
@@ -66,7 +66,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ### 3. Configure your IDE/Setup
 
 <details>
-<summary><b>VSCode</b></summary>
+<summary><b>VSCode (Click to expand)</b></summary>
 One-click config setup:
 
 [![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=lean-lsp&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22lean-lsp-mcp%22%5D%7D)
@@ -118,7 +118,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Cursor</b></summary>
+<summary><b>Cursor (Click to expand)</b></summary>
 1. Open MCP Settings (File > Preferences > Cursor Settings > MCP)
 
 2. "+ Add a new global MCP Server" > ("Create File")
@@ -138,7 +138,7 @@ If that doesn't work, you can try cloning this repository and replace `"lean-lsp
 </details>
 
 <details>
-<summary><b>Claude Code</b></summary>
+<summary><b>Claude Code (Click to expand)</b></summary>
 Run one of these commands in the root directory of your Lean project (where `lakefile.toml` is located):
 
 ```bash
@@ -166,7 +166,11 @@ For the local search tool `lean_local_search`, install [ripgrep](https://github.
 
 ### File interactions (LSP)
 
-#### lean_file_contents
+#### lean_file_outline
+
+Get a concise outline of a Lean file showing imports and declarations with type signatures (theorems, definitions, classes, structures).
+
+#### lean_file_contents (DEPRECATED)
 
 Get the contents of a Lean file, optionally with line number annotations.
 

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/lean_lsp_mcp/__main__.py
 src/lean_lsp_mcp/client_utils.py
 src/lean_lsp_mcp/file_utils.py
 src/lean_lsp_mcp/instructions.py
+src/lean_lsp_mcp/outline_utils.py
 src/lean_lsp_mcp/search_utils.py
 src/lean_lsp_mcp/server.py
 src/lean_lsp_mcp/utils.py
@@ -20,5 +21,6 @@ tests/test_editor_tools.py
 tests/test_file_caching.py
 tests/test_logging.py
 tests/test_misc_tools.py
+tests/test_outline.py
 tests/test_project_tools.py
 tests/test_search_tools.py

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/src/lean_lsp_mcp.egg-info/requires.txt

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

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/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
+        all_diag_text = diag_text
 
-
-@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)
+        # Test 2: Get diagnostics starting from line 10
         diagnostics = await client.call_tool(
             "lean_diagnostic_messages",
             {
@@ -82,35 +66,16 @@ 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 +85,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 +98,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 +105,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 +126,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 +156,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 +168,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 +180,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 +188,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 +203,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,13 +217,11 @@ 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()
+@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"
@@ -334,7 +236,8 @@ def kernel_error_file(test_project_path: Path) -> Path:
         lemma test_lemma : False := by rfl
         """
     ).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
 
 

{lean_lsp_mcp-0.13.1 → lean_lsp_mcp-0.14.0}/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)

lean_lsp_mcp-0.14.0/tests/test_outline.py

@@ -0,0 +1,117 @@
+"""Test outline generation with various Lean files."""
+
+from __future__ import annotations
+
+import re
+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 mathlib_nat_basic(test_project_path: Path) -> Path:
+    """Path to Mathlib Data.Nat.Basic file."""
+    return test_project_path / ".lake/packages/mathlib/Mathlib/Data/Nat/Basic.lean"
+
+
+@pytest.mark.asyncio
+async def test_outline_simple_files(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    test_project_path: Path,
+) -> None:
+    """Test outline generation on simple test files."""
+    test_files = [
+        test_project_path / "StructTest.lean",
+        test_project_path / "TheoremTest.lean",
+    ]
+    
+    async with mcp_client_factory() as client:
+        for test_file in test_files:
+            result = await client.call_tool("lean_file_outline", {"file_path": str(test_file)})
+            outline = result_text(result)
+            
+            # Basic structure checks
+            assert "## Imports" in outline or "## Declarations" in outline
+            assert len(outline) > 0
+
+
+@pytest.mark.asyncio
+async def test_mathlib_outline_structure(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    mathlib_nat_basic: Path,
+) -> None:
+    """Test outline generation with a real Mathlib file."""
+    async with mcp_client_factory() as client:
+        result = await client.call_tool("lean_file_outline", {"file_path": str(mathlib_nat_basic)})
+        outline = result_text(result)
+        
+        # Basic structure checks (no filename header now)
+        assert "## Imports" in outline
+        assert "## Declarations" in outline
+        
+        # Should have imports from Mathlib
+        assert "Mathlib.Data.Nat.Init" in outline
+        
+        # Should have namespace (new format)
+        assert "[Ns:" in outline and "Nat" in outline
+        
+        # Should have instance declarations
+        assert "instLinearOrder" in outline or "LinearOrder" in outline
+
+
+@pytest.mark.asyncio
+async def test_mathlib_outline_has_line_numbers(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    mathlib_nat_basic: Path,
+) -> None:
+    """Verify line numbers are present in outline."""
+    async with mcp_client_factory() as client:
+        result = await client.call_tool("lean_file_outline", {"file_path": str(mathlib_nat_basic)})
+        outline = result_text(result)
+        
+        # Should have line numbers in format "[Tag: L27-135]" or "[Tag: L31]"
+        line_pattern = r'L(\d+)(?:-(\d+))?'
+        matches = re.findall(line_pattern, outline)
+        
+        assert len(matches) > 0, "Should have line number annotations"
+
+
+@pytest.mark.asyncio
+async def test_mathlib_outline_has_types(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    mathlib_nat_basic: Path,
+) -> None:
+    """Verify type signatures are included."""
+    async with mcp_client_factory() as client:
+        result = await client.call_tool("lean_file_outline", {"file_path": str(mathlib_nat_basic)})
+        outline = result_text(result)
+
+        # Should have type annotations with ":"
+        assert "LinearOrder ℕ" in outline or ": " in outline
+
+
+@pytest.mark.asyncio
+async def test_mathlib_outline_file_cleanup(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    mathlib_nat_basic: Path,
+) -> None:
+    """Verify file is properly cleaned up after info_trees extraction."""
+    async with mcp_client_factory() as client:
+        # Get original file content
+        original_content = mathlib_nat_basic.read_text()
+
+        # Generate outline (which inserts and removes #info_trees lines)
+        await client.call_tool("lean_file_outline", {"file_path": str(mathlib_nat_basic)})
+
+        # Read file content again
+        final_content = mathlib_nat_basic.read_text()
+
+        # File should be unchanged
+        assert final_content == original_content, "File should be restored to original state after outline generation"
+
+        # Specifically check that no #info_trees lines remain
+        assert "#info_trees" not in final_content, "No #info_trees directives should remain in file"