crackerjack 0.32.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

crackerjack/managers/publish_manager.py

@@ -5,17 +5,34 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.services.filesystem import FileSystemService
-from crackerjack.services.security import SecurityService
+from crackerjack.models.protocols import FileSystemInterface, SecurityServiceProtocol
 
 
 class PublishManagerImpl:
-    def __init__(self, console: Console, pkg_path: Path, dry_run: bool = False) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        dry_run: bool = False,
+        filesystem: FileSystemInterface | None = None,
+        security: SecurityServiceProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
         self.dry_run = dry_run
-        self.filesystem = FileSystemService()
-        self.security = SecurityService()
+
+        if filesystem is None:
+            from crackerjack.services.filesystem import FileSystemService
+
+            filesystem = FileSystemService()
+
+        if security is None:
+            from crackerjack.services.security import SecurityService
+
+            security = SecurityService()
+
+        self.filesystem = filesystem
+        self.security = security
 
     def _run_command(
         self,

crackerjack/managers/test_command_builder.py

@@ -8,7 +8,7 @@ class TestCommandBuilder:
         self.pkg_path = pkg_path
 
     def build_command(self, options: OptionsProtocol) -> list[str]:
-        cmd = ["python", "-m", "pytest"]
+        cmd = ["uv", "run", "python", "-m", "pytest"]
 
         self._add_coverage_options(cmd, options)
         self._add_worker_options(cmd, options)
@@ -99,7 +99,7 @@ class TestCommandBuilder:
         cmd.append(str(self.pkg_path))
 
     def build_specific_test_command(self, test_pattern: str) -> list[str]:
-        cmd = ["python", "-m", "pytest", "-v"]
+        cmd = ["uv", "run", "python", "-m", "pytest", "-v"]
 
         cmd.extend(
             [
@@ -116,6 +116,8 @@ class TestCommandBuilder:
 
     def build_validation_command(self) -> list[str]:
         return [
+            "uv",
+            "run",
             "python",
             "-m",
             "pytest",

crackerjack/managers/test_manager.py

@@ -5,21 +5,32 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.models.protocols import OptionsProtocol
-from crackerjack.services.coverage_ratchet import CoverageRatchetService
+from crackerjack.models.protocols import CoverageRatchetProtocol, OptionsProtocol
 
 from .test_command_builder import TestCommandBuilder
 from .test_executor import TestExecutor
 
 
 class TestManager:
-    def __init__(self, console: Console, pkg_path: Path) -> None:
+    def __init__(
+        self,
+        console: Console,
+        pkg_path: Path,
+        coverage_ratchet: CoverageRatchetProtocol | None = None,
+    ) -> None:
         self.console = console
         self.pkg_path = pkg_path
 
         self.executor = TestExecutor(console, pkg_path)
         self.command_builder = TestCommandBuilder(pkg_path)
-        self.coverage_ratchet = CoverageRatchetService(pkg_path, console)
+
+        if coverage_ratchet is None:
+            # Import here to avoid circular imports
+            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+            coverage_ratchet = CoverageRatchetService(pkg_path, console)
+
+        self.coverage_ratchet = coverage_ratchet
 
         self._last_test_failures: list[str] = []
         self._progress_callback: t.Callable[[dict[str, t.Any]], None] | None = None

crackerjack/mcp/server_core.py

@@ -7,7 +7,12 @@ from typing import Final
 from rich.console import Console
 
 try:
-    from mcp.server.fastmcp import FastMCP
+    import tomli
+except ImportError:
+    tomli = None
+
+try:
+    from fastmcp import FastMCP
 
     _mcp_available = True
 except ImportError:
@@ -37,6 +42,42 @@ from .tools import (
 console = Console()
 
 
+def _load_mcp_config(project_path: Path) -> dict[str, t.Any]:
+    """Load MCP server configuration from pyproject.toml."""
+    pyproject_path = project_path / "pyproject.toml"
+
+    if not pyproject_path.exists() or not tomli:
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+    try:
+        with pyproject_path.open("rb") as f:
+            pyproject_data = tomli.load(f)
+
+        crackerjack_config = pyproject_data.get("tool", {}).get("crackerjack", {})
+
+        return {
+            "http_port": crackerjack_config.get("mcp_http_port", 8676),
+            "http_host": crackerjack_config.get("mcp_http_host", "127.0.0.1"),
+            "websocket_port": crackerjack_config.get("mcp_websocket_port", 8675),
+            "http_enabled": crackerjack_config.get("mcp_http_enabled", False),
+        }
+    except Exception as e:
+        console.print(
+            f"[yellow]Warning: Failed to load MCP config from pyproject.toml: {e}[/yellow]"
+        )
+        return {
+            "http_port": 8676,
+            "http_host": "127.0.0.1",
+            "websocket_port": 8675,
+            "http_enabled": False,
+        }
+
+
 class MCPOptions:
     def __init__(self, **kwargs: t.Any) -> None:
         self.commit: bool = False
@@ -77,11 +118,14 @@ async def _start_websocket_server() -> bool:
     return False
 
 
-def create_mcp_server() -> t.Any | None:
+def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
     if not MCP_AVAILABLE or FastMCP is None:
         return None
 
-    mcp_app = FastMCP("crackerjack - mcp-server")
+    if config is None:
+        config = {"http_port": 8676, "http_host": "127.0.0.1"}
+
+    mcp_app = FastMCP("crackerjack-mcp-server", streamable_http_path="/mcp")
 
     from crackerjack.slash_commands import get_slash_command_path
 
@@ -128,6 +172,8 @@ def handle_mcp_server_command(
     stop: bool = False,
     restart: bool = False,
     websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
 ) -> None:
     if stop or restart:
         console.print("[yellow]Stopping MCP servers...[/ yellow]")
@@ -157,7 +203,7 @@ def handle_mcp_server_command(
     if start or restart:
         console.print("[green]Starting MCP server...[/ green]")
         try:
-            main(".", websocket_port)
+            main(".", websocket_port, http_mode, http_port)
         except Exception as e:
             console.print(f"[red]Failed to start MCP server: {e}[/ red]")
 
@@ -177,45 +223,111 @@ def _stop_websocket_server() -> None:
             pass
 
 
-def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None:
+def _merge_config_with_args(
+    mcp_config: dict[str, t.Any],
+    http_port: int | None,
+    http_mode: bool,
+) -> dict[str, t.Any]:
+    """Merge MCP configuration with command line arguments."""
+    if http_port:
+        mcp_config["http_port"] = http_port
+    if http_mode:
+        mcp_config["http_enabled"] = True
+    return mcp_config
+
+
+def _setup_server_context(
+    project_path: Path,
+    websocket_port: int | None,
+) -> MCPServerContext:
+    """Set up and initialize the MCP server context."""
+    config = MCPServerConfig(
+        project_path=project_path,
+        rate_limit_config=RateLimitConfig(),
+    )
+
+    context = MCPServerContext(config)
+    context.console = console
+
+    if websocket_port:
+        context.websocket_server_port = websocket_port
+
+    _initialize_context(context)
+    return context
+
+
+def _print_server_info(
+    project_path: Path,
+    mcp_config: dict[str, t.Any],
+    websocket_port: int | None,
+    http_mode: bool,
+) -> None:
+    """Print server startup information."""
+    console.print("[green]Starting Crackerjack MCP Server...[/ green]")
+    console.print(f"Project path: {project_path}")
+
+    if mcp_config.get("http_enabled", False) or http_mode:
+        console.print(
+            f"[cyan]HTTP Mode: http://{mcp_config['http_host']}:{mcp_config['http_port']}/mcp[/ cyan]"
+        )
+    else:
+        console.print("[cyan]STDIO Mode[/ cyan]")
+
+    if websocket_port:
+        console.print(f"WebSocket port: {websocket_port}")
+
+
+def _run_mcp_server(
+    mcp_app: t.Any, mcp_config: dict[str, t.Any], http_mode: bool
+) -> None:
+    """Execute the MCP server with appropriate transport mode."""
+    console.print("[yellow]MCP app created, about to run...[/ yellow]")
+
+    try:
+        if mcp_config.get("http_enabled", False) or http_mode:
+            host = mcp_config.get("http_host", "127.0.0.1")
+            port = mcp_config.get("http_port", 8676)
+            mcp_app.run(transport="streamable-http", host=host, port=port)
+        else:
+            mcp_app.run()
+    except Exception as e:
+        console.print(f"[red]MCP run failed: {e}[/ red]")
+        import traceback
+
+        traceback.print_exc()
+        raise
+
+
+def main(
+    project_path_arg: str = ".",
+    websocket_port: int | None = None,
+    http_mode: bool = False,
+    http_port: int | None = None,
+) -> None:
     if not MCP_AVAILABLE:
         return
 
     try:
         project_path = Path(project_path_arg).resolve()
 
-        config = MCPServerConfig(
-            project_path=project_path,
-            rate_limit_config=RateLimitConfig(),
-        )
-
-        context = MCPServerContext(config)
-        context.console = console
+        # Load and merge configuration
+        mcp_config = _load_mcp_config(project_path)
+        mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
 
-        if websocket_port:
-            context.websocket_server_port = websocket_port
+        # Set up server context
+        _setup_server_context(project_path, websocket_port)
 
-        _initialize_context(context)
-
-        mcp_app = create_mcp_server()
+        # Create MCP server
+        mcp_app = create_mcp_server(mcp_config)
         if not mcp_app:
             console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        console.print("[green]Starting Crackerjack MCP Server...[/ green]")
-        console.print(f"Project path: {project_path}")
-        if websocket_port:
-            console.print(f"WebSocket port: {websocket_port}")
+        # Print server information
+        _print_server_info(project_path, mcp_config, websocket_port, http_mode)
 
-        console.print("[yellow]MCP app created, about to run...[/ yellow]")
-        try:
-            mcp_app.run()
-        except Exception as e:
-            console.print(f"[red]MCP run failed: {e}[/ red]")
-            import traceback
-
-            traceback.print_exc()
-            raise
+        # Run the server
+        _run_mcp_server(mcp_app, mcp_config, http_mode)
 
     except KeyboardInterrupt:
         console.print("Server stopped by user")
@@ -232,7 +344,23 @@ def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None
 if __name__ == "__main__":
     import sys
 
-    project_path = sys.argv[1] if len(sys.argv) > 1 else "."
-    websocket_port = int(sys.argv[2]) if len(sys.argv) > 2 else None
-
-    main(project_path, websocket_port)
+    # Initialize defaults
+    project_path = "."
+    websocket_port = None
+    http_mode = "--http" in sys.argv
+    http_port = None
+
+    # Parse project path from non-flag arguments
+    non_flag_args = [arg for arg in sys.argv[1:] if not arg.startswith("--")]
+    if non_flag_args:
+        project_path = non_flag_args[0]
+        if len(non_flag_args) > 1 and non_flag_args[1].isdigit():
+            websocket_port = int(non_flag_args[1])
+
+    # Parse HTTP port flag
+    if "--http-port" in sys.argv:
+        port_idx = sys.argv.index("--http-port")
+        if port_idx + 1 < len(sys.argv):
+            http_port = int(sys.argv[port_idx + 1])
+
+    main(project_path, websocket_port, http_mode, http_port)

crackerjack/mcp/tools/core_tools.py

@@ -186,7 +186,7 @@ def _execute_init_stage(orchestrator) -> bool:
 
         init_service = InitializationService(console, filesystem, git_service, pkg_path)
 
-        results = init_service.initialize_project(target_path=Path.cwd())
+        results = init_service.initialize_project_full(target_path=Path.cwd())
 
         return results.get("success", False)
 

crackerjack/mcp/tools/execution_tools.py

@@ -161,9 +161,14 @@ def _execute_initialization(target_path: t.Any, force: bool) -> dict[str, t.Any]
 
     console = Console()
 
-    return InitializationService(console, target_path).initialize_project(
-        force_update=force
-    )
+    from crackerjack.services.filesystem import FileSystemService
+    from crackerjack.services.git import GitService
+
+    filesystem = FileSystemService()
+    git_service = GitService()
+    return InitializationService(
+        console, filesystem, git_service, target_path
+    ).initialize_project_full(force=force)
 
 
 def _create_init_error_response(message: str) -> str:

crackerjack/mixins/__init__.py

@@ -0,0 +1,5 @@
+"""Common mixins for crackerjack components."""
+
+from .error_handling import ErrorHandlingMixin
+
+__all__ = ["ErrorHandlingMixin"]

crackerjack/mixins/error_handling.py

@@ -0,0 +1,214 @@
+"""Common error handling patterns for crackerjack components."""
+
+import subprocess
+import typing as t
+from pathlib import Path
+
+from rich.console import Console
+
+
+class ErrorHandlingMixin:
+    """Mixin providing common error handling patterns for crackerjack components."""
+
+    def __init__(self) -> None:
+        # These attributes should be provided by the class using the mixin
+        self.console: Console
+        self.logger: t.Any  # Logger instance
+
+    def handle_subprocess_error(
+        self,
+        error: Exception,
+        command: list[str],
+        operation_name: str,
+        critical: bool = False,
+    ) -> bool:
+        """Handle subprocess errors with consistent logging and user feedback.
+
+        Args:
+            error: The exception that occurred
+            command: The command that failed
+            operation_name: Human-readable name of the operation
+            critical: Whether this is a critical error that should stop execution
+
+        Returns:
+            False to indicate failure
+        """
+        error_msg = f"{operation_name} failed: {error}"
+
+        # Log the error
+        if hasattr(self, "logger") and self.logger:
+            self.logger.error(
+                error_msg,
+                command=" ".join(command),
+                error_type=type(error).__name__,
+                critical=critical,
+            )
+
+        # Display user-friendly error message
+        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:
+        """Handle file operation errors with consistent logging and user feedback.
+
+        Args:
+            error: The exception that occurred
+            file_path: The file that caused the error
+            operation: The operation that failed (e.g., "read", "write", "delete")
+            critical: Whether this is a critical error that should stop execution
+
+        Returns:
+            False to indicate failure
+        """
+        error_msg = f"Failed to {operation} {file_path}: {error}"
+
+        # Log the 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,
+            )
+
+        # Display user-friendly error message
+        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:
+        """Handle timeout errors with consistent logging and user feedback.
+
+        Args:
+            operation_name: Human-readable name of the operation
+            timeout_seconds: The timeout that was exceeded
+            command: Optional command that timed out
+
+        Returns:
+            False to indicate failure
+        """
+        error_msg = f"{operation_name} timed out after {timeout_seconds}s"
+
+        # Log the error
+        if hasattr(self, "logger") and self.logger:
+            self.logger.warning(
+                error_msg,
+                timeout=timeout_seconds,
+                command=" ".join(command) if command else None,
+            )
+
+        # Display user-friendly error message
+        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:
+        """Log successful operations with consistent formatting.
+
+        Args:
+            operation_name: Human-readable name of the operation
+            details: Optional additional details to log
+        """
+        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:
+        """Validate that required external tools are available.
+
+        Args:
+            tools: Dict mapping tool names to their expected commands
+            operation_name: Name of operation requiring the tools
+
+        Returns:
+            True if all tools are available, False otherwise
+        """
+        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:
+        """Safely get an attribute with error handling.
+
+        Args:
+            obj: Object to get attribute from
+            attribute: Name of attribute to get
+            default: Default value if attribute doesn't exist
+            operation_name: Name of operation for error logging
+
+        Returns:
+            The attribute value or default
+        """
+        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/models/config.py

@@ -79,6 +79,14 @@ class EnterpriseConfig:
     organization: str | None = None
 
 
+@dataclass
+class MCPServerConfig:
+    http_port: int = 8676
+    http_host: str = "127.0.0.1"
+    websocket_port: int = 8675
+    http_enabled: bool = False
+
+
 @dataclass
 class WorkflowOptions:
     cleaning: CleaningConfig = field(default_factory=CleaningConfig)
@@ -91,3 +99,4 @@ class WorkflowOptions:
     progress: ProgressConfig = field(default_factory=ProgressConfig)
     cleanup: CleanupConfig = field(default_factory=CleanupConfig)
     enterprise: EnterpriseConfig = field(default_factory=EnterpriseConfig)
+    mcp_server: MCPServerConfig = field(default_factory=MCPServerConfig)