crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/mixins/__init__.py

@@ -1,3 +0,0 @@
-from .error_handling import ErrorHandlingMixin
-
-__all__ = ["ErrorHandlingMixin"]

crackerjack/mixins/error_handling.py

@@ -1,145 +0,0 @@
-import subprocess
-import typing as t
-from pathlib import Path
-
-from rich.console import Console
-
-
-class ErrorHandlingMixin:
-    def __init__(self) -> None:
-        self.console: Console
-        self.logger: t.Any
-
-    def handle_subprocess_error(
-        self,
-        error: Exception,
-        command: list[str],
-        operation_name: str,
-        critical: bool = False,
-    ) -> bool:
-        error_msg = f"{operation_name} failed: {error}"
-
-        if hasattr(self, "logger") and self.logger:
-            self.logger.error(
-                error_msg,
-                command=" ".join(command),
-                error_type=type(error).__name__,
-                critical=critical,
-            )
-
-        if critical:
-            self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
-        else:
-            self.console.print(f"[red]❌ {error_msg}[/red]")
-
-        return False
-
-    def handle_file_operation_error(
-        self,
-        error: Exception,
-        file_path: Path,
-        operation: str,
-        critical: bool = False,
-    ) -> bool:
-        error_msg = f"Failed to {operation} {file_path}: {error}"
-
-        if hasattr(self, "logger") and self.logger:
-            self.logger.error(
-                error_msg,
-                file_path=str(file_path),
-                operation=operation,
-                error_type=type(error).__name__,
-                critical=critical,
-            )
-
-        if critical:
-            self.console.print(f"[red]🚨 CRITICAL: {error_msg}[/red]")
-        else:
-            self.console.print(f"[red]❌ {error_msg}[/red]")
-
-        return False
-
-    def handle_timeout_error(
-        self,
-        operation_name: str,
-        timeout_seconds: float,
-        command: list[str] | None = None,
-    ) -> bool:
-        error_msg = f"{operation_name} timed out after {timeout_seconds}s"
-
-        if hasattr(self, "logger") and self.logger:
-            self.logger.warning(
-                error_msg,
-                timeout=timeout_seconds,
-                command=" ".join(command) if command else None,
-            )
-
-        self.console.print(f"[yellow]⏰ {error_msg}[/yellow]")
-
-        return False
-
-    def log_operation_success(
-        self,
-        operation_name: str,
-        details: dict[str, t.Any] | None = None,
-    ) -> None:
-        if hasattr(self, "logger") and self.logger:
-            self.logger.info(
-                f"{operation_name} completed successfully", **(details or {})
-            )
-
-    def validate_required_tools(
-        self,
-        tools: dict[str, str],
-        operation_name: str,
-    ) -> bool:
-        missing_tools = []
-
-        for tool_name, command in tools.items():
-            try:
-                subprocess.run(
-                    [command, "--version"],
-                    capture_output=True,
-                    check=True,
-                    timeout=5,
-                )
-            except (
-                subprocess.CalledProcessError,
-                subprocess.TimeoutExpired,
-                FileNotFoundError,
-            ):
-                missing_tools.append(tool_name)
-
-        if missing_tools:
-            error_msg = f"Missing required tools for {operation_name}: {', '.join(missing_tools)}"
-
-            if hasattr(self, "logger") and self.logger:
-                self.logger.error(
-                    error_msg,
-                    missing_tools=missing_tools,
-                    operation=operation_name,
-                )
-
-            self.console.print(f"[red]❌ {error_msg}[/red]")
-            return False
-
-        return True
-
-    def safe_get_attribute(
-        self,
-        obj: t.Any,
-        attribute: str,
-        default: t.Any = None,
-        operation_name: str = "attribute access",
-    ) -> t.Any:
-        try:
-            return getattr(obj, attribute, default)
-        except Exception as e:
-            if hasattr(self, "logger") and self.logger:
-                self.logger.warning(
-                    f"Error accessing {attribute} during {operation_name}: {e}",
-                    attribute=attribute,
-                    operation=operation_name,
-                    error_type=type(e).__name__,
-                )
-            return default

