leanback 0.1.0__py3-none-any.whl

leanback/common/project_context.py

@@ -0,0 +1,276 @@
+"""
+Project context management for LeanBack tools.
+
+This module provides a unified context for working with Lean projects,
+handling path resolution, validation, and environment configuration.
+"""
+
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+from leanback.common.path_manager import PathManager
+
+
+class ProjectContext:
+    """
+    Context for working with Lean projects.
+
+    This class provides a unified interface for working with Lean projects,
+    handling path resolution, validation, and environment configuration.
+    It uses PathManager for path-related operations.
+    """
+
+    def __init__(
+        self,
+        project_path: str | Path | None = None,
+        console: Console | None = None,
+    ):
+        """
+        Initialize a project context.
+
+        Args:
+            project_path: Path to the project directory (string or Path)
+            console: Console for output
+        """
+        self.path_manager = PathManager()
+        self.console = console or Console()
+        self.project_path = self._resolve_project_path(project_path)
+        self._config = None
+        self._errors = []
+
+    def _resolve_project_path(self, path: str | Path | None) -> Path | None:
+        """
+        Resolve project path from an absolute path.
+
+        Args:
+            path: Absolute path to a Lean project directory
+
+        Returns:
+            Resolved absolute Path object or None if not found
+        """
+        if path is None:
+            return None
+
+        potential_path = Path(str(path))
+        if (
+            potential_path.is_absolute()
+            and potential_path.exists()
+            and potential_path.is_dir()
+        ):
+            return potential_path.absolute()
+
+        return None
+
+    def _get_config(self) -> dict[str, Any] | None:
+        """
+        Get the lakefile.toml configuration with caching.
+
+        Returns:
+            Dict with the parsed lakefile.toml or None if not found
+        """
+        if self._config is not None:
+            return self._config
+
+        if not self.project_path:
+            return None
+
+        lakefile_path = self.project_path / "lakefile.toml"
+        if not lakefile_path.exists():
+            return None
+
+        try:
+            with open(lakefile_path, "rb") as f:
+                self._config = tomllib.load(f)
+            return self._config
+        except Exception:
+            return None
+
+    def is_valid(self) -> bool:
+        """
+        Check if this context has a valid project path.
+
+        Returns:
+            True if the project path is valid, False otherwise
+        """
+        if not self.project_path:
+            return False
+
+        return self.path_manager.is_valid_project(self.project_path)
+
+    def validate(self) -> tuple[bool, list[str]]:
+        """
+        Validate project structure and return (success, errors).
+
+        Returns:
+            Tuple of (success, list of error messages)
+        """
+        self._errors = []
+
+        # Check if the path exists
+        if not self.project_path:
+            self._errors.append("No project path provided or found.")
+            return False, self._errors
+
+        if not self.project_path.exists():
+            self._errors.append(
+                f"Project directory '{self.project_path}' does not exist."
+            )
+            return False, self._errors
+
+        # Check for lean-toolchain file
+        toolchain_path = self.project_path / "lean-toolchain"
+        if not toolchain_path.exists():
+            self._errors.append(
+                "No lean-toolchain file found. Create one with the desired Lean version "
+                "or create a project with: lake +leanprover-community/mathlib4:lean-toolchain new <name> math"
+            )
+        else:
+            # Verify toolchain file content
+            with open(toolchain_path) as f:
+                toolchain_content = f.read().strip()
+                if not toolchain_content.startswith("leanprover"):
+                    self._errors.append(
+                        f"Invalid lean-toolchain format. Expected 'leanprover/lean4:...' but got '{toolchain_content}'. "
+                        "Update the file with a valid Lean 4 version."
+                    )
+
+        # Check for lakefile (either .toml or .lean)
+        lakefile_toml = self.project_path / "lakefile.toml"
+        lakefile_lean = self.project_path / "lakefile.lean"
+
+        if not lakefile_toml.exists() and not lakefile_lean.exists():
+            self._errors.append(
+                "No lakefile.toml or lakefile.lean found. Create one "
+                "or create a project with: lake +leanprover-community/mathlib4:lean-toolchain new <name> math"
+            )
+
+        # If using lakefile.toml, check for basic configuration
+        if lakefile_toml.exists():
+            config = self._get_config()
+            if config:
+                # Check for project name (top-level or under [package])
+                has_name = "name" in config or "name" in config.get("package", {})
+                if not has_name:
+                    self._errors.append("No 'name' field in lakefile.toml.")
+
+                # Check for Lean library configuration
+                if "lean_lib" not in config:
+                    self._errors.append("No 'lean_lib' entry in lakefile.toml.")
+                elif not config["lean_lib"]:
+                    self._errors.append("Empty 'lean_lib' array in lakefile.toml.")
+            else:
+                self._errors.append("Could not parse lakefile.toml.")
+
+        return len(self._errors) == 0, self._errors
+
+    def resolve_file_path(self, file_path: str | Path) -> Path | None:
+        """
+        Resolve a file path relative to the project with smart resolution.
+
+        This method tries various strategies to find the file:
+        1. Exact path (absolute or relative to project)
+        2. Common project structure patterns
+        3. Search for the file name in the project
+
+        Args:
+            file_path: The file path to resolve (can be relative or just a filename)
+
+        Returns:
+            Resolved absolute Path or None if not found
+        """
+        if not self.project_path:
+            return None
+
+        # Convert to Path
+        file_path = Path(file_path)
+
+        # If already absolute and exists, return it
+        if file_path.is_absolute() and file_path.exists():
+            return file_path
+
+        # Try exact relative path from project root
+        candidate = self.project_path / file_path
+        if candidate.exists():
+            return candidate
+
+        # Get the file name without directory
+        file_name = file_path.name
+
+        # Common patterns to try
+        patterns = []
+
+        # If it's just a filename (no directory), try common locations
+        if str(file_path) == file_name:
+            # Try ProjectName/filename pattern
+            project_name = self.project_path.name
+            patterns.extend(
+                [
+                    self.project_path / project_name / file_name,
+                    self.project_path / "src" / file_name,
+                    self.project_path / "lib" / file_name,
+                ]
+            )
+
+        # Check all patterns
+        for pattern in patterns:
+            if pattern.exists():
+                return pattern
+
+        # If still not found, search for the file in the project
+        # (excluding .lake directory)
+        try:
+            for found_file in self.project_path.rglob(file_name):
+                # Skip files in .lake directory
+                if ".lake" not in found_file.parts:
+                    return found_file
+        except Exception:
+            pass
+
+        return None
+
+    def suggest_file_path(self, file_path: str | Path) -> list[str]:
+        """
+        Suggest possible file paths when the exact path is not found.
+
+        Args:
+            file_path: The file path that wasn't found
+
+        Returns:
+            List of suggestions (relative paths from project root)
+        """
+        if not self.project_path:
+            return []
+
+        suggestions = []
+        file_name = Path(file_path).name
+
+        # Remove .lean extension for matching
+        base_name = file_name.replace(".lean", "")
+
+        try:
+            # Find similar files
+            for found_file in self.project_path.rglob("*.lean"):
+                # Skip files in .lake directory
+                if ".lake" in found_file.parts:
+                    continue
+
+                found_base = found_file.stem
+
+                # Check for similar names (case-insensitive)
+                if (
+                    base_name.lower() in found_base.lower()
+                    or found_base.lower() in base_name.lower()
+                ):
+                    rel_path = found_file.relative_to(self.project_path)
+                    suggestions.append(str(rel_path))
+
+                # Stop after finding 5 suggestions
+                if len(suggestions) >= 5:
+                    break
+        except Exception:
+            pass
+
+        return suggestions

