lean-lsp-mcp 0.17.2__tar.gz → 0.19.0__tar.gz

{lean_lsp_mcp-0.17.2/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.17.2
+Version: 0.19.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: leanclient==0.8.0
+Requires-Dist: leanclient==0.9.1
 Requires-Dist: mcp[cli]==1.25.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
@@ -18,6 +18,7 @@ Requires-Dist: ruff>=0.2.0; extra == "dev"
 Requires-Dist: pytest>=8.3; extra == "dev"
 Requires-Dist: anyio>=4.4; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-timeout>=2.3; extra == "dev"
 Dynamic: license-file
 
 <h1 align="center">
@@ -298,6 +299,27 @@ h_neq : ¬P.card = 2 ^ (Fintype.card S - 1)
 ```
 </details>
 
+#### lean_profile_proof
+
+Profile a theorem to identify slow tactics. Runs `lean --profile` on an isolated copy of the theorem and returns per-line timing data.
+
+<details>
+<summary>Example output (profiling a theorem using simp)</summary>
+
+```json
+{
+  "ms": 42.5,
+  "lines": [
+    {"line": 7, "ms": 38.2, "text": "simp [add_comm, add_assoc]"}
+  ],
+  "categories": {
+    "simp": 35.1,
+    "typeclass inference": 4.2
+  }
+}
+```
+</details>
+
 ### Local Search Tools
 
 #### lean_local_search

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/README.md

@@ -276,6 +276,27 @@ h_neq : ¬P.card = 2 ^ (Fintype.card S - 1)
 ```
 </details>
 
+#### lean_profile_proof
+
+Profile a theorem to identify slow tactics. Runs `lean --profile` on an isolated copy of the theorem and returns per-line timing data.
+
+<details>
+<summary>Example output (profiling a theorem using simp)</summary>
+
+```json
+{
+  "ms": 42.5,
+  "lines": [
+    {"line": 7, "ms": 38.2, "text": "simp [add_comm, add_assoc]"}
+  ],
+  "categories": {
+    "simp": 35.1,
+    "typeclass inference": 4.2
+  }
+}
+```
+</details>
+
 ### Local Search Tools
 
 #### lean_local_search

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/pyproject.toml

@@ -1,19 +1,19 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.17.2"
+version = "0.19.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.8.0", "mcp[cli]==1.25.0", "orjson>=3.11.1"]
+dependencies = ["leanclient==0.9.1", "mcp[cli]==1.25.0", "orjson>=3.11.1"]
 
 [project.urls]
 Repository = "https://github.com/oOo0oOo/lean-lsp-mcp"
 
 [project.optional-dependencies]
 lint = ["ruff>=0.2.0"]
-dev = ["ruff>=0.2.0", "pytest>=8.3", "anyio>=4.4", "pytest-asyncio>=0.23"]
+dev = ["ruff>=0.2.0", "pytest>=8.3", "anyio>=4.4", "pytest-asyncio>=0.23", "pytest-timeout>=2.3"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp/instructions.py

@@ -13,6 +13,7 @@ INSTRUCTIONS = """## General Rules
 - **lean_declaration_file**: Get declaration source. Use sparingly (large output).
 - **lean_run_code**: Run standalone snippet. Use rarely.
 - **lean_build**: Rebuild + restart LSP. Only if needed (new imports). SLOW!
+- **lean_profile_proof**: Profile a theorem for performance. Shows tactic hotspots. SLOW!
 
 ## Search Tools (rate limited)
 - **lean_leansearch** (3/30s): Natural language → mathlib

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp/models.py

@@ -1,6 +1,7 @@
 """Pydantic models for MCP tool structured outputs."""
 
 from typing import List, Optional
+
 from pydantic import BaseModel, Field
 
 
@@ -134,11 +135,18 @@ class DeclarationInfo(BaseModel):
 
 
 class DiagnosticsResult(BaseModel):
-    """Wrapper for diagnostic messages list."""
+    """Wrapper for diagnostic messages list with build status."""
 
+    success: bool = Field(
+        True, description="True if the queried file/range has no errors"
+    )
     items: List[DiagnosticMessage] = Field(
         default_factory=list, description="List of diagnostic messages"
     )
+    failed_dependencies: List[str] = Field(
+        default_factory=list,
+        description="File paths of dependencies that failed to build",
+    )
 
 
 class CompletionsResult(BaseModel):
@@ -203,3 +211,23 @@ class PremiseResults(BaseModel):
     items: List[PremiseResult] = Field(
         default_factory=list, description="List of premise results"
     )
+
+
+class LineProfile(BaseModel):
+    """Timing for a single source line."""
+
+    line: int = Field(description="Source line number (1-indexed)")
+    ms: float = Field(description="Time in milliseconds")
+    text: str = Field(description="Source line content (truncated)")
+
+
+class ProofProfileResult(BaseModel):
+    """Profiling result for a theorem."""
+
+    ms: float = Field(description="Total elaboration time in ms")
+    lines: List[LineProfile] = Field(
+        default_factory=list, description="Time per source line (>1% of total)"
+    )
+    categories: dict[str, float] = Field(
+        default_factory=dict, description="Cumulative time by category in ms"
+    )

lean_lsp_mcp-0.19.0/src/lean_lsp_mcp/profile_utils.py

@@ -0,0 +1,232 @@
+"""Lean proof profiling via CLI trace output."""
+
+import asyncio
+import os
+import re
+import tempfile
+from collections import defaultdict
+from pathlib import Path
+
+from lean_lsp_mcp.models import LineProfile, ProofProfileResult
+
+_TRACE_RE = re.compile(r"^(\s*)\[([^\]]+)\]\s+\[([\d.]+)\]\s+(.+)$")
+_CUMULATIVE_RE = re.compile(r"^\s+(\S+(?:\s+\S+)*)\s+([\d.]+)(ms|s)$")
+_DECL_RE = re.compile(r"^\s*(?:private\s+)?(theorem|lemma|def)\s+(\S+)")
+_HEADER_RE = re.compile(r"^(import|open|set_option|universe|variable)\s")
+_SKIP_CATEGORIES = {"import", "initialization", "parsing", "interpretation", "linting"}
+
+
+def _find_header_end(lines: list[str]) -> int:
+    """Find where imports/header ends and declarations begin."""
+    header_end, in_block = 0, False
+    for i, line in enumerate(lines):
+        s = line.strip()
+        if "/-" in line:
+            in_block = True
+        if "-/" in line:
+            in_block = False
+        if in_block or not s or s.startswith("--") or _HEADER_RE.match(line):
+            header_end = i + 1
+        elif s.startswith(("namespace", "section")):
+            header_end = i + 1
+        elif _DECL_RE.match(line) or s.startswith(("@[", "private ", "protected ")):
+            break
+        else:
+            header_end = i + 1
+    return header_end
+
+
+def _find_theorem_end(lines: list[str], start: int) -> int:
+    """Find where theorem ends (next declaration or EOF)."""
+    for i in range(start + 1, len(lines)):
+        if _DECL_RE.match(lines[i]):
+            return i
+    return len(lines)
+
+
+def _extract_theorem_source(lines: list[str], target_line: int) -> tuple[str, str, int]:
+    """Extract imports/header + single theorem. Returns (source, name, theorem_start_in_source)."""
+    m = _DECL_RE.match(lines[target_line - 1])
+    if not m:
+        raise ValueError(f"No theorem/lemma/def at line {target_line}")
+
+    header_end = _find_header_end(lines)
+    theorem_end = _find_theorem_end(lines, target_line - 1)
+
+    header = "\n".join(lines[:header_end])
+    theorem = "\n".join(lines[target_line - 1 : theorem_end])
+    return f"{header}\n\n{theorem}\n", m.group(2), header_end + 2
+
+
+def _parse_output(
+    output: str,
+) -> tuple[list[tuple[int, str, float, str]], dict[str, float]]:
+    """Parse trace output into (traces, cumulative). Traces are (depth, cls, ms, msg)."""
+    traces, cumulative, in_cumulative = [], {}, False
+
+    for line in output.splitlines():
+        if "cumulative profiling times:" in line:
+            in_cumulative = True
+        elif in_cumulative and (m := _CUMULATIVE_RE.match(line)):
+            cat, val, unit = m.groups()
+            cumulative[cat] = float(val) * (1000 if unit == "s" else 1)
+        elif not in_cumulative and (m := _TRACE_RE.match(line)):
+            indent, cls, time_s, msg = m.groups()
+            traces.append((len(indent) // 2, cls, float(time_s) * 1000, msg))
+
+    return traces, cumulative
+
+
+def _build_proof_items(
+    source_lines: list[str], proof_start: int
+) -> list[tuple[int, str, bool]]:
+    """Build list of (line_no, content, is_bullet) for proof lines."""
+    items = []
+    for i in range(proof_start, len(source_lines)):
+        s = source_lines[i].strip()
+        if s and not s.startswith("--"):
+            is_bullet = s[0] in "·*-"
+            items.append((i + 1, s.lstrip("·*- \t"), is_bullet))
+    return items
+
+
+def _match_line(
+    tactic: str, is_bullet: bool, items: list[tuple[int, str, bool]], used: set[int]
+) -> int | None:
+    """Find matching source line for a tactic trace. Returns line number or None."""
+    for ln, content, src_bullet in items:
+        if ln in used:
+            continue
+        if is_bullet and src_bullet:
+            return ln
+        if (
+            not is_bullet
+            and content
+            and (tactic.startswith(content[:25]) or content.startswith(tactic[:25]))
+        ):
+            return ln
+    return None
+
+
+def _extract_line_times(
+    traces: list[tuple[int, str, float, str]],
+    name: str,
+    proof_items: list[tuple[int, str, bool]],
+) -> tuple[dict[int, float], float]:
+    """Extract per-line timing from traces."""
+    line_times: dict[int, float] = defaultdict(float)
+    total, value_depth, in_value, tactic_depth = 0.0, 0, False, None
+    name_re = re.compile(rf"\b{re.escape(name)}\b")
+    used: set[int] = set()
+
+    for depth, cls, ms, msg in traces:
+        if cls == "Elab.definition.value" and name_re.search(msg):
+            in_value, value_depth, total = True, depth, ms
+        elif cls == "Elab.async" and f"proof of {name}" in msg:
+            total = max(total, ms)
+        elif in_value:
+            if depth <= value_depth:
+                break
+            if cls == "Elab.step" and not msg.startswith("expected type:"):
+                tactic_depth = tactic_depth or depth
+                if depth == tactic_depth:
+                    tactic = msg.split("\n")[0].strip().lstrip("·*- \t")
+                    if ln := _match_line(tactic, not tactic, proof_items, used):
+                        line_times[ln] += ms
+                        used.add(ln)
+
+    return dict(line_times), total
+
+
+def _filter_categories(cumulative: dict[str, float]) -> dict[str, float]:
+    """Filter to relevant categories >= 1ms."""
+    return {
+        k: round(v, 1)
+        for k, v in sorted(cumulative.items(), key=lambda x: -x[1])
+        if k not in _SKIP_CATEGORIES and v >= 1.0
+    }
+
+
+async def _run_lean_profile(file_path: Path, project_path: Path, timeout: float) -> str:
+    """Run lean --profile, return output."""
+    proc = await asyncio.create_subprocess_exec(
+        "lake",
+        "env",
+        "lean",
+        "--profile",
+        "-Dtrace.profiler=true",
+        "-Dtrace.profiler.threshold=0",
+        str(file_path.resolve()),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+        cwd=project_path.resolve(),
+        env=os.environ.copy(),
+    )
+    try:
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        return stdout.decode("utf-8", errors="replace")
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise TimeoutError(f"Profiling timed out after {timeout}s")
+
+
+def _find_proof_start(source_lines: list[str]) -> int:
+    """Find line after ':= by' in source."""
+    for i, line in enumerate(source_lines):
+        if ":= by" in line or line.rstrip().endswith(" by"):
+            return i + 1
+    raise ValueError("No 'by' proof found in theorem")
+
+
+async def profile_theorem(
+    file_path: Path,
+    theorem_line: int,
+    project_path: Path,
+    timeout: float = 60.0,
+    top_n: int = 5,
+) -> ProofProfileResult:
+    """Profile a theorem via `lean --profile`. Returns per-line timing data."""
+    lines = file_path.read_text().splitlines()
+    if not (0 < theorem_line <= len(lines)):
+        raise ValueError(f"Line {theorem_line} out of range")
+
+    source, name, src_start = _extract_theorem_source(lines, theorem_line)
+    source_lines = source.splitlines()
+    line_offset = theorem_line - src_start
+    proof_start = _find_proof_start(source_lines)
+    proof_items = _build_proof_items(source_lines, proof_start)
+
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".lean", dir=project_path, delete=False
+    ) as f:
+        f.write(source)
+        temp_path = Path(f.name)
+
+    try:
+        output = await _run_lean_profile(temp_path, project_path, timeout)
+    finally:
+        temp_path.unlink(missing_ok=True)
+
+    traces, cumulative = _parse_output(output)
+    line_times, total = _extract_line_times(traces, name, proof_items)
+
+    top_lines = sorted(
+        [(ln, ms) for ln, ms in line_times.items() if ms >= total * 0.01],
+        key=lambda x: -x[1],
+    )[:top_n]
+
+    return ProofProfileResult(
+        ms=round(total, 1),
+        lines=[
+            LineProfile(
+                line=ln + line_offset,
+                ms=round(ms, 1),
+                text=source_lines[ln - 1].strip()[:60]
+                if ln <= len(source_lines)
+                else "",
+            )
+            for ln, ms in top_lines
+        ],
+        categories=_filter_categories(cumulative),
+    )

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp/server.py

@@ -50,6 +50,7 @@ from lean_lsp_mcp.models import (
     MultiAttemptResult,
     PremiseResult,
     PremiseResults,
+    ProofProfileResult,
     RunResult,
     StateSearchResult,
     StateSearchResults,
@@ -64,17 +65,38 @@ from lean_lsp_mcp.utils import (
     OutputCapture,
     check_lsp_response,
     deprecated,
+    extract_failed_dependency_paths,
     extract_goals_list,
     extract_range,
     filter_diagnostics_by_position,
     find_start_position,
     get_declaration_range,
+    is_build_stderr,
 )
 
 # LSP Diagnostic severity: 1=error, 2=warning, 3=info, 4=hint
 DIAGNOSTIC_SEVERITY: Dict[int, str] = {1: "error", 2: "warning", 3: "info", 4: "hint"}
 
 
+async def _urlopen_json(req: urllib.request.Request, timeout: float):
+    """Run urllib.request.urlopen in a worker thread to avoid blocking the event loop."""
+
+    def _do_request():
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            return orjson.loads(response.read())
+
+    return await asyncio.to_thread(_do_request)
+
+
+async def _safe_report_progress(
+    ctx: Context, *, progress: int, total: int, message: str
+) -> None:
+    try:
+        await ctx.report_progress(progress=progress, total=total, message=message)
+    except Exception:
+        return
+
+
 _LOG_LEVEL = os.environ.get("LEAN_LOG_LEVEL", "INFO")
 configure_logging("CRITICAL" if _LOG_LEVEL == "NONE" else _LOG_LEVEL)
 logger = get_logger(__name__)
@@ -164,8 +186,7 @@ mcp = FastMCP(**mcp_kwargs)
 
 def rate_limited(category: str, max_requests: int, per_seconds: int):
     def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def _apply_rate_limit(args, kwargs):
             ctx = kwargs.get("ctx")
             if ctx is None:
                 if not args:
@@ -181,11 +202,33 @@ def rate_limited(category: str, max_requests: int, per_seconds: int):
                 if timestamp > current_time - per_seconds
             ]
             if len(rate_limit[category]) >= max_requests:
-                return f"Tool limit exceeded: {max_requests} requests per {per_seconds} s. Try again later."
+                return (
+                    False,
+                    f"Tool limit exceeded: {max_requests} requests per {per_seconds} s. Try again later.",
+                )
             rate_limit[category].append(current_time)
-            return func(*args, **kwargs)
+            return True, None
+
+        if asyncio.iscoroutinefunction(func):
 
-        wrapper.__doc__ = f"Limit: {max_requests}req/{per_seconds}s. " + wrapper.__doc__
+            @functools.wraps(func)
+            async def wrapper(*args, **kwargs):
+                allowed, msg = _apply_rate_limit(args, kwargs)
+                if not allowed:
+                    return msg
+                return await func(*args, **kwargs)
+
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                allowed, msg = _apply_rate_limit(args, kwargs)
+                if not allowed:
+                    return msg
+                return func(*args, **kwargs)
+
+        doc = wrapper.__doc__ or ""
+        wrapper.__doc__ = f"Limit: {max_requests}req/{per_seconds}s. {doc}"
         return wrapper
 
     return decorator
@@ -375,6 +418,7 @@ def file_outline(
 
 
 def _to_diagnostic_messages(diagnostics: List[Dict]) -> List[DiagnosticMessage]:
+    """Convert LSP diagnostics to DiagnosticMessage models."""
     result = []
     for diag in diagnostics:
         r = diag.get("fullRange", diag.get("range"))
@@ -394,6 +438,52 @@ def _to_diagnostic_messages(diagnostics: List[Dict]) -> List[DiagnosticMessage]:
     return result
 
 
+def _process_diagnostics(
+    diagnostics: List[Dict], build_success: bool
+) -> DiagnosticsResult:
+    """Process diagnostics, extracting dependency paths from build stderr.
+
+    Args:
+        diagnostics: List of diagnostic dicts from leanclient
+        build_success: Whether the build succeeded (from leanclient.DiagnosticsResult.success)
+    """
+    items = []
+    failed_deps: List[str] = []
+
+    for diag in diagnostics:
+        r = diag.get("fullRange", diag.get("range"))
+        if r is None:
+            continue
+
+        severity_int = diag.get("severity", 1)
+        message = diag.get("message", "")
+        line = r["start"]["line"] + 1
+        column = r["start"]["character"] + 1
+
+        # Check if this is a build failure at (1,1) - extract dependency paths, skip the item
+        if line == 1 and column == 1 and is_build_stderr(message):
+            failed_deps = extract_failed_dependency_paths(message)
+            continue  # Don't include the build stderr blob as a diagnostic item
+
+        # Normal diagnostic from the queried file
+        items.append(
+            DiagnosticMessage(
+                severity=DIAGNOSTIC_SEVERITY.get(
+                    severity_int, f"unknown({severity_int})"
+                ),
+                message=message,
+                line=line,
+                column=column,
+            )
+        )
+
+    return DiagnosticsResult(
+        success=build_success,
+        items=items,
+        failed_dependencies=failed_deps,
+    )
+
+
 @mcp.tool(
     "lean_diagnostic_messages",
     annotations=ToolAnnotations(
@@ -437,15 +527,14 @@ def diagnostic_messages(
     start_line_0 = (start_line - 1) if start_line is not None else None
     end_line_0 = (end_line - 1) if end_line is not None else None
 
-    diagnostics = client.get_diagnostics(
+    result = client.get_diagnostics(
         rel_path,
         start_line=start_line_0,
         end_line=end_line_0,
         inactivity_timeout=15.0,
     )
-    check_lsp_response(diagnostics, "get_diagnostics")
 
-    return DiagnosticsResult(items=_to_diagnostic_messages(diagnostics))
+    return _process_diagnostics(result.diagnostics, result.success)
 
 
 @mcp.tool(
@@ -880,7 +969,7 @@ class LocalSearchError(Exception):
         openWorldHint=False,
     ),
 )
-def local_search(
+async def local_search(
     ctx: Context,
     query: Annotated[str, Field(description="Declaration name or prefix")],
     limit: Annotated[int, Field(description="Max matches", ge=1)] = 10,
@@ -912,8 +1001,11 @@ def local_search(
         )
 
     try:
-        raw_results = lean_local_search(
-            query=query.strip(), limit=limit, project_root=resolved_root
+        raw_results = await asyncio.to_thread(
+            lean_local_search,
+            query=query.strip(),
+            limit=limit,
+            project_root=resolved_root,
         )
         results = [
             LocalSearchResult(name=r["name"], kind=r["kind"], file=r["file"])
@@ -934,7 +1026,7 @@ def local_search(
     ),
 )
 @rate_limited("leansearch", max_requests=3, per_seconds=30)
-def leansearch(
+async 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,
@@ -954,8 +1046,10 @@ def leansearch(
         method="POST",
     )
 
-    with urllib.request.urlopen(req, timeout=10) as response:
-        results = orjson.loads(response.read())
+    await _safe_report_progress(
+        ctx, progress=1, total=10, message="Awaiting response from leansearch.net"
+    )
+    results = await _urlopen_json(req, timeout=10)
 
     if not results or not results[0]:
         return LeanSearchResults(items=[])
@@ -1029,7 +1123,13 @@ async def loogle(
         )
     rate_limit.append(now)
 
-    result = loogle_remote(query, num_results)
+    await _safe_report_progress(
+        ctx,
+        progress=1,
+        total=10,
+        message="Awaiting response from loogle.lean-lang.org",
+    )
+    result = await asyncio.to_thread(loogle_remote, query, num_results)
     if isinstance(result, str):
         raise LeanToolError(result)  # Error message from remote
     return LoogleResults(items=result)
@@ -1045,7 +1145,7 @@ async def loogle(
     ),
 )
 @rate_limited("leanfinder", max_requests=10, per_seconds=30)
-def leanfinder(
+async 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,
@@ -1063,23 +1163,27 @@ def leanfinder(
     )
 
     results: List[LeanFinderResult] = []
-    with urllib.request.urlopen(req, timeout=10) as response:
-        data = orjson.loads(response.read())
-        for result in data["results"]:
-            if (
-                "https://leanprover-community.github.io/mathlib4_docs"
-                not in result["url"]
-            ):  # Only include mathlib4 results
-                continue
-            match = re.search(r"pattern=(.*?)#doc", result["url"])
-            if match:
-                results.append(
-                    LeanFinderResult(
-                        full_name=match.group(1),
-                        formal_statement=result["formal_statement"],
-                        informal_statement=result["informal_statement"],
-                    )
+    await _safe_report_progress(
+        ctx,
+        progress=1,
+        total=10,
+        message="Awaiting response from Lean Finder (Hugging Face)",
+    )
+    data = await _urlopen_json(req, timeout=10)
+    for result in data["results"]:
+        if (
+            "https://leanprover-community.github.io/mathlib4_docs" not in result["url"]
+        ):  # Only include mathlib4 results
+            continue
+        match = re.search(r"pattern=(.*?)#doc", result["url"])
+        if match:
+            results.append(
+                LeanFinderResult(
+                    full_name=match.group(1),
+                    formal_statement=result["formal_statement"],
+                    informal_statement=result["informal_statement"],
                 )
+            )
 
     return LeanFinderResults(items=results)
 
@@ -1094,7 +1198,7 @@ def leanfinder(
     ),
 )
 @rate_limited("lean_state_search", max_requests=3, per_seconds=30)
-def state_search(
+async def state_search(
     ctx: Context,
     file_path: Annotated[str, Field(description="Absolute path to Lean file")],
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
@@ -1126,8 +1230,10 @@ def state_search(
         method="GET",
     )
 
-    with urllib.request.urlopen(req, timeout=10) as response:
-        results = orjson.loads(response.read())
+    await _safe_report_progress(
+        ctx, progress=1, total=10, message=f"Awaiting response from {url}"
+    )
+    results = await _urlopen_json(req, timeout=10)
 
     items = [StateSearchResult(name=r["name"]) for r in results]
     return StateSearchResults(items=items)
@@ -1143,7 +1249,7 @@ def state_search(
     ),
 )
 @rate_limited("hammer_premise", max_requests=3, per_seconds=30)
-def hammer_premise(
+async def hammer_premise(
     ctx: Context,
     file_path: Annotated[str, Field(description="Absolute path to Lean file")],
     line: Annotated[int, Field(description="Line number (1-indexed)", ge=1)],
@@ -1186,12 +1292,64 @@ def hammer_premise(
         data=orjson.dumps(data),
     )
 
-    with urllib.request.urlopen(req, timeout=10) as response:
-        results = orjson.loads(response.read())
+    await _safe_report_progress(
+        ctx, progress=1, total=10, message=f"Awaiting response from {url}"
+    )
+    results = await _urlopen_json(req, timeout=10)
 
     items = [PremiseResult(name=r["name"]) for r in results]
     return PremiseResults(items=items)
 
 
+@mcp.tool(
+    "lean_profile_proof",
+    annotations=ToolAnnotations(
+        title="Profile Proof",
+        readOnlyHint=True,
+        idempotentHint=True,
+        openWorldHint=False,
+    ),
+)
+async def profile_proof(
+    ctx: Context,
+    file_path: Annotated[str, Field(description="Absolute path to Lean file")],
+    line: Annotated[
+        int, Field(description="Line where theorem starts (1-indexed)", ge=1)
+    ],
+    top_n: Annotated[
+        int, Field(description="Number of slowest lines to return", ge=1)
+    ] = 5,
+    timeout: Annotated[float, Field(description="Max seconds to wait", ge=1)] = 60.0,
+) -> ProofProfileResult:
+    """Run `lean --profile` on a theorem. Returns per-line timing and categories."""
+    from lean_lsp_mcp.profile_utils import profile_theorem
+
+    # Get project path
+    lifespan = ctx.request_context.lifespan_context
+    project_path = lifespan.lean_project_path
+
+    if not project_path:
+        infer_project_path(ctx, file_path)
+        project_path = lifespan.lean_project_path
+
+    if not project_path:
+        raise LeanToolError("Lean project not found")
+
+    file_path_obj = Path(file_path)
+    if not file_path_obj.exists():
+        raise LeanToolError(f"File not found: {file_path}")
+
+    try:
+        return await profile_theorem(
+            file_path=file_path_obj,
+            theorem_line=line,
+            project_path=project_path,
+            timeout=timeout,
+            top_n=top_n,
+        )
+    except (ValueError, TimeoutError) as e:
+        raise LeanToolError(str(e)) from e
+
+
 if __name__ == "__main__":
     mcp.run()

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp/utils.py

@@ -1,4 +1,5 @@
 import os
+import re
 import secrets
 import sys
 import tempfile
@@ -7,6 +8,30 @@ from typing import Any, List, Dict, Optional, Callable
 from mcp.server.auth.provider import AccessToken, TokenVerifier
 
 
+# Pattern to extract file paths from build stderr: "error: path/file.lean:line:col: message"
+BUILD_ERROR_FILE_PATTERN = re.compile(
+    r"^(?:error|warning):\s*([^\s:]+\.lean):\d+:\d+:",
+    re.MULTILINE | re.IGNORECASE,
+)
+
+
+def extract_failed_dependency_paths(message: str) -> List[str]:
+    """Extract unique file paths from lake build stderr output.
+
+    Returns sorted list of .lean file paths that had errors/warnings.
+    """
+    paths = set(BUILD_ERROR_FILE_PATTERN.findall(message))
+    return sorted(paths)
+
+
+def is_build_stderr(message: str) -> bool:
+    """Check if message looks like lake build stderr output."""
+    return (
+        "lake setup-file" in message
+        or BUILD_ERROR_FILE_PATTERN.search(message) is not None
+    )
+
+
 class LeanToolError(Exception):
     """Exception raised when a Lean MCP tool operation fails."""
 

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.17.2
+Version: 0.19.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: leanclient==0.8.0
+Requires-Dist: leanclient==0.9.1
 Requires-Dist: mcp[cli]==1.25.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
@@ -18,6 +18,7 @@ Requires-Dist: ruff>=0.2.0; extra == "dev"
 Requires-Dist: pytest>=8.3; extra == "dev"
 Requires-Dist: anyio>=4.4; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-timeout>=2.3; extra == "dev"
 Dynamic: license-file
 
 <h1 align="center">
@@ -298,6 +299,27 @@ h_neq : ¬P.card = 2 ^ (Fintype.card S - 1)
 ```
 </details>
 
+#### lean_profile_proof
+
+Profile a theorem to identify slow tactics. Runs `lean --profile` on an isolated copy of the theorem and returns per-line timing data.
+
+<details>
+<summary>Example output (profiling a theorem using simp)</summary>
+
+```json
+{
+  "ms": 42.5,
+  "lines": [
+    {"line": 7, "ms": 38.2, "text": "simp [add_comm, add_assoc]"}
+  ],
+  "categories": {
+    "simp": 35.1,
+    "typeclass inference": 4.2
+  }
+}
+```
+</details>
+
 ### Local Search Tools
 
 #### lean_local_search

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/lean_lsp_mcp/instructions.py
 src/lean_lsp_mcp/loogle.py
 src/lean_lsp_mcp/models.py
 src/lean_lsp_mcp/outline_utils.py
+src/lean_lsp_mcp/profile_utils.py
 src/lean_lsp_mcp/search_utils.py
 src/lean_lsp_mcp/server.py
 src/lean_lsp_mcp/utils.py
@@ -25,6 +26,7 @@ tests/test_file_caching.py
 tests/test_logging.py
 tests/test_misc_tools.py
 tests/test_outline.py
+tests/test_profile.py
 tests/test_project_tools.py
 tests/test_search_tools.py
 tests/test_structured_output.py

{lean_lsp_mcp-0.17.2 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,4 +1,4 @@
-leanclient==0.8.0
+leanclient==0.9.1
 mcp[cli]==1.25.0
 orjson>=3.11.1
 
@@ -7,6 +7,7 @@ ruff>=0.2.0
 pytest>=8.3
 anyio>=4.4
 pytest-asyncio>=0.23
+pytest-timeout>=2.3
 
 [lint]
 ruff>=0.2.0

lean_lsp_mcp-0.19.0/tests/test_profile.py

@@ -0,0 +1,103 @@
+"""Integration tests for lean_profile_proof tool.
+
+These tests run actual Lean profiling and verify the output structure.
+If Lean's profiler format changes, these tests should fail.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from lean_lsp_mcp.profile_utils import profile_theorem
+from tests.helpers.mcp_client import MCPToolError, result_json
+
+
+class TestProfileTheorem:
+    """Direct API tests - run real Lean profiling."""
+
+    @pytest.fixture
+    def profile_file(self, test_project_path: Path) -> Path:
+        return test_project_path / "ProfileTest.lean"
+
+    @pytest.mark.asyncio
+    async def test_profiles_rw_theorem(self, profile_file: Path):
+        """Line 3: theorem simple_by using rw tactic."""
+        profile = await profile_theorem(
+            profile_file, theorem_line=3, project_path=profile_file.parent
+        )
+        assert profile.ms > 0
+        assert len(profile.categories) > 0
+        # Should extract timing for line 4 (rw)
+        if profile.lines:
+            ln = profile.lines[0]
+            assert ln.line == 4  # rw is on line 4
+            assert "rw" in ln.text
+
+    @pytest.mark.asyncio
+    async def test_profiles_simp_theorem(self, profile_file: Path):
+        """Line 6: theorem simp_test using simp tactic."""
+        profile = await profile_theorem(
+            profile_file, theorem_line=6, project_path=profile_file.parent
+        )
+        assert profile.ms > 0
+        assert "simp" in profile.categories
+        if profile.lines:
+            assert "simp" in profile.lines[0].text
+
+    @pytest.mark.asyncio
+    async def test_profiles_omega_theorem(self, profile_file: Path):
+        """Line 9: theorem omega_test using omega tactic."""
+        profile = await profile_theorem(
+            profile_file, theorem_line=9, project_path=profile_file.parent
+        )
+        assert profile.ms > 0
+        if profile.lines:
+            ln = profile.lines[0]
+            assert ln.line == 10  # omega is on line 10
+            assert "omega" in ln.text
+            assert ln.ms > 0
+
+    @pytest.mark.asyncio
+    async def test_invalid_line_raises(self, profile_file: Path):
+        with pytest.raises(ValueError):
+            await profile_theorem(
+                profile_file, theorem_line=999, project_path=profile_file.parent
+            )
+
+
+class TestProfileProofTool:
+    """MCP tool tests."""
+
+    @pytest.mark.asyncio
+    async def test_returns_structured_profile(
+        self, mcp_client_factory, test_project_path: Path
+    ):
+        async with mcp_client_factory() as client:
+            result = await client.call_tool(
+                "lean_profile_proof",
+                {
+                    "file_path": str(test_project_path / "ProfileTest.lean"),
+                    "line": 6,
+                },
+            )
+            data = result_json(result)
+            assert data["ms"] > 0
+            assert "simp" in data["categories"]
+            # Verify line structure
+            if data["lines"]:
+                ln = data["lines"][0]
+                assert "text" in ln and "ms" in ln and "line" in ln
+
+    @pytest.mark.asyncio
+    async def test_error_on_invalid_line(
+        self, mcp_client_factory, test_project_path: Path
+    ):
+        async with mcp_client_factory() as client:
+            with pytest.raises(MCPToolError):
+                await client.call_tool(
+                    "lean_profile_proof",
+                    {
+                        "file_path": str(test_project_path / "ProfileTest.lean"),
+                        "line": 999,
+                    },
+                )