leanback 0.1.4__tar.gz → 0.1.6__tar.gz

{leanback-0.1.4 → leanback-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: leanback
-Version: 0.1.4
+Version: 0.1.6
 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.26.0
+Requires-Dist: mcp<2,>=1.26.0
 Requires-Dist: rich>=14.0.0
 Description-Content-Type: text/markdown
 
@@ -140,7 +140,7 @@ search(project="/home/user/lean/myproject", batch="add_assoc,mul_assoc,add_comm"
 
 ## All Tools Are Read-Only
 
-LeanBack never modifies your source files. It only reads project structure and runs Lean to check/evaluate code. File creation and editing is left to your agent's own tools. The one exception: `eval` with `build=True` runs `lake build`, which writes build artifacts to the project's `.lake` directory.
+LeanBack never modifies your source files. It only reads project structure and runs Lean to check/evaluate code. File creation and editing is left to your agent's own tools. Two exceptions write build artifacts to the project's `.lake` directory: `eval` with `build=True` runs `lake build`, and `check` with `file=` compiles out-of-date imports of the checked file, as the Lean language server does.
 
 ## Response Format
 

{leanback-0.1.4 → leanback-0.1.6}/README.md

@@ -121,7 +121,7 @@ search(project="/home/user/lean/myproject", batch="add_assoc,mul_assoc,add_comm"
 
 ## All Tools Are Read-Only
 
-LeanBack never modifies your source files. It only reads project structure and runs Lean to check/evaluate code. File creation and editing is left to your agent's own tools. The one exception: `eval` with `build=True` runs `lake build`, which writes build artifacts to the project's `.lake` directory.
+LeanBack never modifies your source files. It only reads project structure and runs Lean to check/evaluate code. File creation and editing is left to your agent's own tools. Two exceptions write build artifacts to the project's `.lake` directory: `eval` with `build=True` runs `lake build`, and `check` with `file=` compiles out-of-date imports of the checked file, as the Lean language server does.
 
 ## Response Format
 

{leanback-0.1.4 → leanback-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "leanback"
-version = "0.1.4"
+version = "0.1.6"
 description = "MCP server for Lean 4 theorem proving — check, prove, goals, eval, search"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -21,7 +21,7 @@ classifiers = [
 ]
 dependencies = [
     "rich>=14.0.0",
-    "mcp>=1.26.0",
+    "mcp>=1.26.0,<2",
 ]
 
 [dependency-groups]

{leanback-0.1.4 → leanback-0.1.6}/src/leanback/check.py

@@ -23,6 +23,7 @@ def check_file(
     capture_json: bool = True,
     console: Console | None = None,
     preserve_relative: bool = True,
+    stats: dict | None = None,
 ) -> tuple[bool, list[LeanError]]:
     """
     Check a single Lean file for errors.
@@ -33,6 +34,8 @@ def check_file(
         capture_json: Whether to capture output as JSON for better error parsing
         console: Rich console for output (creates a new one if None)
         preserve_relative: Whether to preserve relative paths (True by default)
+        stats: Optional dict that receives run statistics (see
+            ``LeanRunner.run_lean``)
 
     Returns:
         Tuple of (success, errors)
@@ -100,6 +103,7 @@ def check_file(
         project_path=project_path,
         capture_json=capture_json,
         check=False,
+        stats=stats,
     )
 
     # Parse the output for errors
@@ -320,6 +324,7 @@ def check_lean_expr(
     project_path: str | Path | None = None,
     capture_json: bool = True,
     console: Console | None = None,
+    stats: dict | None = None,
 ) -> tuple[bool, list[LeanError]]:
     """
     Check a Lean expression for errors.
@@ -330,6 +335,8 @@ def check_lean_expr(
         project_path: Path to the Lean project (if None, tries to find it)
         capture_json: Whether to capture output as JSON for better error parsing
         console: Rich console for output (creates a new one if None)
+        stats: Optional dict that receives run statistics (see
+            ``LeanRunner.run_lean``)
 
     Returns:
         Tuple of (success, errors)
@@ -356,6 +363,7 @@ def check_lean_expr(
             project_path=project_path,
             capture_json=capture_json,
             console=console,
+            stats=stats,
         )
     finally:
         # Clean up the temporary file

leanback-0.1.6/src/leanback/common/env.py

@@ -0,0 +1,309 @@
+"""
+Lean environment handling utilities.
+
+This module provides functionality for executing Lean commands in the correct environment.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+
+# Timeout (seconds) for `lake setup-file --no-build`. It only reads traces and
+# prints JSON; on a built project it takes 1-3 s.
+SETUP_FILE_TIMEOUT = 60.0
+
+
+def _lib_ext() -> str:
+    if sys.platform == "darwin":
+        return "dylib"
+    if sys.platform == "win32":
+        return "dll"
+    return "so"
+
+
+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. Fallback used when
+    ``lake setup-file`` cannot be consulted.
+    """
+    packages_dir = project_path / ".lake" / "packages"
+    if not packages_dir.is_dir():
+        return []
+    return sorted(packages_dir.glob(f"*/.lake/build/lib/lib*.{_lib_ext()}"))
+
+
+def _has_native_libs(project_path: Path) -> bool:
+    """True if the project or one of its packages has a built shared library.
+
+    Only such projects (``precompileModules``, FFI packages) need plugins or
+    dynlibs, so projects without any skip the ``lake setup-file`` call.
+    """
+    ext = _lib_ext()
+    lake = project_path / ".lake"
+    if any((lake / "build" / "lib").glob(f"lib*.{ext}")):
+        return True
+    return any((lake / "packages").glob(f"*/.lake/build/lib/lib*.{ext}"))
+
+
+def lake_setup_file(
+    project_path: Path, file_path: Path, timeout: float = SETUP_FILE_TIMEOUT
+) -> tuple[list[str], list[str]] | None:
+    """Ask Lake which plugins and dynlibs a file needs.
+
+    Runs ``lake setup-file --no-build`` (what the language server does for an
+    opened file) and returns ``(plugins, dynlibs)`` in Lake's order. Plugins
+    are the precompiled library dylibs of the import closure (projects with
+    ``precompileModules``); passing a project's own dylib without the dylibs
+    of its dependencies crashes Lean, so the order matters. Returns None when
+    Lake fails (unbuilt or out-of-date imports, no lakefile) or times out.
+
+    Handles both JSON schemas: Lake 5 (Lean >= 4.22) prints top-level
+    ``plugins``/``dynlibs``; older versions print ``paths.pluginPaths`` and
+    ``paths.loadDynlibPaths``.
+    """
+    try:
+        result = subprocess.run(
+            ["lake", "setup-file", "--no-build", str(file_path)],
+            cwd=project_path,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+    if result.returncode != 0:
+        return None
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(data, dict):
+        return None
+    paths = data.get("paths")
+    if isinstance(paths, dict):
+        plugins = paths.get("pluginPaths", [])
+        dynlibs = paths.get("loadDynlibPaths", [])
+    else:
+        plugins = data.get("plugins", [])
+        dynlibs = data.get("dynlibs", [])
+    if not isinstance(plugins, list) or not isinstance(dynlibs, list):
+        return None
+    return [str(x) for x in plugins], [str(x) for x in dynlibs]
+
+
+def _max_rss_mb(ru_maxrss: int) -> float:
+    """Convert ``ru_maxrss`` to MB (bytes on macOS, KiB elsewhere)."""
+    if sys.platform == "darwin":
+        return ru_maxrss / (1024 * 1024)
+    return ru_maxrss / 1024
+
+
+def _run_with_rusage(
+    command: list[str],
+    cwd: Path,
+    env: dict[str, str],
+    timeout: float | None,
+) -> tuple[int, str, str, float | None]:
+    """Run a command and return (exit_code, stdout, stderr, max_rss_mb).
+
+    Uses ``os.wait4`` so the peak memory of this child alone is known. Falls
+    back to ``subprocess.run`` (no RSS) where ``wait4`` is unavailable.
+    """
+    if not hasattr(os, "wait4"):
+        result = subprocess.run(
+            command,
+            cwd=cwd,
+            check=False,
+            capture_output=True,
+            text=True,
+            env=env,
+            timeout=timeout,
+        )
+        return result.returncode, result.stdout, result.stderr, None
+
+    with tempfile.TemporaryFile() as out_f, tempfile.TemporaryFile() as err_f:
+        proc = subprocess.Popen(command, cwd=cwd, stdout=out_f, stderr=err_f, env=env)
+        reaped: dict = {}
+
+        def waiter() -> None:
+            _, status, rusage = os.wait4(proc.pid, 0)
+            reaped["status"] = status
+            reaped["rusage"] = rusage
+
+        thread = threading.Thread(target=waiter, daemon=True)
+        thread.start()
+        thread.join(timeout)
+        if thread.is_alive():
+            proc.kill()
+            thread.join()
+            proc.returncode = -9
+            raise subprocess.TimeoutExpired(command, timeout or 0)
+        # Mark the Popen as reaped so it does not try to wait again.
+        proc.returncode = os.waitstatus_to_exitcode(reaped["status"])
+        out_f.seek(0)
+        err_f.seek(0)
+        stdout = out_f.read().decode("utf-8", errors="replace")
+        stderr = err_f.read().decode("utf-8", errors="replace")
+        return (
+            proc.returncode,
+            stdout,
+            stderr,
+            _max_rss_mb(reaped["rusage"].ru_maxrss),
+        )
+
+
+def find_local_modules(project_path: Path, modules: list[str]) -> list[str]:
+    """Filter module names to those with source files in the project.
+
+    A module like ``Foo.Bar`` is local if ``<project>/Foo/Bar.lean`` exists.
+    Dependency modules (e.g. Mathlib.*) and core modules are excluded — they
+    are already built or come from the cache.
+    """
+    local = []
+    for module in modules:
+        source = project_path / (module.replace(".", "/") + ".lean")
+        if source.is_file():
+            local.append(module)
+    return local
+
+
+def build_modules(
+    project_path: Path, modules: list[str], timeout: float = 600
+) -> tuple[bool, str]:
+    """Build the given modules with ``lake build`` in the project directory.
+
+    Returns:
+        Tuple of (success, output). On failure, output contains the
+        combined stdout/stderr from lake.
+    """
+    if not modules:
+        return True, ""
+    try:
+        result = subprocess.run(
+            ["lake", "build", *modules],
+            cwd=project_path,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return False, f"lake build timed out after {timeout:.0f} seconds"
+    output = ((result.stdout or "") + "\n" + (result.stderr or "")).strip()
+    return result.returncode == 0, output
+
+
+class LeanRunner:
+    """
+    Utility for running Lean commands in the appropriate environment.
+    """
+
+    @staticmethod
+    def run_lean(
+        file_path: str | Path,
+        project_path: str | Path | None = None,
+        capture_json: bool = False,
+        check: bool = True,
+        env_vars: dict[str, str] | None = None,
+        timeout: float | None = None,
+        stats: dict | None = None,
+    ) -> tuple[int, str, str]:
+        """
+        Run Lean on a file in the appropriate environment.
+
+        Args:
+            file_path: Path to the Lean file to run
+            project_path: Path to a Lean project (for lake env)
+            capture_json: Whether to request JSON output
+            check: Whether to raise an exception on non-zero exit codes
+            env_vars: Additional environment variables
+            timeout: Timeout in seconds
+            stats: Optional dict that receives run statistics: ``elapsed_s``
+                (wall time of the lean process), ``max_rss_mb`` (peak memory,
+                None if unknown) and ``plugins`` (library files loaded).
+
+        Returns:
+            Tuple of (exit_code, stdout, stderr)
+        """
+        # Convert to Path
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+
+        # We need absolute paths for checking existence internally
+        abs_file_path = file_path.absolute()
+
+        # Determine which path and command to use
+        if project_path:
+            # If a project is specified, use that project's environment
+            project_path = (
+                Path(project_path) if isinstance(project_path, str) else project_path
+            )
+
+            # Always use lake env lean for projects - this ensures proper dependency management
+            command = ["lake", "env", "lean"]
+
+            # Load precompiled libraries (precompileModules) and FFI dynlibs
+            # the way `lake build` does. Lake knows the exact set and order;
+            # projects without any built shared library skip the lookup.
+            if _has_native_libs(project_path):
+                setup = lake_setup_file(project_path, abs_file_path)
+                if setup is not None:
+                    plugins, dynlibs = setup
+                else:
+                    plugins = []
+                    dynlibs = [str(lib) for lib in _find_native_dynlibs(project_path)]
+                for lib in plugins:
+                    command.append(f"--plugin={lib}")
+                for lib in dynlibs:
+                    command.append(f"--load-dynlib={lib}")
+                if stats is not None:
+                    stats["plugins"] = plugins + dynlibs
+
+            if capture_json:
+                command.append("--json")
+            command.append(str(abs_file_path))
+            cwd = project_path
+
+            # Lake automatically handles all dependency paths - no manual LEAN_PATH setup needed
+
+        else:
+            # Default: run directly with lean for files without project context
+            command = ["lean"]
+            if capture_json:
+                command.append("--json")
+            command.append(str(abs_file_path))
+
+            cwd = file_path.parent
+
+        # Set up environment
+        proc_env = os.environ.copy()
+        if env_vars:
+            proc_env.update(env_vars)
+
+        start = time.monotonic()
+        try:
+            exit_code, stdout, stderr, max_rss_mb = _run_with_rusage(
+                command, cwd=cwd, env=proc_env, timeout=timeout
+            )
+        except subprocess.TimeoutExpired:
+            if stats is not None:
+                stats["elapsed_s"] = round(time.monotonic() - start, 3)
+                stats["max_rss_mb"] = None
+            return 124, "", "Lean execution timed out"
+        if stats is not None:
+            stats["elapsed_s"] = round(time.monotonic() - start, 3)
+            stats["max_rss_mb"] = (
+                round(max_rss_mb, 1) if max_rss_mb is not None else None
+            )
+        if check and exit_code != 0:
+            raise subprocess.CalledProcessError(exit_code, command, stdout, stderr)
+        return exit_code, stdout, stderr

leanback-0.1.6/src/leanback/common/stale.py

@@ -0,0 +1,83 @@
+"""
+Detection of out-of-date project modules in a file's import closure.
+
+Lean loads the compiled ``.olean`` of every import. When a project module
+was edited after its ``.olean`` was built, a plain ``lean`` run (and a warm
+language-server worker that opened the file earlier) silently uses the old
+compiled version, so a green check can be a false pass. This module finds
+such modules by comparing modification times of source and ``.olean`` for
+project-local imports, transitively. Lake decides by content hashes, so a
+module whose source was merely touched is reported as well; that is a
+harmless over-approximation.
+"""
+
+import re
+from pathlib import Path
+
+
+_IMPORT_RE = re.compile(r"^\s*import\s+(\S+)", re.MULTILINE)
+
+
+def parse_imports(source: str) -> list[str]:
+    """Return the module names of all ``import`` lines in a Lean source text."""
+    return _IMPORT_RE.findall(source)
+
+
+def module_source(project_path: Path, module: str) -> Path | None:
+    """Path of the source file of a project-local module, or None."""
+    source = project_path / (module.replace(".", "/") + ".lean")
+    return source if source.is_file() else None
+
+
+def module_olean(project_path: Path, module: str) -> Path | None:
+    """Path of the compiled ``.olean`` of a project-local module, or None."""
+    rel = module.replace(".", "/") + ".olean"
+    for lib_dir in ("lean", ""):
+        candidate = project_path / ".lake" / "build" / "lib" / lib_dir / rel
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def find_stale_modules(project_path: Path, modules: list[str]) -> list[str]:
+    """Project-local modules in the import closure of ``modules`` whose
+    source is newer than their ``.olean``.
+
+    Only modules whose source lives in the project are followed; dependencies
+    and core modules are assumed up to date. Modules without any ``.olean``
+    are skipped (Lean reports those as missing anyway).
+    """
+    stale: list[str] = []
+    seen: set[str] = set()
+    queue = list(modules)
+    while queue:
+        module = queue.pop(0)
+        if module in seen:
+            continue
+        seen.add(module)
+        src = module_source(project_path, module)
+        if src is None:
+            continue
+        olean = module_olean(project_path, module)
+        if olean is not None:
+            try:
+                if src.stat().st_mtime > olean.stat().st_mtime:
+                    stale.append(module)
+            except OSError:
+                pass
+        try:
+            queue.extend(
+                parse_imports(src.read_text(encoding="utf-8", errors="replace"))
+            )
+        except OSError:
+            pass
+    return stale
+
+
+def find_stale_imports(project_path: Path, file_path: Path) -> list[str]:
+    """Stale project-local modules in the import closure of a file."""
+    try:
+        source = file_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+    return find_stale_modules(project_path, parse_imports(source))

{leanback-0.1.4 → leanback-0.1.6}/src/leanback/common/warm.py

@@ -148,6 +148,15 @@ _registry = _WorkerRegistry()
 atexit.register(_registry.shutdown_all)
 
 
+def discard_project(project_path: Path) -> None:
+    """Shut down the project's warm worker so the next check starts fresh.
+
+    Used when a project module in the import closure is out of date: a new
+    ``lake serve`` worker rebuilds stale imports when it opens the file.
+    """
+    _registry.discard(project_path.resolve())
+
+
 def check_file_warm(
     project_path: Path, file_path: Path, timeout: float = 600.0
 ) -> list[dict] | None:

{leanback-0.1.4 → leanback-0.1.6}/src/leanback/mcp_server.py

@@ -57,8 +57,9 @@ mcp = FastMCP(
     instructions="""\
 LeanBack provides tools for Lean 4 theorem proving. All tools are read-only for source files — \
 they never modify your .lean files. Use your own file tools to create/edit .lean files, then use \
-LeanBack to verify them. (Exception: eval with build=true compiles project modules, writing build \
-artifacts to .lake/.)
+LeanBack to verify them. Two operations write build artifacts to .lake/: eval with build=true \
+compiles project modules, and check(file=...) compiles out-of-date imports of the checked file \
+(like the Lean language server does).
 
 ## Getting Started
 1. Call project_info(project="/path/to/project") to check if a project is ready
@@ -428,6 +429,34 @@ def project_info(project: str) -> str:
         )
 
 
+def _add_run_stats(result: dict, stats: dict) -> None:
+    """Attach peak memory and loaded plugins of a cold Lean run."""
+    if stats.get("max_rss_mb") is not None:
+        result["max_rss_mb"] = stats["max_rss_mb"]
+    if stats.get("plugins"):
+        result["plugins_loaded"] = [Path(p).name for p in stats["plugins"]]
+
+
+def _stale_import_warnings(stale: list[str], file_name: str) -> list:
+    """One warning per out-of-date project module used by a cold check."""
+    from leanback.common.errors import LeanError
+
+    return [
+        LeanError(
+            file_name=file_name,
+            line=0,
+            column=0,
+            severity="warning",
+            message=(
+                f"Import {module} is out of date: its source is newer than its "
+                f"compiled .olean, so this check used the OLD compiled version."
+            ),
+            suggestion=f"Run `lake build {module}` in the project, then check again.",
+        )
+        for module in stale
+    ]
+
+
 @mcp.tool()
 @_with_elapsed
 def check(
@@ -450,7 +479,7 @@ def check(
 
     Parameters:
     - project: Absolute path to the Lean project directory (e.g., "/home/user/lean/myproject")
-    - file: Path to a .lean file within the project (e.g., "Basic.lean", "src/Logic.lean"). Repeated checks of the same file reuse a warm Lean server: the first check pays the import cost (~20-30s with Mathlib), subsequent checks after edits take seconds as long as the file's import lines are unchanged.
+    - file: Path to a .lean file within the project (e.g., "Basic.lean", "src/Logic.lean"). Repeated checks of the same file reuse a warm Lean server: the first check pays the import cost (~20-30s with Mathlib), subsequent checks after edits take seconds as long as the file's import lines are unchanged. Like the Lean language server, a file check compiles out-of-date imports of THIS project when it opens the file (writing to .lake/build); the result lists them under 'imports_rebuilt'.
     - 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"]). First Mathlib import takes ~20-30s.
@@ -461,6 +490,7 @@ def check(
     - severity: "error", "warning", or "info" (e.g., output from #check)
     - message: The error or output message
     - suggestion: Helpful hint to fix the issue (when available)
+    Other fields: 'elapsed_ms' (whole call); 'engine' (file checks only: "warm" = the persistent Lean server, the normal case, which rebuilds out-of-date imports itself; "cold" = a fresh lean process, used when the warm server fails and for all expression checks); 'max_rss_mb' (peak memory of the Lean process, cold runs only); 'plugins_loaded' (cold runs on projects with precompileModules only: the precompiled libraries passed to Lean, which may include toolchain libraries such as libLake_shared); 'stale_imports' (cold runs only: project modules whose source is newer than their compiled .olean, so the check used the OLD version; run `lake build` and check again); 'imports_rebuilt' (warm file checks only: out-of-date project modules the Lean server recompiled before checking).
 
     Examples:
     - Verify project compiles: check(project="/home/user/lean/myproject")
@@ -524,12 +554,18 @@ def check(
             ):
                 expr = f"#check ({expr_stripped})"
 
+            from leanback.common.stale import find_stale_modules
+
+            stats: dict = {}
             success, errors = check_lean_expr(
                 expr=expr,
                 imports=imports or [],
                 project_path=project_path,
                 console=console,
+                stats=stats,
             )
+            stale = find_stale_modules(project_path, imports or [])
+            errors.extend(_stale_import_warnings(stale, "<inline>"))
 
             error_count = sum(1 for e in errors if e.severity == "error")
             warning_count = sum(1 for e in errors if e.severity == "warning")
@@ -547,6 +583,9 @@ def check(
                     "total_info": info_count,
                 },
             }
+            _add_run_stats(result, stats)
+            if stale:
+                result["stale_imports"] = stale
             return _json(result)
 
         # Case 2: Check a specific file
@@ -587,9 +626,20 @@ def check(
             # repeated checks of the same file fast (the import environment
             # stays in memory). Falls back to the cold path on any failure.
             from leanback.common.errors import lsp_diagnostics_to_errors
-            from leanback.common.warm import check_file_warm
+            from leanback.common.stale import find_stale_imports
+            from leanback.common.warm import check_file_warm, discard_project
+
+            # Project modules edited after their .olean was built: a warm
+            # worker that opened the file earlier would keep using the old
+            # compiled version, so it is replaced; a fresh lake serve worker
+            # rebuilds stale imports when it opens the file. The cold path
+            # cannot rebuild and reports them instead.
+            stale = find_stale_imports(project_path, file_path)
+            if stale:
+                discard_project(project_path)
 
             engine = "cold"
+            stats: dict = {}
             warm_diags = check_file_warm(project_path, file_path)
             if warm_diags is not None:
                 errors = lsp_diagnostics_to_errors(warm_diags, str(display_path))
@@ -600,7 +650,10 @@ def check(
                     file_path=file_path,
                     project_path=project_path,
                     console=console,
+                    stats=stats,
                 )
+            if stale and engine == "cold":
+                errors.extend(_stale_import_warnings(stale, str(display_path)))
 
             error_count = sum(1 for e in errors if e.severity == "error")
             warning_count = sum(1 for e in errors if e.severity == "warning")
@@ -619,6 +672,12 @@ def check(
                     "files_checked": 1,
                 },
             }
+            _add_run_stats(result, stats)
+            if stale:
+                if engine == "warm":
+                    result["imports_rebuilt"] = stale
+                else:
+                    result["stale_imports"] = stale
             if file_path.name == "lakefile.lean" and not success:
                 result["note"] = (
                     "lakefile.lean uses Lake DSL which may produce errors "

leanback-0.1.4/src/leanback/common/env.py

@@ -1,157 +0,0 @@
-"""
-Lean environment handling utilities.
-
-This module provides functionality for executing Lean commands in the correct environment.
-"""
-
-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}"))
-
-
-def find_local_modules(project_path: Path, modules: list[str]) -> list[str]:
-    """Filter module names to those with source files in the project.
-
-    A module like ``Foo.Bar`` is local if ``<project>/Foo/Bar.lean`` exists.
-    Dependency modules (e.g. Mathlib.*) and core modules are excluded — they
-    are already built or come from the cache.
-    """
-    local = []
-    for module in modules:
-        source = project_path / (module.replace(".", "/") + ".lean")
-        if source.is_file():
-            local.append(module)
-    return local
-
-
-def build_modules(
-    project_path: Path, modules: list[str], timeout: float = 600
-) -> tuple[bool, str]:
-    """Build the given modules with ``lake build`` in the project directory.
-
-    Returns:
-        Tuple of (success, output). On failure, output contains the
-        combined stdout/stderr from lake.
-    """
-    if not modules:
-        return True, ""
-    try:
-        result = subprocess.run(
-            ["lake", "build", *modules],
-            cwd=project_path,
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
-        return False, f"lake build timed out after {timeout:.0f} seconds"
-    output = ((result.stdout or "") + "\n" + (result.stderr or "")).strip()
-    return result.returncode == 0, output
-
-
-class LeanRunner:
-    """
-    Utility for running Lean commands in the appropriate environment.
-    """
-
-    @staticmethod
-    def run_lean(
-        file_path: str | Path,
-        project_path: str | Path | None = None,
-        capture_json: bool = False,
-        check: bool = True,
-        env_vars: dict[str, str] | None = None,
-        timeout: float | None = None,
-    ) -> tuple[int, str, str]:
-        """
-        Run Lean on a file in the appropriate environment.
-
-        Args:
-            file_path: Path to the Lean file to run
-            project_path: Path to a Lean project (for lake env)
-            capture_json: Whether to request JSON output
-            check: Whether to raise an exception on non-zero exit codes
-            env_vars: Additional environment variables
-            timeout: Timeout in seconds
-
-        Returns:
-            Tuple of (exit_code, stdout, stderr)
-        """
-        # Convert to Path
-        if isinstance(file_path, str):
-            file_path = Path(file_path)
-
-        # We need absolute paths for checking existence internally
-        abs_file_path = file_path.absolute()
-
-        # Determine which path and command to use
-        if project_path:
-            # If a project is specified, use that project's environment
-            project_path = (
-                Path(project_path) if isinstance(project_path, str) else project_path
-            )
-
-            # 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))
-            cwd = project_path
-
-            # Lake automatically handles all dependency paths - no manual LEAN_PATH setup needed
-
-        else:
-            # Default: run directly with lean for files without project context
-            command = ["lean"]
-            if capture_json:
-                command.append("--json")
-            command.append(str(abs_file_path))
-
-            cwd = file_path.parent
-
-        # Set up environment
-        proc_env = os.environ.copy()
-        if env_vars:
-            proc_env.update(env_vars)
-
-        try:
-            result = subprocess.run(
-                command,
-                cwd=cwd,
-                check=check,
-                capture_output=True,
-                text=True,
-                env=proc_env,
-                timeout=timeout,
-            )
-            return result.returncode, result.stdout, result.stderr
-        except subprocess.CalledProcessError as e:
-            return e.returncode, e.stdout, e.stderr
-        except subprocess.TimeoutExpired:
-            return 124, "", "Lean execution timed out"