crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/cli/handlers.py

@@ -4,18 +4,22 @@ import sys
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from .options import Options
 
 if t.TYPE_CHECKING:
-    from crackerjack.services.config_template import (
+    from crackerjack.services.quality.config_template import (
         ConfigTemplateService,
         ConfigUpdateInfo,
     )
 
 
-def setup_ai_agent_env(ai_agent: bool, debug_mode: bool = False) -> None:
+@depends.inject  # type: ignore[misc]
+def setup_ai_agent_env(
+    ai_agent: bool, debug_mode: bool = False, console: Inject[Console] = None
+) -> None:
     if debug_mode:
         os.environ["CRACKERJACK_DEBUG"] = "1"
 
@@ -26,7 +30,6 @@ def setup_ai_agent_env(ai_agent: bool, debug_mode: bool = False) -> None:
             os.environ["AI_AGENT_DEBUG"] = "1"
             os.environ["AI_AGENT_VERBOSE"] = "1"
 
-            console = Console()
             console.print(
                 "[bold cyan]🐛 AI Agent Debug Mode Configuration: [/ bold cyan]",
             )
@@ -38,6 +41,25 @@ def setup_ai_agent_env(ai_agent: bool, debug_mode: bool = False) -> None:
                 f" • Verbose Mode: {'✅ Enabled' if os.environ.get('AI_AGENT_VERBOSE') == '1' else '❌ Disabled'}",
             )
             console.print(" • Enhanced logging will be available during execution")
+    elif debug_mode:  # Handle debug mode without AI agent
+        os.environ["AI_AGENT_DEBUG"] = "1"
+        os.environ["AI_AGENT_VERBOSE"] = "1"
+        console.print(
+            "[bold cyan]🐛 AI Debug Mode Configuration: [/ bold cyan]",
+        )
+        console.print(
+            f" • Debug Mode: {'✅ Enabled' if os.environ.get('AI_AGENT_DEBUG') == '1' else '❌ Disabled'}",
+        )
+        console.print(
+            f" • Verbose Mode: {'✅ Enabled' if os.environ.get('AI_AGENT_VERBOSE') == '1' else '❌ Disabled'}",
+        )
+        console.print(" • Structured logging enabled for debugging")
+
+    # Set up structured logging if debug or ai_agent is enabled
+    if ai_agent or debug_mode:
+        from crackerjack.services.logging import setup_structured_logging
+
+        setup_structured_logging(level="DEBUG", json_output=True)
 
 
 def handle_mcp_server(websocket_port: int | None = None) -> None:
@@ -51,10 +73,12 @@ def handle_mcp_server(websocket_port: int | None = None) -> None:
         start_mcp_main(project_path)
 
 
-def handle_monitor_mode(dev_mode: bool = False) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_monitor_mode(
+    dev_mode: bool = False, console: Inject[Console] = None
+) -> None:
     from crackerjack.mcp.progress_monitor import run_progress_monitor
 
