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

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,26 @@ class PhaseCoordinator:
             security_logger=None,
             backup_service=None,
         )
+
+        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
-        )
 
         self.logger = logging.getLogger("crackerjack.phases")
 
+        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()
+
+        self._lazy_autofix = create_lazy_service(
+            lambda: AutofixCoordinator(console=console, pkg_path=pkg_path),
+            "autofix_coordinator",
+        )
+
+        super().__init__()
+
     def run_cleaning_phase(self, options: OptionsProtocol) -> bool:
         if not options.clean:
             return True
@@ -71,29 +93,54 @@ 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 _display_version_bump_header(self, version_type: str) -> None:
+        self.console.print("\n" + "-" * 74)
+        self.console.print(
+            f"[bold bright_magenta]📦 BUMP VERSION[/bold bright_magenta] [bold bright_white]Updating package version ({version_type})[/bold bright_white]",
+        )
+        self.console.print("-" * 74 + "\n")
+
+    def _display_publish_header(self) -> None:
+        self.console.print("\n" + "-" * 74)
+        self.console.print(
+            "[bold bright_yellow]🚀 PUBLISH[/bold bright_yellow] [bold bright_white]Publishing to PyPI[/bold bright_white]",
+        )
+        self.console.print("-" * 74 + "\n")
+
+    def _display_git_staging_header(self) -> None:
+        self.console.print("\n" + "-" * 74)
+        self.console.print(
+            "[bold bright_cyan]🏷️ GIT OPERATIONS[/bold bright_cyan] [bold bright_white]Staging files and creating tags[/bold bright_white]",
+        )
+        self.console.print("-" * 74 + "\n")
+
+    def _display_commit_push_header(self) -> None:
+        self.console.print("\n" + "-" * 74)
+        self.console.print(
+            "[bold bright_green]📤 COMMIT & PUSH[/bold bright_green] [bold bright_white]Committing and pushing changes[/bold bright_white]",
+        )
+        self.console.print("-" * 74 + "\n")
+
     def _execute_cleaning_process(self) -> bool:
-        # Use the comprehensive backup cleaning system for safety
         cleaning_result = self.code_cleaner.clean_files(self.pkg_path, use_backup=True)
 
         if isinstance(cleaning_result, list):
-            # Legacy mode (should not happen with use_backup=True, but handle gracefully)
             cleaned_files = [str(r.file_path) for r in cleaning_result if r.success]
             self._report_cleaning_results(cleaned_files)
             return all(r.success for r in cleaning_result) if cleaning_result else True
         else:
-            # PackageCleaningResult from backup mode
             self._report_package_cleaning_results(cleaning_result)
             return cleaning_result.overall_success
 
@@ -114,7 +161,6 @@ class PhaseCoordinator:
             self.session.complete_task("cleaning", "No cleaning needed")
 
     def _report_package_cleaning_results(self, result: PackageCleaningResult) -> None:
-        """Report package cleaning results with backup information."""
         if result.overall_success:
             self.console.print(
                 f"[green]✅[/ green] Package cleaning completed successfully! "
@@ -156,35 +202,18 @@ 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
 
     def _execute_configuration_steps(self, options: OptionsProtocol) -> bool:
-        """Execute all configuration steps and return overall success."""
         success = True
 
-        # FIRST STEP: Smart config merge before all other operations
-        self._handle_smart_config_merge(options)
-
-        # Handle crackerjack project specific configuration
-        if self._is_crackerjack_project() and not self._copy_config_files_to_package():
-            success = False
-
-        # Update configuration files
         success &= self._update_configuration_files(options)
 
         return success
 
-    def _handle_smart_config_merge(self, options: OptionsProtocol) -> None:
-        """Handle smart config merge with warning on failure."""
-        if not self._perform_smart_config_merge(options):
-            self.console.print(
-                "[yellow]⚠️[/yellow] Smart config merge encountered issues (continuing)"
-            )
-            # Don't fail the entire configuration phase, just log the warning
-
     def _update_configuration_files(self, options: OptionsProtocol) -> bool:
-        """Update precommit and pyproject configuration files."""
         success = True
         if not self.config_service.update_precommit_config(options):
             success = False
@@ -193,7 +222,6 @@ class PhaseCoordinator:
         return success
 
     def _complete_configuration_task(self, success: bool) -> None:
-        """Complete the configuration task with appropriate message."""
         message = (
             "Configuration updated successfully"
             if success
@@ -201,95 +229,6 @@ class PhaseCoordinator:
         )
         self.session.complete_task("configuration", message)
 
-    def _perform_smart_config_merge(self, options: OptionsProtocol) -> bool:
-        """Perform smart config merge before git operations."""
-        try:
-            self.logger.debug("Starting smart config merge process")
-
-            # Smart merge for critical configuration files
-            merged_files = []
-
-            # Skip smart merge if explicitly requested or in specific modes
-            if hasattr(options, "skip_config_merge") and options.skip_config_merge:
-                self.logger.debug("Config merge skipped by option")
-                return True
-
-            # Merge .gitignore patterns (always safe to do)
-            if self._smart_merge_gitignore():
-                merged_files.append(".gitignore")
-
-            # Merge configuration files (pyproject.toml, .pre-commit-config.yaml)
-            # Only for crackerjack projects to avoid breaking user projects
-            if self._is_crackerjack_project():
-                if self._smart_merge_project_configs():
-                    merged_files.extend(["pyproject.toml", ".pre-commit-config.yaml"])
-
-            if merged_files:
-                files_str = ", ".join(merged_files)
-                self.console.print(
-                    f"[green]🔧[/green] Smart-merged configurations: {files_str}"
-                )
-                self.logger.info(f"Smart config merge completed: {merged_files}")
-            else:
-                self.logger.debug("No configuration files needed smart merging")
-
-            return True
-
-        except Exception as e:
-            self.console.print(f"[yellow]⚠️[/yellow] Smart config merge failed: {e}")
-            self.logger.warning(
-                f"Smart config merge failed: {e} (type: {type(e).__name__})"
-            )
-            # Return True to not block the workflow - this is fail-safe
-            return True
-
-    def _smart_merge_gitignore(self) -> bool:
-        """Smart merge .gitignore patterns."""
-        try:
-            gitignore_path = self.pkg_path / ".gitignore"
-            if not gitignore_path.exists():
-                return False
-
-            # Standard crackerjack ignore patterns to merge
-            standard_patterns = [
-                "# Crackerjack generated files",
-                ".crackerjack/",
-                "*.crackerjack.bak",
-                ".coverage.*",
-                "crackerjack-debug-*.log",
-                "__pycache__/",
-                "*.py[cod]",
-                "*$py.class",
-                ".pytest_cache/",
-                ".tox/",
-                ".mypy_cache/",
-                ".ruff_cache/",
-            ]
-
-            self.config_merge_service.smart_merge_gitignore(
-                patterns=standard_patterns, target_path=str(gitignore_path)
-            )
-
-            return True
-
-        except Exception as e:
-            self.logger.warning(f"Failed to smart merge .gitignore: {e}")
-            return False
-
-    def _smart_merge_project_configs(self) -> bool:
-        """Smart merge pyproject.toml and pre-commit config for crackerjack projects."""
-        try:
-            # This would be where we implement project config merging
-            # For now, just return True as the existing config service handles this
-            self.logger.debug(
-                "Project config smart merge placeholder - handled by existing config service"
-            )
-            return True
-
-        except Exception as e:
-            self.logger.warning(f"Failed to smart merge project configs: {e}")
-            return False
-
     def _is_crackerjack_project(self) -> bool:
         pyproject_path = self.pkg_path / "pyproject.toml"
         if not pyproject_path.exists():
@@ -301,58 +240,11 @@ class PhaseCoordinator:
             with pyproject_path.open("rb") as f:
                 data = tomllib.load(f)
 
-            project_name = data.get("project", {}).get("name", "")
+            project_name: str = data.get("project", {}).get("name", "")
             return project_name == "crackerjack"
         except Exception:
             return False
 
-    def _copy_config_files_to_package(self) -> bool:
-        try:
-            files_to_copy = [
-                "pyproject.toml",
-                ".pre-commit-config.yaml",
-                "CLAUDE.md",
-                "RULES.md",
-                ".gitignore",
-                "example.mcp.json",
-                "uv.lock",
-            ]
-
-            package_dir = self.pkg_path / "crackerjack"
-            if not package_dir.exists():
-                self.console.print(
-                    "[yellow]⚠️[/ yellow] Package directory not found: crackerjack /",
-                )
-                return False
-
-            copied_count = 0
-            for filename in files_to_copy:
-                src_path = self.pkg_path / filename
-                if src_path.exists():
-                    dst_path = package_dir / filename
-                    try:
-                        import shutil
-
-                        shutil.copy2(src_path, dst_path)
-                        copied_count += 1
-                        self.logger.debug(f"Copied {filename} to package directory")
-                    except Exception as e:
-                        self.console.print(
-                            f"[yellow]⚠️[/ yellow] Failed to copy {filename}: {e}",
-                        )
-
-            if copied_count > 0:
-                self.console.print(
-                    f"[green]✅[/ green] Copied {copied_count} config files to package directory",
-                )
-
-            return True
-        except Exception as e:
-            self.console.print(
-                f"[red]❌[/ red] Failed to copy config files to package: {e}",
-            )
-            return False
-
     def run_hooks_phase(self, options: OptionsProtocol) -> bool:
         if options.skip_hooks:
             return True
@@ -370,32 +262,26 @@ class PhaseCoordinator:
         if options.skip_hooks:
             return True
 
-        return self._execute_hooks_with_retry(
-            "fast",
-            self.hook_manager.run_fast_hooks,
-            options,
-        )
+        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,
-        )
+        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" + "-" * 74)
             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("-" * 74 + "\n")
             if not self.test_manager.validate_test_environment():
                 self.session.fail_task("testing", "Test environment validation failed")
                 return False
@@ -430,9 +316,15 @@ class PhaseCoordinator:
 
     def _determine_version_type(self, options: OptionsProtocol) -> str | None:
         if options.publish:
-            return options.publish
+            publish_value: str | None = (
+                options.publish if isinstance(options.publish, str) else None
+            )
+            return publish_value
         if options.all:
-            return options.all
+            all_value: str | None = (
+                options.all if isinstance(options.all, str) else None
+            )
+            return all_value
         if options.bump:
             self._handle_version_bump_only(options.bump)
             return None
@@ -443,9 +335,12 @@ class PhaseCoordinator:
         options: OptionsProtocol,
         version_type: str,
     ) -> bool:
+        # Display version bump header
+        self._display_version_bump_header(version_type)
         new_version = self.publish_manager.bump_version(version_type)
 
-        # Stage all changes after version bumping and code cleaning (if enabled)
+        # Display git operations header for staging and tagging
+        self._display_git_staging_header()
         self.console.print("[blue]📂[/ blue] Staging all changes for publishing...")
         if not self.git_service.add_all_files():
             self.console.print(
@@ -455,6 +350,8 @@ class PhaseCoordinator:
         if not options.no_git_tags:
             self.publish_manager.create_git_tag(new_version)
 
+        # Display publish header
+        self._display_publish_header()
         if self.publish_manager.publish_package():
             self._handle_successful_publish(options, new_version)
             return True
@@ -476,6 +373,9 @@ class PhaseCoordinator:
     def run_commit_phase(self, options: OptionsProtocol) -> bool:
         if not options.commit:
             return True
+
+        # Display commit & push header
+        self._display_commit_push_header()
         self.session.track_task("commit", "Git commit and push")
         try:
             changed_files = self.git_service.get_changed_files()
@@ -491,7 +391,6 @@ class PhaseCoordinator:
     def _handle_no_changes_to_commit(self) -> bool:
         self.console.print("[yellow]ℹ️[/ yellow] No changes to commit")
 
-        # Check if there are unpushed commits
         from contextlib import suppress
 
         with suppress(ValueError, Exception):
@@ -559,6 +458,8 @@ class PhaseCoordinator:
     def _handle_version_bump_only(self, bump_type: str) -> bool:
         self.session.track_task("version_bump", f"Version bump ({bump_type})")
         try:
+            # Display version bump header
+            self._display_version_bump_header(bump_type)
             new_version = self.publish_manager.bump_version(bump_type)
             self.console.print(f"[green]🎯[/ green] Version bumped to {new_version}")
             self.session.complete_task("version_bump", f"Bumped to {new_version}")
@@ -573,6 +474,49 @@ class PhaseCoordinator:
         changed_files: list[str],
         options: OptionsProtocol,
     ) -> str:
+        # Check if smart commit is enabled
+        if getattr(options, "smart_commit", False):
+            try:
+                from crackerjack.services.intelligent_commit import (
+                    CommitMessageGenerator,
+                )
+
+                self.console.print(
+                    "[cyan]🤖[/cyan] Generating intelligent commit message..."
+                )
+                commit_generator = CommitMessageGenerator(
+                    console=self.console, git_service=self.git_service
+                )
+
+                intelligent_message = commit_generator.generate_commit_message(
+                    include_body=False,
+                    conventional_commits=True,
+                )
+
+                if not options.interactive:
+                    self.console.print(
+                        f"[green]✨[/green] Generated: {intelligent_message}"
+                    )
+                    return intelligent_message
+
+                # In interactive mode, offer the intelligent message plus fallback suggestions
+                suggestions = [intelligent_message]
+                fallback_suggestions = self.git_service.get_commit_message_suggestions(
+                    changed_files
+                )
+                suggestions.extend(
+                    fallback_suggestions[:3]
+                )  # Add up to 3 fallback options
+
+                return self._interactive_commit_message_selection(suggestions)
+
+            except Exception as e:
+                self.console.print(
+                    f"[yellow]⚠️[/yellow] Intelligent commit generation failed: {e}"
+                )
+                # Fallback to original logic
+
+        # Original logic for non-smart commits
         suggestions = self.git_service.get_commit_message_suggestions(changed_files)
 
         if not suggestions:
@@ -615,33 +559,58 @@ 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:
+        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:
+        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 +640,12 @@ class PhaseCoordinator:
         return False
 
     def _attempt_autofix_for_fast_hooks(self, results: list[t.Any]) -> bool:
-        """Attempt to autofix fast hook failures."""
         try:
             self.logger.info("Attempting autofix for fast hook failures")
-            # Apply autofixes for fast hooks
-            return self.autofix_coordinator.apply_fast_stage_fixes()
+
+            autofix_coordinator = self._lazy_autofix.get()
+            fix_result: bool = autofix_coordinator.apply_fast_stage_fixes()
+            return fix_result
         except Exception as e:
             self.logger.warning(f"Autofix attempt failed: {e}")
             return False
@@ -697,15 +667,13 @@ class PhaseCoordinator:
             f"[red]❌[/ red] {hook_type.title()} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
         )
 
-        # Try autofix for fast hooks before giving up
         if hook_type == "fast" and attempt < max_retries - 1:
             if self._attempt_autofix_for_fast_hooks(results):
                 self.console.print(
                     "[yellow]🔧[/ yellow] Applied autofixes for fast hooks, retrying...",
                 )
-                return True  # Return True to continue the retry loop
+                return True
 
-        # Display detailed hook errors in verbose mode
         if getattr(options, "verbose", False):
             self._display_verbose_hook_errors(results, hook_type)
 
@@ -720,13 +688,11 @@ class PhaseCoordinator:
     def _display_verbose_hook_errors(
         self, results: list[t.Any], hook_type: str
     ) -> None:
-        """Display detailed hook error output in verbose mode."""
         self.console.print(
-            f"\n[bold yellow]📋 Detailed {hook_type} hook errors:[/bold yellow]"
+            f"\n[bold yellow]📋 Detailed {hook_type} hook errors: [/bold yellow]"
         )
 
         for result in results:
-            # Check if this hook failed
             status = getattr(result, "status", "")
             if status not in ("failed", "error", "timeout"):
                 continue
@@ -739,12 +705,10 @@ class PhaseCoordinator:
             if issues:
                 for issue in issues:
                     if isinstance(issue, str) and issue.strip():
-                        # Clean up the issue text and display with proper indentation
                         cleaned_issue = issue.strip()
-                        self.console.print(f"   {cleaned_issue}")
+                        self.console.print(f" {cleaned_issue}")
             else:
-                # If no specific issues, show generic failure message
-                self.console.print(f"   Hook failed with exit code (status: {status})")
+                self.console.print(f" Hook failed with exit code (status: {status})")
 
     def _build_detailed_hook_error_message(
         self, results: list[t.Any], summary: dict[str, t.Any]
@@ -798,3 +762,78 @@ 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
+
+    async def _execute_hooks_with_parallel_support(
+        self,
+        hook_type: str,
+        hook_runner: t.Callable[[], list[t.Any]],
+        options: OptionsProtocol,
+    ) -> bool:
+        self._initialize_hook_execution(hook_type)
+
+        try:
+            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:
+        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_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:
+        if hook_type != "fast":
+            return self._handle_hook_failures(
+                hook_type, options, summary, results, 0, 1
+            )
+
+        if not self._attempt_autofix_for_fast_hooks(results):
+            return self._handle_hook_failures(
+                hook_type, options, summary, results, 0, 1
+            )
+
+        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:
+        self.console.print(
+            "[yellow]🔧[/ yellow] Applied autofixes for fast hooks, retrying..."
+        )
+
+        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) -> AutofixCoordinator:
+        coordinator: AutofixCoordinator = self._lazy_autofix.get()
+        return coordinator