lean-lsp-mcp 0.16.1__tar.gz → 0.16.2__tar.gz

{lean_lsp_mcp-0.16.1/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.16.1
+Version: 0.16.2
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,9 +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.6.1
-Requires-Dist: mcp[cli]==1.23.1
-Requires-Dist: mcp[cli]>=1.22.0
+Requires-Dist: leanclient==0.6.2
+Requires-Dist: mcp[cli]==1.24.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.16.1"
+version = "0.16.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.6.1",
-    "mcp[cli]==1.23.1", "mcp[cli]>=1.22.0",
+    "leanclient==0.6.2",
+    "mcp[cli]==1.24.0",
     "orjson>=3.11.1",
 ]
 

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/src/lean_lsp_mcp/models.py

@@ -118,3 +118,80 @@ class RunResult(BaseModel):
 class DeclarationInfo(BaseModel):
     file_path: str = Field(description="Path to declaration file")
     content: str = Field(description="File content")
+
+
+# Wrapper models for list-returning tools
+# FastMCP flattens bare lists into separate TextContent blocks, causing serialization issues.
+# Wrapping in a model ensures proper JSON serialization.
+
+
+class DiagnosticsResult(BaseModel):
+    """Wrapper for diagnostic messages list."""
+
+    items: List[DiagnosticMessage] = Field(
+        default_factory=list, description="List of diagnostic messages"
+    )
+
+
+class CompletionsResult(BaseModel):
+    """Wrapper for completions list."""
+
+    items: List[CompletionItem] = Field(
+        default_factory=list, description="List of completion items"
+    )
+
+
+class MultiAttemptResult(BaseModel):
+    """Wrapper for multi-attempt results list."""
+
+    items: List[AttemptResult] = Field(
+        default_factory=list, description="List of attempt results"
+    )
+
+
+class LocalSearchResults(BaseModel):
+    """Wrapper for local search results list."""
+
+    items: List[LocalSearchResult] = Field(
+        default_factory=list, description="List of local search results"
+    )
+
+
+class LeanSearchResults(BaseModel):
+    """Wrapper for LeanSearch results list."""
+
+    items: List[LeanSearchResult] = Field(
+        default_factory=list, description="List of LeanSearch results"
+    )
+
+
+class LoogleResults(BaseModel):
+    """Wrapper for Loogle results list."""
+
+    items: List[LoogleResult] = Field(
+        default_factory=list, description="List of Loogle results"
+    )
+
+
+class LeanFinderResults(BaseModel):
+    """Wrapper for Lean Finder results list."""
+
+    items: List[LeanFinderResult] = Field(
+        default_factory=list, description="List of Lean Finder results"
+    )
+
+
+class StateSearchResults(BaseModel):
+    """Wrapper for state search results list."""
+
+    items: List[StateSearchResult] = Field(
+        default_factory=list, description="List of state search results"
+    )
+
+
+class PremiseResults(BaseModel):
+    """Wrapper for premise results list."""
+
+    items: List[PremiseResult] = Field(
+        default_factory=list, description="List of premise results"
+    )

lean_lsp_mcp-0.16.2/src/lean_lsp_mcp/search_utils.py

