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

crackerjack/cli/facade.py

@@ -0,0 +1,100 @@
+import asyncio
+from pathlib import Path
+
+from rich.console import Console
+
+from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+from crackerjack.models.protocols import OptionsProtocol
+
+
+class CrackerjackCLIFacade:
+    def __init__(
+        self,
+        console: Console | None = None,
+        pkg_path: Path | None = None,
+    ) -> None:
+        self.console = console or Console(force_terminal=True)
+        self.pkg_path = pkg_path or Path.cwd()
+        self.orchestrator = WorkflowOrchestrator(
+            console=self.console,
+            pkg_path=self.pkg_path,
+        )
+
+    def process(self, options: OptionsProtocol) -> None:
+        try:
+            if self._should_handle_special_mode(options):
+                self._handle_special_modes(options)
+                return
+            success = asyncio.run(self.orchestrator.run_complete_workflow(options))
+            if not success:
+                self.console.print("[red]❌ Workflow completed with errors[/ red]")
+            else:
+                self.console.print(
+                    "[green]🎉 Workflow completed successfully ![/ green]"
+                )
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]⏹️ Operation cancelled by user[/ yellow]")
+            raise SystemExit(130)
+        except Exception as e:
+            self.console.print(f"[red]💥 Unexpected error: {e}[/ red]")
+            if options.verbose:
+                import traceback
+
+                self.console.print(f"[dim]{traceback.format_exc()}[/ dim]")
+            raise SystemExit(1)
+
+    async def process_async(self, options: OptionsProtocol) -> None:
+        await asyncio.to_thread(self.process, options)
+
+    def _should_handle_special_mode(self, options: OptionsProtocol) -> bool:
+        return (
+            getattr(options, "start_mcp_server", False)
+            or getattr(options, "enterprise_batch", False)
+            or getattr(options, "monitor_dashboard", False)
+        )
+
+    def _handle_special_modes(self, options: OptionsProtocol) -> None:
+        if getattr(options, "start_mcp_server", False):
+            self._start_mcp_server()
+        elif getattr(options, "enterprise_batch", False):
+            self._handle_enterprise_batch(options)
+        elif getattr(options, "monitor_dashboard", False):
+            self._handle_monitor_dashboard(options)
+
+    def _start_mcp_server(self) -> None:
+        try:
+            from crackerjack.mcp.server import main as start_mcp_main
+
+            self.console.print(
+                "[bold cyan]🤖 Starting Crackerjack MCP Server...[/ bold cyan]",
+            )
+            start_mcp_main(str(self.pkg_path))
+        except ImportError:
+            self.console.print(
+                "[red]❌ MCP server requires additional dependencies[/ red]",
+            )
+            self.console.print("[yellow]Install with: uv sync --group mcp[/ yellow]")
+            raise SystemExit(1)
+        except Exception as e:
+            self.console.print(f"[red]❌ Failed to start MCP server: {e}[/ red]")
+            raise SystemExit(1)
+
+    def _handle_enterprise_batch(self, options: OptionsProtocol) -> None:
+        self.console.print(
+            "[red]❌ Enterprise batch processing is not yet implemented[/ red]"
+        )
+        raise SystemExit(1)
+
+    def _handle_monitor_dashboard(self, options: OptionsProtocol) -> None:
+        self.console.print("[red]❌ Monitoring dashboard is not yet implemented[/ red]")
+        raise SystemExit(1)
+
+
+def create_crackerjack_runner(
+    console: Console | None = None,
+    pkg_path: Path | None = None,
+) -> CrackerjackCLIFacade:
+    return CrackerjackCLIFacade(console=console, pkg_path=pkg_path)
+
+
+CrackerjackRunner = CrackerjackCLIFacade

crackerjack/cli/handlers.py

@@ -1,26 +1,31 @@
 import asyncio
 import os
 import sys
+import typing as t
 from pathlib import Path
 
 from rich.console import Console
 
 from .options import Options
 
+if t.TYPE_CHECKING:
+    from crackerjack.services.config_template import (
+        ConfigTemplateService,
+        ConfigUpdateInfo,
+    )
+
 
 def setup_ai_agent_env(ai_agent: bool, debug_mode: bool = False) -> None:
-    # Only set debug environment variable if debug mode is explicitly enabled
     if debug_mode:
         os.environ["CRACKERJACK_DEBUG"] = "1"
 
     if ai_agent:
         os.environ["AI_AGENT"] = "1"
-        # Only enable AI agent debug if debug mode is explicitly requested
+
         if debug_mode:
             os.environ["AI_AGENT_DEBUG"] = "1"
             os.environ["AI_AGENT_VERBOSE"] = "1"
 
