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

crackerjack/core/workflow_orchestrator.py

@@ -1,3 +1,4 @@
+import asyncio
 import time
 import typing as t
 from pathlib import Path
@@ -7,12 +8,22 @@ from rich.console import Console
 from crackerjack.agents.base import AgentContext, Issue, IssueType, Priority
 from crackerjack.agents.coordinator import AgentCoordinator
 from crackerjack.models.protocols import OptionsProtocol
-from crackerjack.services.debug import get_ai_agent_debugger
+from crackerjack.services.debug import (
+    AIAgentDebugger,
+    NoOpDebugger,
+    get_ai_agent_debugger,
+)
 from crackerjack.services.logging import (
     LoggingContext,
     get_logger,
     setup_structured_logging,
 )
+from crackerjack.services.memory_optimizer import get_memory_optimizer, memory_optimized
+from crackerjack.services.performance_cache import get_performance_cache
+from crackerjack.services.performance_monitor import (
+    get_performance_monitor,
+    phase_monitor,
+)
 
 from .phase_coordinator import PhaseCoordinator
 from .session_coordinator import SessionCoordinator
@@ -40,13 +51,17 @@ class WorkflowPipeline:
         self.session = session
         self.phases = phases
         self._mcp_state_manager: t.Any = None
-        self._last_security_audit: t.Any = None  # Store security audit report
+        self._last_security_audit: t.Any = None
 
         self.logger = get_logger("crackerjack.pipeline")
-        self._debugger = None
+        self._debugger: AIAgentDebugger | NoOpDebugger | None = None
+
+        self._performance_monitor = get_performance_monitor()
+        self._memory_optimizer = get_memory_optimizer()
+        self._cache = get_performance_cache()
 
     @property
-    def debugger(self):
+    def debugger(self) -> AIAgentDebugger | NoOpDebugger:
         if self._debugger is None:
             self._debugger = get_ai_agent_debugger()
         return self._debugger
@@ -56,7 +71,14 @@ class WorkflowPipeline:
 
         return os.environ.get("AI_AGENT_DEBUG", "0") == "1"
 
+    @memory_optimized
     async def run_complete_workflow(self, options: OptionsProtocol) -> bool:
+        workflow_id = f"workflow_{int(time.time())}"
+
+        self._performance_monitor.start_workflow(workflow_id)
+
+        await self._cache.start()
+
         with LoggingContext(
             "workflow_execution",
             testing=getattr(options, "test", False),
@@ -66,24 +88,43 @@ class WorkflowPipeline:
             self._initialize_workflow_session(options)
 
             try:
-                success = await self._execute_workflow_with_timing(options, start_time)
+                success = await self._execute_workflow_with_timing(
+                    options, start_time, workflow_id
+                )
+
+                workflow_perf = self._performance_monitor.end_workflow(
+                    workflow_id, success
+                )
+                self.logger.info(
+                    f"Workflow performance: {workflow_perf.performance_score: .1f} score, "
+                    f"{workflow_perf.total_duration_seconds: .2f}s duration"
+                )
+
                 return success
 
             except KeyboardInterrupt:
+                self._performance_monitor.end_workflow(workflow_id, False)
                 return self._handle_user_interruption()
 
             except Exception as e:
+                self._performance_monitor.end_workflow(workflow_id, False)
                 return self._handle_workflow_exception(e)
 
             finally:
                 self.session.cleanup_resources()
 
+                self._memory_optimizer.optimize_memory()
+                await self._cache.stop()
+
     def _initialize_workflow_session(self, options: OptionsProtocol) -> None:
         self.session.initialize_session_tracking(options)
         self.session.track_task("workflow", "Complete crackerjack workflow")
 
         self._log_workflow_startup_debug(options)
         self._configure_session_cleanup(options)
+        self._initialize_zuban_lsp(options)
+        self._configure_hook_manager_lsp(options)
+        self._register_lsp_cleanup_handler(options)
         self._log_workflow_startup_info(options)
 
     def _log_workflow_startup_debug(self, options: OptionsProtocol) -> None:
@@ -104,6 +145,138 @@ class WorkflowPipeline:
         if hasattr(options, "cleanup"):
             self.session.set_cleanup_config(options.cleanup)
 
+    def _initialize_zuban_lsp(self, options: OptionsProtocol) -> None:
+        """Initialize Zuban LSP server if not disabled."""
+        # Check if LSP is disabled via CLI flag or configuration
+        if getattr(options, "no_zuban_lsp", False):
+            self.logger.debug("Zuban LSP server disabled by --no-zuban-lsp flag")
+            return
+
+        # Get configuration from options (will use config system if available)
+        config = getattr(options, "zuban_lsp", None)
+        if config and not config.enabled:
+            self.logger.debug("Zuban LSP server disabled in configuration")
+            return
+
+        if config and not config.auto_start:
+            self.logger.debug("Zuban LSP server auto-start disabled in configuration")
+            return
+
+        # Check if LSP server is already running to avoid duplicates
+        from crackerjack.services.server_manager import find_zuban_lsp_processes
+
+        existing_processes = find_zuban_lsp_processes()
+        if existing_processes:
+            self.logger.debug(
+                f"Zuban LSP server already running (PID: {existing_processes[0]['pid']})"
+            )
+            return
+
+        # Auto-start LSP server in background
+        try:
+            import subprocess
+            import sys
+
+            # Use configuration values if available, otherwise fallback to CLI options
+            if config:
+                zuban_lsp_port = config.port
+                zuban_lsp_mode = config.mode
+            else:
+                zuban_lsp_port = getattr(options, "zuban_lsp_port", 8677)
+                zuban_lsp_mode = getattr(options, "zuban_lsp_mode", "stdio")
+
+            cmd = [
+                sys.executable,
+                "-m",
+                "crackerjack",
+                "--start-zuban-lsp",
+                "--zuban-lsp-port",
+                str(zuban_lsp_port),
+                "--zuban-lsp-mode",
+                zuban_lsp_mode,
+            ]
+
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+
+            self.logger.info(
+                f"Auto-started Zuban LSP server on port {zuban_lsp_port} ({zuban_lsp_mode} mode)"
+            )
+
+        except Exception as e:
+            self.logger.warning(f"Failed to auto-start Zuban LSP server: {e}")
+
+    def _log_zuban_lsp_status(self) -> None:
+        """Display current Zuban LSP server status during workflow startup."""
+        from crackerjack.services.server_manager import find_zuban_lsp_processes
+
+        try:
+            lsp_processes = find_zuban_lsp_processes()
+
+            if lsp_processes:
+                proc = lsp_processes[0]  # Show first running process
+                self.logger.info(
+                    f"🔍 Zuban LSP server running (PID: {proc['pid']}, "
+                    f"CPU: {proc['cpu']}%, Memory: {proc['mem']}%)"
+                )
+            else:
+                self.logger.info("🔍 Zuban LSP server not running")
+
+        except Exception as e:
+            self.logger.debug(f"Failed to check Zuban LSP status: {e}")
+
+    def _configure_hook_manager_lsp(self, options: OptionsProtocol) -> None:
+        """Configure hook manager with LSP optimization settings."""
+        # Check if LSP hooks are enabled
+        enable_lsp_hooks = getattr(options, "enable_lsp_hooks", False)
+
+        # Configure the hook manager
+        hook_manager = self.phases.hook_manager
+        if hasattr(hook_manager, "configure_lsp_optimization"):
+            hook_manager.configure_lsp_optimization(enable_lsp_hooks)
+
+            if enable_lsp_hooks and not getattr(options, "no_zuban_lsp", False):
+                self.console.print(
+                    "🔍 LSP-optimized hook execution enabled for faster type checking",
+                    style="blue",
+                )
+
+    def _register_lsp_cleanup_handler(self, options: OptionsProtocol) -> None:
+        """Register cleanup handler to stop LSP server when workflow completes."""
+        # Get configuration to check if we should handle LSP cleanup
+        config = getattr(options, "zuban_lsp", None)
+        if config and not config.enabled:
+            return
+
+        if getattr(options, "no_zuban_lsp", False):
+            return
+
+        def cleanup_lsp_server() -> None:
+            """Cleanup function to gracefully stop LSP server if it was auto-started."""
+            try:
+                from crackerjack.services.server_manager import (
+                    find_zuban_lsp_processes,
+                    stop_process,
+                )
+
+                lsp_processes = find_zuban_lsp_processes()
+                if lsp_processes:
+                    for proc in lsp_processes:
+                        self.logger.debug(
+                            f"Stopping auto-started Zuban LSP server (PID: {proc['pid']})"
+                        )
+                        stop_process(proc["pid"])
+
+            except Exception as e:
+                self.logger.debug(f"Error during LSP cleanup: {e}")
+
+        # Register the cleanup handler with the session
+        self.session.register_cleanup(cleanup_lsp_server)
+
     def _log_workflow_startup_info(self, options: OptionsProtocol) -> None:
         self.logger.info(
             "Starting complete workflow execution",
@@ -112,10 +285,13 @@ class WorkflowPipeline:
             package_path=str(self.pkg_path),
         )
 
+        # Display Zuban LSP server status
+        self._log_zuban_lsp_status()
+
     async def _execute_workflow_with_timing(
-        self, options: OptionsProtocol, start_time: float
+        self, options: OptionsProtocol, start_time: float, workflow_id: str
     ) -> bool:
-        success = await self._execute_workflow_phases(options)
+        success = await self._execute_workflow_phases(options, workflow_id)
         self.session.finalize_session(start_time, success)
 
         duration = time.time() - start_time
@@ -161,62 +337,127 @@ class WorkflowPipeline:
         )
         return False
 
-    async def _execute_workflow_phases(self, options: OptionsProtocol) -> bool:
+    async def _execute_workflow_phases(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
         success = True
-        self.phases.run_configuration_phase(options)
 
-        # Code cleaning is now integrated into the quality phase
-        # to run after fast hooks but before comprehensive hooks
-        quality_success = await self._execute_quality_phase(options)
+        with phase_monitor(workflow_id, "configuration"):
+            config_success = self.phases.run_configuration_phase(options)
+            success = success and config_success
+
+        quality_success = await self._execute_quality_phase(options, workflow_id)
         if not quality_success:
             success = False
-            # Don't return early - continue to publishing/commit phases if requested
-            # This allows -p and -c flags to work even when quality checks fail
-            if not (options.publish or options.all or options.commit):
-                # Only exit early if no publishing/commit operations are requested
+
+            if self._is_publishing_workflow(options):
                 return False
 
-        if not self.phases.run_publishing_phase(options):
+        if not await self._execute_publishing_workflow(options, workflow_id):
             success = False
-            self.session.fail_task("workflow", "Publishing failed")
             return False
-        if not self.phases.run_commit_phase(options):
+
+        if not await self._execute_commit_workflow(options, workflow_id):
             success = False
 
         return success
 
-    async def _execute_quality_phase(self, options: OptionsProtocol) -> bool:
+    def _is_publishing_workflow(self, options: OptionsProtocol) -> bool:
+        return bool(options.publish or options.all or options.commit)
+
+    async def _execute_publishing_workflow(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        if not options.publish and not options.all:
+            return True
+
+        with phase_monitor(workflow_id, "publishing"):
+            if not self.phases.run_publishing_phase(options):
+                self.session.fail_task("workflow", "Publishing failed")
+                return False
+        return True
+
+    async def _execute_commit_workflow(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        if not options.commit:
+            return True
+
+        with phase_monitor(workflow_id, "commit"):
+            if not self.phases.run_commit_phase(options):
+                return False
+        return True
+
+    async def _execute_quality_phase(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
         if hasattr(options, "fast") and options.fast:
-            return self._run_fast_hooks_phase(options)
+            return await self._run_fast_hooks_phase_monitored(options, workflow_id)
         if hasattr(options, "comp") and options.comp:
-            return self._run_comprehensive_hooks_phase(options)
+            return await self._run_comprehensive_hooks_phase_monitored(
+                options, workflow_id
+            )
         if getattr(options, "test", False):
-            return await self._execute_test_workflow(options)
-        return self._execute_standard_hooks_workflow(options)
+            return await self._execute_test_workflow(options, workflow_id)
+        return await self._execute_standard_hooks_workflow_monitored(
+            options, workflow_id
+        )
 
-    async def _execute_test_workflow(self, options: OptionsProtocol) -> bool:
+    async def _execute_test_workflow(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
         iteration = self._start_iteration_tracking(options)
 
-        if not self._run_initial_fast_hooks(options, iteration):
+        if not await self._execute_initial_phases(options, workflow_id, iteration):
             return False
 
-        # Run code cleaning after fast hooks but before comprehensive hooks
-        if getattr(options, "clean", False):
-            if not self._run_code_cleaning_phase(options):
-                return False
-            # Run fast hooks again after cleaning for sanity check
-            if not self._run_post_cleaning_fast_hooks(options):
+        (
+            testing_passed,
+            comprehensive_passed,
+        ) = await self._run_main_quality_phases_async(options, workflow_id)
+
+        return await self._handle_workflow_completion(
+            options, iteration, testing_passed, comprehensive_passed, workflow_id
+        )
+
+    async def _execute_initial_phases(
+        self, options: OptionsProtocol, workflow_id: str, iteration: int
+    ) -> bool:
+        with phase_monitor(workflow_id, "fast_hooks") as monitor:
+            if not await self._run_initial_fast_hooks_async(
+                options, iteration, monitor
+            ):
                 return False
-            self._mark_code_cleaning_complete()
 
-        testing_passed, comprehensive_passed = self._run_main_quality_phases(options)
+        return self._execute_optional_cleaning_phase(options)
+
+    def _execute_optional_cleaning_phase(self, options: OptionsProtocol) -> bool:
+        if not getattr(options, "clean", False):
+            return True
+
+        if not self._run_code_cleaning_phase(options):
+            return False
+
+        if not self._run_post_cleaning_fast_hooks(options):
+            return False
+
+        self._mark_code_cleaning_complete()
+        return True
 
+    async def _handle_workflow_completion(
+        self,
+        options: OptionsProtocol,
+        iteration: int,
+        testing_passed: bool,
+        comprehensive_passed: bool,
+        workflow_id: str = "unknown",
+    ) -> bool:
         if options.ai_agent:
             return await self._handle_ai_agent_workflow(
-                options, iteration, testing_passed, comprehensive_passed
+                options, iteration, testing_passed, comprehensive_passed, workflow_id
             )
 
-        return self._handle_standard_workflow(
+        return await self._handle_standard_workflow(
             options, iteration, testing_passed, comprehensive_passed
         )
 
@@ -234,9 +475,36 @@ class WorkflowPipeline:
             return False
         return True
 
-    def _run_main_quality_phases(self, options: OptionsProtocol) -> tuple[bool, bool]:
-        testing_passed = self._run_testing_phase(options)
-        comprehensive_passed = self._run_comprehensive_hooks_phase(options)
+    async def _run_main_quality_phases_async(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> tuple[bool, bool]:
+        testing_task = asyncio.create_task(
+            self._run_testing_phase_async(options, workflow_id)
+        )
+        comprehensive_task = asyncio.create_task(
+            self._run_comprehensive_hooks_phase_monitored(options, workflow_id)
+        )
+
+        results = await asyncio.gather(
+            testing_task, comprehensive_task, return_exceptions=True
+        )
+
+        testing_result, comprehensive_result = results
+
+        if isinstance(testing_result, Exception):
+            self.logger.error(f"Testing phase failed with exception: {testing_result}")
+            testing_passed = False
+        else:
+            testing_passed = bool(testing_result)
+
+        if isinstance(comprehensive_result, Exception):
+            self.logger.error(
+                f"Comprehensive hooks failed with exception: {comprehensive_result}"
+            )
+            comprehensive_passed = False
+        else:
+            comprehensive_passed = bool(comprehensive_result)
+
         return testing_passed, comprehensive_passed
 
     async def _handle_ai_agent_workflow(
@@ -245,77 +513,101 @@ class WorkflowPipeline:
         iteration: int,
         testing_passed: bool,
         comprehensive_passed: bool,
+        workflow_id: str = "unknown",
     ) -> bool:
-        # Check security gates for publishing operations
+        if not await self._process_security_gates(options):
+            return False
+
+        needs_ai_fixing = self._determine_ai_fixing_needed(
+            testing_passed, comprehensive_passed, bool(options.publish or options.all)
+        )
+
+        if needs_ai_fixing:
+            return await self._execute_ai_fixing_workflow(options, iteration)
+
+        return self._finalize_ai_workflow_success(
+            options, iteration, testing_passed, comprehensive_passed
+        )
+
+    async def _process_security_gates(self, options: OptionsProtocol) -> bool:
         publishing_requested, security_blocks = (
             self._check_security_gates_for_publishing(options)
         )
 
-        if publishing_requested and security_blocks:
-            # Try AI fixing for security issues, then re-check
-            security_fix_result = await self._handle_security_gate_failure(
-                options, allow_ai_fixing=True
-            )
-            if not security_fix_result:
-                return False
-            # If AI fixing resolved security issues, continue with normal flow
+        if not (publishing_requested and security_blocks):
+            return True
 
-        # Determine if we need AI fixing based on publishing requirements
-        needs_ai_fixing = self._determine_ai_fixing_needed(
-            testing_passed, comprehensive_passed, publishing_requested
+        security_fix_result = await self._handle_security_gate_failure(
+            options, allow_ai_fixing=True
         )
+        return security_fix_result
 
-        if needs_ai_fixing:
-            success = await self._run_ai_agent_fixing_phase(options)
-            if self._should_debug():
-                self.debugger.log_iteration_end(iteration, success)
-            return success
+    async def _execute_ai_fixing_workflow(
+        self, options: OptionsProtocol, iteration: int
+    ) -> bool:
+        success = await self._run_ai_agent_fixing_phase(options)
+        if self._should_debug():
+            self.debugger.log_iteration_end(iteration, success)
+        return success
+
+    def _finalize_ai_workflow_success(
+        self,
+        options: OptionsProtocol,
+        iteration: int,
+        testing_passed: bool,
+        comprehensive_passed: bool,
+    ) -> bool:
+        publishing_requested = bool(options.publish or options.all)
 
-        # Determine final success based on publishing requirements
         final_success = self._determine_workflow_success(
-            testing_passed,
-            comprehensive_passed,
-            publishing_requested,
-            workflow_type="ai",
+            testing_passed, comprehensive_passed, publishing_requested
         )
 
-        # Show security audit warning for partial success in publishing workflows
-        if (
-            publishing_requested
-            and final_success
-            and not (testing_passed and comprehensive_passed)
-        ):
-            self._show_security_audit_warning()
+        self._show_partial_success_warning_if_needed(
+            publishing_requested, final_success, testing_passed, comprehensive_passed
+        )
 
         if self._should_debug():
             self.debugger.log_iteration_end(iteration, final_success)
+
         return final_success
 
-    def _handle_standard_workflow(
+    def _show_partial_success_warning_if_needed(
+        self,
+        publishing_requested: bool,
+        final_success: bool,
+        testing_passed: bool,
+        comprehensive_passed: bool,
+    ) -> None:
+        should_show_warning = (
+            publishing_requested
+            and final_success
+            and not (testing_passed and comprehensive_passed)
+        )
+
+        if should_show_warning:
+            self._show_security_audit_warning()
+
+    async def _handle_standard_workflow(
         self,
         options: OptionsProtocol,
         iteration: int,
         testing_passed: bool,
         comprehensive_passed: bool,
     ) -> bool:
-        # Check security gates for publishing operations
         publishing_requested, security_blocks = (
             self._check_security_gates_for_publishing(options)
         )
 
         if publishing_requested and security_blocks:
-            # Standard workflow cannot bypass security gates
-            return self._handle_security_gate_failure(options, allow_ai_fixing=False)
+            return await self._handle_security_gate_failure(options)
 
-        # Determine success based on publishing requirements
         success = self._determine_workflow_success(
             testing_passed,
             comprehensive_passed,
             publishing_requested,
-            workflow_type="standard",
         )
 
-        # Show security audit warning for partial success in publishing workflows
         if (
             publishing_requested
             and success
@@ -324,10 +616,9 @@ class WorkflowPipeline:
             self._show_security_audit_warning()
         elif publishing_requested and not success:
             self.console.print(
-                "[red]❌ Both tests and comprehensive hooks failed - cannot proceed to publishing[/red]"
+                "[red]❌ Quality checks failed - cannot proceed to publishing[/red]"
             )
 
-        # Show verbose failure details if requested
         if not success and getattr(options, "verbose", False):
             self._show_verbose_failure_details(testing_passed, comprehensive_passed)
 
@@ -378,7 +669,6 @@ class WorkflowPipeline:
             self._mcp_state_manager.update_stage_status(stage, status)
 
     def _run_code_cleaning_phase(self, options: OptionsProtocol) -> bool:
-        """Run code cleaning phase after fast hooks but before comprehensive hooks."""
         self.console.print("\n[bold blue]🧹 Running Code Cleaning Phase...[/bold blue]")
 
         success = self.phases.run_cleaning_phase(options)
@@ -391,7 +681,6 @@ class WorkflowPipeline:
         return success
 
     def _run_post_cleaning_fast_hooks(self, options: OptionsProtocol) -> bool:
-        """Run fast hooks again after code cleaning for sanity check."""
         self.console.print(
             "\n[bold cyan]🔍 Running Post-Cleaning Fast Hooks Sanity Check...[/bold cyan]"
         )
@@ -406,11 +695,9 @@ class WorkflowPipeline:
         return success
 
     def _has_code_cleaning_run(self) -> bool:
-        """Check if code cleaning has already run in this workflow."""
         return getattr(self, "_code_cleaning_complete", False)
 
     def _mark_code_cleaning_complete(self) -> None:
-        """Mark code cleaning as complete for this workflow."""
         self._code_cleaning_complete = True
 
     def _handle_test_failures(self) -> None:
@@ -443,24 +730,21 @@ class WorkflowPipeline:
     def _execute_standard_hooks_workflow(self, options: OptionsProtocol) -> bool:
         self._update_hooks_status_running()
 
-        # Run fast hooks first
         fast_hooks_success = self._run_fast_hooks_phase(options)
         if not fast_hooks_success:
             self._handle_hooks_completion(False)
             return False
 
-        # Run code cleaning after fast hooks but before comprehensive hooks
         if getattr(options, "clean", False):
             if not self._run_code_cleaning_phase(options):
                 self._handle_hooks_completion(False)
                 return False
-            # Run fast hooks again after cleaning for sanity check
+
             if not self._run_post_cleaning_fast_hooks(options):
                 self._handle_hooks_completion(False)
                 return False
             self._mark_code_cleaning_complete()
 
-        # Run comprehensive hooks
         comprehensive_success = self._run_comprehensive_hooks_phase(options)
 
         hooks_success = fast_hooks_success and comprehensive_success
@@ -494,36 +778,59 @@ class WorkflowPipeline:
             self._mcp_state_manager.update_stage_status("comprehensive", "completed")
 
     async def _run_ai_agent_fixing_phase(self, options: OptionsProtocol) -> bool:
-        self._update_mcp_status("ai_fixing", "running")
-        self.logger.info("Starting AI agent fixing phase")
-        self._log_debug_phase_start()
+        self._initialize_ai_fixing_phase(options)
 
         try:
-            # If code cleaning is enabled and hasn't run yet, run it first
-            # to provide cleaner, more standardized code for the AI agents
-            if getattr(options, "clean", False) and not self._has_code_cleaning_run():
-                self.console.print(
-                    "\n[bold yellow]🤖 AI agents recommend running code cleaning first for better results...[/bold yellow]"
-                )
-                if self._run_code_cleaning_phase(options):
-                    # Run fast hooks sanity check after cleaning
-                    self._run_post_cleaning_fast_hooks(options)
-                    self._mark_code_cleaning_complete()
+            self._prepare_ai_fixing_environment(options)
 
-            agent_coordinator = self._setup_agent_coordinator()
-            issues = await self._collect_issues_from_failures()
+            agent_coordinator, issues = await self._setup_ai_fixing_workflow()
 
             if not issues:
                 return self._handle_no_issues_found()
 
-            self.logger.info(f"AI agents will attempt to fix {len(issues)} issues")
-            fix_result = await agent_coordinator.handle_issues(issues)
-
-            return await self._process_fix_results(options, fix_result)
+            return await self._execute_ai_fixes(options, agent_coordinator, issues)
 
         except Exception as e:
             return self._handle_fixing_phase_error(e)
 
+    def _initialize_ai_fixing_phase(self, options: OptionsProtocol) -> None:
+        self._update_mcp_status("ai_fixing", "running")
+        self.logger.info("Starting AI agent fixing phase")
+        self._log_debug_phase_start()
+
+    def _prepare_ai_fixing_environment(self, options: OptionsProtocol) -> None:
+        should_run_cleaning = (
+            getattr(options, "clean", False) and not self._has_code_cleaning_run()
+        )
+
+        if not should_run_cleaning:
+            return
+
+        self.console.print(
+            "\n[bold yellow]🤖 AI agents recommend running code cleaning first for better results...[/bold yellow]"
+        )
+
+        if self._run_code_cleaning_phase(options):
+            self._run_post_cleaning_fast_hooks(options)
+            self._mark_code_cleaning_complete()
+
+    async def _setup_ai_fixing_workflow(
+        self,
+    ) -> tuple[AgentCoordinator, list[t.Any]]:
+        agent_coordinator = self._setup_agent_coordinator()
+        issues = await self._collect_issues_from_failures()
+        return agent_coordinator, issues
+
+    async def _execute_ai_fixes(
+        self,
+        options: OptionsProtocol,
+        agent_coordinator: AgentCoordinator,
+        issues: list[t.Any],
+    ) -> bool:
+        self.logger.info(f"AI agents will attempt to fix {len(issues)} issues")
+        fix_result = await agent_coordinator.handle_issues(issues)
+        return await self._process_fix_results(options, fix_result)
+
     def _log_debug_phase_start(self) -> None:
         if self._should_debug():
             self.debugger.log_workflow_phase(
@@ -631,12 +938,10 @@ class WorkflowPipeline:
 
         verification_success = True
 
-        # Verify test fixes
         if self._should_verify_test_fixes(fix_result.fixes_applied):
             if not await self._verify_test_fixes(options):
                 verification_success = False
 
-        # Verify hook fixes
         if self._should_verify_hook_fixes(fix_result.fixes_applied):
             if not await self._verify_hook_fixes(options):
                 verification_success = False
@@ -645,11 +950,9 @@ class WorkflowPipeline:
         return verification_success
 
     def _should_verify_test_fixes(self, fixes_applied: list[str]) -> bool:
-        """Check if test fixes need verification."""
         return any("test" in fix.lower() for fix in fixes_applied)
 
     async def _verify_test_fixes(self, options: OptionsProtocol) -> bool:
-        """Verify test fixes by re-running tests."""
         self.logger.info("Re-running tests to verify test fixes")
         test_success = self.phases.run_testing_phase(options)
         if not test_success:
@@ -657,7 +960,6 @@ class WorkflowPipeline:
         return test_success
 
     def _should_verify_hook_fixes(self, fixes_applied: list[str]) -> bool:
-        """Check if hook fixes need verification."""
         hook_fixes = [
             f
             for f in fixes_applied
@@ -668,7 +970,6 @@ class WorkflowPipeline:
         return bool(hook_fixes)
 
     async def _verify_hook_fixes(self, options: OptionsProtocol) -> bool:
-        """Verify hook fixes by re-running comprehensive hooks."""
         self.logger.info("Re-running comprehensive hooks to verify hook fixes")
         hook_success = self.phases.run_comprehensive_hooks_only(options)
         if not hook_success:
@@ -676,7 +977,6 @@ class WorkflowPipeline:
         return hook_success
 
     def _log_verification_result(self, verification_success: bool) -> None:
-        """Log the final verification result."""
         if verification_success:
             self.logger.info("All AI agent fixes verified successfully")
         else:
@@ -833,7 +1133,6 @@ class WorkflowPipeline:
         )
 
     def _parse_hook_error_details(self, task_id: str, error_msg: str) -> list[Issue]:
-        """Parse hook error details and create specific issues."""
         issues: list[Issue] = []
 
         if task_id == "comprehensive_hooks":
@@ -844,11 +1143,9 @@ class WorkflowPipeline:
         return issues
 
     def _parse_comprehensive_hook_errors(self, error_msg: str) -> list[Issue]:
-        """Parse comprehensive hook error messages and create specific issues."""
         issues: list[Issue] = []
         error_lower = error_msg.lower()
 
-        # Check each error type
         complexity_issue = self._check_complexity_error(error_lower)
         if complexity_issue:
             issues.append(complexity_issue)
@@ -876,7 +1173,6 @@ class WorkflowPipeline:
         return issues
 
     def _check_complexity_error(self, error_lower: str) -> Issue | None:
-        """Check for complexity errors and create issue if found."""
         if "complexipy" in error_lower or "c901" in error_lower:
             return Issue(
                 id="complexity_violation",
@@ -888,7 +1184,6 @@ class WorkflowPipeline:
         return None
 
     def _check_type_error(self, error_lower: str) -> Issue | None:
-        """Check for type errors and create issue if found."""
         if "pyright" in error_lower:
             return Issue(
                 id="pyright_type_error",
@@ -900,7 +1195,6 @@ class WorkflowPipeline:
         return None
 
     def _check_security_error(self, error_lower: str) -> Issue | None:
-        """Check for security errors and create issue if found."""
         if "bandit" in error_lower:
             return Issue(
                 id="bandit_security_issue",
@@ -912,7 +1206,6 @@ class WorkflowPipeline:
         return None
 
     def _check_performance_error(self, error_lower: str) -> Issue | None:
-        """Check for performance errors and create issue if found."""
         if "refurb" in error_lower:
             return Issue(
                 id="refurb_quality_issue",
@@ -924,7 +1217,6 @@ class WorkflowPipeline:
         return None
 
     def _check_dead_code_error(self, error_lower: str) -> Issue | None:
-        """Check for dead code errors and create issue if found."""
         if "vulture" in error_lower:
             return Issue(
                 id="vulture_dead_code",
@@ -936,7 +1228,6 @@ class WorkflowPipeline:
         return None
 
     def _check_regex_validation_error(self, error_lower: str) -> Issue | None:
-        """Check for regex validation errors and create issue if found."""
         regex_keywords = ("raw regex", "regex pattern", r"\g<", "replacement")
         if "validate-regex-patterns" in error_lower or any(
             keyword in error_lower for keyword in regex_keywords
@@ -951,7 +1242,6 @@ class WorkflowPipeline:
         return None
 
     def _create_fast_hook_issue(self) -> Issue:
-        """Create an issue for fast hook errors."""
         return Issue(
             id="fast_hooks_formatting",
             type=IssueType.FORMATTING,
@@ -978,10 +1268,8 @@ class WorkflowPipeline:
         return issues
 
     def _classify_issue(self, issue_str: str) -> tuple[IssueType, Priority]:
-        """Classify an issue string to determine its type and priority."""
         issue_lower = issue_str.lower()
 
-        # Check high-priority issues first
         if self._is_type_error(issue_lower):
             return IssueType.TYPE_ERROR, Priority.HIGH
         if self._is_security_issue(issue_lower):
@@ -991,7 +1279,6 @@ class WorkflowPipeline:
         if self._is_regex_validation_issue(issue_lower):
             return IssueType.REGEX_VALIDATION, Priority.HIGH
 
-        # Check medium-priority issues
         if self._is_dead_code_issue(issue_lower):
             return IssueType.DEAD_CODE, Priority.MEDIUM
         if self._is_performance_issue(issue_lower):
@@ -999,30 +1286,25 @@ class WorkflowPipeline:
         if self._is_import_error(issue_lower):
             return IssueType.IMPORT_ERROR, Priority.MEDIUM
 
-        # Default to formatting issue
         return IssueType.FORMATTING, Priority.MEDIUM
 
     def _is_type_error(self, issue_lower: str) -> bool:
-        """Check if issue is related to type errors."""
         return any(
             keyword in issue_lower for keyword in ("type", "annotation", "pyright")
         )
 
     def _is_security_issue(self, issue_lower: str) -> bool:
-        """Check if issue is related to security."""
         return any(
             keyword in issue_lower for keyword in ("security", "bandit", "hardcoded")
         )
 
     def _is_complexity_issue(self, issue_lower: str) -> bool:
-        """Check if issue is related to code complexity."""
         return any(
             keyword in issue_lower
             for keyword in ("complexity", "complexipy", "c901", "too complex")
         )
 
     def _is_regex_validation_issue(self, issue_lower: str) -> bool:
-        """Check if issue is related to regex validation."""
         return any(
             keyword in issue_lower
             for keyword in (
@@ -1035,17 +1317,14 @@ class WorkflowPipeline:
         )
 
     def _is_dead_code_issue(self, issue_lower: str) -> bool:
-        """Check if issue is related to dead code."""
         return any(keyword in issue_lower for keyword in ("unused", "dead", "vulture"))
 
     def _is_performance_issue(self, issue_lower: str) -> bool:
-        """Check if issue is related to performance."""
         return any(
             keyword in issue_lower for keyword in ("performance", "refurb", "furb")
         )
 
     def _is_import_error(self, issue_lower: str) -> bool:
-        """Check if issue is related to import errors."""
         return any(keyword in issue_lower for keyword in ("import", "creosote"))
 
     def _log_failure_counts_if_debugging(
@@ -1058,41 +1337,25 @@ class WorkflowPipeline:
     def _check_security_gates_for_publishing(
         self, options: OptionsProtocol
     ) -> tuple[bool, bool]:
-        """Check if publishing is requested and if security gates block it.
-
-        Returns:
-            tuple[bool, bool]: (publishing_requested, security_blocks_publishing)
-        """
         publishing_requested = bool(options.publish or options.all or options.commit)
 
         if not publishing_requested:
             return False, False
 
-        # Check security gates for publishing operations
         try:
             security_blocks_publishing = self._check_security_critical_failures()
             return publishing_requested, security_blocks_publishing
         except Exception as e:
-            # Fail securely if security check fails
             self.logger.warning(f"Security check failed: {e} - blocking publishing")
             self.console.print(
                 "[red]🔒 SECURITY CHECK FAILED: Unable to verify security status - publishing BLOCKED[/red]"
             )
-            # Return True for security_blocks to fail securely
+
             return publishing_requested, True
 
     async def _handle_security_gate_failure(
         self, options: OptionsProtocol, allow_ai_fixing: bool = False
     ) -> bool:
-        """Handle security gate failures with optional AI fixing.
-
-        Args:
-            options: Workflow options
-            allow_ai_fixing: Whether AI fixing is allowed for security issues
-
-        Returns:
-            bool: True if security issues resolved, False if still blocked
-        """
         self.console.print(
             "[red]🔒 SECURITY GATE: Critical security checks failed[/red]"
         )
@@ -1105,10 +1368,8 @@ class WorkflowPipeline:
                 "[yellow]🤖 Attempting AI-assisted security issue resolution...[/yellow]"
             )
 
-            # Try AI fixing for security issues
             ai_fix_success = await self._run_ai_agent_fixing_phase(options)
             if ai_fix_success:
-                # Re-check security after AI fixing
                 try:
                     security_still_blocks = self._check_security_critical_failures()
                     if not security_still_blocks:
@@ -1128,7 +1389,6 @@ class WorkflowPipeline:
                     return False
             return False
         else:
-            # Standard workflow cannot bypass security gates
             self.console.print(
                 "[red]Security-critical hooks (bandit, pyright, gitleaks) must pass before publishing[/red]"
             )
@@ -1140,33 +1400,25 @@ class WorkflowPipeline:
         comprehensive_passed: bool,
         publishing_requested: bool,
     ) -> bool:
-        """Determine if AI fixing is needed based on test results and publishing requirements."""
         if publishing_requested:
-            # For publish/commit workflows, only trigger AI fixing if both fail
-            return not testing_passed and not comprehensive_passed
-        else:
-            # For regular workflows, trigger AI fixing if either fails
             return not testing_passed or not comprehensive_passed
 
+        return not testing_passed or not comprehensive_passed
+
     def _determine_workflow_success(
         self,
         testing_passed: bool,
         comprehensive_passed: bool,
         publishing_requested: bool,
-        workflow_type: str,
     ) -> bool:
-        """Determine workflow success based on test results and workflow type."""
         if publishing_requested:
-            # For publishing workflows, either test or comprehensive passing is sufficient
-            return testing_passed or comprehensive_passed
-        else:
-            # For regular workflows, both must pass
             return testing_passed and comprehensive_passed
 
+        return testing_passed and comprehensive_passed
+
     def _show_verbose_failure_details(
         self, testing_passed: bool, comprehensive_passed: bool
     ) -> None:
-        """Show detailed failure information in verbose mode."""
         self.console.print(
             f"[yellow]⚠️ Quality phase results - testing_passed: {testing_passed}, comprehensive_passed: {comprehensive_passed}[/yellow]"
         )
@@ -1178,105 +1430,89 @@ class WorkflowPipeline:
             )
 
     def _check_security_critical_failures(self) -> bool:
-        """Check if any security-critical hooks have failed.
-
-        Returns:
-            True if security-critical hooks failed and block publishing
-        """
         try:
             from crackerjack.security.audit import SecurityAuditor
 
             auditor = SecurityAuditor()
 
-            # Get hook results - we need to be careful not to re-run hooks
-            # Instead, check the session tracker for recent failures
             fast_results = self._get_recent_fast_hook_results()
             comprehensive_results = self._get_recent_comprehensive_hook_results()
 
-            # Generate security audit report
             audit_report = auditor.audit_hook_results(
                 fast_results, comprehensive_results
             )
 
-            # Store audit report for later use
             self._last_security_audit = audit_report
 
-            # Block publishing if critical failures exist
             return audit_report.has_critical_failures
 
         except Exception as e:
-            # Fail securely - if we can't determine security status, block publishing
             self.logger.warning(f"Security audit failed: {e} - failing securely")
-            # Re-raise the exception so it can be caught by the calling method
+
             raise
 
     def _get_recent_fast_hook_results(self) -> list[t.Any]:
-        """Get recent fast hook results from session tracker."""
-        results = []
+        results = self._extract_hook_results_from_session("fast_hooks")
+
+        if not results:
+            results = self._create_mock_hook_results(["gitleaks"])
 
-        # Try to get results from session tracker
-        if hasattr(self.session, "session_tracker") and self.session.session_tracker:
-            for task_id, task_data in self.session.session_tracker.tasks.items():
-                if task_id == "fast_hooks" and hasattr(task_data, "hook_results"):
+        return results
+
+    def _extract_hook_results_from_session(self, hook_type: str) -> list[t.Any]:
+        results: list[t.Any] = []
+
+        session_tracker = self._get_session_tracker()
+        if not session_tracker:
+            return results
+
+        for task_id, task_data in session_tracker.tasks.items():
+            if task_id == hook_type and hasattr(task_data, "hook_results"):
+                if task_data.hook_results:
                     results.extend(task_data.hook_results)
 
-        # If no results from session, create mock failed results for critical hooks
-        # This ensures we fail securely when we can't determine actual status
-        if not results:
-            critical_fast_hooks = ["gitleaks"]
-            for hook_name in critical_fast_hooks:
-                # Create a mock result that appears to have failed
-                # This will trigger security blocking if we can't determine actual status
-                mock_result = type(
-                    "MockResult",
-                    (),
-                    {
-                        "name": hook_name,
-                        "status": "unknown",  # Unknown status = fail securely
-                        "output": "Unable to determine hook status",
-                    },
-                )()
-                results.append(mock_result)
+        return results
+
+    def _get_session_tracker(self) -> t.Any | None:
+        return (
+            getattr(self.session, "session_tracker", None)
+            if hasattr(self.session, "session_tracker")
+            else None
+        )
+
+    def _create_mock_hook_results(self, critical_hooks: list[str]) -> list[t.Any]:
+        results: list[t.Any] = []
+
+        for hook_name in critical_hooks:
+            mock_result = self._create_mock_hook_result(hook_name)
+            results.append(mock_result)
 
         return results
 
+    def _create_mock_hook_result(self, hook_name: str) -> t.Any:
+        return type(
+            "MockResult",
+            (),
+            {
+                "name": hook_name,
+                "status": "unknown",
+                "output": "Unable to determine hook status",
+            },
+        )()
+
     def _get_recent_comprehensive_hook_results(self) -> list[t.Any]:
-        """Get recent comprehensive hook results from session tracker."""
-        results = []
-
-        # Try to get results from session tracker
-        if hasattr(self.session, "session_tracker") and self.session.session_tracker:
-            for task_id, task_data in self.session.session_tracker.tasks.items():
-                if task_id == "comprehensive_hooks" and hasattr(
-                    task_data, "hook_results"
-                ):
-                    results.extend(task_data.hook_results)
+        results = self._extract_hook_results_from_session("comprehensive_hooks")
 
-        # If no results from session, create mock failed results for critical hooks
         if not results:
-            critical_comprehensive_hooks = ["bandit", "pyright"]
-            for hook_name in critical_comprehensive_hooks:
-                mock_result = type(
-                    "MockResult",
-                    (),
-                    {
-                        "name": hook_name,
-                        "status": "unknown",  # Unknown status = fail securely
-                        "output": "Unable to determine hook status",
-                    },
-                )()
-                results.append(mock_result)
+            results = self._create_mock_hook_results(["bandit", "pyright"])
 
         return results
 
     def _is_security_critical_failure(self, result: t.Any) -> bool:
-        """Check if a hook result represents a security-critical failure."""
-
-        # List of security-critical hook names (fail-safe approach)
         security_critical_hooks = {
-            "bandit",  # Security vulnerability scanning
-            "pyright",  # Type safety prevents security holes
-            "gitleaks",  # Secret detection
+            "bandit",
+            "pyright",
+            "gitleaks",
         }
 
         hook_name = getattr(result, "name", "").lower()
@@ -1289,8 +1525,6 @@ class WorkflowPipeline:
         return hook_name in security_critical_hooks and is_failed
 
     def _show_security_audit_warning(self) -> None:
-        """Show security audit warning when proceeding with partial success."""
-        # Use stored audit report if available
         audit_report = getattr(self, "_last_security_audit", None)
 
         if audit_report:
@@ -1298,23 +1532,19 @@ class WorkflowPipeline:
                 "[yellow]⚠️ SECURITY AUDIT: Proceeding with partial quality success[/yellow]"
             )
 
-            # Show security status
             for warning in audit_report.security_warnings:
                 if "CRITICAL" in warning:
-                    # This shouldn't happen if we're showing warnings, but fail-safe
                     self.console.print(f"[red]{warning}[/red]")
                 elif "HIGH" in warning:
                     self.console.print(f"[yellow]{warning}[/yellow]")
                 else:
                     self.console.print(f"[blue]{warning}[/blue]")
 
-            # Show recommendations
             if audit_report.recommendations:
-                self.console.print("[bold]Security Recommendations:[/bold]")
-                for rec in audit_report.recommendations[:3]:  # Show top 3
+                self.console.print("[bold]Security Recommendations: [/bold]")
+                for rec in audit_report.recommendations[:3]:
                     self.console.print(f"[dim]{rec}[/dim]")
         else:
-            # Fallback if no audit report available
             self.console.print(
                 "[yellow]⚠️ SECURITY AUDIT: Proceeding with partial quality success[/yellow]"
             )
@@ -1325,6 +1555,92 @@ class WorkflowPipeline:
                 "[yellow]⚠️ Some non-critical quality checks failed - consider reviewing before production deployment[/yellow]"
             )
 
+    async def _run_initial_fast_hooks_async(
+        self, options: OptionsProtocol, iteration: int, monitor: t.Any
+    ) -> bool:
+        monitor.record_sequential_op()
+        fast_hooks_passed = self._run_fast_hooks_phase(options)
+        if not fast_hooks_passed:
+            if options.ai_agent and self._should_debug():
+                self.debugger.log_iteration_end(iteration, False)
+            return False
+        return True
+
+    async def _run_fast_hooks_phase_monitored(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        with phase_monitor(workflow_id, "fast_hooks") as monitor:
+            monitor.record_sequential_op()
+            return self._run_fast_hooks_phase(options)
+
+    async def _run_comprehensive_hooks_phase_monitored(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        with phase_monitor(workflow_id, "comprehensive_hooks") as monitor:
+            monitor.record_sequential_op()
+            return self._run_comprehensive_hooks_phase(options)
+
+    async def _run_testing_phase_async(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        with phase_monitor(workflow_id, "testing") as monitor:
+            monitor.record_sequential_op()
+            return self._run_testing_phase(options)
+
+    async def _execute_standard_hooks_workflow_monitored(
+        self, options: OptionsProtocol, workflow_id: str
+    ) -> bool:
+        with phase_monitor(workflow_id, "hooks") as monitor:
+            self._update_hooks_status_running()
+
+            fast_hooks_success = self._execute_monitored_fast_hooks_phase(
+                options, monitor
+            )
+            if not fast_hooks_success:
+                self._handle_hooks_completion(False)
+                return False
+
+            if not self._execute_monitored_cleaning_phase(options):
+                self._handle_hooks_completion(False)
+                return False
+
+            comprehensive_success = self._execute_monitored_comprehensive_phase(
+                options, monitor
+            )
+
+            hooks_success = fast_hooks_success and comprehensive_success
+            self._handle_hooks_completion(hooks_success)
+            return hooks_success
+
+    def _execute_monitored_fast_hooks_phase(
+        self, options: OptionsProtocol, monitor: t.Any
+    ) -> bool:
+        fast_hooks_success = self._run_fast_hooks_phase(options)
+        if fast_hooks_success:
+            monitor.record_sequential_op()
+        return fast_hooks_success
+
+    def _execute_monitored_cleaning_phase(self, options: OptionsProtocol) -> bool:
+        if not getattr(options, "clean", False):
+            return True
+
+        if not self._run_code_cleaning_phase(options):
+            return False
+
+        if not self._run_post_cleaning_fast_hooks(options):
+            return False
+
+        self._mark_code_cleaning_complete()
+        return True
+
+    def _execute_monitored_comprehensive_phase(
+        self, options: OptionsProtocol, monitor: t.Any
+    ) -> bool:
+        comprehensive_success = self._run_comprehensive_hooks_phase(options)
+        if comprehensive_success:
+            monitor.record_sequential_op()
+        return comprehensive_success
+
 
 class WorkflowOrchestrator:
     def __init__(
@@ -1352,7 +1668,6 @@ class WorkflowOrchestrator:
             TestManagerProtocol,
         )
 
-        # Initialize logging first so container creation respects log levels
         self._initialize_logging()
 
         self.logger = get_logger("crackerjack.orchestrator")
@@ -1393,13 +1708,11 @@ class WorkflowOrchestrator:
         session_id = getattr(self, "web_job_id", None) or str(int(time.time()))[:8]
         debug_log_file = log_manager.create_debug_log_file(session_id)
 
-        # Set log level based on debug flag only - verbose should not enable DEBUG logs
         log_level = "DEBUG" if self.debug else "INFO"
         setup_structured_logging(
             level=log_level, json_output=False, log_file=debug_log_file
         )
 
-        # Use a temporary logger for the initialization message
         temp_logger = get_logger("crackerjack.orchestrator.init")
         temp_logger.debug(
             "Structured logging initialized",
@@ -1446,7 +1759,12 @@ class WorkflowOrchestrator:
         return self.phases.run_configuration_phase(options)
 
     async def run_complete_workflow(self, options: OptionsProtocol) -> bool:
-        return await self.pipeline.run_complete_workflow(options)
+        result: bool = await self.pipeline.run_complete_workflow(options)
+        return result
+
+    def run_complete_workflow_sync(self, options: OptionsProtocol) -> bool:
+        """Sync wrapper for run_complete_workflow."""
+        return asyncio.run(self.run_complete_workflow(options))
 
     def _cleanup_resources(self) -> None:
         self.session.cleanup_resources()