@@ -0,0 +1,236 @@
+"""Utilities for Lean search tools."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from functools import lru_cache
+import platform
+import re
+import shutil
+import subprocess
+import threading
+from orjson import loads as _json_loads
+from pathlib import Path
+
+
+INSTALL_URL = "https://github.com/BurntSushi/ripgrep#installation"
+
+_PLATFORM_INSTRUCTIONS: dict[str, Iterable[str]] = {
+    "Windows": (
+        "winget install BurntSushi.ripgrep.MSVC",
+        "choco install ripgrep",
+    ),
+    "Darwin": ("brew install ripgrep",),
+    "Linux": (
+        "sudo apt-get install ripgrep",
+        "sudo dnf install ripgrep",
+    ),
+}
+
+
+def _create_ripgrep_process(command: list[str], *, cwd: str) -> subprocess.Popen[str]:
+    """Spawn ripgrep and return a process with line-streaming stdout.
+
+    Separated for test monkeypatching and to allow early termination once we
+    have enough matches.
+    """
+    return subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        cwd=cwd,
+    )
+
+
+def check_ripgrep_status() -> tuple[bool, str]:
+    """Check whether ``rg`` is available on PATH and return status + message."""
+
+    if shutil.which("rg"):
+        return True, ""
+
+    system = platform.system()
+    platform_instructions = _PLATFORM_INSTRUCTIONS.get(
+        system, ("Check alternative installation methods.",)
+    )
+
+    lines = [
+        "ripgrep (rg) was not found on your PATH. The lean_local_search tool uses ripgrep for fast declaration search.",
+        "",
+        "Installation options:",
+        *(f"  - {item}" for item in platform_instructions),
+        f"More installation options: {INSTALL_URL}",
+    ]
+
+    return False, "\n".join(lines)
+
+
+def lean_local_search(
+    query: str,
+    limit: int = 32,
+    project_root: Path | None = None,
+) -> list[dict[str, str]]:
+    """Search Lean declarations matching ``query`` using ripgrep; results include theorems, lemmas, defs, classes, instances, structures, inductives, abbrevs, and opaque decls."""
+    root = (project_root or Path.cwd()).resolve()
+
+    pattern = (
+        rf"^\s*(?:theorem|lemma|def|axiom|class|instance|structure|inductive|abbrev|opaque)\s+"
+        rf"(?:[A-Za-z0-9_'.]+\.)*{re.escape(query)}[A-Za-z0-9_'.]*(?:\s|:)"
+    )
+
+    command = [
+        "rg",
+        "--json",
+        "--no-ignore",
+        "--smart-case",
+        "--hidden",
+        "--color",
+        "never",
+        "--no-messages",
+        "-g",
+        "*.lean",
+        "-g",
+        "!.git/**",
+        "-g",
+        "!.lake/build/**",
+        pattern,
+        str(root),
+    ]
+
+    if lean_src := _get_lean_src_search_path():
+        command.append(lean_src)
+
+    process = _create_ripgrep_process(command, cwd=str(root))
+
+    matches: list[dict[str, str]] = []
+    stderr_text = ""
+    terminated_early = False
+    stderr_chunks: list[str] = []
+    stderr_chars = 0
+    stderr_truncated = False
+    max_stderr_chars = 100_000
+
+    def _drain_stderr(pipe) -> None:
+        nonlocal stderr_chars, stderr_truncated
+        try:
+            for err_line in pipe:
+                if stderr_chars < max_stderr_chars:
+                    stderr_chunks.append(err_line)
+                    stderr_chars += len(err_line)
+                else:
+                    stderr_truncated = True
+        except Exception:
+            return
+
+    stderr_thread: threading.Thread | None = None
+    if process.stderr is not None:
+        stderr_thread = threading.Thread(
+            target=_drain_stderr,
+            args=(process.stderr,),
+            name="lean-local-search-rg-stderr",
+            daemon=True,
+        )
+        stderr_thread.start()
+
+    try:
+        stdout = process.stdout
+        if stdout is None:
+            raise RuntimeError("ripgrep did not provide stdout pipe")
+
+        for line in stdout:
+            if not line or (event := _json_loads(line)).get("type") != "match":
+                continue
+
+            data = event["data"]
+            parts = data["lines"]["text"].lstrip().split(maxsplit=2)
+            if len(parts) < 2:
+                continue
+
+            decl_kind, decl_name = parts[0], parts[1].rstrip(":")
+            file_path = Path(data["path"]["text"])
+            abs_path = (
+                file_path if file_path.is_absolute() else (root / file_path).resolve()
+            )
+
+            try:
+                display_path = str(abs_path.relative_to(root))
+            except ValueError:
+                display_path = str(file_path)
+
+            matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
+
+            if len(matches) >= limit:
+                terminated_early = True
+                try:
+                    process.terminate()
+                except Exception:
+                    pass
+                break
+
+        try:
+            if terminated_early:
+                process.wait(timeout=5)
+            else:
+                process.wait()
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+    finally:
+        if process.returncode is None:
+            try:
+                process.terminate()
+            except Exception:
+                pass
+            try:
+                process.wait(timeout=5)
+            except Exception:
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+                try:
+                    process.wait(timeout=5)
+                except Exception:
+                    pass
+        if stderr_thread is not None:
+            stderr_thread.join(timeout=1)
+        if process.stdout is not None:
+            process.stdout.close()
+        if process.stderr is not None:
+            process.stderr.close()
+
+    if stderr_chunks:
+        stderr_text = "".join(stderr_chunks)
+        if stderr_truncated:
+            stderr_text += "\n[stderr truncated]"
+
+    returncode = process.returncode if process.returncode is not None else 0
+
+    if returncode not in (0, 1) and not matches:
+        error_msg = f"ripgrep exited with code {returncode}"
+        if stderr_text:
+            error_msg += f"\n{stderr_text}"
+        raise RuntimeError(error_msg)
+
+    return matches
+
+
+@lru_cache(maxsize=1)
+def _get_lean_src_search_path() -> str | None:
+    """Return the Lean stdlib directory, if available (cache once)."""
+    try:
+        completed = subprocess.run(
+            ["lean", "--print-prefix"], capture_output=True, text=True
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return None
+
+    prefix = completed.stdout.strip()
+    if not prefix:
+        return None
+
+    candidate = Path(prefix).expanduser().resolve() / "src"
+    if candidate.exists():
+        return str(candidate)
+
+    return None

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/src/lean_lsp_mcp/server.py

@@ -12,7 +12,7 @@ import functools
 import uuid
 from pathlib import Path
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 from mcp.server.fastmcp import Context, FastMCP
 from mcp.server.fastmcp.utilities.logging import get_logger, configure_logging
 from mcp.server.auth.settings import AuthSettings
@@ -46,6 +46,16 @@ from lean_lsp_mcp.models import (
     BuildResult,
     RunResult,
     DeclarationInfo,
+    # Wrapper models for list-returning tools
+    DiagnosticsResult,
+    CompletionsResult,
+    MultiAttemptResult,
+    LocalSearchResults,
+    LeanSearchResults,
+    LoogleResults,
+    LeanFinderResults,
+    StateSearchResults,
+    PremiseResults,
 )
 from lean_lsp_mcp.utils import (
     COMPLETION_KIND,
@@ -67,13 +77,6 @@ class LeanToolError(Exception):
     pass
 
 
-def _to_json_array(items: List[BaseModel]) -> str:
-    """Serialize list of models as JSON array (avoids FastMCP list flattening)."""
-    return orjson.dumps(
-        [item.model_dump() for item in items], option=orjson.OPT_INDENT_2
-    ).decode()
-
-
 _LOG_LEVEL = os.environ.get("LEAN_LOG_LEVEL", "INFO")
 configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
 logger = get_logger(__name__)
@@ -414,7 +417,7 @@ def diagnostic_messages(
     declaration_name: Annotated[
         Optional[str], Field(description="Filter to declaration (slow)")
     ] = None,
-) -> str:
+) -> DiagnosticsResult:
     """Get compiler diagnostics (errors, warnings, infos) for a Lean file."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -443,7 +446,7 @@ def diagnostic_messages(
         inactivity_timeout=15.0,
     )
 
-    return _to_json_array(_to_diagnostic_messages(diagnostics))
+    return DiagnosticsResult(items=_to_diagnostic_messages(diagnostics))
 
 
 @mcp.tool(
@@ -610,7 +613,7 @@ def completions(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     max_completions: Annotated[int, Field(description="Max completions", ge=1)] = 32,
-) -> str:
+) -> CompletionsResult:
     """Get IDE autocompletions. Use on INCOMPLETE code (after `.` or partial name)."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -639,7 +642,7 @@ def completions(
         )
 
     if not items:
-        return "[]"
+        return CompletionsResult(items=[])
 
     # Find the sort term: The last word/identifier before the cursor
     lines = content.splitlines()
@@ -666,7 +669,7 @@ def completions(
         items.sort(key=lambda x: x.label.lower())
 
     # Truncate if too many results
-    return _to_json_array(items[:max_completions])
+    return CompletionsResult(items=items[:max_completions])
 
 
 @mcp.tool(
@@ -741,7 +744,7 @@ def multi_attempt(
     snippets: Annotated[
         List[str], Field(description="Tactics to try (3+ recommended)")
     ],
-) -> str:
+) -> MultiAttemptResult:
     """Try multiple tactics without modifying file. Returns goal state for each."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -753,8 +756,6 @@ def multi_attempt(
     client.open_file(rel_path)
 
     try:
-        client.open_file(rel_path)
-
         results: List[AttemptResult] = []
         # Avoid mutating caller-provided snippets; normalize locally per attempt
         for snippet in snippets:
@@ -781,7 +782,7 @@ def multi_attempt(
                 )
             )
 
-        return _to_json_array(results)
+        return MultiAttemptResult(items=results)
     finally:
         try:
             client.close_files([rel_path])
@@ -878,7 +879,7 @@ def local_search(
     project_root: Annotated[
         Optional[str], Field(description="Project root (inferred if omitted)")
     ] = None,
-) -> str:
+) -> LocalSearchResults:
     """Fast local search to verify declarations exist. Use BEFORE trying a lemma name."""
     if not _RG_AVAILABLE:
         raise LocalSearchError(_RG_MESSAGE)
@@ -910,7 +911,7 @@ def local_search(
             LocalSearchResult(name=r["name"], kind=r["kind"], file=r["file"])
             for r in raw_results
         ]
-        return _to_json_array(results)
+        return LocalSearchResults(items=results)
     except RuntimeError as exc:
         raise LocalSearchError(f"Search failed: {exc}")
 