-    console = Console()
     console.print("[bold cyan]🌟 Starting Multi-Project Progress Monitor[/ bold cyan]")
     console.print(
         "[bold yellow]🐕 With integrated Service Watchdog and WebSocket polling[/ bold yellow]",
@@ -66,10 +90,12 @@ def handle_monitor_mode(dev_mode: bool = False) -> None:
         console.print("\n[yellow]🛑 Monitor stopped[/ yellow]")
 
 
-def handle_enhanced_monitor_mode(dev_mode: bool = False) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_enhanced_monitor_mode(
+    dev_mode: bool = False, console: Inject[Console] = None
+) -> None:
     from crackerjack.mcp.enhanced_progress_monitor import run_enhanced_progress_monitor
 
-    console = Console()
     console.print("[bold magenta]✨ Starting Enhanced Progress Monitor[/ bold magenta]")
     console.print(
         "[bold cyan]📊 With advanced MetricCard widgets and modern web UI patterns[/ bold cyan]",
@@ -81,10 +107,12 @@ def handle_enhanced_monitor_mode(dev_mode: bool = False) -> None:
         console.print("\n[yellow]🛑 Enhanced Monitor stopped[/ yellow]")
 
 
-def handle_dashboard_mode(dev_mode: bool = False) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_dashboard_mode(
+    dev_mode: bool = False, console: Inject[Console] = None
+) -> None:
     from crackerjack.mcp.dashboard import run_dashboard
 
-    console = Console()
     console.print("[bold green]🎯 Starting Comprehensive Dashboard[/ bold green]")
     console.print(
         "[bold cyan]📈 With system metrics, job tracking, and performance monitoring[/ bold cyan]",
@@ -96,10 +124,12 @@ def handle_dashboard_mode(dev_mode: bool = False) -> None:
         console.print("\n[yellow]🛑 Dashboard stopped[/ yellow]")
 
 
-def handle_unified_dashboard_mode(port: int = 8675, dev_mode: bool = False) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_unified_dashboard_mode(
+    port: int = 8675, dev_mode: bool = False, console: Inject[Console] = None
+) -> None:
     from crackerjack.monitoring.websocket_server import CrackerjackMonitoringServer
 
-    console = Console()
     console.print("[bold green]🚀 Starting Unified Monitoring Dashboard[/bold green]")
     console.print(
         f"[bold cyan]🌐 WebSocket server on port {port} with real-time streaming and web UI[/bold cyan]",
@@ -114,10 +144,10 @@ def handle_unified_dashboard_mode(port: int = 8675, dev_mode: bool = False) -> N
         console.print(f"\n[red]❌ Unified Dashboard failed: {e}[/red]")
 
 
-def handle_watchdog_mode() -> None:
+@depends.inject  # type: ignore[misc]
+def handle_watchdog_mode(console: Inject[Console] = None) -> None:
     from crackerjack.mcp.service_watchdog import main as start_watchdog
 
-    console = Console()
     try:
         asyncio.run(start_watchdog())
     except KeyboardInterrupt:
@@ -142,10 +172,13 @@ def handle_restart_websocket_server(port: int = 8675) -> None:
     handle_websocket_server_command(restart=True, port=port)
 
 
-def handle_stop_mcp_server() -> None:
-    from crackerjack.services.server_manager import list_server_status, stop_all_servers
+@depends.inject  # type: ignore[misc]
+def handle_stop_mcp_server(console: Inject[Console] = None) -> None:
+    from crackerjack.services.server_manager import (
+        list_server_status,
+        stop_all_servers,
+    )
 
-    console = Console()
     console.print("[bold red]🛑 Stopping MCP Servers[/ bold red]")
 
     list_server_status(console)
@@ -157,10 +190,12 @@ def handle_stop_mcp_server() -> None:
         raise SystemExit(1)
 
 
-def handle_restart_mcp_server(websocket_port: int | None = None) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_restart_mcp_server(
+    websocket_port: int | None = None, console: Inject[Console] = None
+) -> None:
     from crackerjack.services.server_manager import restart_mcp_server
 
-    console = Console()
     if restart_mcp_server(websocket_port, console):
         console.print("\n[bold green]✅ MCP server restart completed[/ bold green]")
     else:
@@ -168,11 +203,15 @@ def handle_restart_mcp_server(websocket_port: int | None = None) -> None:
         raise SystemExit(1)
 
 
-def handle_start_zuban_lsp(port: int = 8677, mode: str = "tcp") -> None:
+@depends.inject  # type: ignore[misc]
+def handle_start_zuban_lsp(
+    port: int = 8677, mode: str = "tcp", console: Inject[Console] = None
+) -> None:
     """Start Zuban LSP server."""
-    from crackerjack.services.zuban_lsp_service import create_zuban_lsp_service
+    from crackerjack.services.zuban_lsp_service import (
+        create_zuban_lsp_service,
+    )
 
-    console = Console()
     console.print("[bold cyan]🚀 Starting Zuban LSP Server[/bold cyan]")
 
     async def _start() -> None:
@@ -193,11 +232,11 @@ def handle_start_zuban_lsp(port: int = 8677, mode: str = "tcp") -> None:
         console.print("\n[yellow]🛑 Zuban LSP startup interrupted[/yellow]")
 
 
-def handle_stop_zuban_lsp() -> None:
+@depends.inject  # type: ignore[misc]
+def handle_stop_zuban_lsp(console: Inject[Console] = None) -> None:
     """Stop Zuban LSP server."""
     from crackerjack.services.server_manager import stop_zuban_lsp
 
-    console = Console()
     console.print("[bold red]🛑 Stopping Zuban LSP Server[/bold red]")
 
     if stop_zuban_lsp(console):
@@ -209,11 +248,13 @@ def handle_stop_zuban_lsp() -> None:
         raise SystemExit(1)
 
 
-def handle_restart_zuban_lsp(port: int = 8677, mode: str = "tcp") -> None:
+@depends.inject  # type: ignore[misc]
+def handle_restart_zuban_lsp(
+    port: int = 8677, mode: str = "tcp", console: Inject[Console] = None
+) -> None:
     """Restart Zuban LSP server."""
     from crackerjack.services.server_manager import restart_zuban_lsp
 
-    console = Console()
     if restart_zuban_lsp(console):
         console.print(
             "\n[bold green]✅ Zuban LSP server restart completed[/bold green]"
@@ -224,7 +265,7 @@ def handle_restart_zuban_lsp(port: int = 8677, mode: str = "tcp") -> None:
 
 
 def handle_interactive_mode(options: Options) -> None:
-    from crackerjack.cli.utils import get_package_version
+    from crackerjack.cli.version import get_package_version
 
     from .interactive import launch_interactive_cli
 
@@ -232,23 +273,36 @@ def handle_interactive_mode(options: Options) -> None:
     launch_interactive_cli(pkg_version, options)
 
 
+@depends.inject  # type: ignore[misc]
 def handle_standard_mode(
     options: Options,
     async_mode: bool,
     job_id: str | None = None,
     orchestrated: bool = False,
+    console: Inject[Console] = None,
 ) -> None:
-    from rich.console import Console
-
-    console = Console()
+    # Run the async configure method in an isolated event loop
+    import asyncio
 
     from crackerjack.executors.hook_lock_manager import hook_lock_manager
 
+    # Call the synchronous method directly
     hook_lock_manager.configure_from_options(options)
 
+    # Phase 4.2 COMPLETE: ACB workflows are now the default
+    # Use --use-legacy-orchestrator to opt out and use the old orchestration system
+    if not getattr(options, "use_legacy_orchestrator", False):
+        # Default path: ACB workflow engine (Phase 4.2 complete)
+        # Only skip if user explicitly opted out with --use-legacy-orchestrator
+        handle_acb_workflow_mode(options, job_id, console)
+        return
+
+    # Legacy orchestrator path (only if use_legacy_orchestrator=True)
     if orchestrated:
         handle_orchestrated_mode(options, job_id)
-    else:
+
+    # Default path: Legacy orchestrator (Phase 4.0 status)
+    if not orchestrated:
         from crackerjack.core.async_workflow_orchestrator import (
             AsyncWorkflowOrchestrator,
         )
@@ -264,18 +318,19 @@ def handle_standard_mode(
                 web_job_id=job_id,
                 verbose=options.verbose,
                 debug=getattr(options, "debug", False),
+                changed_only=getattr(options, "changed_only", False),
             )
             success = asyncio.run(
                 async_orchestrator.run_complete_workflow_async(options)
             )
         else:
             sync_orchestrator = WorkflowOrchestrator(
-                console=console,
                 pkg_path=pkg_path,
                 dry_run=getattr(options, "dry_run", False),
                 web_job_id=job_id,
                 verbose=options.verbose,
                 debug=getattr(options, "debug", False),
+                changed_only=getattr(options, "changed_only", False),
             )
             success = sync_orchestrator.run_complete_workflow_sync(options)
 
@@ -283,14 +338,152 @@ def handle_standard_mode(
             raise SystemExit(1)
 
 
-def handle_orchestrated_mode(options: Options, job_id: str | None = None) -> None:
-    from rich.console import Console
+@depends.inject  # type: ignore[misc]
+def handle_acb_workflow_mode(
+    options: Options,
+    job_id: str | None = None,
+    console: Inject[Console] = None,
+) -> None:
+    """Execute workflow using ACB workflow engine (Phase 3 Production).
+
+    This handler routes execution to the CrackerjackWorkflowEngine using
+    the WorkflowContainerBuilder to set up the full DI container with all
+    28 services across 7 levels. Action handlers use WorkflowPipeline from
+    the container for production-quality workflow execution.
+
+    Args:
+        options: CLI options with use_acb_workflows=True
+        job_id: Optional WebSocket job ID for progress tracking
+        console: Rich console for output
+    """
+    import asyncio
+
+    from acb.depends import depends
+
+    from crackerjack.events.workflow_bus import WorkflowEventBus
+    from crackerjack.workflows import (
+        CrackerjackWorkflowEngine,
+        EventBridgeAdapter,
+        WorkflowContainerBuilder,
+        register_actions,
+        select_workflow_for_options,
+    )
+
+    console.print("[bold cyan]🚀 Crackerjack Workflow Engine (ACB-Powered)[/bold cyan]")
 
-    console = Console()
+    try:
+        # Phase 4: ACB workflows are now the default!
+        console.print(
+            "[dim]Building DI container (28 services across 7 levels)...[/dim]"
+        )
+        builder = WorkflowContainerBuilder(options, console=console)
+        builder.build()
+
+        # Validate all services are available
+        health = builder.health_check()
+        if not health["all_available"]:
+            missing = ", ".join(health["missing"])
+            console.print(f"[yellow]⚠️  Missing services: {missing}[/yellow]")
+            console.print(
+                "[yellow]Container health check failed, continuing with available services[/yellow]"
+            )
+
+        console.print("[dim]✓ DI container ready with WorkflowPipeline[/dim]")
+
+        # Register ACB Logger explicitly (needed for BasicWorkflowEngine)
+        from acb.logger import Logger
+
+        try:
+            logger = depends.get_sync(Logger)
+        except Exception:
+            # ACB Logger not available, this shouldn't happen but handle gracefully
+            import logging
+
+            logger = logging.getLogger("crackerjack")
+            depends.set(Logger, logger)
+
+        # Register WorkflowEventBus with DI container
+        event_bus = WorkflowEventBus()
+        depends.set(WorkflowEventBus, event_bus)
+
+        # Register EventBridgeAdapter BEFORE creating engine (engine needs it for DI!)
+        event_bridge = EventBridgeAdapter()
+        depends.set(EventBridgeAdapter, event_bridge)
+
+        # Initialize engine (EventBridgeAdapter will be injected)
+        engine = CrackerjackWorkflowEngine()
+
+        # Register action handlers with engine
+        register_actions(engine)
+
+        # Select workflow based on options (fast/comp/test/standard)
+        workflow = select_workflow_for_options(options)
+
+        console.print(f"[dim]Selected workflow: {workflow.name}[/dim]")
+
+        # Show orchestration status
+        from crackerjack.config import CrackerjackSettings
+
+        settings = depends.get_sync(CrackerjackSettings)
+        if settings.enable_orchestration:
+            mode_info = f" ({settings.orchestration_mode} mode)"
+            console.print(
+                f"[dim]Orchestration: [cyan]⚡ enabled[/cyan]{mode_info} - async hooks with caching[/dim]"
+            )
+
+        # Phase 4.1: Retrieve WorkflowPipeline from DI container (synchronous context)
+        # and pass it explicitly in workflow context to avoid async DI scope issues
+        from crackerjack.core.workflow_orchestrator import WorkflowPipeline
+
+        pipeline = depends.get_sync(WorkflowPipeline)
+
+        # Phase 4.2: All dependencies now use Inject[] instead of deprecated depends()
+        # This ensures they are properly resolved when retrieved from DI container
+
+        # Execute workflow with options and pipeline in context
+        result = asyncio.run(
+            engine.execute(
+                workflow,
+                context={
+                    "options": options,
+                    "pipeline": pipeline,  # Pass pipeline with all dependencies properly resolved
+                },
+            )
+        )
+
+        # Check result and exit with appropriate code
+        from acb.workflows import WorkflowState
+
+        if result.state != WorkflowState.COMPLETED:
+            console.print(f"[red]Workflow failed: {result.error}[/red]")
+            raise SystemExit(1)
+
+        console.print("[bold green]✓ Workflow completed successfully[/bold green]")
+
+    except Exception as e:
+        import traceback
+
+        console.print(f"[red]ACB workflow execution failed: {e}[/red]")
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+        console.print("[yellow]Falling back to legacy orchestrator[/yellow]")
+        # Enable legacy orchestrator flag and retry
+        options.use_legacy_orchestrator = True
+        options.use_acb_workflows = False
+        handle_standard_mode(options, False, job_id, False, console)
+
+
+@depends.inject  # type: ignore[misc]
+def handle_orchestrated_mode(
+    options: Options, job_id: str | None = None, console: Inject[Console] = None
+) -> None:
     console.print("[bold bright_blue]🚀 ORCHESTRATED MODE ENABLED[/ bold bright_blue]")
 
+    # Run the async configure method in an isolated event loop
+    import asyncio
+
     from crackerjack.executors.hook_lock_manager import hook_lock_manager
 
+    # Call the synchronous method directly
     hook_lock_manager.configure_from_options(options)
 
     try:
@@ -363,11 +556,11 @@ def handle_orchestrated_mode(options: Options, job_id: str | None = None) -> Non
         sys.exit(1)
 
 
-def handle_config_updates(options: Options) -> None:
+@depends.inject  # type: ignore[misc]
+def handle_config_updates(options: Options, console: Inject[Console] = None) -> None:
     """Handle configuration update commands."""
-    from crackerjack.services.config_template import ConfigTemplateService
+    from crackerjack.services.quality.config_template import ConfigTemplateService
 
-    console = Console()
     pkg_path = Path.cwd()
     config_service = ConfigTemplateService(console, pkg_path)
 
@@ -383,8 +576,9 @@ def handle_config_updates(options: Options) -> None:
         _handle_refresh_cache(config_service, pkg_path, console)
 
 
+@depends.inject  # type: ignore[misc]
 def _handle_check_updates(
-    config_service: "ConfigTemplateService", pkg_path: Path, console: Console
+    config_service: "ConfigTemplateService", pkg_path: Path, console: Inject[Console]
 ) -> None:
     """Handle checking for configuration updates."""
     console.print("[bold cyan]🔍 Checking for configuration updates...[/bold cyan]")
@@ -403,11 +597,12 @@ def _handle_check_updates(
     console.print("\nUse --apply-config-updates to apply these updates")
 
 
+@depends.inject  # type: ignore[misc]
 def _handle_apply_updates(
     config_service: "ConfigTemplateService",
     pkg_path: Path,
     interactive: bool,
-    console: Console,
+    console: Inject[Console],
 ) -> None:
     """Handle applying configuration updates."""
     console.print("[bold cyan]🔧 Applying configuration updates...[/bold cyan]")
@@ -428,11 +623,12 @@ def _handle_apply_updates(
     _report_update_results(success_count, len(configs_to_update), console)
 
 
+@depends.inject  # type: ignore[misc]
 def _handle_diff_config(
     config_service: "ConfigTemplateService",
     pkg_path: Path,
     config_type: str,
-    console: Console,
+    console: Inject[Console],
 ) -> None:
     """Handle showing configuration diff."""
     console.print(f"[bold cyan]📊 Showing diff for {config_type}...[/bold cyan]")
@@ -441,17 +637,19 @@ def _handle_diff_config(
     console.print(diff_preview)
 
 
+@depends.inject  # type: ignore[misc]
 def _handle_refresh_cache(
-    config_service: "ConfigTemplateService", pkg_path: Path, console: Console
+    config_service: "ConfigTemplateService", pkg_path: Path, console: Inject[Console]
 ) -> None:
-    """Handle refreshing pre-commit cache."""
-    console.print("[bold cyan]🧹 Refreshing pre-commit cache...[/bold cyan]")
-    config_service._invalidate_precommit_cache(pkg_path)
-    console.print("[green]✅ Pre-commit cache refreshed[/green]")
+    """Handle refreshing cache."""
+    console.print("[bold cyan]🧹 Refreshing cache...[/bold cyan]")
+    config_service._invalidate_cache(pkg_path)
+    console.print("[green]✅ Cache refreshed[/green]")
 
 
+@depends.inject  # type: ignore[misc]
 def _display_available_updates(
-    updates: dict[str, "ConfigUpdateInfo"], console: Console
+    updates: dict[str, "ConfigUpdateInfo"], console: Inject[Console]
 ) -> None:
     """Display available configuration updates."""
     console.print("[yellow]📋 Available updates:[/yellow]")
@@ -471,12 +669,13 @@ def _get_configs_needing_update(updates: dict[str, "ConfigUpdateInfo"]) -> list[
     ]
 
 
+@depends.inject  # type: ignore[misc]
 def _apply_config_updates_batch(
     config_service: "ConfigTemplateService",
     configs: list[str],
     pkg_path: Path,
     interactive: bool,
-    console: Console,
+    console: Inject[Console],
 ) -> int:
     """Apply configuration updates in batch and return success count."""
     success_count = 0
@@ -486,8 +685,9 @@ def _apply_config_updates_batch(
     return success_count
 
 
+@depends.inject  # type: ignore[misc]
 def _report_update_results(
-    success_count: int, total_count: int, console: Console
+    success_count: int, total_count: int, console: Inject[Console]
 ) -> None:
     """Report the results of configuration updates."""
     if success_count == total_count:

crackerjack/cli/interactive.py

@@ -2,8 +2,9 @@ import time
 import typing as t
 from enum import Enum, auto
 
+from acb.console import Console
+from acb.depends import depends
 from rich.box import ROUNDED
-from rich.console import Console
 from rich.layout import Layout
 from rich.live import Live
 from rich.panel import Panel
@@ -116,7 +117,7 @@ class InteractiveWorkflowManager:
             deps = ["cleaning"] if options.clean else []
             self.add_task(
                 "hooks",
-                "Run pre-commit hooks (fast + comprehensive)",
+                "Run quality hooks (fast + comprehensive)",
                 "run_hooks_phase",
                 dependencies=deps,
             )
@@ -383,8 +384,10 @@ class InteractiveWorkflowManager:
                 duration_text,
                 details,
             )
+        from rich.panel import Panel
+
         self.console.print("\n")
-        self.console.print(table)
+        self.console.print(Panel(table, border_style="magenta"))
         if failed_count == 0:
             self.console.print(
                 f"\n[bold green]🎉 Workflow completed ! {success_count} / {len(self.tasks)} tasks successful[/ bold green]",
@@ -398,8 +401,8 @@ class InteractiveWorkflowManager:
 class InteractiveCLI:
     def __init__(self, pkg_version: str, console: Console | None = None) -> None:
         self.pkg_version = pkg_version
-        self.console = console or Console(force_terminal=True)
-        self.orchestrator = WorkflowOrchestrator(console=self.console)
+        self.console = console or depends.get_sync(Console)
+        self.orchestrator = WorkflowOrchestrator()
         self.workflow_manager = InteractiveWorkflowManager(
             self.console,
             self.orchestrator,