-            # Show debug configuration when debug mode is enabled
             console = Console()
             console.print(
                 "[bold cyan]🐛 AI Agent Debug Mode Configuration: [/ bold cyan]",
@@ -91,6 +96,24 @@ 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:
+    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]",
+    )
+
+    try:
+        server = CrackerjackMonitoringServer()
+        asyncio.run(server.start_monitoring(port))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]🛑 Unified Dashboard stopped[/yellow]")
+    except Exception as e:
+        console.print(f"\n[red]❌ Unified Dashboard failed: {e}[/red]")
+
+
 def handle_watchdog_mode() -> None:
     from crackerjack.mcp.service_watchdog import main as start_watchdog
 
@@ -145,6 +168,61 @@ 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:
+    """Start Zuban LSP server."""
+    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:
+        lsp_service = await create_zuban_lsp_service(
+            port=port, mode=mode, console=console
+        )
+        if await lsp_service.start():
+            console.print(
+                f"[bold green]✅ Zuban LSP server started on port {port} ({mode} mode)[/bold green]"
+            )
+        else:
+            console.print("[bold red]❌ Failed to start Zuban LSP server[/bold red]")
+            raise SystemExit(1)
+
+    try:
+        asyncio.run(_start())
+    except KeyboardInterrupt:
+        console.print("\n[yellow]🛑 Zuban LSP startup interrupted[/yellow]")
+
+
+def handle_stop_zuban_lsp() -> 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):
+        console.print(
+            "\n[bold green]✅ Zuban LSP server stopped successfully[/bold green]"
+        )
+    else:
+        console.print("\n[bold red]❌ Failed to stop Zuban LSP server[/bold red]")
+        raise SystemExit(1)
+
+
+def handle_restart_zuban_lsp(port: int = 8677, mode: str = "tcp") -> 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]"
+        )
+    else:
+        console.print("\n[bold red]❌ Zuban LSP server restart failed[/bold red]")
+        raise SystemExit(1)
+
+
 def handle_interactive_mode(options: Options) -> None:
     from crackerjack.cli.utils import get_package_version
 
