lean-lsp-mcp 0.18.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

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/models.py

@@ -1,6 +1,7 @@
 """Pydantic models for MCP tool structured outputs."""
 
 from typing import List, Optional
+
 from pydantic import BaseModel, Field
 
 
@@ -210,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/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/server.py

@@ -50,6 +50,7 @@ from lean_lsp_mcp.models import (
     MultiAttemptResult,
     PremiseResult,
     PremiseResults,
+    ProofProfileResult,
     RunResult,
     StateSearchResult,
     StateSearchResults,
@@ -1300,5 +1301,55 @@ async def hammer_premise(
     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.18.0.dist-info → lean_lsp_mcp-0.19.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.18.0
+Version: 0.19.1
 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.9.0
+Requires-Dist: leanclient==0.9.2
 Requires-Dist: mcp[cli]==1.25.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
@@ -299,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.18.0.dist-info → lean_lsp_mcp-0.19.1.dist-info}/RECORD

@@ -2,16 +2,17 @@ lean_lsp_mcp/__init__.py,sha256=MN_bNFyb5-p33JWWGbrlUYBd1UUMQKtZYGC9KCh2mtM,1403
 lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
 lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
 lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
-lean_lsp_mcp/instructions.py,sha256=iJk_oD67tqNaC8K5OXEuXafULKSbbiHjZAsSRebOwdw,1904
+lean_lsp_mcp/instructions.py,sha256=HgENbIe1nwIzKXqf_yYC44f7YQ8j47zJgKBYmmaD_UI,1994
 lean_lsp_mcp/loogle.py,sha256=zUgnDWoTIqa4G6GXStAIxxJUR545YbU8Z-8KMjddKV0,15500
-lean_lsp_mcp/models.py,sha256=WVW5K27m54W2THoAUMKvBC--qCSD6eSYjd9bcaiMk2s,6879
+lean_lsp_mcp/models.py,sha256=dyjM6m36PscEtBiLjGxDxeM5b0ELpRTw1SUayYDeOwA,7549
 lean_lsp_mcp/outline_utils.py,sha256=i7xL27UO2rTT48IdKXkoMq5FVJNxyA3tPuQREOBf_gU,11105
+lean_lsp_mcp/profile_utils.py,sha256=LwtBmgwrywPiNhWS6xK-_QF-FTy0uWkW6NCK5l5rCQI,8144
 lean_lsp_mcp/search_utils.py,sha256=MLqKGe4bhEvyfFLIBCmiDxkbcH4O5J3vl9mWnRSb_v0,6801
-lean_lsp_mcp/server.py,sha256=UDTuHeRX_RUxsfLrR3PqGWnAYLvmEb89iZtq0dNqymU,43859
+lean_lsp_mcp/server.py,sha256=VFdyRxHJsBM0sehHyvEkdG17HQl78MYgBgH8usBkpUU,45430
 lean_lsp_mcp/utils.py,sha256=dGv84a4E-szOkQVYtSE-q9GbawpiVk47qvrkTN-Clts,13478
-lean_lsp_mcp-0.18.0.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
-lean_lsp_mcp-0.18.0.dist-info/METADATA,sha256=xXkTL1pV9lCCopASzat8OYGppv_GRT95GTVdMVccAAw,20838
-lean_lsp_mcp-0.18.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lean_lsp_mcp-0.18.0.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
-lean_lsp_mcp-0.18.0.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
-lean_lsp_mcp-0.18.0.dist-info/RECORD,,
+lean_lsp_mcp-0.19.1.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
+lean_lsp_mcp-0.19.1.dist-info/METADATA,sha256=D2CgfgVE_jKV0Lnz3TDlbCgOdywCk48WXP1Bp9xLZNs,21274
+lean_lsp_mcp-0.19.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lean_lsp_mcp-0.19.1.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
+lean_lsp_mcp-0.19.1.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
+lean_lsp_mcp-0.19.1.dist-info/RECORD,,