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

crackerjack/core/phase_coordinator.py

@@ -64,29 +64,24 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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)
-        # 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:
@@ -110,17 +105,42 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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
 
@@ -141,7 +161,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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! "
@@ -188,31 +207,13 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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
@@ -221,7 +222,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         return success
 
     def _complete_configuration_task(self, success: bool) -> None:
-        """Complete the configuration task with appropriate message."""
         message = (
             "Configuration updated successfully"
             if success
@@ -229,95 +229,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         )
         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():
@@ -329,58 +240,11 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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
@@ -398,7 +262,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         if options.skip_hooks:
             return True
 
-        # 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)
 
@@ -406,7 +269,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         if options.skip_hooks:
             return True
 
-        # 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)
 
@@ -415,11 +277,11 @@ class PhaseCoordinator(ErrorHandlingMixin):
             return True
         self.session.track_task("testing", "Test execution")
         try:
-            self.console.print("\n" + "-" * 40)
+            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("-" * 40 + "\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
@@ -454,9 +316,15 @@ class PhaseCoordinator(ErrorHandlingMixin):
 
     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
@@ -467,9 +335,12 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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(
@@ -479,6 +350,8 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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
@@ -500,6 +373,9 @@ class PhaseCoordinator(ErrorHandlingMixin):
     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()
@@ -515,7 +391,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
     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):
@@ -583,6 +458,8 @@ class PhaseCoordinator(ErrorHandlingMixin):
     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}")
@@ -597,6 +474,49 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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:
@@ -663,7 +583,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
     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)
@@ -680,7 +599,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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"
@@ -722,12 +640,12 @@ class PhaseCoordinator(ErrorHandlingMixin):
         return False
 
     def _attempt_autofix_for_fast_hooks(self, results: list[t.Any]) -> bool:
-        """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 using lazy-loaded service
+
             autofix_coordinator = self._lazy_autofix.get()
-            return autofix_coordinator.apply_fast_stage_fixes()
+            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
@@ -749,15 +667,13 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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)
 
@@ -772,13 +688,11 @@ class PhaseCoordinator(ErrorHandlingMixin):
     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
@@ -791,12 +705,10 @@ class PhaseCoordinator(ErrorHandlingMixin):
             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]
@@ -851,18 +763,15 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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
             )
@@ -876,16 +785,12 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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
         )
@@ -898,19 +803,16 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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(
@@ -919,12 +821,10 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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)
 
@@ -934,6 +834,6 @@ class PhaseCoordinator(ErrorHandlingMixin):
         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()
+    def autofix_coordinator(self) -> AutofixCoordinator:
+        coordinator: AutofixCoordinator = self._lazy_autofix.get()
+        return coordinator