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

crackerjack/mcp/tools/workflow_executor.py

@@ -13,8 +13,24 @@ async def execute_crackerjack_workflow(
 ) -> dict[str, t.Any]:
     job_id = str(uuid.uuid4())[:8]
 
+    # Configure extended timeout for long-running test operations
+    execution_timeout = kwargs.get("execution_timeout", 900)  # 15 minutes default
+    if kwargs.get("test", False) or kwargs.get("testing", False):
+        execution_timeout = max(execution_timeout, 1200)  # 20 minutes for test runs
+
     try:
-        return await _execute_crackerjack_sync(job_id, args, kwargs, get_context())
+        # Add overall execution timeout with keep-alive
+        return await asyncio.wait_for(
+            _execute_crackerjack_sync(job_id, args, kwargs, get_context()),
+            timeout=execution_timeout,
+        )
+    except TimeoutError:
+        return {
+            "job_id": job_id,
+            "status": "timeout",
+            "error": f"Execution timed out after {execution_timeout} seconds",
+            "timestamp": time.time(),
+        }
     except Exception as e:
         import traceback
 
@@ -143,9 +159,9 @@ async def _create_advanced_orchestrator(
     from pathlib import Path
 
     from crackerjack.core.async_workflow_orchestrator import AsyncWorkflowOrchestrator
-    from crackerjack.core.enhanced_container import EnhancedContainer
+    from crackerjack.core.enhanced_container import EnhancedDependencyContainer
 
-    container = EnhancedContainer()
+    container = EnhancedDependencyContainer()
 
     await _register_core_services(container, Path(working_dir))
 
@@ -171,41 +187,37 @@ def _create_standard_orchestrator(
 async def _register_core_services(container: t.Any, working_dir: t.Any) -> None:
     from rich.console import Console
 
-    from crackerjack.core.enhanced_container import ServiceLifetime
     from crackerjack.managers.hook_manager import AsyncHookManager
-    from crackerjack.managers.publish_manager import PublishManager
-    from crackerjack.managers.test_manager import TestManager
+    from crackerjack.managers.publish_manager import PublishManagerImpl
+    from crackerjack.managers.test_manager import TestManagementImpl
     from crackerjack.models.protocols import (
-        HookManagerProtocol,
-        PublishManagerProtocol,
+        FileSystemInterface,
+        HookManager,
+        PublishManager,
         TestManagerProtocol,
     )
     from crackerjack.services.enhanced_filesystem import EnhancedFileSystemService
 
     console = Console()
 
-    container.register_service(
-        HookManagerProtocol,
-        AsyncHookManager(console, working_dir),
-        ServiceLifetime.SINGLETON,
+    container.register_singleton(
+        HookManager,
+        factory=lambda: AsyncHookManager(console, working_dir),
     )
 
-    container.register_service(
+    container.register_singleton(
         TestManagerProtocol,
-        TestManager(console, working_dir),
-        ServiceLifetime.SINGLETON,
+        factory=lambda: TestManagementImpl(console, working_dir),
     )
 
-    container.register_service(
-        PublishManagerProtocol,
-        PublishManager(console, working_dir),
-        ServiceLifetime.SINGLETON,
+    container.register_singleton(
+        PublishManager,
+        factory=lambda: PublishManagerImpl(console, working_dir),
     )
 
-    container.register_service(
-        EnhancedFileSystemService,
-        EnhancedFileSystemService(),
-        ServiceLifetime.SINGLETON,
+    container.register_singleton(
+        FileSystemInterface,
+        factory=EnhancedFileSystemService,
     )
 
 
@@ -218,17 +230,29 @@ async def _run_workflow_iterations(
     options = _create_workflow_options(kwargs)
     max_iterations = kwargs.get("max_iterations", 10)
 
-    for iteration in range(max_iterations):
-        _update_progress(
-            job_id,
-            {
-                "type": "iteration",
-                "iteration": iteration + 1,
-                "max_iterations": max_iterations,
-                "status": "running",
-            },
-            context,
+    # Start keep-alive task to prevent TCP timeouts
+    keep_alive_task = asyncio.create_task(_keep_alive_heartbeat(job_id, context))
+
+    try:
+        result = await _execute_iterations_loop(
+            job_id, orchestrator, options, kwargs, max_iterations, context
         )
+        return result
+    finally:
+        await _cleanup_keep_alive_task(keep_alive_task)
+
+
+async def _execute_iterations_loop(
+    job_id: str,
+    orchestrator: t.Any,
+    options: t.Any,
+    kwargs: dict[str, t.Any],
+    max_iterations: int,
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Execute the main iterations loop."""
+    for iteration in range(max_iterations):
+        _update_iteration_progress(job_id, iteration, max_iterations, context)
 
         try:
             success = await _execute_single_iteration(
@@ -236,13 +260,8 @@ async def _run_workflow_iterations(
             )
 
             if success:
-                coverage_result = None
-                if kwargs.get("boost_coverage", False):
-                    coverage_result = await _attempt_coverage_improvement(
-                        job_id, orchestrator, context
-                    )
-                return _create_success_result(
-                    job_id, iteration + 1, context, coverage_result
+                return await _handle_iteration_success(
+                    job_id, iteration, orchestrator, kwargs, context
                 )
 
             if iteration < max_iterations - 1:
@@ -254,6 +273,77 @@ async def _run_workflow_iterations(
     return _create_failure_result(job_id, max_iterations, context)
 
 
+def _update_iteration_progress(
+    job_id: str, iteration: int, max_iterations: int, context: t.Any
+) -> None:
+    """Update progress for current iteration."""
+    _update_progress(
+        job_id,
+        {
+            "type": "iteration",
+            "iteration": iteration + 1,
+            "max_iterations": max_iterations,
+            "status": "running",
+        },
+        context,
+    )
+
+
+async def _handle_iteration_success(
+    job_id: str,
+    iteration: int,
+    orchestrator: t.Any,
+    kwargs: dict[str, t.Any],
+    context: t.Any,
+) -> dict[str, t.Any]:
+    """Handle successful iteration."""
+    coverage_result = None
+    if kwargs.get("boost_coverage", False):
+        coverage_result = await _attempt_coverage_improvement(
+            job_id, orchestrator, context
+        )
+    return _create_success_result(job_id, iteration + 1, context, coverage_result)
+
+
+async def _cleanup_keep_alive_task(keep_alive_task: asyncio.Task[t.Any]) -> None:
+    """Clean up the keep-alive task."""
+    if not keep_alive_task.cancelled():
+        keep_alive_task.cancel()
+        try:
+            await keep_alive_task
+        except asyncio.CancelledError:
+            pass
+
+
+async def _keep_alive_heartbeat(job_id: str, context: t.Any) -> None:
+    """Send periodic keep-alive messages to prevent TCP timeouts."""
+    try:
+        while True:
+            # Send heartbeat every 60 seconds (well under 2-minute TCP timeout)
+            await asyncio.sleep(60)
+            _update_progress(
+                job_id,
+                {
+                    "type": "keep_alive",
+                    "status": "heartbeat",
+                    "timestamp": time.time(),
+                    "message": "Keep-alive heartbeat to prevent connection timeout",
+                },
+                context,
+            )
+    except asyncio.CancelledError:
+        # Task was cancelled, cleanup
+        _update_progress(
+            job_id,
+            {
+                "type": "keep_alive",
+                "status": "cancelled",
+                "timestamp": time.time(),
+            },
+            context,
+        )
+
+
 def _create_workflow_options(kwargs: dict[str, t.Any]) -> t.Any:
     from types import SimpleNamespace
 

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)

crackerjack/models/protocols.py

@@ -83,8 +83,12 @@ class GitInterface(t.Protocol):
 
     def add_files(self, files: list[str]) -> bool: ...
 
+    def add_all_files(self) -> bool: ...
+
     def get_commit_message_suggestions(self, changed_files: list[str]) -> list[str]: ...
 
+    def get_unpushed_commit_count(self) -> int: ...
+
 
 @t.runtime_checkable
 class HookManager(t.Protocol):
@@ -99,6 +103,116 @@ class HookManager(t.Protocol):
     def get_hook_summary(self, results: t.Any) -> t.Any: ...
 
 
+@t.runtime_checkable
+class SecurityAwareHookManager(HookManager, t.Protocol):
+    """Security-aware hook manager that tracks security-critical failures."""
+
+    def get_security_critical_failures(self, results: list[t.Any]) -> list[t.Any]:
+        """Extract security-critical failures from hook results.
+
+        Args:
+            results: List of hook results from run_fast_hooks or run_comprehensive_hooks
+
+        Returns:
+            List of results that are security-critical and failed
+        """
+        ...
+
+    def has_security_critical_failures(self, results: list[t.Any]) -> bool:
+        """Check if any security-critical hooks failed.
+
+        Args:
+            results: List of hook results
+
+        Returns:
+            True if any CRITICAL security level hooks failed
+        """
+        ...
+
+    def get_security_audit_report(
+        self, fast_results: list[t.Any], comprehensive_results: list[t.Any]
+    ) -> dict[str, t.Any]:
+        """Generate security audit report for publishing decisions.
+
+        Args:
+            fast_results: Results from fast hooks
+            comprehensive_results: Results from comprehensive hooks
+
+        Returns:
+            Dict containing security status, failed critical checks, and recommendations
+        """
+        ...
+
+
+@t.runtime_checkable
+class CoverageRatchetProtocol(t.Protocol):
+    """Protocol for coverage ratchet service."""
+
+    def get_baseline_coverage(self) -> float: ...
+
+    def update_baseline_coverage(self, new_coverage: float) -> bool: ...
+
+    def is_coverage_regression(self, current_coverage: float) -> bool: ...
+
+    def get_coverage_improvement_needed(self) -> float: ...
+
+    def get_status_report(self) -> dict[str, t.Any]: ...
+
+    def get_coverage_report(self) -> str | None: ...
+
+    def check_and_update_coverage(self) -> dict[str, t.Any]: ...
+
+
+@t.runtime_checkable
+class ConfigurationServiceProtocol(t.Protocol):
+    """Protocol for configuration service."""
+
+    def update_precommit_config(self, options: OptionsProtocol) -> bool: ...
+
+    def update_pyproject_config(self, options: OptionsProtocol) -> bool: ...
+
+    def get_temp_config_path(self) -> str | None: ...
+
+
+@t.runtime_checkable
+class SecurityServiceProtocol(t.Protocol):
+    """Protocol for security service."""
+
+    def validate_file_safety(self, path: str | Path) -> bool: ...
+
+    def check_hardcoded_secrets(self, content: str) -> list[dict[str, t.Any]]: ...
+
+    def is_safe_subprocess_call(self, cmd: list[str]) -> bool: ...
+
+    def create_secure_command_env(self) -> dict[str, str]: ...
+
+    def mask_tokens(self, text: str) -> str: ...
+
+    def validate_token_format(self, token: str, token_type: str) -> bool: ...
+
+
+@t.runtime_checkable
+class InitializationServiceProtocol(t.Protocol):
+    """Protocol for initialization service."""
+
+    def initialize_project(self, project_path: str | Path) -> bool: ...
+
+    def validate_project_structure(self) -> bool: ...
+
+    def setup_git_hooks(self) -> bool: ...
+
+
+@t.runtime_checkable
+class UnifiedConfigurationServiceProtocol(t.Protocol):
+    """Protocol for unified configuration service."""
+
+    def merge_configurations(self) -> dict[str, t.Any]: ...
+
+    def validate_configuration(self, config: dict[str, t.Any]) -> bool: ...
+
+    def get_merged_config(self) -> dict[str, t.Any]: ...
+
+
 @t.runtime_checkable
 class TestManagerProtocol(t.Protocol):
     def run_tests(self, options: OptionsProtocol) -> bool: ...

crackerjack/models/task.py

@@ -56,10 +56,13 @@ class TaskStatusData:
     details: str | None = None
     error_message: str | None = None
     files_changed: list[str] | None = None
+    hook_results: list[t.Any] | None = None
 
     def __post_init__(self) -> None:
         if self.files_changed is None:
             self.files_changed = []
+        if self.hook_results is None:
+            self.hook_results = []
         if self.start_time is not None and self.end_time is not None:
             self.duration = self.end_time - self.start_time
 

crackerjack/security/__init__.py

@@ -0,0 +1 @@
+"""Security utilities for Crackerjack."""