crackerjack/services/config.py

@@ -1,358 +0,0 @@
-import subprocess
-import typing as t
-from pathlib import Path
-
-from rich.console import Console
-
-from crackerjack.dynamic_config import DynamicConfigGenerator, generate_config_for_mode
-from crackerjack.models.protocols import OptionsProtocol
-
-
-class ConfigurationService:
-    def __init__(self, console: Console, pkg_path: Path) -> None:
-        self.console = console
-        self.pkg_path = pkg_path
-        # Extract package directory name from the pkg_path and sanitize it
-        package_directory = pkg_path.name if pkg_path != Path.cwd() else None
-        if package_directory:
-            package_directory = package_directory.replace("-", "_")
-        self.config_generator = DynamicConfigGenerator(package_directory)
-
-    def update_precommit_config(self, options: OptionsProtocol) -> bool:
-        try:
-            mode = self._determine_config_mode(options)
-            # Extract package directory name from the pkg_path
-            package_directory = (
-                self.pkg_path.name if self.pkg_path != Path.cwd() else None
-            )
-            config_temp_path = generate_config_for_mode(
-                mode, package_directory=package_directory
-            )
-            if not config_temp_path:
-                self.console.print("[yellow]⚠️ No configuration generated[/ yellow]")
-                return False
-
-            config_file = self.pkg_path / ".pre-commit-config.yaml"
-            config_content = config_temp_path.read_text()
-
-            from crackerjack.services.filesystem import FileSystemService
-
-            config_content = FileSystemService.clean_trailing_whitespace_and_newlines(
-                config_content
-            )
-            config_file.write_text(config_content)
-
-            self._temp_config_path = config_temp_path
-            self.console.print("[green]✅[/ green] Pre-commit configuration generated")
-
-            if getattr(options, "update_precommit", False):
-                success = self._run_precommit_autoupdate()
-                if success:
-                    self.console.print("[green]✅[/ green] Pre-commit hooks updated")
-                else:
-                    self.console.print(
-                        "[yellow]⚠️[/ yellow] Pre-commit autoupdate had issues"
-                    )
-
-                self._update_dynamic_config_versions()
-
-            return True
-        except Exception as e:
-            self.console.print(
-                f"[red]❌[/ red] Failed to generate pre-commit config: {e}",
-            )
-            return False
-
-    def get_temp_config_path(self) -> str | None:
-        path = getattr(self, "_temp_config_path", None)
-        return str(path) if path else None
-
-    def _determine_config_mode(self, options: OptionsProtocol) -> str:
-        if options.experimental_hooks:
-            return "experimental"
-        if hasattr(options, "test") and options.test:
-            return "comprehensive"
-        return "comprehensive"
-
-    def validate_config(self) -> bool:
-        try:
-            config_file = self.pkg_path / ".pre-commit-config.yaml"
-            if not config_file.exists():
-                self.console.print(
-                    "[yellow]⚠️ No pre-commit configuration found[/ yellow]",
-                )
-                return False
-            import yaml
-
-            with config_file.open() as f:
-                yaml_result = yaml.safe_load(f)
-                _ = (
-                    t.cast("dict[str, t.Any]", yaml_result)
-                    if yaml_result is not None
-                    else {}
-                )
-            self.console.print("[green]✅[/ green] Pre-commit configuration is valid")
-            return True
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Configuration validation failed: {e}")
-            return False
-
-    def backup_config(self) -> Path | None:
-        try:
-            config_file = self.pkg_path / ".pre-commit-config.yaml"
-            if not config_file.exists():
-                return None
-            import time
-
-            timestamp = int(time.time())
-            backup_file = self.pkg_path / f".pre-commit-config.yaml.backup.{timestamp}"
-            backup_file.write_text(config_file.read_text())
-            self.console.print(
-                f"[cyan]💾[/ cyan] Configuration backed up to {backup_file.name}",
-            )
-            return backup_file
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️[/ yellow] Failed to backup configuration: {e}",
-            )
-            return None
-
-    def restore_config(self, backup_file: Path) -> bool:
-        try:
-            if not backup_file.exists():
-                self.console.print(
-                    f"[red]❌[/ red] Backup file not found: {backup_file}",
-                )
-                return False
-            config_file = self.pkg_path / ".pre-commit-config.yaml"
-            config_file.write_text(backup_file.read_text())
-            self.console.print(
-                f"[green]✅[/ green] Configuration restored from {backup_file.name}",
-            )
-            return True
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Failed to restore configuration: {e}")
-            return False
-
-    def get_config_info(self) -> dict[str, t.Any]:
-        try:
-            config_file = self.pkg_path / ".pre-commit-config.yaml"
-            if not config_file.exists():
-                return {"exists": False}
-            import yaml
-
-            with config_file.open() as f:
-                yaml_result = yaml.safe_load(f)
-                config_data = yaml_result if isinstance(yaml_result, dict) else {}
-            repos = config_data.get("repos", [])
-            if not isinstance(repos, list):
-                repos = []
-            hook_count = sum(
-                len(repo.get("hooks", []))
-                for repo in t.cast(list[dict[str, t.Any]], repos)
-                if isinstance(repo, dict)
-            )
-            stat = config_file.stat()
-
-            return {
-                "exists": True,
-                "file_size": stat.st_size,
-                "modified_time": stat.st_mtime,
-                "repo_count": len(
-                    [
-                        r
-                        for r in t.cast(list[dict[str, t.Any]], repos)
-                        if isinstance(r, dict)
-                    ]
-                ),
-                "hook_count": hook_count,
-                "repos": [
-                    {
-                        "repo": repo.get("repo", "unknown"),
-                        "rev": repo.get("rev", "unknown"),
-                        "hooks": len(repo.get("hooks", [])),
-                    }
-                    for repo in t.cast(list[dict[str, t.Any]], repos)
-                    if isinstance(repo, dict)
-                ],
-            }
-        except Exception as e:
-            return {"exists": True, "error": str(e)}
-
-    def update_pyproject_config(self, options: OptionsProtocol) -> bool:
-        try:
-            pyproject_file = self.pkg_path / "pyproject.toml"
-            if not pyproject_file.exists():
-                self.console.print("[yellow]⚠️ No pyproject.toml found[/ yellow]")
-                return False
-            from tomllib import loads
-
-            from tomli_w import dumps
-
-            with pyproject_file.open() as f:
-                content = f.read()
-            config = loads(content)
-            if "tool" not in config:
-                config["tool"] = {}
-            if "ruff" not in config["tool"]:
-                config["tool"]["ruff"] = {
-                    "target-version": "py313",
-                    "line-length": 88,
-                    "fix": True,
-                    "unsafe-fixes": True,
-                    "show-fixes": True,
-                    "output-format": "full",
-                }
-                config["tool"]["ruff"]["format"] = {"docstring - code-format": True}
-                config["tool"]["ruff"]["lint"] = {
-                    "extend-select": ["C901", "F", "I", "UP"],
-                    "ignore": ["E402", "F821"],
-                    "fixable": ["ALL"],
-                }
-            if "pytest" not in config["tool"]:
-                config["tool"]["pytest"] = {
-                    "ini_options": {
-                        "asyncio_mode": "auto",
-                        "timeout": 300,
-                        "addopts": "- - cov=crackerjack - - cov-report=term",
-                        "markers": [
-                            "unit: marks test as a unit test",
-                            "benchmark: mark test as a benchmark",
-                            "integration: marks test as an integration test",
-                            "no_leaks: detect asyncio task leaks",
-                        ],
-                    },
-                }
-
-            from crackerjack.services.filesystem import FileSystemService
-
-            content = dumps(config)
-            content = FileSystemService.clean_trailing_whitespace_and_newlines(content)
-            with pyproject_file.open("w") as f:
-                f.write(content)
-            self.console.print(
-                "[green]✅[/ green] pyproject.toml configuration updated"
-            )
-            return True
-        except Exception as e:
-            self.console.print(f"[red]❌[/ red] Failed to update pyproject.toml: {e}")
-            return False
-
-    def _run_precommit_autoupdate(self) -> bool:
-        import subprocess
-
-        try:
-            self.console.print("[cyan]🔄[/ cyan] Running pre-commit autoupdate...")
-            result = self._execute_precommit_autoupdate()
-
-            if result.returncode == 0:
-                self._display_autoupdate_results(result.stdout)
-                return True
-            else:
-                self._handle_autoupdate_error(result.stderr)
-                return False
-
-        except subprocess.TimeoutExpired:
-            self.console.print("[red]❌[/ red] Pre-commit autoupdate timed out")
-            return False
-        except Exception as e:
-            self.console.print(
-                f"[red]❌[/ red] Failed to run pre-commit autoupdate: {e}"
-            )
-            return False
-
-    def _execute_precommit_autoupdate(self) -> subprocess.CompletedProcess[str]:
-        return subprocess.run(
-            ["uv", "run", "pre-commit", "autoupdate"],
-            cwd=self.pkg_path,
-            capture_output=True,
-            text=True,
-            timeout=60,
-        )
-
-    def _display_autoupdate_results(self, stdout: str) -> None:
-        if self._has_updates(stdout):
-            for line in stdout.split("\n"):
-                if self._is_update_line(line):
-                    self.console.print(f"[dim] {line.strip()}[/ dim]")
-
-    def _has_updates(self, stdout: str) -> bool:
-        stdout_lower = stdout.lower()
-        return "updating" in stdout_lower or "updated" in stdout_lower
-
-    def _is_update_line(self, line: str) -> bool:
-        return "updating" in line.lower() or "- >" in line
-
-    def _handle_autoupdate_error(self, stderr: str) -> None:
-        if stderr:
-            self.console.print(
-                f"[yellow]Pre-commit autoupdate stderr: [/ yellow] {stderr}"
-            )
-
-    def _update_dynamic_config_versions(self) -> None:
-        try:
-            self.console.print("[cyan]🔄[/ cyan] Updating dynamic config versions...")
-
-            version_updates = self._extract_version_updates()
-            if version_updates:
-                self._update_dynamic_config_file(version_updates)
-
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️[/ yellow] Failed to update dynamic config versions: {e}"
-            )
-
-    def _extract_version_updates(self) -> dict[str, str]:
-        config_file = self.pkg_path / ".pre-commit-config.yaml"
-        if not config_file.exists():
-            return {}
-
-        import yaml
-
-        with config_file.open() as f:
-            config = yaml.safe_load(f)
-
-        if not config or "repos" not in config:
-            return {}
-
-        version_updates = {}
-        repos: list[dict[str, t.Any]] = (
-            config.get("repos", []) if isinstance(config, dict) else []
-        )
-        for repo in repos:
-            repo_url = repo.get("repo", "")
-            rev = repo.get("rev", "")
-            if repo_url and rev:
-                version_updates[repo_url] = rev
-
-        return version_updates
-
-    def _update_dynamic_config_file(self, version_updates: dict[str, str]) -> None:
-        dynamic_config_path = self.pkg_path / "crackerjack" / "dynamic_config.py"
-        if dynamic_config_path.exists():
-            self._apply_version_updates(dynamic_config_path, version_updates)
-
-    def _apply_version_updates(
-        self, config_path: Path, version_updates: dict[str, str]
-    ) -> None:
-        try:
-            content = config_path.read_text()
-            updated = False
-
-            for repo_url, new_rev in version_updates.items():
-                from .regex_patterns import update_repo_revision
-
-                new_content = update_repo_revision(content, repo_url, new_rev)
-                if new_content != content:
-                    content = new_content
-                    updated = True
-                    self.console.print(f"[dim] Updated {repo_url} to {new_rev}[/ dim]")
-
-            if updated:
-                config_path.write_text(content)
-                self.console.print("[green]✅[/ green] Dynamic config versions updated")
-
-        except Exception as e:
-            self.console.print(
-                f"[yellow]⚠️[/ yellow] Failed to apply version updates: {e}"
-            )

