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

crackerjack/cli/facade.py

@@ -0,0 +1,162 @@
+import asyncio
+import shlex
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import depends
+
+from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+from crackerjack.models.protocols import OptionsProtocol
+
+# Valid semantic commands for crackerjack operations
+VALID_COMMANDS = {"test", "lint", "check", "format", "security", "complexity", "all"}
+
+
+def validate_command(
+    command: str | None, args: str | None = None
+) -> tuple[str, list[str]]:
+    """Validate command and detect common misuse patterns.
+
+    Args:
+        command: Semantic command name (test, lint, check, etc.)
+        args: Additional arguments as a string
+
+    Returns:
+        Tuple of (validated_command, cleaned_args_list)
+
+    Raises:
+        ValueError: If command is invalid or misused
+
+    Examples:
+        >>> validate_command("test", "")
+        ("test", [])
+        >>> validate_command("check", "--verbose")
+        ("check", ["--verbose"])
+        >>> validate_command("--ai-fix", "-t")
+        Traceback (most recent call last):
+        ...
+        ValueError: Invalid command: '--ai-fix'...
+    """
+    # CRITICAL: Check for None command first
+    if command is None:
+        raise ValueError("Command cannot be None")
+
+    # Detect if user put flags in command parameter
+    if command.startswith("--") or command.startswith("-"):
+        raise ValueError(
+            f"Invalid command: {command!r}\n"
+            f"Commands should be semantic (e.g., 'test', 'lint', 'check')\n"
+            f"Use ai_agent_mode=True parameter for auto-fix, not --ai-fix in command"
+        )
+
+    # Validate against known semantic commands
+    if command not in VALID_COMMANDS:
+        raise ValueError(
+            f"Unknown command: {command!r}\n"
+            f"Valid commands: {', '.join(sorted(VALID_COMMANDS))}"
+        )
+
+    # Parse args and detect --ai-fix misuse
+    # Handle None gracefully by converting to empty string
+    args_str = args if args is not None else ""
+    # Use shlex.split for proper shell argument parsing (handles quotes)
+    parsed_args = shlex.split(args_str) if args_str else []
+    if "--ai-fix" in parsed_args:
+        raise ValueError(
+            "Do not pass --ai-fix in args parameter\n"
+            "Use ai_agent_mode=True parameter instead"
+        )
+
+    return command, parsed_args
+
+
+class CrackerjackCLIFacade:
+    def __init__(
+        self,
+        console: Console | None = None,
+        pkg_path: Path | None = None,
+    ) -> None:
+        self.console = console or depends.get_sync(Console)
+        self.pkg_path = pkg_path or Path.cwd()
+        self.orchestrator = WorkflowOrchestrator(
+            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, "advanced_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, "advanced_batch", False):
+            self._handle_advanced_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_advanced_batch(self, options: OptionsProtocol) -> None:
+        self.console.print(
+            "[red]❌ Advanced 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/formatting.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from crackerjack.config import get_console_width
+
+
+def separator(char: str = "-", width: int | None = None) -> str:
+    """Return a horizontal separator string.
+
+    - char: the character to repeat (default '-')
+    - width: explicit width; if None, uses configured console width
+    """
+    w = width if isinstance(width, int) and width > 0 else get_console_width()
+    return char * w

crackerjack/cli/handlers/__init__.py

@@ -0,0 +1,85 @@
+"""CLI handlers module for Crackerjack.
+
+This module contains all the command handlers for the Crackerjack CLI.
+"""
+
+# Import specific functions from the modular handlers
+# Import other specific functions from other handlers files
+from . import (
+    advanced,
+    ai_features,
+    analytics,
+    changelog,
+    config_handlers,
+    coverage,
+    documentation,
+    monitoring,
+)
+from .advanced import *
+from .ai_features import *
+from .analytics import *
+from .changelog import *
+from .config_handlers import *
+from .coverage import *
+from .documentation import *
+
+# Import main handler functions that coordinate the core CLI workflows
+from .main_handlers import (
+    handle_acb_workflow_mode,
+    handle_config_updates,
+    handle_interactive_mode,
+    handle_orchestrated_mode,
+    handle_standard_mode,
+    setup_ai_agent_env,
+)
+from .monitoring import (
+    handle_dashboard_mode,
+    handle_enhanced_monitor_mode,
+    handle_mcp_commands,
+    handle_mcp_server,
+    handle_monitor_mode,
+    handle_monitoring_commands,
+    handle_restart_mcp_server,
+    handle_restart_websocket_server,
+    handle_restart_zuban_lsp,
+    handle_server_commands,
+    handle_start_websocket_server,
+    handle_start_zuban_lsp,
+    handle_stop_mcp_server,
+    handle_stop_websocket_server,
+    handle_stop_zuban_lsp,
+    handle_unified_dashboard_mode,
+    handle_watchdog_mode,
+    handle_websocket_commands,
+    handle_zuban_lsp_commands,
+)
+
+__all__ = [
+    "handle_interactive_mode",
+    "handle_monitor_mode",
+    "handle_orchestrated_mode",
+    "handle_standard_mode",
+    "handle_watchdog_mode",
+    "setup_ai_agent_env",
+    # Add other functions from the modular handlers
+    "handle_dashboard_mode",
+    "handle_enhanced_monitor_mode",
+    "handle_mcp_server",
+    "handle_restart_mcp_server",
+    "handle_restart_websocket_server",
+    "handle_restart_zuban_lsp",
+    "handle_start_websocket_server",
+    "handle_start_zuban_lsp",
+    "handle_stop_mcp_server",
+    "handle_stop_websocket_server",
+    "handle_stop_zuban_lsp",
+    "handle_unified_dashboard_mode",
+    "handle_acb_workflow_mode",
+    "handle_config_updates",
+    "handle_monitoring_commands",
+    "handle_websocket_commands",
+    "handle_mcp_commands",
+    "handle_zuban_lsp_commands",
+    "handle_server_commands",
+    # Add other functions as they are moved to modular handlers
+]

crackerjack/cli/handlers/advanced.py

@@ -0,0 +1,103 @@
+"""CLI handlers for advanced optimization features"""
+
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+
+@depends.inject  # type: ignore[misc]
+def handle_advanced_optimizer(
+    advanced_optimizer: bool,
+    advanced_profile: str | None,
+    advanced_report: str | None,
+    console: Inject[Console] = None,
+) -> bool:
+    if not advanced_optimizer:
+        return True
+
+    console.print("[cyan]🏢[/cyan] Running advanced-scale optimization analysis...")
+    try:
+        optimizer = setup_advanced_optimizer(advanced_profile)
+        result = run_advanced_optimization(optimizer)
+        display_advanced_results(result, advanced_report)
+        return False
+
+    except Exception as e:
+        console.print(f"[red]❌[/red] Advanced optimizer error: {e}")
+        return False
+
+
+def setup_advanced_optimizer(advanced_profile: str | None) -> t.Any:
+    import tempfile
+
+    from crackerjack.services.ai.advanced_optimizer import AdvancedOptimizer
+
+    config_dir = Path.cwd() / ".crackerjack"
+    storage_dir = Path(tempfile.gettempdir()) / "crackerjack_storage"
+    optimizer = AdvancedOptimizer(config_dir, storage_dir)
+
+    if advanced_profile:
+        optimizer.performance_profile.optimization_strategy = advanced_profile
+
+    return optimizer
+
+
+@depends.inject  # type: ignore[misc]
+def run_advanced_optimization(optimizer: t.Any, console: Inject[Console]) -> t.Any:
+    import asyncio
+
+    console.print("[blue]📊[/blue] Analyzing system resources and performance...")
+    return asyncio.run(optimizer.run_optimization_cycle())
+
+
+@depends.inject  # type: ignore[misc]
+def display_advanced_results(
+    result: t.Any, advanced_report: str | None, console: Inject[Console]
+) -> None:
+    if result["status"] == "success":
+        console.print("[green]✅[/green] Advanced optimization completed successfully")
+        display_advanced_metrics(result["metrics"])
+        display_advanced_recommendations(result["recommendations"])
+        save_advanced_report(result, advanced_report)
+    else:
+        console.print(
+            f"[red]❌[/red] Advanced optimization failed: {result.get('message', 'Unknown error')}"
+        )
+
+
+@depends.inject  # type: ignore[misc]
+def display_advanced_metrics(metrics: t.Any, console: Inject[Console]) -> None:
+    console.print(f"[blue]CPU Usage:[/blue] {metrics['cpu_percent']:.1f}%")
+    console.print(f"[blue]Memory Usage:[/blue] {metrics['memory_percent']:.1f}%")
+    console.print(f"[blue]Storage Usage:[/blue] {metrics['disk_usage_percent']:.1f}%")
+
+
+@depends.inject  # type: ignore[misc]
+def display_advanced_recommendations(
+    recommendations: t.Any, console: Inject[Console]
+) -> None:
+    if recommendations:
+        console.print(
+            f"\n[yellow]💡[/yellow] Found {len(recommendations)} optimization recommendations:"
+        )
+        for rec in recommendations[:3]:
+            priority_color = {"high": "red", "medium": "yellow", "low": "blue"}[
+                rec["priority"]
+            ]
+            console.print(
+                f" [{priority_color}]{rec['priority'].upper()}[/{priority_color}]: {rec['title']}"
+            )
+
+
+@depends.inject  # type: ignore[misc]
+def save_advanced_report(
+    result: t.Any, advanced_report: str | None, console: Inject[Console]
+) -> None:
+    if advanced_report:
+        import json
+
+        with open(advanced_report, "w") as f:
+            json.dump(result, f, indent=2)
+        console.print(f"[green]📄[/green] Advanced report saved to: {advanced_report}")

crackerjack/cli/handlers/ai_features.py

@@ -0,0 +1,62 @@
+"""CLI handlers for AI-powered features (contextual AI assistant)"""
+
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+
+@depends.inject  # type: ignore[misc]
+def handle_contextual_ai(
+    contextual_ai: bool,
+    ai_recommendations: int,
+    ai_help_query: str | None,
+    console: Inject[Console],
+) -> bool:
+    if not contextual_ai and not ai_help_query:
+        return True
+
+    from crackerjack.services.ai.contextual_ai_assistant import ContextualAIAssistant
+
+    console.print("[cyan]🤖[/cyan] Running contextual AI assistant analysis...")
+
+    try:
+
+        class FileSystemImpl:
+            def read_file(self, path: str | t.Any) -> str:
+                return Path(path).read_text()
+
+            def write_file(self, path: str | t.Any, content: str) -> None:
+                Path(path).write_text(content)
+
+            def exists(self, path: str | t.Any) -> bool:
+                return Path(path).exists()
+
+            def mkdir(self, path: str | t.Any, parents: bool = False) -> None:
+                Path(path).mkdir(parents=parents, exist_ok=True)
+
+        filesystem = FileSystemImpl()
+        assistant = ContextualAIAssistant(filesystem)
+
+        if ai_help_query:
+            help_response = assistant.get_quick_help(ai_help_query)
+            console.print(f"\n[blue]🔍[/blue] AI Help for '{ai_help_query}':")
+            console.print(help_response)
+            return False
+
+        console.print(
+            "[blue]🧠[/blue] Analyzing project context for AI recommendations..."
+        )
+        recommendations = assistant.get_contextual_recommendations(ai_recommendations)
+
+        if recommendations:
+            assistant.display_recommendations(recommendations)
+        else:
+            console.print("[green]✨[/green] Great job! No immediate recommendations")
+
+        return False
+
+    except Exception as e:
+        console.print(f"[red]❌[/red] Contextual AI error: {e}")
+        return False