@@ -929,7 +930,7 @@ def leansearch(
     ctx: Context,
     query: Annotated[str, Field(description="Natural language or Lean term query")],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> LeanSearchResults:
     """Search Mathlib via leansearch.net using natural language.
 
     Examples: "sum of two even numbers is even", "Cauchy-Schwarz inequality",
@@ -949,7 +950,7 @@ def leansearch(
         results = orjson.loads(response.read())
 
     if not results or not results[0]:
-        return "[]"
+        return LeanSearchResults(items=[])
 
     raw_results = [r["result"] for r in results[0][:num_results]]
     items = [
@@ -961,7 +962,7 @@ def leansearch(
         )
         for r in raw_results
     ]
-    return _to_json_array(items)
+    return LeanSearchResults(items=items)
 
 
 @mcp.tool(
@@ -979,7 +980,7 @@ async def loogle(
         str, Field(description="Type pattern, constant, or name substring")
     ],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 8,
-) -> str:
+) -> LoogleResults:
     """Search Mathlib by type signature via loogle.lean-lang.org.
 
     Examples: `Real.sin`, `"comm"`, `(?a → ?b) → List ?a → List ?b`,
@@ -992,7 +993,7 @@ async def loogle(
         try:
             results = await app_ctx.loogle_manager.query(query, num_results)
             if not results:
-                return "No results found."
+                return LoogleResults(items=[])
             items = [
                 LoogleResult(
                     name=r.get("name", ""),
@@ -1001,7 +1002,7 @@ async def loogle(
                 )
                 for r in results
             ]
-            return _to_json_array(items)
+            return LoogleResults(items=items)
         except Exception as e:
             logger.warning(f"Local loogle failed: {e}, falling back to remote")
 
@@ -1010,13 +1011,15 @@ async def loogle(
     now = int(time.time())
     rate_limit[:] = [t for t in rate_limit if now - t < 30]
     if len(rate_limit) >= 3:
-        return "Rate limit exceeded: 3 requests per 30s. Use --loogle-local to avoid limits."
+        raise LeanToolError(
+            "Rate limit exceeded: 3 requests per 30s. Use --loogle-local to avoid limits."
+        )
     rate_limit.append(now)
 
     result = loogle_remote(query, num_results)
     if isinstance(result, str):
-        return result  # Error message
-    return _to_json_array(result)
+        raise LeanToolError(result)  # Error message from remote
+    return LoogleResults(items=result)
 
 
 @mcp.tool(
@@ -1033,7 +1036,7 @@ def leanfinder(
     ctx: Context,
     query: Annotated[str, Field(description="Mathematical concept or proof state")],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> LeanFinderResults:
     """Semantic search by mathematical meaning via Lean Finder.
 
     Examples: "commutativity of addition on natural numbers",
@@ -1065,7 +1068,7 @@ def leanfinder(
                     )
                 )
 
-    return _to_json_array(results)
+    return LeanFinderResults(items=results)
 
 
 @mcp.tool(
@@ -1084,7 +1087,7 @@ def state_search(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 5,
-) -> str:
+) -> StateSearchResults:
     """Find lemmas to close the goal at a position. Searches premise-search.com."""
     rel_path = setup_client_for_file(ctx, file_path)
     if not rel_path:
@@ -1114,7 +1117,7 @@ def state_search(
         results = orjson.loads(response.read())
 
     items = [StateSearchResult(name=r["name"]) for r in results]
-    return _to_json_array(items)
+    return StateSearchResults(items=items)
 
 
 @mcp.tool(
@@ -1133,7 +1136,7 @@ def hammer_premise(
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
     column: Annotated[int, Field(description="Column number (1-indexed)", ge=1)],
     num_results: Annotated[int, Field(description="Max results", ge=1)] = 32,
-) -> str:
+) -> PremiseResults:
     """Get premise suggestions for automation tactics at a goal position.
 
     Returns lemma names to try with `simp only [...]`, `aesop`, or as hints.
@@ -1174,7 +1177,7 @@ def hammer_premise(
         results = orjson.loads(response.read())
 
     items = [PremiseResult(name=r["name"]) for r in results]
-    return _to_json_array(items)
+    return PremiseResults(items=items)
 
 
 if __name__ == "__main__":

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.16.1
+Version: 0.16.2
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,9 +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.6.1
-Requires-Dist: mcp[cli]==1.23.1
-Requires-Dist: mcp[cli]>=1.22.0
+Requires-Dist: leanclient==0.6.2
+Requires-Dist: mcp[cli]==1.24.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/src/lean_lsp_mcp.egg-info/SOURCES.txt

@@ -25,4 +25,5 @@ tests/test_logging.py
 tests/test_misc_tools.py
 tests/test_outline.py
 tests/test_project_tools.py
-tests/test_search_tools.py
+tests/test_search_tools.py
+tests/test_structured_output.py

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,6 +1,5 @@
-leanclient==0.6.1
-mcp[cli]==1.23.1
-mcp[cli]>=1.22.0
+leanclient==0.6.2
+mcp[cli]==1.24.0
 orjson>=3.11.1
 
 [dev]

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/tests/test_diagnostic_line_range.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import textwrap
 from collections.abc import Callable
 from pathlib import Path
@@ -10,6 +11,21 @@ import pytest
 from tests.helpers.mcp_client import MCPClient, MCPToolError, result_text
 
 
+def parse_diagnostics_result(result) -> list[dict]:
+    """Parse diagnostics result, handling both structured and text formats."""
+    if result.structuredContent is not None:
+        return result.structuredContent.get("items", [])
+    # Fallback to parsing text output
+    text = result_text(result).strip()
+    if not text or text == "[]":
+        return []
+    try:
+        parsed = json.loads(text)
+        return parsed.get("items", parsed) if isinstance(parsed, dict) else parsed
+    except json.JSONDecodeError:
+        return []
+
+
 @pytest.fixture(scope="module")
 def diagnostic_file(test_project_path: Path) -> Path:
     path = test_project_path / "DiagnosticTest.lean"
@@ -51,12 +67,16 @@ async def test_diagnostic_messages_line_filtering(
             "lean_diagnostic_messages",
             {"file_path": str(diagnostic_file)},
         )
-        diag_text = result_text(diagnostics)
-        # Should contain both errors - now returns JSON with "severity" field
-        assert "string" in diag_text.lower() or "error" in diag_text.lower()
-        # Count occurrences of "severity" in JSON output (appears as field name)
-        assert diag_text.count('"severity"') >= 2
-        all_diag_text = diag_text
+        all_items = parse_diagnostics_result(diagnostics)
+        # Should contain at least 2 errors
+        assert len(all_items) >= 2, (
+            f"Expected at least 2 diagnostics, got {len(all_items)}"
+        )
+        # Verify items have expected structure
+        for item in all_items:
+            assert "severity" in item
+            assert "message" in item
+            assert "line" in item
 
         # Test 2: Get diagnostics starting from line 10
         diagnostics = await client.call_tool(
@@ -66,18 +86,13 @@ async def test_diagnostic_messages_line_filtering(
                 "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()
-        assert len(diag_text) < len(all_diag_text)
+        filtered_items = parse_diagnostics_result(diagnostics)
+        # Should have fewer diagnostics than unfiltered
+        assert len(filtered_items) < len(all_items)
 
         # Test 3: Get diagnostics for specific line range
-        import re
-
-        # Extract start_line from JSON format (e.g., "start_line": 7)
-        line_matches = re.findall(r'"start_line":\s*(\d+)', all_diag_text)
-        if line_matches:
-            first_error_line = int(line_matches[0])
+        if all_items:
+            first_error_line = all_items[0]["line"]
             diagnostics = await client.call_tool(
                 "lean_diagnostic_messages",
                 {
@@ -86,9 +101,9 @@ async def test_diagnostic_messages_line_filtering(
                     "end_line": first_error_line,
                 },
             )
-            diag_text = result_text(diagnostics)
-            assert "string" in diag_text.lower() or len(diag_text) > 0
-            assert len(diag_text) < len(all_diag_text)
+            range_items = parse_diagnostics_result(diagnostics)
+            assert len(range_items) >= 1
+            assert len(range_items) < len(all_items)
 
         # Test 4: Get diagnostics for range with no errors (lines 14-17)
         diagnostics = await client.call_tool(
@@ -99,9 +114,9 @@ async def test_diagnostic_messages_line_filtering(
                 "end_line": 17,
             },
         )
-        diag_text = result_text(diagnostics)
-        # Empty array or no diagnostics
-        assert diag_text.strip() == "[]" or len(diag_text.strip()) == 0
+        empty_items = parse_diagnostics_result(diagnostics)
+        # Should be empty
+        assert len(empty_items) == 0, f"Expected no diagnostics, got {len(empty_items)}"
 
 
 @pytest.fixture(scope="module")
@@ -142,9 +157,8 @@ async def test_diagnostic_messages_declaration_filtering(
             "lean_diagnostic_messages",
             {"file_path": str(declaration_diagnostic_file)},
         )
-        all_diag_text = result_text(all_diagnostics)
-        assert len(all_diag_text) > 0
-        assert "string" in all_diag_text.lower() or "type" in all_diag_text.lower()
+        all_items = parse_diagnostics_result(all_diagnostics)
+        assert len(all_items) > 0, "Expected diagnostics in file with errors"
 
         # Test 2: Get diagnostics for firstTheorem only
         diagnostics = await client.call_tool(
@@ -154,9 +168,9 @@ async def test_diagnostic_messages_declaration_filtering(
                 "declaration_name": "firstTheorem",
             },
         )
-        diag_text = result_text(diagnostics)
-        assert len(diag_text) > 0
-        assert len(diag_text) <= len(all_diag_text)
+        first_items = parse_diagnostics_result(diagnostics)
+        assert len(first_items) > 0
+        assert len(first_items) <= len(all_items)
 
         # Test 3: Get diagnostics for secondTheorem (has type error in statement)
         diagnostics = await client.call_tool(
@@ -166,9 +180,8 @@ async def test_diagnostic_messages_declaration_filtering(
                 "declaration_name": "secondTheorem",
             },
         )
-        diag_text = result_text(diagnostics)
-        assert len(diag_text) > 0
-        assert isinstance(diag_text, str)
+        second_items = parse_diagnostics_result(diagnostics)
+        assert len(second_items) > 0
 
         # Test 4: Get diagnostics for validFunction (no errors)
         diagnostics = await client.call_tool(
@@ -178,11 +191,9 @@ async def test_diagnostic_messages_declaration_filtering(
                 "declaration_name": "validFunction",
             },
         )
-        diag_text = result_text(diagnostics)
-        assert (
-            "no" in diag_text.lower()
-            or len(diag_text.strip()) == 0
-            or diag_text == "[]"
+        valid_items = parse_diagnostics_result(diagnostics)
+        assert len(valid_items) == 0, (
+            f"Expected no diagnostics for valid function, got {len(valid_items)}"
         )
 
 
@@ -250,9 +261,12 @@ async def test_diagnostic_messages_detects_kernel_errors(
             "lean_diagnostic_messages",
             {"file_path": str(kernel_error_file)},
         )
-        diag_text = result_text(diagnostics)
+        items = parse_diagnostics_result(diagnostics)
+
+        # Should have at least 2 diagnostics
+        assert len(items) >= 2, f"Expected at least 2 diagnostics, got {len(items)}"
 
-        # 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
+        # Check for kernel error and regular error in message content
+        all_messages = " ".join(item.get("message", "").lower() for item in items)
+        assert "kernel" in all_messages or "unsafe" in all_messages
+        assert "rfl" in all_messages or "failed" in all_messages

{lean_lsp_mcp-0.16.1 → lean_lsp_mcp-0.16.2}/tests/test_search_tools.py

@@ -10,18 +10,28 @@ import pytest
 from tests.helpers.mcp_client import MCPClient, result_text
 
 
-def _first_json_block(result) -> dict[str, str] | None:
-    """Extract the first JSON object from result content.
+def _first_result_item(result) -> dict[str, str] | None:
+    """Extract the first item from a result that returns a list wrapped in {"items": [...]}.
 
-    Handles both single JSON objects and JSON arrays (extracts first element).
+    Handles both structured content and text content formats.
     """
+    # Try structured content first (new format)
+    if result.structuredContent is not None:
+        items = result.structuredContent.get("items", [])
+        return items[0] if items else None
+
+    # Fall back to parsing text content
     for block in result.content:
         text = getattr(block, "text", "").strip()
         if not text:
             continue
         try:
             parsed = orjson.loads(text)
-            # If it's a list, return the first element
+            # Handle {"items": [...]} wrapper format
+            if isinstance(parsed, dict) and "items" in parsed:
+                items = parsed["items"]
+                return items[0] if items else None
+            # Handle bare list format (legacy)
             if isinstance(parsed, list):
                 return parsed[0] if parsed else None
             return parsed
@@ -54,7 +64,7 @@ async def test_search_tools(
             "lean_loogle",
             {"query": "Nat"},
         )
-        loogle_entry = _first_json_block(loogle)
+        loogle_entry = _first_result_item(loogle)
         if loogle_entry is None:
             pytest.skip("lean_loogle did not return JSON content")
         assert {"module", "name", "type"} <= set(loogle_entry.keys())
@@ -78,7 +88,7 @@ async def test_search_tools(
             },
         )
         # Now returns JSON array of StateSearchResult models
-        state_entry = _first_json_block(state_search)
+        state_entry = _first_result_item(state_search)
         if state_entry is None:
             pytest.skip("lean_state_search did not return JSON content")
         assert "name" in state_entry
@@ -92,7 +102,7 @@ async def test_search_tools(
             },
         )
         # Now returns JSON array of PremiseResult models
-        hammer_entry = _first_json_block(hammer)
+        hammer_entry = _first_result_item(hammer)
         if hammer_entry is None:
             pytest.skip("lean_hammer_premise did not return JSON content")
         assert "name" in hammer_entry
@@ -104,7 +114,7 @@ async def test_search_tools(
                 "project_root": str(goal_file.parent),
             },
         )
-        local_entry = _first_json_block(local_search)
+        local_entry = _first_result_item(local_search)
         if local_entry is None:
             message = result_text(local_search).strip()
             if "ripgrep" in message.lower():
@@ -120,7 +130,7 @@ async def test_search_tools(
             "lean_leansearch",
             {"query": "Nat.succ"},
         )
-        entry = _first_json_block(leansearch)
+        entry = _first_result_item(leansearch)
         if entry is None:
             pytest.skip("lean_leansearch did not return JSON content")
         assert {"module_name", "name", "type"} <= set(entry.keys())
@@ -133,7 +143,7 @@ async def test_search_tools(
                 "num_results": 3,
             },
         )
-        finder_results = _first_json_block(finder_informal)
+        finder_results = _first_result_item(finder_informal)
         if finder_results:
             assert isinstance(finder_results, dict) and len(finder_results.keys()) == 3
             assert {"full_name", "formal_statement", "informal_statement"} <= set(

lean_lsp_mcp-0.16.2/tests/test_structured_output.py

@@ -0,0 +1,124 @@
+"""Test that tool outputs are properly structured JSON, not double-encoded strings.
+
+This test addresses an issue where tools returning lists would produce
+double-encoded JSON in the structuredContent field. For example, instead of:
+
+    {"items": [{"severity": "error", ...}]}
+
+The output would be:
+
+    {"result": "[\\n  {\\\"severity\\\": \\\"error\\\", ...}]"}
+
+Where the list is encoded as an escaped string instead of a proper JSON array.
+"""
+
+from __future__ import annotations
+
+import json
+import textwrap
+from collections.abc import Callable
+from pathlib import Path
+from typing import AsyncContextManager
+
+import pytest
+
+from tests.helpers.mcp_client import MCPClient
+
+
+@pytest.fixture(scope="module")
+def error_file(test_project_path: Path) -> Path:
+    """Create a Lean file with a type error for testing diagnostics."""
+    path = test_project_path / "StructuredOutputTest.lean"
+    content = textwrap.dedent(
+        """
+        import Mathlib
+
+        -- This line has a type error: assigning String to Nat
+        def badDef : Nat := "not a number"
+        """
+    ).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_diagnostics_structured_output_not_double_encoded(
+    mcp_client_factory: Callable[[], AsyncContextManager[MCPClient]],
+    error_file: Path,
+) -> None:
+    """Verify diagnostics are returned as structured data, not double-encoded JSON.
+
+    The structuredContent should contain an 'items' field with a list of
+    diagnostic objects, not a 'result' field with an escaped JSON string.
+    """
+    async with mcp_client_factory() as client:
+        result = await client.call_tool(
+            "lean_diagnostic_messages",
+            {"file_path": str(error_file)},
+        )
+
+        # structuredContent should be present
+        assert result.structuredContent is not None, (
+            "Tool should return structured content"
+        )
+
+        structured = result.structuredContent
+
+        # The result should have an 'items' field, not a 'result' field
+        # If it has 'result' with a string value, that indicates double-encoding
+        if "result" in structured:
+            result_value = structured["result"]
+            if isinstance(result_value, str):
+                # Try to parse it as JSON to confirm it's double-encoded
+                try:
+                    parsed = json.loads(result_value)
+                    pytest.fail(
+                        f"Diagnostics are double-encoded! "
+                        f"structuredContent['result'] is a JSON string that parses to: {type(parsed).__name__}. "
+                        f"Expected structuredContent to contain 'items' with a list directly."
+                    )
+                except json.JSONDecodeError:
+                    pass  # Not JSON, different issue
+
+        # Should have 'items' field with a list
+        assert "items" in structured, (
+            f"Expected 'items' field in structuredContent, got keys: {list(structured.keys())}"
+        )
+        items = structured["items"]
+        assert isinstance(items, list), (
+            f"Expected 'items' to be a list, got {type(items).__name__}"
+        )
+
+        # Each item should be a dict with proper fields, not strings
+        for i, item in enumerate(items):
+            assert isinstance(item, dict), (
+                f"Item {i} should be a dict, got {type(item).__name__}. "
+                f"This suggests the list items are double-encoded as strings."
+            )
+
+            # Verify the diagnostic has the expected fields as proper types
+            assert "severity" in item, f"Item {i} missing 'severity' field"
+            assert isinstance(item["severity"], str), (
+                f"Item {i} 'severity' should be a string, got {type(item['severity']).__name__}"
+            )
+
+            assert "message" in item, f"Item {i} missing 'message' field"
+            assert isinstance(item["message"], str), (
+                f"Item {i} 'message' should be a string, got {type(item['message']).__name__}"
+            )
+
+            assert "line" in item, f"Item {i} missing 'line' field"
+            assert isinstance(item["line"], int), (
+                f"Item {i} 'line' should be an int, got {type(item['line']).__name__}"
+            )
+
+            assert "column" in item, f"Item {i} missing 'column' field"
+            assert isinstance(item["column"], int), (
+                f"Item {i} 'column' should be an int, got {type(item['column']).__name__}"
+            )
+
+        # We should have at least one diagnostic (the type error)
+        assert len(items) >= 1, (
+            "Expected at least one diagnostic for the type error in the test file"
+        )

lean_lsp_mcp-0.16.1/src/lean_lsp_mcp/search_utils.py

@@ -1,142 +0,0 @@
-"""Utilities for Lean search tools."""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from functools import lru_cache
-import platform
-import re
-import shutil
-import subprocess
-from orjson import loads as _json_loads
-from pathlib import Path
-
-
-INSTALL_URL = "https://github.com/BurntSushi/ripgrep#installation"
-
-_PLATFORM_INSTRUCTIONS: dict[str, Iterable[str]] = {
-    "Windows": (
-        "winget install BurntSushi.ripgrep.MSVC",
-        "choco install ripgrep",
-    ),
-    "Darwin": ("brew install ripgrep",),
-    "Linux": (
-        "sudo apt-get install ripgrep",
-        "sudo dnf install ripgrep",
-    ),
-}
-
-
-def check_ripgrep_status() -> tuple[bool, str]:
-    """Check whether ``rg`` is available on PATH and return status + message."""
-
-    if shutil.which("rg"):
-        return True, ""
-
-    system = platform.system()
-    platform_instructions = _PLATFORM_INSTRUCTIONS.get(
-        system, ("Check alternative installation methods.",)
-    )
-
-    lines = [
-        "ripgrep (rg) was not found on your PATH. The lean_local_search tool uses ripgrep for fast declaration search.",
-        "",
-        "Installation options:",
-        *(f"  - {item}" for item in platform_instructions),
-        f"More installation options: {INSTALL_URL}",
-    ]
-
-    return False, "\n".join(lines)
-
-
-def lean_local_search(
-    query: str,
-    limit: int = 32,
-    project_root: Path | None = None,
-) -> list[dict[str, str]]:
-    """Search Lean declarations matching ``query`` using ripgrep; results include theorems, lemmas, defs, classes, instances, structures, inductives, abbrevs, and opaque decls."""
-    root = (project_root or Path.cwd()).resolve()
-
-    pattern = (
-        rf"^\s*(?:theorem|lemma|def|axiom|class|instance|structure|inductive|abbrev|opaque)\s+"
-        rf"(?:[A-Za-z0-9_'.]+\.)*{re.escape(query)}[A-Za-z0-9_'.]*(?:\s|:)"
-    )
-
-    command = [
-        "rg",
-        "--json",
-        "--no-ignore",
-        "--smart-case",
-        "--hidden",
-        "--color",
-        "never",
-        "--no-messages",
-        "-g",
-        "*.lean",
-        "-g",
-        "!.git/**",
-        "-g",
-        "!.lake/build/**",
-        pattern,
-        str(root),
-    ]
-
-    if lean_src := _get_lean_src_search_path():
-        command.append(lean_src)
-
-    result = subprocess.run(command, capture_output=True, text=True, cwd=str(root))
-
-    matches = []
-    for line in result.stdout.splitlines():
-        if not line or (event := _json_loads(line)).get("type") != "match":
-            continue
-
-        data = event["data"]
-        parts = data["lines"]["text"].lstrip().split(maxsplit=2)
-        if len(parts) < 2:
-            continue
-
-        decl_kind, decl_name = parts[0], parts[1].rstrip(":")
-        file_path = Path(data["path"]["text"])
-        abs_path = (
-            file_path if file_path.is_absolute() else (root / file_path).resolve()
-        )
-
-        try:
-            display_path = str(abs_path.relative_to(root))
-        except ValueError:
-            display_path = str(file_path)
-
-        matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
-
-        if len(matches) >= limit:
-            break
-
-    if result.returncode not in (0, 1) and not matches:
-        error_msg = f"ripgrep exited with code {result.returncode}"
-        if result.stderr:
-            error_msg += f"\n{result.stderr}"
-        raise RuntimeError(error_msg)
-
-    return matches
-
-
-@lru_cache(maxsize=1)
-def _get_lean_src_search_path() -> str | None:
-    """Return the Lean stdlib directory, if available (cache once)."""
-    try:
-        completed = subprocess.run(
-            ["lean", "--print-prefix"], capture_output=True, text=True
-        )
-    except (FileNotFoundError, subprocess.CalledProcessError):
-        return None
-
-    prefix = completed.stdout.strip()
-    if not prefix:
-        return None
-
-    candidate = Path(prefix).expanduser().resolve() / "src"
-    if candidate.exists():
-        return str(candidate)
-
-    return None