crackerjack/ui/server_panels.py

@@ -1,125 +0,0 @@
-"""Rich panel utilities for MCP server operations with consistent styling."""
-
-from pathlib import Path
-
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
-
-
-class ServerPanels:
-    """Rich panel utilities for server operations with 74-char width limit."""
-
-    WIDTH = 74  # Match session-mgmt-mcp width constraint
-
-    def __init__(self, console: Console | None = None) -> None:
-        self.console = console or Console()
-
-    def restart_header(self) -> None:
-        """Display server restart header panel."""
-        panel = Panel(
-            "🔄 Restarting Crackerjack MCP Server...",
-            width=self.WIDTH,
-            title="Server Restart",
-            style="cyan",
-        )
-        self.console.print(panel)
-
-    def stop_servers(self, count: int) -> None:
-        """Display stopping servers status."""
-        self.console.print("📴 Stopping existing servers...")
-        self.console.print(f"🛑 Stopping {count} server process(es)...")
-
-    def process_stopped(self, pid: int) -> None:
-        """Display process stopped message."""
-        self.console.print(f"Stopping process {pid}...")
-        self.console.print(f"✅ Process {pid} terminated gracefully")
-
-    def stop_complete(self, count: int) -> None:
-        """Display stop completion panel."""
-        panel = Panel(
-            f"✅ Successfully stopped {count} process(es)",
-            width=self.WIDTH,
-            title="Server Stopped",
-            style="green",
-        )
-        self.console.print(panel)
-
-    def cleanup_wait(self) -> None:
-        """Display cleanup waiting message."""
-        self.console.print("⏳ Waiting for cleanup...")
-
-    def starting_server(self) -> None:
-        """Display starting server message."""
-        self.console.print("🚀 Starting fresh server instance...")
-        self.console.print("🚀 Starting Crackerjack MCP Server...")
-        self.console.print("⏳ Waiting for server to start...")
-
-    def success_panel(
-        self,
-        http_endpoint: str | None = None,
-        websocket_monitor: str | None = None,
-        process_id: int | None = None,
-    ) -> None:
-        """Display success panel with server details."""
-        content = Text()
-        content.append("✅ Server started successfully!\n", style="green bold")
-
-        if http_endpoint:
-            content.append(f"🌐 HTTP Endpoint: {http_endpoint}\n", style="cyan")
-
-        if websocket_monitor:
-            content.append(f"🔌 WebSocket Monitor: {websocket_monitor}\n", style="cyan")
-
-        if process_id:
-            content.append(f"📊 Process ID: {process_id}", style="cyan")
-
-        panel = Panel(
-            content,
-            width=self.WIDTH,
-            title="Crackerjack MCP Server",
-            style="green",
-        )
-        self.console.print(panel)
-
-    def failure_panel(self, error: str) -> None:
-        """Display failure panel with error details."""
-        panel = Panel(
-            f"❌ Server failed to start: {error}",
-            width=self.WIDTH,
-            title="Server Error",
-            style="red",
-        )
-        self.console.print(panel)
-
-    def start_panel(
-        self,
-        project_path: Path,
-        mode: str = "STDIO",
-        http_endpoint: str | None = None,
-        websocket_port: int | None = None,
-    ) -> None:
-        """Display server start panel with configuration details."""
-        content = Text()
-        content.append("🚀 Starting Crackerjack MCP Server...\n", style="green bold")
-        content.append(f"📁 Project: {project_path.name}\n", style="cyan")
-        content.append(f"🔗 Mode: {mode}\n", style="cyan")
-
-        if http_endpoint:
-            content.append(f"🌐 HTTP: {http_endpoint}\n", style="cyan")
-
-        if websocket_port:
-            content.append(f"🔌 WebSocket: {websocket_port}", style="cyan")
-
-        panel = Panel(
-            content,
-            width=self.WIDTH,
-            title="Server Configuration",
-            style="green",
-        )
-        self.console.print(panel)
-
-
-def create_server_panels(console: Console | None = None) -> ServerPanels:
-    """Factory function to create ServerPanels instance."""
-    return ServerPanels(console)