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

{lean_lsp_mcp-0.18.0/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.18.0
+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.9.0
+Requires-Dist: leanclient==0.9.1
 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 → 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.18.0 → lean_lsp_mcp-0.19.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.18.0"
+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.9.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"

{lean_lsp_mcp-0.18.0 → 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.18.0 → 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
 
 
@@ -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-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.18.0 → 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,
@@ -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 → 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.18.0
+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.9.0
+Requires-Dist: leanclient==0.9.1
 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 → 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.18.0 → lean_lsp_mcp-0.19.0}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,4 +1,4 @@
-leanclient==0.9.0
+leanclient==0.9.1
 mcp[cli]==1.25.0
 orjson>=3.11.1
 

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,
+                    },
+                )