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

crackerjack/core/enhanced_container.py

@@ -11,11 +11,16 @@ from rich.console import Console
 
 from crackerjack.models.protocols import (
     ConfigMergeServiceProtocol,
+    ConfigurationServiceProtocol,
+    CoverageRatchetProtocol,
     FileSystemInterface,
     GitInterface,
     HookManager,
+    InitializationServiceProtocol,
     PublishManager,
+    SecurityServiceProtocol,
     TestManagerProtocol,
+    UnifiedConfigurationServiceProtocol,
 )
 from crackerjack.services.logging import get_logger
 
@@ -470,17 +475,79 @@ class ServiceCollectionBuilder:
 
         return self
 
+    def add_service_protocols(self) -> "ServiceCollectionBuilder":
+        """Add registrations for service protocols that don't have explicit builders."""
+        console = self.console or Console(force_terminal=True)
+        pkg_path = self.pkg_path or Path.cwd()
+
+        # Register CoverageRatchetProtocol
+        def create_coverage_ratchet() -> CoverageRatchetProtocol:
+            from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+            return CoverageRatchetService(pkg_path, console)
+
+        self.container.register_transient(
+            CoverageRatchetProtocol,
+            factory=create_coverage_ratchet,
+        )
+
+        # Register ConfigurationServiceProtocol
+        def create_configuration_service() -> ConfigurationServiceProtocol:
+            from crackerjack.services.config import ConfigurationService
+
+            return ConfigurationService(console=console, pkg_path=pkg_path)
+
+        self.container.register_transient(
+            ConfigurationServiceProtocol,
+            factory=create_configuration_service,
+        )
+
+        # Register SecurityServiceProtocol
+        def create_security_service() -> SecurityServiceProtocol:
+            from crackerjack.services.security import SecurityService
+
+            return SecurityService()
+
+        self.container.register_transient(
+            SecurityServiceProtocol,
+            factory=create_security_service,
+        )
+
+        # Register InitializationServiceProtocol
+        def create_initialization_service() -> InitializationServiceProtocol:
+            from crackerjack.services.filesystem import FileSystemService
+            from crackerjack.services.git import GitService
+            from crackerjack.services.initialization import InitializationService
+
+            filesystem = FileSystemService()
+            git_service = GitService(console, pkg_path)
+            return InitializationService(console, filesystem, git_service, pkg_path)
+
+        self.container.register_transient(
+            InitializationServiceProtocol,
+            factory=create_initialization_service,
+        )
+
+        return self
+
     def add_configuration_services(self) -> "ServiceCollectionBuilder":
         console = self.console or Console(force_terminal=True)
         pkg_path = self.pkg_path or Path.cwd()
 
         from crackerjack.services.unified_config import UnifiedConfigurationService
 
+        # Register concrete class for backwards compatibility
         self.container.register_singleton(
             UnifiedConfigurationService,
             factory=lambda: UnifiedConfigurationService(console, pkg_path),
         )
 
+        # Register protocol interface
+        self.container.register_singleton(
+            UnifiedConfigurationServiceProtocol,
+            factory=lambda: self.container.get(UnifiedConfigurationService),
+        )
+
         # Register ConfigMergeService for smart configuration merging
         from crackerjack.services.config_merge import ConfigMergeService
 

crackerjack/core/phase_coordinator.py

@@ -7,6 +7,7 @@ from rich.console import Console
 
 from crackerjack.code_cleaner import CodeCleaner, PackageCleaningResult
 from crackerjack.core.autofix_coordinator import AutofixCoordinator
