leanback 0.1.1__tar.gz → 0.1.3__tar.gz

{leanback-0.1.1 → leanback-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leanback
-Version: 0.1.1
+Version: 0.1.3
 Summary: MCP server for Lean 4 theorem proving — check, prove, goals, eval, search
 Author: Stefan Szeider
 License: Apache-2.0
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.11
-Requires-Dist: mcp>=1.9.4
+Requires-Dist: mcp>=1.26.0
 Requires-Dist: rich>=14.0.0
 Description-Content-Type: text/markdown
 

{leanback-0.1.1 → leanback-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "leanback"
-version = "0.1.1"
+version = "0.1.3"
 description = "MCP server for Lean 4 theorem proving — check, prove, goals, eval, search"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -21,15 +21,15 @@ classifiers = [
 ]
 dependencies = [
     "rich>=14.0.0",
-    "mcp>=1.9.4",
+    "mcp>=1.26.0",
 ]
 
 [dependency-groups]
 dev = [
-    "pytest>=8.4.0",
-    "ruff>=0.11.0",
-    "mypy>=1.16.0",
-    "coverage>=7.8.0",
+    "pytest>=9.0.0",
+    "ruff>=0.15.0",
+    "mypy>=1.19.0",
+    "coverage>=7.13.0",
 ]
 
 [tool.ruff]
@@ -47,6 +47,9 @@ line-length = 88
 # Auto-fix issues
 fix = true
 
+# Exclude non-Python project directories
+exclude = ["projects/"]
+
 [tool.ruff.format]
 # Black-compatible formatting
 quote-style = "double"
@@ -87,7 +90,7 @@ lines-after-imports = 2
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use assert and have unused imports
-"tests/*" = ["S101", "F401", "F841"]
+"tests/*" = ["S101", "F401", "F841", "RUF059"]
 "__init__.py" = ["F401"]
 
 [tool.mypy]

{leanback-0.1.1 → leanback-0.1.3}/src/leanback/__init__.py

@@ -1,3 +1,3 @@
 """LeanBack - Lean 4 development tools for Claude Code."""
 
-__version__ = "0.3.0"
+__version__ = "0.1.2"

{leanback-0.1.1 → leanback-0.1.3}/src/leanback/check.py

@@ -295,8 +295,8 @@ def check_project(
     lean_files = list(project_path.glob("**/*.lean"))
 
     for file_path in lean_files:
-        # Skip files in .lake directory
-        if ".lake" in file_path.parts:
+        # Skip files in .lake directory and lakefile.lean (uses Lake DSL, not standard Lean)
+        if ".lake" in file_path.parts or file_path.name == "lakefile.lean":
             continue
 
         console.print(f"Checking {file_path.relative_to(project_path)}...")

{leanback-0.1.1 → leanback-0.1.3}/src/leanback/common/env.py

@@ -6,9 +6,29 @@ This module provides functionality for executing Lean commands in the correct en
 
 import os
 import subprocess
+import sys
 from pathlib import Path
 
 
+def _find_native_dynlibs(project_path: Path) -> list[Path]:
+    """Discover native shared libraries in Lake packages.
+
+    Scans .lake/packages/*/.lake/build/lib/ for .so (Linux) or .dylib (macOS)
+    files that need --load-dynlib for the Lean interpreter.
+    """
+    packages_dir = project_path / ".lake" / "packages"
+    if not packages_dir.is_dir():
+        return []
+
+    if sys.platform == "darwin":
+        ext = "dylib"
+    elif sys.platform == "win32":
+        ext = "dll"
+    else:
+        ext = "so"
+    return sorted(packages_dir.glob(f"*/.lake/build/lib/lib*.{ext}"))
+
+
 class LeanRunner:
     """
     Utility for running Lean commands in the appropriate environment.
@@ -53,6 +73,11 @@ class LeanRunner:
 
             # Always use lake env lean for projects - this ensures proper dependency management
             command = ["lake", "env", "lean"]
+
+            # Load native shared libraries for FFI-dependent packages (e.g., cvc5)
+            for lib in _find_native_dynlibs(project_path):
+                command.append(f"--load-dynlib={lib}")
+
             if capture_json:
                 command.append("--json")
             command.append(str(abs_file_path))

{leanback-0.1.1 → leanback-0.1.3}/src/leanback/mcp_server.py

@@ -14,6 +14,8 @@ import time
 from pathlib import Path
 
 from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.exceptions import ToolError
+from mcp.server.fastmcp.tools.tool_manager import ToolManager
 
 
 def _json(obj: object) -> str:
@@ -87,6 +89,25 @@ modify files. Use your own file tools to create/edit .lean files, then use LeanB
 )
 
 
+class _StrictToolManager(ToolManager):
+    """Rejects unknown parameters instead of silently dropping them."""
+
+    async def call_tool(self, name, arguments, context=None, **kwargs):
+        tool = self.get_tool(name)
+        if tool and arguments:
+            known = set(tool.parameters.get("properties", {}).keys())
+            unknown = set(arguments.keys()) - known
+            if unknown:
+                raise ToolError(
+                    f"Unknown parameter(s) for '{name}': {', '.join(sorted(unknown))}. "
+                    f"Valid parameters: {', '.join(sorted(known))}"
+                )
+        return await super().call_tool(name, arguments, context, **kwargs)
+
+
+mcp._tool_manager = _StrictToolManager()
+
+
 def _resolve_project(project: str) -> Path | None:
     """Resolve and validate a project path. Returns Path or None."""
     p = Path(project)
@@ -170,11 +191,26 @@ def _clean_lean_message(message: str) -> str:
     return message
 
 
-def _serialize_errors(errors: list, sanitize_paths: bool = False) -> list[dict]:
-    """Serialize LeanError objects to dicts for JSON output."""
+def _serialize_errors(
+    errors: list, sanitize_paths: bool = False, source_file: str | None = None
+) -> list[dict]:
+    """Serialize LeanError objects to dicts for JSON output.
+
+    If source_file is provided, temp file paths are replaced with it
+    instead of the generic '<inline>' label.
+    """
+
+    def _resolve_path(file_name: str) -> str:
+        if not sanitize_paths:
+            return file_name
+        sanitized = _sanitize_file_path(file_name)
+        if sanitized == "<inline>" and source_file:
+            return source_file
+        return sanitized
+
     return [
         {
-            "file": _sanitize_file_path(e.file_name) if sanitize_paths else e.file_name,
+            "file": _resolve_path(e.file_name),
             "line": e.line,
             "column": e.column,
             "end_line": e.end_line,
@@ -413,7 +449,7 @@ def check(
     - file: Path to a .lean file within the project (e.g., "Basic.lean", "src/Logic.lean")
     - check_all: Check each file individually for detailed error reporting (slower but more thorough)
     - expr: A Lean expression or command to check (e.g., "2 + 2 = 4", "Nat.add", "#eval 1 + 1"). Bare expressions are auto-wrapped in #check.
-    - imports: List of modules to import when checking expressions (e.g., ["Mathlib.Tactic"])
+    - imports: List of modules to import when checking expressions (e.g., ["Mathlib.Tactic"]). First Mathlib import takes ~20-30s.
 
     Returns JSON with 'success' boolean. The 'messages' array contains objects with:
     - file: Path to the file (or "<inline>" for expressions)
@@ -565,6 +601,12 @@ def check(
                     "files_checked": 1,
                 },
             }
+            if file_path.name == "lakefile.lean" and not success:
+                result["note"] = (
+                    "lakefile.lean uses Lake DSL which may produce errors "
+                    "when checked outside the build system. "
+                    "These errors are typically not actionable."
+                )
             return _json(result)
 
         # Case 3: Check entire project
@@ -591,6 +633,9 @@ def check(
                 "total_info": info_count,
                 "files_with_errors": len(files_with_errors),
             },
+            "hint": "This checked the entire project via 'lake build'. "
+            "To check specific code, use expr=. "
+            "To execute code, use the eval tool.",
         }
         return _json(result)
 
@@ -620,7 +665,7 @@ def prove(
     - tactics: List of proof tactics to apply in order (e.g., ["intro n", "rfl"])
     - file: Path to a .lean file containing complete proofs to verify
     - imports: Additional modules to import (e.g., ["Mathlib.Data.Nat.Basic"])
-    - mathlib: Import Mathlib.Tactic for all standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.)
+    - mathlib: Import Mathlib.Tactic for all standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.). First call takes ~8-11s for import.
 
     Use either (theorem + tactics) OR (file), not both. When using theorem + tactics,
     the tool constructs and verifies the proof. When using file, it verifies existing proofs.
@@ -798,7 +843,7 @@ def goals(
     - theorem: Theorem statement to prove (e.g., "2 + 2 = 4", "∀ n : Nat, n + 0 = n")
     - tactics: List of tactics applied so far (e.g., ["intro n"]). Omit or pass [] to see the initial goal.
     - imports: Additional modules to import (e.g., ["Mathlib.Data.Nat.Basic"])
-    - mathlib: Import Mathlib.Tactic for standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.)
+    - mathlib: Import Mathlib.Tactic for standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.). First call takes ~8-11s for import.
 
     Returns JSON with:
     - success: Whether the tool ran without internal errors
@@ -884,7 +929,7 @@ def eval(
     - code: Lean code to execute (e.g., "#eval 2 + 2", "#check Nat.add", "def f := 5")
     - file: Path to a .lean file to execute instead of inline code
     - imports: Additional modules to import (e.g., ["Mathlib.Data.Finset.Basic"])
-    - mathlib: Import Mathlib.Tactic for all standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.)
+    - mathlib: Import Mathlib.Tactic for all standard tactics (simp, ring, omega, linarith, norm_num, decide, aesop, etc.). First call takes ~8-11s for import.
 
     Use either 'code' OR 'file', not both. The tool can handle multi-line code.
 
@@ -984,7 +1029,9 @@ def eval(
                 "type": "code_execution",
                 "code": code_to_execute,
                 "imports": resolved_imports,
-                "messages": _serialize_errors(errors, sanitize_paths=True),
+                "messages": _serialize_errors(
+                    errors, sanitize_paths=True, source_file=file
+                ),
             }
         )
 
@@ -1089,6 +1136,12 @@ def search(
                 )
 
             results = batch_search_declarations(patterns, project_path, **search_params)
+            if isinstance(results, dict):
+                results["note"] = (
+                    "Search covers Mathlib declarations only, "
+                    "not core Lean (e.g., Nat.add_comm, List.map). "
+                    "Use eval with #check to inspect core declarations."
+                )
             return _json(results)
         else:
             try:
@@ -1122,6 +1175,11 @@ def search(
                     "results": serializable_results,
                     "metadata": metadata,
                 }
+                result["note"] = (
+                    "Search covers Mathlib declarations only, "
+                    "not core Lean (e.g., Nat.add_comm, List.map). "
+                    "Use eval with #check to inspect core declarations."
+                )
                 if len(serializable_results) == 0:
                     if filter_namespace and total_found > 0:
                         result["note"] = (
@@ -1133,7 +1191,7 @@ def search(
                         result["note"] = (
                             "No matches found. This search covers Mathlib declarations only, "
                             "not core Lean (e.g., Nat.add_comm, List.map). "
-                            "Try a broader pattern or check the declaration name."
+                            "Try a broader pattern, or use eval with #check to inspect core declarations."
                         )
                 return _json(result)
             except SearchError as e: