lean-lsp-mcp 0.13.2__py3-none-any.whl → 0.14.1__py3-none-any.whl

lean_lsp_mcp/client_utils.py

@@ -40,9 +40,7 @@ def startup_client(ctx: Context):
         prevent_cache = bool(os.environ.get("LEAN_LSP_TEST_MODE"))
         with OutputCapture() as output:
             client = LeanLSPClient(
-                lean_project_path, 
-                initial_build=False,
-                prevent_cache_get=prevent_cache
+                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()

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/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/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/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.2.dist-info → lean_lsp_mcp-0.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.13.2
+Version: 0.14.1
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -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.14.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+lean_lsp_mcp/__init__.py,sha256=lxqDq0G_sI2iu2Nniy-pTW7BE9Ux7ZXeDoGf0OAWIDc,763
+lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
+lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
+lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
+lean_lsp_mcp/instructions.py,sha256=GUOCDILr5N4H_kNE5hiXtzy4Sz9tu-BnE7Y0ktXIF9M,955
+lean_lsp_mcp/outline_utils.py,sha256=bXBpLp_QnxmvwoP2y1juCYog2eln6329MAKuOXOz0-E,7807
+lean_lsp_mcp/search_utils.py,sha256=X2LPynDNLi767UDxbxHpMccOkbnfKJKv_HxvRNxIXM4,3984
+lean_lsp_mcp/server.py,sha256=qf0iRVeWrrvX91EmJsgbx7DW8kwn28zMs1WyfkxCh5A,37644
+lean_lsp_mcp/utils.py,sha256=qY2Ef82SmD46y0IgyX1jimigkgr6Q8-Hrme-yUYSBGo,11094
+lean_lsp_mcp-0.14.1.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
+lean_lsp_mcp-0.14.1.dist-info/METADATA,sha256=XzcCebo_ZF4-alJTmjY5Cu2M7OpVgEJmCriT4Sl2CMw,19855
+lean_lsp_mcp-0.14.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lean_lsp_mcp-0.14.1.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
+lean_lsp_mcp-0.14.1.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
+lean_lsp_mcp-0.14.1.dist-info/RECORD,,

lean_lsp_mcp-0.13.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-lean_lsp_mcp/__init__.py,sha256=lxqDq0G_sI2iu2Nniy-pTW7BE9Ux7ZXeDoGf0OAWIDc,763
-lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
-lean_lsp_mcp/client_utils.py,sha256=lzWOuiuho-PrI_ARH0Kdn93yBXmK--G3izccMsuu-7g,4930
-lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
-lean_lsp_mcp/instructions.py,sha256=1Xgh_fkdRpz-lqdl6kpETdwEu-IGRQGIdSdU7o9t5hc,853
-lean_lsp_mcp/search_utils.py,sha256=X2LPynDNLi767UDxbxHpMccOkbnfKJKv_HxvRNxIXM4,3984
-lean_lsp_mcp/server.py,sha256=g_CcgMl4aOE0MqcNv5O0DvSR7mN_fSdmJQAddDSclfA,36261
-lean_lsp_mcp/utils.py,sha256=YE6o6eswOi47AYojITQ2RcR-DspqKtgACeV-O7xgOKM,10554
-lean_lsp_mcp-0.13.2.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
-lean_lsp_mcp-0.13.2.dist-info/METADATA,sha256=8UFbXM1OVizqVDOthRMcbQo5mN4VeGMFm-qINdvvXC8,19626
-lean_lsp_mcp-0.13.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lean_lsp_mcp-0.13.2.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
-lean_lsp_mcp-0.13.2.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
-lean_lsp_mcp-0.13.2.dist-info/RECORD,,