@@ -164,7 +242,6 @@ def handle_standard_mode(
 
     console = Console()
 
-    # Configure global lock manager from CLI options
     from crackerjack.executors.hook_lock_manager import hook_lock_manager
 
     hook_lock_manager.configure_from_options(options)
@@ -180,7 +257,7 @@ def handle_standard_mode(
         pkg_path = Path.cwd()
 
         if async_mode:
-            orchestrator = AsyncWorkflowOrchestrator(
+            async_orchestrator = AsyncWorkflowOrchestrator(
                 console=console,
                 pkg_path=pkg_path,
                 dry_run=getattr(options, "dry_run", False),
@@ -188,9 +265,11 @@ def handle_standard_mode(
                 verbose=options.verbose,
                 debug=getattr(options, "debug", False),
             )
-            success = asyncio.run(orchestrator.run_complete_workflow_async(options))
+            success = asyncio.run(
+                async_orchestrator.run_complete_workflow_async(options)
+            )
         else:
-            orchestrator = WorkflowOrchestrator(
+            sync_orchestrator = WorkflowOrchestrator(
                 console=console,
                 pkg_path=pkg_path,
                 dry_run=getattr(options, "dry_run", False),
@@ -198,7 +277,7 @@ def handle_standard_mode(
                 verbose=options.verbose,
                 debug=getattr(options, "debug", False),
             )
-            success = asyncio.run(orchestrator.run_complete_workflow(options))
+            success = sync_orchestrator.run_complete_workflow_sync(options)
 
         if not success:
             raise SystemExit(1)
@@ -210,7 +289,6 @@ def handle_orchestrated_mode(options: Options, job_id: str | None = None) -> Non
     console = Console()
     console.print("[bold bright_blue]🚀 ORCHESTRATED MODE ENABLED[/ bold bright_blue]")
 
-    # Configure global lock manager from CLI options
     from crackerjack.executors.hook_lock_manager import hook_lock_manager
 
     hook_lock_manager.configure_from_options(options)
@@ -283,3 +361,140 @@ def handle_orchestrated_mode(options: Options, job_id: str | None = None) -> Non
     except Exception as e:
         console.print(f"\n[red]💥 Orchestrated workflow error: {e}[/ red]")
         sys.exit(1)
+
+
+def handle_config_updates(options: Options) -> None:
+    """Handle configuration update commands."""
+    from crackerjack.services.config_template import ConfigTemplateService
+
+    console = Console()
+    pkg_path = Path.cwd()
+    config_service = ConfigTemplateService(console, pkg_path)
+
+    if options.check_config_updates:
+        _handle_check_updates(config_service, pkg_path, console)
+    elif options.apply_config_updates:
+        _handle_apply_updates(
+            config_service, pkg_path, options.config_interactive, console
+        )
+    elif options.diff_config:
+        _handle_diff_config(config_service, pkg_path, options.diff_config, console)
+    elif options.refresh_cache:
+        _handle_refresh_cache(config_service, pkg_path, console)
+
+
+def _handle_check_updates(
+    config_service: "ConfigTemplateService", pkg_path: Path, console: Console
+) -> None:
+    """Handle checking for configuration updates."""
+    console.print("[bold cyan]🔍 Checking for configuration updates...[/bold cyan]")
+    updates = config_service.check_updates(pkg_path)
+
+    if not updates:
+        console.print("[green]✅ No configuration templates available[/green]")
+        return
+
+    has_updates = any(update.needs_update for update in updates.values())
+    if not has_updates:
+        console.print("[green]✅ All configurations are up to date[/green]")
+        return
+
+    _display_available_updates(updates, console)
+    console.print("\nUse --apply-config-updates to apply these updates")
+
+
+def _handle_apply_updates(
+    config_service: "ConfigTemplateService",
+    pkg_path: Path,
+    interactive: bool,
+    console: Console,
+) -> None:
+    """Handle applying configuration updates."""
+    console.print("[bold cyan]🔧 Applying configuration updates...[/bold cyan]")
+    updates = config_service.check_updates(pkg_path)
+
+    if not updates:
+        console.print("[yellow]⚠️ No configuration templates available[/yellow]")
+        return
+
+    configs_to_update = _get_configs_needing_update(updates)
+    if not configs_to_update:
+        console.print("[green]✅ All configurations are already up to date[/green]")
+        return
+
+    success_count = _apply_config_updates_batch(
+        config_service, configs_to_update, pkg_path, interactive, console
+    )
+    _report_update_results(success_count, len(configs_to_update), console)
+
+
+def _handle_diff_config(
+    config_service: "ConfigTemplateService",
+    pkg_path: Path,
+    config_type: str,
+    console: Console,
+) -> None:
+    """Handle showing configuration diff."""
+    console.print(f"[bold cyan]📊 Showing diff for {config_type}...[/bold cyan]")
+    diff_preview = config_service._generate_diff_preview(config_type, pkg_path)
+    console.print(f"\nChanges for {config_type}:")
+    console.print(diff_preview)
+
+
+def _handle_refresh_cache(
+    config_service: "ConfigTemplateService", pkg_path: Path, console: 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]")
+
+
+def _display_available_updates(
+    updates: dict[str, "ConfigUpdateInfo"], console: Console
+) -> None:
+    """Display available configuration updates."""
+    console.print("[yellow]📋 Available updates:[/yellow]")
+    for config_type, update_info in updates.items():
+        if update_info.needs_update:
+            console.print(
+                f"  • {config_type}: {update_info.current_version} → {update_info.latest_version}"
+            )
+
+
+def _get_configs_needing_update(updates: dict[str, "ConfigUpdateInfo"]) -> list[str]:
+    """Get list of configurations that need updates."""
+    return [
+        config_type
+        for config_type, update_info in updates.items()
+        if update_info.needs_update
+    ]
+
+
+def _apply_config_updates_batch(
+    config_service: "ConfigTemplateService",
+    configs: list[str],
+    pkg_path: Path,
+    interactive: bool,
+    console: Console,
+) -> int:
+    """Apply configuration updates in batch and return success count."""
+    success_count = 0
+    for config_type in configs:
+        if config_service.apply_update(config_type, pkg_path, interactive=interactive):
+            success_count += 1
+    return success_count
+
+
+def _report_update_results(
+    success_count: int, total_count: int, console: Console
+) -> None:
+    """Report the results of configuration updates."""
+    if success_count == total_count:
+        console.print(
+            f"[green]✅ Successfully updated {success_count} configurations[/green]"
+        )
+    else:
+        console.print(
+            f"[yellow]⚠️ Updated {success_count}/{total_count} configurations[/yellow]"
+        )

crackerjack/cli/interactive.py

@@ -1,4 +1,5 @@
 import time
+import typing as t
 from enum import Enum, auto
 
 from rich.box import ROUNDED
@@ -146,7 +147,7 @@ class InteractiveWorkflowManager:
 
     def _setup_commit_task(self, options: OptionsProtocol) -> None:
         if options.commit:
-            all_deps = list(self.tasks.keys())
+            all_deps = list[t.Any](self.tasks.keys())
             self.add_task(
                 "commit",
                 "Commit changes and push to Git",
@@ -193,9 +194,10 @@ class InteractiveWorkflowManager:
         task.start()
         try:
             phase_method = getattr(self.orchestrator, task.phase_method)
-            success = phase_method(options)
-            task.complete(success)
-            return success
+            success_result = phase_method(options)
+            success_bool = bool(success_result)
+            task.complete(success_bool)
+            return success_bool
         except Exception as e:
             error = CrackerjackError(
                 message=str(e),