lean-lsp-mcp 0.11.0__tar.gz → 0.11.2__tar.gz

{lean_lsp_mcp-0.11.0/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.11.0
+Version: 0.11.2
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -77,7 +77,11 @@ OR using the setup wizard:
 
 Ctrl+Shift+P > "MCP: Add Server..." > "Command (stdio)" > "uvx lean-lsp-mcp" > "lean-lsp" (or any name you like) > Global or Workspace
 
-OR manually add config to `mcp.json`:
+OR manually adding config by opening `mcp.json` with: 
+
+Ctrl+Shift+P > "MCP: Open User Configuration"
+
+and adding the following
 
 ```jsonc
 {
@@ -92,6 +96,25 @@ OR manually add config to `mcp.json`:
     }
 }
 ```
+
+If you installed VSCode on Windows and are using WSL2 as your development environment, you may need to use this config instead:
+
+```jsonc
+{
+    "servers": {
+        "lean-lsp": {
+            "type": "stdio",
+            "command": "wsl.exe",
+            "args": [
+                "uvx",
+                "lean-lsp-mcp"
+            ]
+        }
+    }
+}
+```
+If that doesn't work, you can try cloning this repository and replace `"lean-lsp-mcp"` with `"/path/to/cloned/lean-lsp-mcp"`.
+
 </details>
 
 <details>
@@ -520,6 +543,10 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
+## Publications using lean-lsp-mcp
+
+- Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+
 ## Related Projects
 
 - [LeanTool](https://github.com/GasStationManager/LeanTool)

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/README.md

@@ -55,7 +55,11 @@ OR using the setup wizard:
 
 Ctrl+Shift+P > "MCP: Add Server..." > "Command (stdio)" > "uvx lean-lsp-mcp" > "lean-lsp" (or any name you like) > Global or Workspace
 
-OR manually add config to `mcp.json`:
+OR manually adding config by opening `mcp.json` with: 
+
+Ctrl+Shift+P > "MCP: Open User Configuration"
+
+and adding the following
 
 ```jsonc
 {
@@ -70,6 +74,25 @@ OR manually add config to `mcp.json`:
     }
 }
 ```
+
+If you installed VSCode on Windows and are using WSL2 as your development environment, you may need to use this config instead:
+
+```jsonc
+{
+    "servers": {
+        "lean-lsp": {
+            "type": "stdio",
+            "command": "wsl.exe",
+            "args": [
+                "uvx",
+                "lean-lsp-mcp"
+            ]
+        }
+    }
+}
+```
+If that doesn't work, you can try cloning this repository and replace `"lean-lsp-mcp"` with `"/path/to/cloned/lean-lsp-mcp"`.
+
 </details>
 
 <details>
@@ -498,6 +521,10 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
+## Publications using lean-lsp-mcp
+
+- Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+
 ## Related Projects
 
 - [LeanTool](https://github.com/GasStationManager/LeanTool)
@@ -517,4 +544,4 @@ Citing this repository is highly appreciated but not required by the license.
   month = {3},
   year = {2025}
 }
-```
+```

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.11.0"
+version = "0.11.2"
 description = "Lean Theorem Prover MCP"
 authors = [{name="Oliver Dressler", email="hey@oli.show"}]
 readme = "README.md"

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/src/lean_lsp_mcp/client_utils.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from threading import Lock
 
@@ -64,35 +65,58 @@ def valid_lean_project_path(path: Path | str) -> bool:
 
 
 def setup_client_for_file(ctx: Context, file_path: str) -> str | None:
-    """Check if the current LSP client is already set up and correct for this file. Otherwise, set it up.
+    """Ensure the LSP client matches the file's Lean project and return its relative path."""
 
-    Args:
-        ctx (Context): Context object.
-        file_path (str): Absolute path to the Lean file.
+    lifespan = ctx.request_context.lifespan_context
+    project_cache = getattr(lifespan, "project_cache", {})
+    if not hasattr(lifespan, "project_cache"):
+        lifespan.project_cache = project_cache
 
-    Returns:
-        str: Relative file path if the client is set up correctly, otherwise None.
-    """
-    # Check if the file_path works for the current lean_project_path.
-    lean_project_path = ctx.request_context.lifespan_context.lean_project_path
-    if lean_project_path is not None:
-        rel_path = get_relative_file_path(lean_project_path, file_path)
+    abs_file_path = os.path.abspath(file_path)
+    file_dir = os.path.dirname(abs_file_path)
+
+    def activate_project(project_path: Path, cache_dirs: list[str]) -> str | None:
+        project_path_obj = project_path
+        rel = get_relative_file_path(project_path_obj, file_path)
+        if rel is None:
+            return None
+
+        project_path_obj = project_path_obj.resolve()
+        lifespan.lean_project_path = project_path_obj
+
+        cache_targets: list[str] = []
+        for directory in cache_dirs + [str(project_path_obj)]:
+            if directory and directory not in cache_targets:
+                cache_targets.append(directory)
+
+        for directory in cache_targets:
+            project_cache[directory] = project_path_obj
+
+        startup_client(ctx)
+        return rel
+
+    # Fast path: current Lean project already valid for this file
+    if lifespan.lean_project_path is not None:
+        rel_path = activate_project(lifespan.lean_project_path, [file_dir])
         if rel_path is not None:
-            startup_client(ctx)
             return rel_path
 
-    # Try to find the correct project path by checking all directories in file_path.
-    file_path_obj = Path(file_path)
-    rel_path = None
-    for parent in file_path_obj.parents:
-        if valid_lean_project_path(parent):
-            lean_project_path = parent
-            rel_path = get_relative_file_path(lean_project_path, file_path)
+    # Walk up from file directory to root, using cache hits or lean-toolchain
+    prev_dir = None
+    current_dir = file_dir
+    while current_dir and current_dir != prev_dir:
+        cached_root = project_cache.get(current_dir)
+        if cached_root:
+            rel_path = activate_project(Path(cached_root), [current_dir])
+            if rel_path is not None:
+                return rel_path
+        elif valid_lean_project_path(current_dir):
+            rel_path = activate_project(Path(current_dir), [current_dir])
             if rel_path is not None:
-                ctx.request_context.lifespan_context.lean_project_path = (
-                    lean_project_path
-                )
-                startup_client(ctx)
-                break
+                return rel_path
+        else:
+            project_cache[current_dir] = ""
+        prev_dir = current_dir
+        current_dir = os.path.dirname(current_dir)
 
-    return rel_path
+    return None

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/src/lean_lsp_mcp/search_utils.py

@@ -56,10 +56,10 @@ def lean_local_search(
 ) -> 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()
-    escaped_query = re.escape(query)
-    ripgrep_pattern = (
+
+    pattern = (
         rf"^\s*(?:theorem|lemma|def|axiom|class|instance|structure|inductive|abbrev|opaque)\s+"
-        rf"{escaped_query}[A-Za-z0-9_'.]*(?:\s|:)"
+        rf"(?:[A-Za-z0-9_'.]+\.)*{re.escape(query)}[A-Za-z0-9_'.]*(?:\s|:)"
     )
 
     command = [
@@ -70,68 +70,55 @@ def lean_local_search(
         "--hidden",
         "--color",
         "never",
+        "--no-messages",
         "-g",
         "*.lean",
         "-g",
         "!.git/**",
         "-g",
         "!.lake/build/**",
-        ripgrep_pattern,
-        ".",
+        pattern,
+        str(root),
     ]
 
-    lean_src_path = _get_lean_src_search_path()
-    if lean_src_path is not None:
-        command.append(lean_src_path)
-
-    completed = subprocess.run(
-        command,
-        capture_output=True,
-        text=True,
-        cwd=str(root),
-    )
+    if lean_src := _get_lean_src_search_path():
+        command.append(lean_src)
 
-    results: list[dict[str, str]] = []
+    result = subprocess.run(command, capture_output=True, text=True, cwd=str(root))
 
-    for raw_line in completed.stdout.splitlines():
-        if not raw_line:
-            continue
-
-        event = _json_loads(raw_line)
-
-        if event.get("type") != "match":
+    matches = []
+    for line in result.stdout.splitlines():
+        if not line or (event := _json_loads(line)).get("type") != "match":
             continue
 
         data = event["data"]
-        line_text = data["lines"]["text"]
-        parts = line_text.lstrip().split(maxsplit=2)
+        parts = data["lines"]["text"].lstrip().split(maxsplit=2)
         if len(parts) < 2:
             continue
 
-        decl_kind, raw_name = parts[0], parts[1]
-        decl_name = raw_name.rstrip(":")
-
-        path_text = data["path"]["text"]
-        file_path = Path(path_text)
-        absolute_path = (
+        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(absolute_path.relative_to(root))
+            display_path = str(abs_path.relative_to(root))
         except ValueError:
             display_path = str(file_path)
 
-        results.append({"name": decl_name, "kind": decl_kind, "file": display_path})
+        matches.append({"name": decl_name, "kind": decl_kind, "file": display_path})
 
-        if len(results) >= limit:
+        if len(matches) >= limit:
             break
 
-    if completed.returncode not in (0, 1):
-        raise RuntimeError(
-            f"ripgrep exited with code {completed.returncode}\n{completed.stderr}"
-        )
+    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 results
+    return matches
 
 
 @lru_cache(maxsize=1)

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/src/lean_lsp_mcp/server.py

@@ -7,7 +7,7 @@ from contextlib import asynccontextmanager
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 import urllib
-import json
+import orjson
 import functools
 import subprocess
 import uuid
@@ -555,28 +555,37 @@ def multi_attempt(
     update_file(ctx, rel_path)
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
 
-    client.open_file(rel_path)
+    try:
+        client.open_file(rel_path)
 
-    results = []
-    snippets[0] += "\n"  # Extra newline for the first snippet
-    for snippet in snippets:
-        # Create a DocumentContentChange for the snippet
-        change = DocumentContentChange(
-            snippet + "\n",
-            [line - 1, 0],
-            [line, 0],
-        )
-        # Apply the change to the file, capture diagnostics and goal state
-        client.update_file(rel_path, [change])
-        diag = client.get_diagnostics(rel_path)
-        formatted_diag = "\n".join(format_diagnostics(diag, select_line=line - 1))
-        goal = client.get_goal(rel_path, line - 1, len(snippet))
-        formatted_goal = format_goal(goal, "Missing goal")
-        results.append(f"{snippet}:\n {formatted_goal}\n\n{formatted_diag}")
+        results = []
+        # Avoid mutating caller-provided snippets; normalize locally per attempt
+        for snippet in snippets:
+            snippet_str = snippet.rstrip("\n")
+            payload = f"{snippet_str}\n"
+            # Create a DocumentContentChange for the snippet
+            change = DocumentContentChange(
+                payload,
+                [line - 1, 0],
+                [line, 0],
+            )
+            # Apply the change to the file, capture diagnostics and goal state
+            client.update_file(rel_path, [change])
+            diag = client.get_diagnostics(rel_path)
+            formatted_diag = "\n".join(format_diagnostics(diag, select_line=line - 1))
+            # Use the snippet text length without any trailing newline for the column
+            goal = client.get_goal(rel_path, line - 1, len(snippet_str))
+            formatted_goal = format_goal(goal, "Missing goal")
+            results.append(f"{snippet_str}:\n {formatted_goal}\n\n{formatted_diag}")
 
-    # Make sure it's clean after the attempts
-    client.close_files([rel_path])
-    return results
+        return results
+    finally:
+        try:
+            client.close_files([rel_path])
+        except Exception as exc:  # pragma: no cover - close failures only logged
+            logger.warning(
+                "Failed to close `%s` after multi_attempt: %s", rel_path, exc
+            )
 
 
 @mcp.tool("lean_run_code")
@@ -674,11 +683,10 @@ def local_search(
         return _RG_MESSAGE
 
     stored_root = ctx.request_context.lifespan_context.lean_project_path
-    project_root = Path(stored_root) if stored_root else None
-    results = lean_local_search(
-        query=query.strip(), limit=limit, project_root=project_root
-    )
-    return results
+    if stored_root is None:
+        return "Lean project path not set. Call a file-based tool (like lean_goal) first to set the project path."
+
+    return lean_local_search(query=query.strip(), limit=limit, project_root=stored_root)
 
 
 @mcp.tool("lean_leansearch")
@@ -702,9 +710,7 @@ def leansearch(ctx: Context, query: str, num_results: int = 5) -> List[Dict] | s
     """
     try:
         headers = {"User-Agent": "lean-lsp-mcp/0.1", "Content-Type": "application/json"}
-        payload = json.dumps(
-            {"num_results": str(num_results), "query": [query]}
-        ).encode("utf-8")
+        payload = orjson.dumps({"num_results": str(num_results), "query": [query]})
 
         req = urllib.request.Request(
             "https://leansearch.net/search",
@@ -714,7 +720,7 @@ def leansearch(ctx: Context, query: str, num_results: int = 5) -> List[Dict] | s
         )
 
         with urllib.request.urlopen(req, timeout=20) as response:
-            results = json.loads(response.read().decode("utf-8"))
+            results = orjson.loads(response.read())
 
         if not results or not results[0]:
             return "No results found."
@@ -760,14 +766,14 @@ def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
         )
 
         with urllib.request.urlopen(req, timeout=20) as response:
-            results = json.loads(response.read().decode("utf-8"))
+            results = orjson.loads(response.read())
 
         if "hits" not in results:
             return "No results found."
 
         results = results["hits"][:num_results]
         for result in results:
-            result.pop("doc")
+            result.pop("doc", None)
         return results
     except Exception as e:
         return f"loogle error:\n{str(e)}"
@@ -775,73 +781,52 @@ def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
 
 @mcp.tool("lean_leanfinder")
 @rate_limited("leanfinder", max_requests=10, per_seconds=30)
-def leanfinder(
-    ctx: Context, query: str, num_results: int = 5
-) -> List[tuple] | str:
-    """Search Mathlib theorems/definitions semantically by mathematical concept using Lean Finder.
+def leanfinder(ctx: Context, query: str, num_results: int = 5) -> List[Dict] | str:
+    """Search Mathlib theorems/definitions semantically by mathematical concept or proof state using Lean Finder.
 
     Effective query types:
-    - Math + API: "setAverage Icc interval", "integral_pow symmetric bounds"
-    - Conceptual: "algebraic elements same minimal polynomial", "quadrature nodes"
-    - Structure: "Finset expect sum commute", "polynomial degree bounded eval"
-    - Natural: "average equals point values", "root implies equal polynomials"
+    - Natural language mathematical statement: "For any natural numbers n and m, the sum n+m is equal to m+n."
+    - Natural language questions: "I'm working with algebraic elements over a field extension … Does this imply that the minimal polynomials of x and y are equal?"
+    - Proof state. For better results, enter a proof state followed by how you want to transform the proof state.
+    - Statement definition: Fragment or the whole statement definition.
 
-    Tips: Mix informal math terms with Lean identifiers. Multiple targeted queries beat one complex query.
+    Tips: Multiple targeted queries beat one complex query.
 
     Args:
-        query (str): Mathematical concepts combined with Lean terms
+        query (str): Mathematical concept or proof state
         num_results (int, optional): Max results. Defaults to 5.
 
     Returns:
-        List[tuple] | str: (lean_statement, english_description) pairs or error
+        List[Dict] | str: List of Lean statement objects (full name, formal statement, informal statement) or error msg
     """
     try:
         headers = {"User-Agent": "lean-lsp-mcp/0.1", "Content-Type": "application/json"}
-        payload = json.dumps({"data": [query, num_results, "Normal"]}).encode("utf-8")
-
+        request_url = (
+            "https://bxrituxuhpc70w8w.us-east-1.aws.endpoints.huggingface.cloud"
+        )
+        payload = orjson.dumps({"inputs": query, "top_k": int(num_results)})
         req = urllib.request.Request(
-            "https://delta-lab-ai-lean-finder.hf.space/gradio_api/call/retrieve",
-            data=payload,
-            headers=headers,
-            method="POST",
+            request_url, data=payload, headers=headers, method="POST"
         )
 
-        with urllib.request.urlopen(req, timeout=10) as response:
-            event_data = json.loads(response.read().decode("utf-8"))
-            event_id = event_data.get("event_id")
-
-        if not event_id:
-            return "Lean Finder has timed out or errored. It might be warming up, try a second time in 2 minutes."
-
-        result_url = f"https://delta-lab-ai-lean-finder.hf.space/gradio_api/call/retrieve/{event_id}"
-        req = urllib.request.Request(result_url, headers=headers, method="GET")
-
+        results = []
         with urllib.request.urlopen(req, timeout=30) as response:
-            for line in response:
-                line = line.decode("utf-8").strip()
-                if line.startswith("data: "):
-                    data = json.loads(line[6:])
-                    if isinstance(data, list) and len(data) > 0:
-                        html = data[0] if isinstance(data[0], str) else str(data)
-
-                        # Parse HTML table rows
-                        rows = re.findall(
-                            r"<tr><td>\d+</td><td>(.*?)</td><td>(.*?)</td></tr>",
-                            html, re.DOTALL
-                        )
-                        results = []
-                        for formal_cell, informal_cell in rows:
-                            formal = re.search(r"<code[^>]*>(.*?)</code>", formal_cell, re.DOTALL)
-                            informal = re.search(r"<span[^>]*>(.*?)</span>", informal_cell, re.DOTALL)
-                            if formal:
-                                results.append((
-                                    formal.group(1).strip(),
-                                    informal.group(1).strip() if informal else ""
-                                ))
-
-                        return results if results else "Lean Finder: No results parsed"
-
-        return "Lean Finder: No results received"
+            data = orjson.loads(response.read())
+            for result in data["results"]:
+                if (
+                    "https://leanprover-community.github.io/mathlib4_docs"
+                    not in result["url"]
+                ):  # Do not include results from other sources other than mathlib4, since users might not have imported them
+                    continue
+                full_name = re.search(r"pattern=(.*?)#doc", result["url"]).group(1)
+                obj = {
+                    "full_name": full_name,
+                    "formal_statement": result["formal_statement"],
+                    "informal_statement": result["informal_statement"],
+                }
+                results.append(obj)
+
+        return results if results else "Lean Finder: No results parsed"
     except Exception as e:
         return f"Lean Finder Error:\n{str(e)}"
 
@@ -887,7 +872,7 @@ def state_search(
         )
 
         with urllib.request.urlopen(req, timeout=20) as response:
-            results = json.loads(response.read().decode("utf-8"))
+            results = orjson.loads(response.read())
 
         for result in results:
             result.pop("rev")
@@ -941,11 +926,11 @@ def hammer_premise(
                 "Content-Type": "application/json",
             },
             method="POST",
-            data=json.dumps(data).encode("utf-8"),
+            data=orjson.dumps(data),
         )
 
         with urllib.request.urlopen(req, timeout=20) as response:
-            results = json.loads(response.read().decode("utf-8"))
+            results = orjson.loads(response.read())
 
         results = [result["name"] for result in results]
         results.insert(0, f"Results for line:\n{f_line}")

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/src/lean_lsp_mcp/utils.py

@@ -1,4 +1,5 @@
 import os
+import secrets
 import sys
 import tempfile
 from typing import List, Dict, Optional
@@ -41,6 +42,19 @@ class OutputCapture:
         return self.captured_output
 
 
+class OptionalTokenVerifier(TokenVerifier):
+    """Minimal verifier that accepts a single pre-shared token."""
+
+    def __init__(self, expected_token: str):
+        self._expected_token = expected_token
+
+    async def verify_token(self, token: str | None) -> AccessToken | None:
+        if token is None or not secrets.compare_digest(token, self._expected_token):
+            return None
+        # AccessToken requires both client_id and scopes parameters to be provided.
+        return AccessToken(token=token, client_id="lean-lsp-mcp-optional", scopes=[])
+
+
 def format_diagnostics(diagnostics: List[Dict], select_line: int = -1) -> List[str]:
     """Format the diagnostics messages.
 
@@ -190,38 +204,58 @@ def format_line(
 
 
 def filter_diagnostics_by_position(
-    diagnostics: List[Dict], line: int, column: Optional[int]
+    diagnostics: List[Dict], line: Optional[int], column: Optional[int]
 ) -> List[Dict]:
-    """Find diagnostics at a specific position.
-
-    Args:
-        diagnostics (List[Dict]): List of diagnostics.
-        line (int): The line number (0-indexed).
-        column (Optional[int]): The column number (0-indexed).
-
-    Returns:
-        List[Dict]: List of diagnostics at the specified position.
-    """
-    if column is None:
-        return [
-            d
-            for d in diagnostics
-            if d["range"]["start"]["line"] <= line <= d["range"]["end"]["line"]
-        ]
-
-    return [
-        d
-        for d in diagnostics
-        if d["range"]["start"]["line"] <= line <= d["range"]["end"]["line"]
-        and d["range"]["start"]["character"] <= column < d["range"]["end"]["character"]
-    ]
-
-
-class OptionalTokenVerifier(TokenVerifier):
-    def __init__(self, expected_token: str):
-        self.expected_token = expected_token
-
-    async def verify_token(self, token: str) -> AccessToken | None:
-        if token == self.expected_token:
-            return AccessToken(token=token, client_id="lean-lsp-mcp", scopes=["user"])
-        return None
+    """Return diagnostics that intersect the requested (0-indexed) position."""
+
+    if line is None:
+        return list(diagnostics)
+
+    matches: List[Dict] = []
+    for diagnostic in diagnostics:
+        diagnostic_range = diagnostic.get("range") or diagnostic.get("fullRange")
+        if not diagnostic_range:
+            continue
+
+        start = diagnostic_range.get("start", {})
+        end = diagnostic_range.get("end", {})
+        start_line = start.get("line")
+        end_line = end.get("line")
+
+        if start_line is None or end_line is None:
+            continue
+        if line < start_line or line > end_line:
+            continue
+
+        start_char = start.get("character")
+        end_char = end.get("character")
+
+        if column is None:
+            if (
+                line == end_line
+                and line != start_line
+                and end_char is not None
+                and end_char == 0
+            ):
+                continue
+            matches.append(diagnostic)
+            continue
+
+        if start_char is None:
+            start_char = 0
+        if end_char is None:
+            end_char = column + 1
+
+        if start_line == end_line and start_char == end_char:
+            if column == start_char:
+                matches.append(diagnostic)
+            continue
+
+        if line == start_line and column < start_char:
+            continue
+        if line == end_line and column >= end_char:
+            continue
+
+        matches.append(diagnostic)
+
+    return matches

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.11.0
+Version: 0.11.2
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -77,7 +77,11 @@ OR using the setup wizard:
 
 Ctrl+Shift+P > "MCP: Add Server..." > "Command (stdio)" > "uvx lean-lsp-mcp" > "lean-lsp" (or any name you like) > Global or Workspace
 
-OR manually add config to `mcp.json`:
+OR manually adding config by opening `mcp.json` with: 
+
+Ctrl+Shift+P > "MCP: Open User Configuration"
+
+and adding the following
 
 ```jsonc
 {
@@ -92,6 +96,25 @@ OR manually add config to `mcp.json`:
     }
 }
 ```
+
+If you installed VSCode on Windows and are using WSL2 as your development environment, you may need to use this config instead:
+
+```jsonc
+{
+    "servers": {
+        "lean-lsp": {
+            "type": "stdio",
+            "command": "wsl.exe",
+            "args": [
+                "uvx",
+                "lean-lsp-mcp"
+            ]
+        }
+    }
+}
+```
+If that doesn't work, you can try cloning this repository and replace `"lean-lsp-mcp"` with `"/path/to/cloned/lean-lsp-mcp"`.
+
 </details>
 
 <details>
@@ -520,6 +543,10 @@ uv sync --all-extras
 uv run pytest tests
 ```
 
+## Publications using lean-lsp-mcp
+
+- Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics [arxiv](https://arxiv.org/abs/2510.12787)
+
 ## Related Projects
 
 - [LeanTool](https://github.com/GasStationManager/LeanTool)

{lean_lsp_mcp-0.11.0 → lean_lsp_mcp-0.11.2}/tests/test_search_tools.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import json
+import orjson
 from collections.abc import Callable
 from pathlib import Path
 from typing import AsyncContextManager
@@ -16,8 +16,8 @@ def _first_json_block(result) -> dict[str, str] | None:
         if not text:
             continue
         try:
-            return json.loads(text)
-        except json.JSONDecodeError:
+            return orjson.loads(text)
+        except orjson.JSONDecodeError:
             continue
     return None
 
@@ -120,12 +120,10 @@ async def test_search_tools(
         )
         finder_results = _first_json_block(finder_informal)
         if finder_results:
-            assert isinstance(finder_results, list) and len(finder_results) > 0
-            assert isinstance(finder_results[0], list) and len(finder_results[0]) == 2
-            formal, informal = finder_results[0]
-            assert isinstance(formal, str) and len(formal) > 0
-            assert isinstance(informal, str)
+            assert isinstance(finder_results, dict) and len(finder_results.keys()) == 3
+            assert {"full_name", "formal_statement", "informal_statement"} <= set(
+                finder_results.keys()
+            )
         else:
             finder_text = result_text(finder_informal)
             assert finder_text and len(finder_text) > 0
-