+from crackerjack.mixins import ErrorHandlingMixin
 from crackerjack.models.protocols import (
     ConfigMergeServiceProtocol,
     FileSystemInterface,
@@ -16,12 +17,20 @@ from crackerjack.models.protocols import (
     PublishManager,
     TestManagerProtocol,
 )
-from crackerjack.services.config import ConfigurationService
+from crackerjack.services.memory_optimizer import (
+    create_lazy_service,
+    get_memory_optimizer,
+)
+from crackerjack.services.parallel_executor import (
+    get_async_executor,
+    get_parallel_executor,
+)
+from crackerjack.services.performance_cache import get_filesystem_cache, get_git_cache
 
 from .session_coordinator import SessionCoordinator
 
 
-class PhaseCoordinator:
+class PhaseCoordinator(ErrorHandlingMixin):
     def __init__(
         self,
         console: Console,
@@ -55,13 +64,31 @@ class PhaseCoordinator:
             security_logger=None,
             backup_service=None,
         )
+        # Initialize configuration service - could be injected via DI
+        from crackerjack.services.config import ConfigurationService
+
         self.config_service = ConfigurationService(console=console, pkg_path=pkg_path)
-        self.autofix_coordinator = AutofixCoordinator(
-            console=console, pkg_path=pkg_path
-        )
+        # Lazy-loaded autofix coordinator (now using lazy service)
+        # self.autofix_coordinator will be accessed via property
 
         self.logger = logging.getLogger("crackerjack.phases")
 
+        # Performance optimization services
+        self._memory_optimizer = get_memory_optimizer()
+        self._parallel_executor = get_parallel_executor()
+        self._async_executor = get_async_executor()
+        self._git_cache = get_git_cache()
+        self._filesystem_cache = get_filesystem_cache()
+
+        # Lazy-loaded heavy services
+        self._lazy_autofix = create_lazy_service(
+            lambda: AutofixCoordinator(console=console, pkg_path=pkg_path),
+            "autofix_coordinator",
+        )
+
+        # Initialize ErrorHandlingMixin
+        super().__init__()
+
     def run_cleaning_phase(self, options: OptionsProtocol) -> bool:
         if not options.clean:
             return True
@@ -71,16 +98,16 @@ class PhaseCoordinator:
             self._display_cleaning_header()
             return self._execute_cleaning_process()
         except Exception as e:
-            self.console.print(f"[red]❌[/ red] Cleaning failed: {e}")
+            self.handle_subprocess_error(e, [], "Code cleaning", critical=False)
             self.session.fail_task("cleaning", str(e))
             return False
 
     def _display_cleaning_header(self) -> None:
-        self.console.print("\n" + "-" * 80)
+        self.console.print("\n" + "-" * 40)
         self.console.print(
             "[bold bright_magenta]🛠️ SETUP[/bold bright_magenta] [bold bright_white]Initializing project structure[/bold bright_white]",
         )
-        self.console.print("-" * 80 + "\n")
+        self.console.print("-" * 40 + "\n")
         self.console.print("[yellow]🧹[/yellow] Starting code cleaning...")
 
     def _execute_cleaning_process(self) -> bool:
@@ -156,6 +183,7 @@ class PhaseCoordinator:
             self._complete_configuration_task(success)
             return success
         except Exception as e:
+            self.handle_subprocess_error(e, [], "Configuration phase", critical=False)
             self.session.fail_task("configuration", str(e))
             return False
 
@@ -370,32 +398,28 @@ class PhaseCoordinator:
         if options.skip_hooks:
             return True
 
-        return self._execute_hooks_with_retry(
-            "fast",
-            self.hook_manager.run_fast_hooks,
-            options,
-        )
+        # Use standard execution for now - parallel support can be added later
+        hook_results = self.hook_manager.run_fast_hooks()
+        return all(r.status == "passed" for r in hook_results)
 
     def run_comprehensive_hooks_only(self, options: OptionsProtocol) -> bool:
         if options.skip_hooks:
             return True
 
-        return self._execute_hooks_with_retry(
-            "comprehensive",
-            self.hook_manager.run_comprehensive_hooks,
-            options,
-        )
+        # Use standard execution for now - parallel support can be added later
+        hook_results = self.hook_manager.run_comprehensive_hooks()
+        return all(r.status == "passed" for r in hook_results)
 
     def run_testing_phase(self, options: OptionsProtocol) -> bool:
         if not options.test:
             return True
         self.session.track_task("testing", "Test execution")
         try:
-            self.console.print("\n" + "-" * 80)
+            self.console.print("\n" + "-" * 40)
             self.console.print(
                 "[bold bright_blue]🧪 TESTS[/ bold bright_blue] [bold bright_white]Running test suite[/ bold bright_white]",
             )
-            self.console.print("-" * 80 + "\n")
+            self.console.print("-" * 40 + "\n")
             if not self.test_manager.validate_test_environment():
                 self.session.fail_task("testing", "Test environment validation failed")
                 return False
@@ -615,33 +639,60 @@ class PhaseCoordinator:
 
         for attempt in range(max_retries):
             try:
-                results = hook_runner()
-                summary = self.hook_manager.get_hook_summary(results)
-
-                if self._has_hook_failures(summary):
-                    if self._should_retry_hooks(
-                        hook_type,
-                        attempt,
-                        max_retries,
-                        results,
-                    ):
-                        continue
-
-                    return self._handle_hook_failures(
-                        hook_type,
-                        options,
-                        summary,
-                        results,
-                        attempt,
-                        max_retries,
-                    )
-                return self._handle_hook_success(hook_type, summary)
+                execution_result = self._execute_single_hook_attempt(hook_runner)
+                if execution_result is None:
+                    return False
+
+                results, summary = execution_result
+                should_continue = self._process_hook_results(
+                    hook_type, options, summary, results, attempt, max_retries
+                )
+
+                if should_continue == "continue":
+                    continue
+                elif should_continue == "success":
+                    return True
+                else:
+                    return False
 
             except Exception as e:
                 return self._handle_hook_exception(hook_type, e)
 
         return False
 
+    def _execute_single_hook_attempt(
+        self, hook_runner: t.Callable[[], list[t.Any]]
+    ) -> tuple[list[t.Any], dict[str, t.Any]] | None:
+        """Execute a single hook attempt and return results and summary."""
+        try:
+            results = hook_runner()
+            summary = self.hook_manager.get_hook_summary(results)
+            return results, summary
+        except Exception:
+            return None
+
+    def _process_hook_results(
+        self,
+        hook_type: str,
+        options: OptionsProtocol,
+        summary: dict[str, t.Any],
+        results: list[t.Any],
+        attempt: int,
+        max_retries: int,
+    ) -> str:
+        """Process hook results and return action: 'continue', 'success', or 'failure'."""
+        if not self._has_hook_failures(summary):
+            self._handle_hook_success(hook_type, summary)
+            return "success"
+
+        if self._should_retry_hooks(hook_type, attempt, max_retries, results):
+            return "continue"
+
+        self._handle_hook_failures(
+            hook_type, options, summary, results, attempt, max_retries
+        )
+        return "failure"
+
     def _initialize_hook_execution(self, hook_type: str) -> None:
         self.logger.info(f"Starting {hook_type} hooks execution")
         self.session.track_task(
@@ -671,11 +722,12 @@ class PhaseCoordinator:
         return False
 
     def _attempt_autofix_for_fast_hooks(self, results: list[t.Any]) -> bool:
-        """Attempt to autofix fast hook failures."""
+        """Attempt to autofix fast hook failures using lazy-loaded coordinator."""
         try:
             self.logger.info("Attempting autofix for fast hook failures")
-            # Apply autofixes for fast hooks
-            return self.autofix_coordinator.apply_fast_stage_fixes()
+            # Apply autofixes for fast hooks using lazy-loaded service
+            autofix_coordinator = self._lazy_autofix.get()
+            return autofix_coordinator.apply_fast_stage_fixes()
         except Exception as e:
             self.logger.warning(f"Autofix attempt failed: {e}")
             return False
@@ -798,3 +850,90 @@ class PhaseCoordinator:
         self.console.print(f"[red]❌[/ red] {hook_type.title()} hooks error: {e}")
         self.session.fail_task(f"{hook_type}_hooks", str(e))
         return False
+
+    # Performance-optimized hook execution methods
+    async def _execute_hooks_with_parallel_support(
+        self,
+        hook_type: str,
+        hook_runner: t.Callable[[], list[t.Any]],
+        options: OptionsProtocol,
+    ) -> bool:
+        """Execute hooks with parallel optimization where safe."""
+        self._initialize_hook_execution(hook_type)
+
+        try:
+            # Execute hooks and handle results
+            return await self._process_parallel_hook_execution(
+                hook_type, hook_runner, options
+            )
+
+        except Exception as e:
+            return self._handle_hook_exception(hook_type, e)
+
+    async def _process_parallel_hook_execution(
+        self,
+        hook_type: str,
+        hook_runner: t.Callable[[], list[t.Any]],
+        options: OptionsProtocol,
+    ) -> bool:
+        """Process hook execution with autofix retry logic."""
+        # For now, maintain sequential execution for safety
+        # Future enhancement: implement parallel execution for independent hooks
+        results = hook_runner()
+        summary = self.hook_manager.get_hook_summary(results)
+
+        if not self._has_hook_failures(summary):
+            return self._handle_hook_success(hook_type, summary)
+
+        # Handle failures with potential autofix retry
+        return self._handle_parallel_hook_failures(
+            hook_type, hook_runner, options, results, summary
+        )
+
+    def _handle_parallel_hook_failures(
+        self,
+        hook_type: str,
+        hook_runner: t.Callable[[], list[t.Any]],
+        options: OptionsProtocol,
+        results: list[t.Any],
+        summary: dict[str, t.Any],
+    ) -> bool:
+        """Handle hook failures with autofix retry for fast hooks."""
+        if hook_type != "fast":
+            return self._handle_hook_failures(
+                hook_type, options, summary, results, 0, 1
+            )
+
+        # Try autofix for fast hooks
+        if not self._attempt_autofix_for_fast_hooks(results):
+            return self._handle_hook_failures(
+                hook_type, options, summary, results, 0, 1
+            )
+
+        # Retry after successful autofix
+        return self._retry_hooks_after_autofix(hook_type, hook_runner, options)
+
+    def _retry_hooks_after_autofix(
+        self,
+        hook_type: str,
+        hook_runner: t.Callable[[], list[t.Any]],
+        options: OptionsProtocol,
+    ) -> bool:
+        """Retry hooks after autofix was applied."""
+        self.console.print(
+            "[yellow]🔧[/ yellow] Applied autofixes for fast hooks, retrying..."
+        )
+
+        # Retry after autofix
+        results = hook_runner()
+        summary = self.hook_manager.get_hook_summary(results)
+
+        if not self._has_hook_failures(summary):
+            return self._handle_hook_success(hook_type, summary)
+
+        return self._handle_hook_failures(hook_type, options, summary, results, 0, 1)
+
+    @property
+    def autofix_coordinator(self):
+        """Lazy property for autofix coordinator."""
+        return self._lazy_autofix.get()