crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/core/phase_coordinator.py

@@ -5,8 +5,10 @@ from pathlib import Path
 
 from rich.console import Console
 
-from crackerjack.code_cleaner import CodeCleaner
+from crackerjack.code_cleaner import CodeCleaner, PackageCleaningResult
+from crackerjack.core.autofix_coordinator import AutofixCoordinator
 from crackerjack.models.protocols import (
+    ConfigMergeServiceProtocol,
     FileSystemInterface,
     GitInterface,
     HookManager,
@@ -30,6 +32,7 @@ class PhaseCoordinator:
         hook_manager: HookManager,
         test_manager: TestManagerProtocol,
         publish_manager: PublishManager,
+        config_merge_service: ConfigMergeServiceProtocol,
     ) -> None:
         self.console = console
         self.pkg_path = pkg_path
@@ -40,9 +43,22 @@ class PhaseCoordinator:
         self.hook_manager = hook_manager
         self.test_manager = test_manager
         self.publish_manager = publish_manager
-
-        self.code_cleaner = CodeCleaner(console=console)
+        self.config_merge_service = config_merge_service
+
+        self.code_cleaner = CodeCleaner(
+            console=console,
+            base_directory=pkg_path,
+            file_processor=None,
+            error_handler=None,
+            pipeline=None,
+            logger=None,
+            security_logger=None,
+            backup_service=None,
+        )
         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")
 
@@ -55,82 +71,226 @@ 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.console.print(f"[red]❌[/ red] Cleaning failed: {e}")
             self.session.fail_task("cleaning", str(e))
             return False
 
     def _display_cleaning_header(self) -> None:
-        self.console.print("\n" + " - " * 80)
+        self.console.print("\n" + "-" * 80)
         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("-" * 80 + "\n")
         self.console.print("[yellow]🧹[/yellow] Starting code cleaning...")
 
     def _execute_cleaning_process(self) -> bool:
-        python_files = list(self.pkg_path.rglob("*.py"))
-
-        if not python_files:
-            return self._handle_no_files_to_clean()
-
-        cleaned_files = self._clean_python_files(python_files)
-        self._report_cleaning_results(cleaned_files)
-        return True
+        # 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
 
     def _handle_no_files_to_clean(self) -> bool:
-        self.console.print("[yellow]⚠️[/yellow] No Python files found to clean")
+        self.console.print("[yellow]⚠️[/ yellow] No Python files found to clean")
         self.session.complete_task("cleaning", "No files to clean")
         return True
 
-    def _clean_python_files(self, python_files: list[Path]) -> list[str]:
-        cleaned_files: list[str] = []
-        for file_path in python_files:
-            if self.code_cleaner.should_process_file(file_path):
-                if self.code_cleaner.clean_file(file_path):
-                    cleaned_files.append(str(file_path))
-        return cleaned_files
-
     def _report_cleaning_results(self, cleaned_files: list[str]) -> None:
         if cleaned_files:
-            self.console.print(f"[green]✅[/green] Cleaned {len(cleaned_files)} files")
+            self.console.print(f"[green]✅[/ green] Cleaned {len(cleaned_files)} files")
             self.session.complete_task(
                 "cleaning",
                 f"Cleaned {len(cleaned_files)} files",
             )
         else:
-            self.console.print("[green]✅[/green] No cleaning needed")
+            self.console.print("[green]✅[/ green] No cleaning needed")
             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! "
+                f"({result.successful_files}/{result.total_files} files cleaned)"
+            )
+            self.session.complete_task(
+                "cleaning",
+                f"Cleaned {result.successful_files}/{result.total_files} files with backup protection",
+            )
+        else:
+            self.console.print(
+                f"[red]❌[/ red] Package cleaning failed! "
+                f"({result.failed_files}/{result.total_files} files failed)"
+            )
+
+            if result.backup_restored:
+                self.console.print(
+                    "[yellow]⚠️[/ yellow] Files were automatically restored from backup"
+                )
+                self.session.complete_task(
+                    "cleaning", "Failed with automatic backup restoration"
+                )
+            else:
+                self.session.fail_task(
+                    "cleaning", f"Failed to clean {result.failed_files} files"
+                )
+
+            if result.backup_metadata:
+                self.console.print(
+                    f"[blue]📦[/ blue] Backup available at: {result.backup_metadata.backup_directory}"
+                )
+
     def run_configuration_phase(self, options: OptionsProtocol) -> bool:
         if options.no_config_updates:
             return True
         self.session.track_task("configuration", "Configuration updates")
         try:
-            success = True
+            success = self._execute_configuration_steps(options)
+            self._complete_configuration_task(success)
+            return success
+        except Exception as e:
+            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
+        if not self.config_service.update_pyproject_config(options):
+            success = False
+        return success
+
+    def _complete_configuration_task(self, success: bool) -> None:
+        """Complete the configuration task with appropriate message."""
+        message = (
+            "Configuration updated successfully"
+            if success
+            else "Some configuration updates failed"
+        )
+        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")
 
-            # Check if we're running from the crackerjack project root
+            # 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 not self._copy_config_files_to_package():
-                    success = False
+                if self._smart_merge_project_configs():
+                    merged_files.extend(["pyproject.toml", ".pre-commit-config.yaml"])
 
-            if not self.config_service.update_precommit_config(options):
-                success = False
-            if not self.config_service.update_pyproject_config(options):
-                success = False
-            self.session.complete_task(
-                "configuration",
-                "Configuration updated successfully"
-                if success
-                else "Some configuration updates failed",
+            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 success
+            # 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.session.fail_task("configuration", str(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:
-        """Check if we're running from the crackerjack project root."""
-        # Check for crackerjack-specific markers
         pyproject_path = self.pkg_path / "pyproject.toml"
         if not pyproject_path.exists():
             return False
@@ -141,16 +301,13 @@ class PhaseCoordinator:
             with pyproject_path.open("rb") as f:
                 data = tomllib.load(f)
 
-            # Check if this is the crackerjack project
             project_name = data.get("project", {}).get("name", "")
             return project_name == "crackerjack"
         except Exception:
             return False
 
     def _copy_config_files_to_package(self) -> bool:
-        """Copy configuration files from project root to package root."""
         try:
-            # Files to copy from project root to package root
             files_to_copy = [
                 "pyproject.toml",
                 ".pre-commit-config.yaml",
@@ -164,7 +321,7 @@ class PhaseCoordinator:
             package_dir = self.pkg_path / "crackerjack"
             if not package_dir.exists():
                 self.console.print(
-                    "[yellow]⚠️[/yellow] Package directory not found: crackerjack/",
+                    "[yellow]⚠️[/ yellow] Package directory not found: crackerjack /",
                 )
                 return False
 
@@ -181,18 +338,18 @@ class PhaseCoordinator:
                         self.logger.debug(f"Copied {filename} to package directory")
                     except Exception as e:
                         self.console.print(
-                            f"[yellow]⚠️[/yellow] Failed to copy {filename}: {e}",
+                            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",
+                    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}",
+                f"[red]❌[/ red] Failed to copy config files to package: {e}",
             )
             return False
 
@@ -236,7 +393,7 @@ class PhaseCoordinator:
         try:
             self.console.print("\n" + "-" * 80)
             self.console.print(
-                "[bold bright_blue]🧪 TESTS[/bold bright_blue] [bold bright_white]Running test suite[/bold bright_white]",
+                "[bold bright_blue]🧪 TESTS[/ bold bright_blue] [bold bright_white]Running test suite[/ bold bright_white]",
             )
             self.console.print("-" * 80 + "\n")
             if not self.test_manager.validate_test_environment():
@@ -247,7 +404,7 @@ class PhaseCoordinator:
                 coverage_info = self.test_manager.get_coverage()
                 self.session.complete_task(
                     "testing",
-                    f"Tests passed, coverage: {coverage_info.get('total_coverage', 0):.1f}%",
+                    f"Tests passed, coverage: {coverage_info.get('total_coverage', 0): .1f}%",
                 )
             else:
                 self.session.fail_task("testing", "Tests failed")
@@ -267,7 +424,7 @@ class PhaseCoordinator:
         try:
             return self._execute_publishing_workflow(options, version_type)
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Publishing failed: {e}")
+            self.console.print(f"[red]❌[/ red] Publishing failed: {e}")
             self.session.fail_task("publishing", str(e))
             return False
 
@@ -302,7 +459,7 @@ class PhaseCoordinator:
         options: OptionsProtocol,
         new_version: str,
     ) -> None:
-        self.console.print(f"[green]🚀[/green] Successfully published {new_version}!")
+        self.console.print(f"[green]🚀[/ green] Successfully published {new_version}!")
 
         if options.cleanup_pypi:
             self.publish_manager.cleanup_old_releases(options.keep_releases)
@@ -320,12 +477,12 @@ class PhaseCoordinator:
             commit_message = self._get_commit_message(changed_files, options)
             return self._execute_commit_and_push(changed_files, commit_message)
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Commit failed: {e}")
+            self.console.print(f"[red]❌[/ red] Commit failed: {e}")
             self.session.fail_task("commit", str(e))
             return False
 
     def _handle_no_changes_to_commit(self) -> bool:
-        self.console.print("[yellow]ℹ️[/yellow] No changes to commit")
+        self.console.print("[yellow]ℹ️[/ yellow] No changes to commit")
         self.session.complete_task("commit", "No changes to commit")
         return True
 
@@ -347,7 +504,7 @@ class PhaseCoordinator:
     def _handle_push_result(self, commit_message: str) -> bool:
         if self.git_service.push():
             self.console.print(
-                f"[green]🎉[/green] Committed and pushed: {commit_message}",
+                f"[green]🎉[/ green] Committed and pushed: {commit_message}",
             )
             self.session.complete_task(
                 "commit",
@@ -355,7 +512,7 @@ class PhaseCoordinator:
             )
         else:
             self.console.print(
-                f"[yellow]⚠️[/yellow] Committed but push failed: {commit_message}",
+                f"[yellow]⚠️[/ yellow] Committed but push failed: {commit_message}",
             )
             self.session.complete_task(
                 "commit",
@@ -375,11 +532,11 @@ class PhaseCoordinator:
         self.session.track_task("version_bump", f"Version bump ({bump_type})")
         try:
             new_version = self.publish_manager.bump_version(bump_type)
-            self.console.print(f"[green]🎯[/green] Version bumped to {new_version}")
+            self.console.print(f"[green]🎯[/ green] Version bumped to {new_version}")
             self.session.complete_task("version_bump", f"Bumped to {new_version}")
             return True
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Version bump failed: {e}")
+            self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             self.session.fail_task("version_bump", str(e))
             return False
 
@@ -403,14 +560,14 @@ class PhaseCoordinator:
 
         try:
             choice = self.console.input(
-                f"\nSelect message (1 - {len(suggestions)}) or enter custom: ",
+                f"\nSelect message (1-{len(suggestions)}) or enter custom: ",
             )
             return self._process_commit_choice(choice, suggestions)
         except (KeyboardInterrupt, EOFError):
             return suggestions[0]
 
     def _display_commit_suggestions(self, suggestions: list[str]) -> None:
-        self.console.print("[cyan]📝[/cyan] Commit message suggestions: ")
+        self.console.print("[cyan]📝[/ cyan] Commit message suggestions: ")
         for i, suggestion in enumerate(suggestions, 1):
             self.console.print(f" {i}. {suggestion}")
 
@@ -480,11 +637,21 @@ class PhaseCoordinator:
         if hook_type == "fast" and attempt < max_retries - 1:
             if self._should_retry_fast_hooks(results):
                 self.console.print(
-                    "[yellow]🔄[/yellow] Fast hooks modified files, retrying all fast hooks...",
+                    "[yellow]🔄[/ yellow] Fast hooks modified files, retrying all fast hooks...",
                 )
                 return True
         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()
+        except Exception as e:
+            self.logger.warning(f"Autofix attempt failed: {e}")
+            return False
+
     def _handle_hook_failures(
         self,
         hook_type: str,
@@ -494,15 +661,26 @@ class PhaseCoordinator:
         attempt: int,
         max_retries: int,
     ) -> bool:
-        self.logger.warning(
+        self.logger.debug(
             f"{hook_type} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
         )
 
         self.console.print(
-            f"[red]❌[/red] {hook_type.title()} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
+            f"[red]❌[/ red] {hook_type.title()} hooks failed: {summary['failed']} failed, {summary['errors']} errors",
         )
 
-        # Collect detailed hook failure information for AI agent processing
+        # 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
+
+        # Display detailed hook errors in verbose mode
+        if getattr(options, "verbose", False):
+            self._display_verbose_hook_errors(results, hook_type)
+
         detailed_error_msg = self._build_detailed_hook_error_message(results, summary)
 
         self.session.fail_task(
@@ -511,13 +689,40 @@ class PhaseCoordinator:
         )
         return False
 
+    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]"
+        )
+
+        for result in results:
+            # Check if this hook failed
+            status = getattr(result, "status", "")
+            if status not in ("failed", "error", "timeout"):
+                continue
+
+            hook_name = getattr(result, "name", "unknown")
+            issues = getattr(result, "issues_found", [])
+
+            self.console.print(f"\n[red]❌ {hook_name}[/red]")
+
+            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}")
+            else:
+                # If no specific issues, show generic failure message
+                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]
     ) -> str:
-        """Build detailed error message with specific hook failure information."""
         error_parts = [f"{summary['failed']} failed, {summary['errors']} errors"]
 
-        # Extract specific hook failures
         failed_hooks = []
         for result in results:
             if hasattr(result, "failed") and result.failed:
@@ -532,38 +737,20 @@ class PhaseCoordinator:
         return " | ".join(error_parts)
 
     def _should_retry_fast_hooks(self, results: list[t.Any]) -> bool:
-        formatting_hooks = {
-            "ruff-format",
-            "ruff-check",
-            "trailing-whitespace",
-            "end-of-file-fixer",
-        }
-
         for result in results:
-            hook_id = getattr(result, "hook_id", "") or getattr(result, "name", "")
-            if (
-                hook_id in formatting_hooks
-                and hasattr(result, "failed")
-                and result.failed
-            ):
-                output = getattr(result, "output", "") or getattr(result, "stdout", "")
-                if any(
-                    phrase in output.lower()
-                    for phrase in (
-                        "files were modified",
-                        "fixed",
-                        "reformatted",
-                        "fixing",
-                    )
-                ):
-                    return True
+            if hasattr(result, "failed") and result.failed:
+                return True
+
+            status = getattr(result, "status", "")
+            if status in ("failed", "error", "timeout"):
+                return True
         return False
 
     def _apply_retry_backoff(self, attempt: int) -> None:
         if attempt > 0:
             backoff_delay = 2 ** (attempt - 1)
             self.logger.debug(f"Applying exponential backoff: {backoff_delay}s")
-            self.console.print(f"[dim]Waiting {backoff_delay}s before retry...[/dim]")
+            self.console.print(f"[dim]Waiting {backoff_delay}s before retry...[/ dim]")
             time.sleep(backoff_delay)
 
     def _handle_hook_success(self, hook_type: str, summary: dict[str, t.Any]) -> bool:
@@ -571,7 +758,7 @@ class PhaseCoordinator:
             f"{hook_type} hooks passed: {summary['passed']} / {summary['total']}",
         )
         self.console.print(
-            f"[green]✅[/green] {hook_type.title()} hooks passed: {summary['passed']} / {summary['total']}",
+            f"[green]✅[/ green] {hook_type.title()} hooks passed: {summary['passed']} / {summary['total']}",
         )
         self.session.complete_task(
             f"{hook_type}_hooks",
@@ -580,6 +767,6 @@ class PhaseCoordinator:
         return True
 
     def _handle_hook_exception(self, hook_type: str, e: Exception) -> bool:
-        self.console.print(f"[red]❌[/red] {hook_type.title()} hooks error: {e}")
+        self.console.print(f"[red]❌[/ red] {hook_type.title()} hooks error: {e}")
         self.session.fail_task(f"{hook_type}_hooks", str(e))
         return False