leanback/common/util.py

@@ -0,0 +1,72 @@
+"""
+Utility functions for the LeanBack tools.
+
+This module contains common utility functions used across the tools.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+
+def create_temp_file(content: str, suffix: str = ".lean") -> Path:
+    """
+    Create a temporary file with the given content.
+
+    Args:
+        content: Content to write to the file
+        suffix: File suffix
+
+    Returns:
+        Path to the temporary file
+    """
+    fd, temp_path = tempfile.mkstemp(suffix=suffix)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        return Path(temp_path)
+    except Exception:
+        # Clean up if something goes wrong
+        os.unlink(temp_path)
+        raise
+
+
+def build_proof_content(
+    theorem: str,
+    tactics: list[str],
+    imports: list[str],
+) -> tuple[str, dict[int, int]]:
+    """Build a Lean proof file from theorem, tactics, and imports.
+
+    Returns:
+        (content, line_to_tactic_map) where line_to_tactic_map maps
+        1-based line numbers to 0-based tactic indices. Multi-line
+        tactics get entries for each line they span.
+    """
+    lines: list[str] = []
+
+    # Imports
+    for imp in imports:
+        lines.append(f"import {imp}")
+    if imports:
+        lines.append("")  # blank separator
+
+    # Theorem statement — wrap bare propositions
+    theorem_stmt = theorem.strip()
+    if not any(
+        theorem_stmt.startswith(kw + " ") for kw in ["theorem", "lemma", "example"]
+    ):
+        theorem_stmt = f"theorem test_theorem : {theorem_stmt}"
+    lines.append(f"{theorem_stmt} := by")
+
+    # Tactics with line mapping (1-based line numbers, 0-based tactic indices)
+    line_to_tactic: dict[int, int] = {}
+    for i, tactic in enumerate(tactics):
+        tactic_lines = tactic.split("\n")
+        for tl in tactic_lines:
+            lines.append(f"  {tl}")
+            line_number = len(lines)  # 1-based (len after append)
+            line_to_tactic[line_number] = i
+
+    content = "\n".join(lines) + "\n"
+    return content, line_to_tactic

leanback/goals.py

@@ -0,0 +1,167 @@
+"""
+Implementation of the leanback-goals tool.
+
+This module provides goal state inspection during Lean proof construction.
+"""
+
+import os
+from pathlib import Path
+
+from rich.console import Console
+
+from leanback.common.util import build_proof_content, create_temp_file
+
+
+def parse_goals(data: str) -> list[str]:
+    """Parse Lean's 'unsolved goals' data into individual goal strings.
+
+    Strips the 'unsolved goals' prefix and splits on blank lines.
+    Each chunk is one goal (hypotheses + ⊢ conclusion).
+
+    Args:
+        data: The raw data string from a Tactic.unsolvedGoals message.
+
+    Returns:
+        List of goal strings.
+    """
+    text = data.strip()
+
+    # Strip "unsolved goals\n" prefix if present
+    prefix = "unsolved goals\n"
+    if text.startswith(prefix):
+        text = text[len(prefix) :]
+    elif text == "unsolved goals":
+        return []
+
+    if not text:
+        return []
+
+    # Split on blank lines (double newline)
+    raw_goals = text.split("\n\n")
+    return [g.strip() for g in raw_goals if g.strip()]
+
+
+def extract_goals(
+    theorem: str,
+    tactics: list[str] | None,
+    imports: list[str] | None,
+    project_path: Path,
+    console: Console,
+) -> dict:
+    """Run a partial proof and return the goal state.
+
+    Args:
+        theorem: Theorem statement.
+        tactics: Tactic list (None/empty for initial goal).
+        imports: Module imports.
+        project_path: Path to Lean project.
+        console: Rich console for logging.
+
+    Returns:
+        Structured dict with success, status, goals, etc.
+    """
+    from leanback.check import check_file
+
+    effective_tactics = list(tactics) if tactics else []
+    use_skip = len(effective_tactics) == 0
+
+    # Use 'skip' for empty tactics to avoid syntax error from empty by block
+    build_tactics = ["skip"] if use_skip else effective_tactics
+
+    content, line_to_tactic = build_proof_content(
+        theorem=theorem,
+        tactics=build_tactics,
+        imports=imports or [],
+    )
+
+    temp_file = create_temp_file(content)
+
+    try:
+        success, errors = check_file(
+            file_path=temp_file,
+            project_path=project_path,
+            console=console,
+        )
+    finally:
+        try:
+            os.unlink(temp_file)
+        except OSError:
+            pass
+
+    # Classify output using kind field
+    unsolved_goals_msgs = [e for e in errors if e.kind == "Tactic.unsolvedGoals"]
+    sorry_msgs = [e for e in errors if e.kind == "hasSorry"]
+    other_errors = [
+        e for e in errors if e.severity == "error" and e.kind != "Tactic.unsolvedGoals"
+    ]
+
+    tactics_count = len(effective_tactics)
+
+    # Case 1: Proof complete (no errors)
+    if success and not sorry_msgs:
+        return {
+            "success": True,
+            "status": "complete",
+            "tactics_applied": tactics_count,
+            "goals": [],
+        }
+
+    # Case 2: Sorry used (proof "complete" but not valid)
+    if success and sorry_msgs:
+        return {
+            "success": True,
+            "status": "complete",
+            "tactics_applied": tactics_count,
+            "goals": [],
+            "sorry_used": True,
+        }
+
+    # Case 3: Goals remain (unsolved goals, no other errors)
+    if unsolved_goals_msgs and not other_errors:
+        goals = []
+        for msg in unsolved_goals_msgs:
+            goals.extend(parse_goals(msg.message))
+        return {
+            "success": True,
+            "status": "incomplete",
+            "tactics_applied": tactics_count,
+            "goals": goals,
+        }
+
+    # Case 4: Tactic or setup error
+    # Try to identify which tactic failed using line mapping
+    failed_tactic_info = None
+    goals_from_unsolved = []
+
+    if unsolved_goals_msgs:
+        for msg in unsolved_goals_msgs:
+            goals_from_unsolved.extend(parse_goals(msg.message))
+
+    for err in other_errors:
+        if err.line in line_to_tactic and not use_skip:
+            tactic_idx = line_to_tactic[err.line]
+            failed_tactic_info = {
+                "index": tactic_idx,
+                "tactic": effective_tactics[tactic_idx],
+                "error": err.message,
+            }
+            break
+
+    result: dict = {
+        "success": False,
+        "status": "error",
+        "tactics_applied": failed_tactic_info["index"] if failed_tactic_info else 0,
+        "goals": goals_from_unsolved,
+    }
+
+    if failed_tactic_info:
+        result["failed_tactic"] = failed_tactic_info
+
+    # Include raw messages for debugging
+    result["messages"] = [
+        {"severity": e.severity, "message": e.message}
+        for e in errors
+        if e.severity == "error"
+    ]
+
+    return result

leanback/mathlib_search.py

@@ -0,0 +1,190 @@
+"""
+Mathlib search functionality for LeanBack.
+
+Provides simple regex-based search of Mathlib declarations in your project.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .mathlib_search_simple import SimpleMathlibSearch
+
+
+@dataclass
+class SearchResult:
+    """Structured search result."""
+
+    name: str
+    type_signature: str
+    module: str | None = None
+    suggested_import: str | None = None
+
+
+class SearchError(Exception):
+    """Search error with suggestions."""
+
+    def __init__(
+        self, message: str, error_code: str, suggestions: list[str] | None = None
+    ):
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code
+        self.suggestions = suggestions or []
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON output."""
+        return {
+            "error": True,
+            "message": self.message,
+            "error_code": self.error_code,
+            "suggestions": self.suggestions,
+        }
+
+
+def search_mathlib_declarations(
+    pattern: str,
+    project_path: Path,
+    timeout: int = 30,  # Kept for compatibility
+    filter_namespace: str | None = None,  # Kept for compatibility
+    exclude_internal: bool = True,  # Kept for compatibility
+    max_results: int = 50,
+    use_minimal_import: bool = False,  # Kept for compatibility
+    backend: str = "auto",  # Kept for compatibility
+) -> tuple[list[SearchResult], int]:
+    """
+    Search Mathlib declarations in the project.
+
+    Args:
+        pattern: Search pattern (exact name, substring, or regex)
+        project_path: Path to Lean project
+        max_results: Maximum results to return
+        Other args kept for backwards compatibility
+
+    Returns:
+        Tuple of (results list, total_found count before truncation)
+    """
+    total_scanned = 0
+    try:
+        # Use simple search on project's Mathlib
+        simple_search = SimpleMathlibSearch(project_path)
+        # When post-filters are active, scan without limit so filtering
+        # doesn't discard matches that happen to appear after max_results.
+        has_post_filters = bool(filter_namespace) or exclude_internal
+        scan_limit = 10000 if has_post_filters else max_results
+        simple_results = simple_search.search(pattern, scan_limit)
+        total_scanned = getattr(simple_search, "_last_total_found", 0)
+
+        # Apply filters if provided
+        if filter_namespace:
+            simple_results = [
+                r
+                for r in simple_results
+                if r.name.startswith(filter_namespace + ".")
+                or r.file.startswith(filter_namespace.replace(".", "/"))
+            ]
+
+        if exclude_internal:
+            simple_results = [
+                r
+                for r in simple_results
+                if not (
+                    r.name.endswith("'")
+                    or r.name.endswith(".match")
+                    or r.name.endswith(".proof")
+                    or r.name.endswith(".rec")
+                    or r.name.endswith(".mk")
+                    or "._" in r.name
+                )
+            ]
+
+        # Rank results: exact matches first, then prefix, then rest
+        query_lower = pattern.lower()
+        query_suffix = "." + query_lower  # e.g. ".add_comm"
+
+        def _rank(r):
+            name_lower = r.name.lower()
+            # Exact match (e.g. "add_comm" or "Nat.add_comm" for query "add_comm")
+            if name_lower == query_lower or name_lower.endswith(query_suffix):
+                return 0
+            # Name starts with query (prefix match)
+            if name_lower.startswith(query_lower):
+                return 1
+            # Last component starts with query
+            last = name_lower.rsplit(".", 1)[-1]
+            if last.startswith(query_lower):
+                return 1
+            return 2
+
+        simple_results.sort(key=_rank)
+
+        # Truncate to requested max_results after filtering and ranking
+        simple_results = simple_results[:max_results]
+
+        # Convert to SearchResult format
+        results = []
+        for sr in simple_results:
+            # Convert file path to module name
+            module = sr.file.replace("/", ".").replace(".lean", "")
+            if module.startswith("Mathlib."):
+                import_stmt = f"import {module}"
+            else:
+                import_stmt = f"import Mathlib.{module}"
+
+            results.append(
+                SearchResult(
+                    name=sr.name,
+                    type_signature=sr.text,
+                    module=module,
+                    suggested_import=import_stmt,
+                )
+            )
+
+        return results, total_scanned
+
+    except Exception as e:
+        raise SearchError(
+            f"Search failed: {e!s}",
+            "SEARCH_ERROR",
+            ["Check that project has Mathlib", "Try a simpler pattern"],
+        ) from e
+
+
+def batch_search_declarations(
+    patterns: list[str], project_path: Path, **kwargs
+) -> dict:
+    """
+    Search multiple patterns efficiently.
+
+    Args:
+        patterns: List of search patterns
+        project_path: Path to project
+        **kwargs: Additional arguments passed to search
+
+    Returns:
+        Dictionary mapping patterns to results or errors
+    """
+    results = {}
+
+    for pattern in patterns:
+        try:
+            search_results, total_found = search_mathlib_declarations(
+                pattern, project_path, **kwargs
+            )
+            results[pattern] = {
+                "success": True,
+                "results": [
+                    {
+                        "name": r.name,
+                        "type_signature": r.type_signature,
+                        "module": r.module,
+                        "suggested_import": r.suggested_import,
+                    }
+                    for r in search_results
+                ],
+                "count": len(search_results),
+                "total_found": total_found,
+            }
+        except SearchError as e:
+            results[pattern] = e.to_dict()
+
+    return results