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

crackerjack/mcp/server_core.py

@@ -1,12 +1,17 @@
 import subprocess
 import time
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 from typing import Final
+from uuid import UUID, uuid4
 
-from rich.console import Console
+from acb import console as acb_console
+from acb.depends import depends
+from mcp_common.ui import ServerPanels
 
-from ..ui.server_panels import create_server_panels
+# Get the actual Console instance
+console = acb_console.console
 
 try:
     import tomli
@@ -21,8 +26,20 @@ except ImportError:
     _mcp_available = False
     FastMCP = None  # type: ignore[misc,assignment,no-redef]
 
+# Import FastMCP rate limiting middleware (Phase 3 Security Hardening)
+try:
+    from fastmcp.server.middleware.rate_limiting import RateLimitingMiddleware
+
+    RATE_LIMITING_AVAILABLE = True
+except ImportError:
+    RATE_LIMITING_AVAILABLE = False
+
 MCP_AVAILABLE: Final[bool] = _mcp_available
 
+# Phase 9.1: ACB Integration - Module registration for dependency injection
+MODULE_ID: Final[UUID] = uuid4()
+MODULE_STATUS: Final[str] = "stable"
+
 from .context import (
     MCPServerConfig,
     MCPServerContext,
@@ -38,10 +55,11 @@ from .tools import (
     register_monitoring_tools,
     register_proactive_tools,
     register_progress_tools,
+    register_semantic_tools,
     register_utility_tools,
 )
 
-console = Console()
+# console imported from acb
 
 
 def _load_mcp_config(project_path: Path) -> dict[str, t.Any]:
@@ -128,9 +146,22 @@ def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
 
     mcp_app = FastMCP("crackerjack-mcp-server", streamable_http_path="/mcp")
 
+    # Add rate limiting middleware (Phase 3 Security Hardening)
+    if RATE_LIMITING_AVAILABLE:
+        rate_limiter = RateLimitingMiddleware(
+            max_requests_per_second=12.0,  # Sustainable rate for code quality operations
+            burst_capacity=35,  # Allow bursts for test/lint operations
+            global_limit=True,  # Protect the crackerjack server globally
+        )
+        # Use public API (Phase 3.1 C1 fix: standardize middleware access)
+        mcp_app.add_middleware(rate_limiter)
+
     from crackerjack.slash_commands import get_slash_command_path
 
-    @mcp_app.prompt("run")
+    @mcp_app.prompt(
+        "run",
+        description="Run Crackerjack quality checks with customizable options (hooks, tests, AI fixing)",
+    )
     async def get_crackerjack_run_prompt() -> str:
         try:
             command_path = get_slash_command_path("run")
@@ -139,7 +170,10 @@ def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
             msg = f"Failed to read run command: {e}"
             raise ValueError(msg)
 
-    @mcp_app.prompt("init")
+    @mcp_app.prompt(
+        "init",
+        description="Initialize Crackerjack in a new project (creates pyproject.toml config, pre-commit hooks)",
+    )
     async def get_crackerjack_init_prompt() -> str:
         try:
             command_path = get_slash_command_path("init")
@@ -148,7 +182,10 @@ def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
             msg = f"Failed to read init command: {e}"
             raise ValueError(msg)
 
-    @mcp_app.prompt("status")
+    @mcp_app.prompt(
+        "status",
+        description="Get comprehensive Crackerjack status (hooks, coverage, git state, server health)",
+    )
     async def get_crackerjack_status_prompt() -> str:
         try:
             command_path = get_slash_command_path("status")
@@ -163,6 +200,7 @@ def create_mcp_server(config: dict[str, t.Any] | None = None) -> t.Any | None:
     register_monitoring_tools(mcp_app)
     register_progress_tools(mcp_app)
     register_proactive_tools(mcp_app)
+    register_semantic_tools(mcp_app)
     register_utility_tools(mcp_app)
 
     return mcp_app
@@ -181,7 +219,7 @@ def handle_mcp_server_command(
 
         try:
             result = subprocess.run(
-                ["pkill", "- f", "crackerjack - mcp-server"],
+                ["pkill", "-f", "crackerjack-mcp-server"],
                 check=False,
                 capture_output=True,
                 text=True,
@@ -261,8 +299,6 @@ def _print_server_info(
     websocket_port: int | None,
     http_mode: bool,
 ) -> None:
-    panels = create_server_panels(console)
-
     if mcp_config.get("http_enabled", False) or http_mode:
         mode = "HTTP"
         http_endpoint = (
@@ -271,12 +307,19 @@ def _print_server_info(
     else:
         mode = "STDIO"
         http_endpoint = None
-
-    panels.start_panel(
-        project_path=project_path,
-        mode=mode,
-        http_endpoint=http_endpoint,
-        websocket_port=websocket_port,
+    # Use mcp-common ServerPanels info panel
+    items: dict[str, str] = {
+        "Project": project_path.name,
+        "Mode": mode,
+    }
+    if http_endpoint:
+        items["HTTP"] = http_endpoint
+    if websocket_port:
+        items["WebSocket Port"] = str(websocket_port)
+    ServerPanels.info(
+        title="Server Configuration",
+        message="Starting Crackerjack MCP Server...",
+        items=items,
     )
 
 
@@ -300,6 +343,73 @@ def _run_mcp_server(
         raise
 
 
+def _initialize_project_and_config(
+    project_path_arg: str,
+    http_port: int | None,
+    http_mode: bool,
+) -> tuple[Path, dict[str, t.Any]]:
+    """Initialize project path and config."""
+    project_path = Path(project_path_arg).resolve()
+    mcp_config = _load_mcp_config(project_path)
+    mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
+    return project_path, mcp_config
+
+
+def _create_and_validate_server(mcp_config: dict[str, t.Any]) -> t.Any | None:
+    """Create and validate the MCP server."""
+    mcp_app = create_mcp_server(mcp_config)
+    if not mcp_app:
+        console.print("[red]Failed to create MCP server[/ red]")
+    return mcp_app
+
+
+def _start_websocket_if_needed(websocket_port: int | None) -> None:
+    """Start WebSocket server if needed."""
+    if websocket_port:
+        import asyncio
+
+        try:
+            asyncio.run(_start_websocket_server())
+            console.print(
+                f"[green]✅ WebSocket server auto-started on port {websocket_port}[/green]"
+            )
+        except Exception as e:
+            console.print(f"[yellow]⚠️ WebSocket server auto-start failed: {e}[/yellow]")
+
+
+def _show_server_startup_info(
+    project_path: Path,
+    mcp_config: dict[str, t.Any],
+    websocket_port: int | None,
+    http_mode: bool,
+) -> None:
+    """Show server startup information."""
+    _print_server_info(project_path, mcp_config, websocket_port, http_mode)
+
+    # Show final success panel before starting the server
+    if mcp_config.get("http_enabled", False) or http_mode:
+        http_endpoint = (
+            f"http://{mcp_config['http_host']}:{mcp_config['http_port']}/mcp"
+        )
+    else:
+        http_endpoint = None
+
+    websocket_monitor = f"ws://127.0.0.1:{websocket_port}" if websocket_port else None
+
+    # Final startup success panel via mcp-common
+    if websocket_monitor:
+        ServerPanels.startup_success(
+            server_name="Crackerjack MCP",
+            endpoint=http_endpoint,
+            websocket_monitor=websocket_monitor,  # type: ignore[arg-type]
+        )
+    else:
+        ServerPanels.startup_success(
+            server_name="Crackerjack MCP",
+            endpoint=http_endpoint,
+        )
+
+
 def main(
     project_path_arg: str = ".",
     websocket_port: int | None = None,
@@ -310,53 +420,19 @@ def main(
         return
 
     try:
-        project_path = Path(project_path_arg).resolve()
-
-        mcp_config = _load_mcp_config(project_path)
-        mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
+        project_path, mcp_config = _initialize_project_and_config(
+            project_path_arg, http_port, http_mode
+        )
 
         _setup_server_context(project_path, websocket_port)
 
-        mcp_app = create_mcp_server(mcp_config)
+        mcp_app = _create_and_validate_server(mcp_config)
         if not mcp_app:
-            console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        _print_server_info(project_path, mcp_config, websocket_port, http_mode)
-
-        # Auto-start WebSocket server if websocket_port is specified
-        if websocket_port:
-            import asyncio
-
-            try:
-                asyncio.run(_start_websocket_server())
-                console.print(
-                    f"[green]✅ WebSocket server auto-started on port {websocket_port}[/green]"
-                )
-            except Exception as e:
-                console.print(
-                    f"[yellow]⚠️ WebSocket server auto-start failed: {e}[/yellow]"
-                )
-
-        # Show final success panel before starting the server
-        panels = create_server_panels(console)
-
-        if mcp_config.get("http_enabled", False) or http_mode:
-            http_endpoint = (
-                f"http://{mcp_config['http_host']}:{mcp_config['http_port']}/mcp"
-            )
-        else:
-            http_endpoint = None
-
-        websocket_monitor = (
-            f"ws://127.0.0.1:{websocket_port}" if websocket_port else None
-        )
+        _show_server_startup_info(project_path, mcp_config, websocket_port, http_mode)
 
-        panels.success_panel(
-            http_endpoint=http_endpoint,
-            websocket_monitor=websocket_monitor,
-            process_id=None,  # Will be set by the process manager
-        )
+        _start_websocket_if_needed(websocket_port)
 
         _run_mcp_server(mcp_app, mcp_config, http_mode)
 
@@ -392,3 +468,59 @@ if __name__ == "__main__":
             http_port = int(sys.argv[port_idx + 1])
 
     main(project_path, websocket_port, http_mode, http_port)
+
+
+# Phase 9.1: ACB Integration - Service wrapper for dependency injection
+class MCPServerService:
+    """Service wrapper for MCP server to enable ACB dependency injection.
+
+    This class wraps the MCP server creation and management functions,
+    providing a clean interface for dependency injection via ACB.
+    """
+
+    def __init__(self) -> None:
+        """Initialize MCP server service."""
+        self.module_id = MODULE_ID
+        self.module_status = MODULE_STATUS
+
+    def create_server(self, config: dict[str, t.Any] | None = None) -> t.Any | None:
+        """Create MCP server instance with optional configuration.
+
+        Args:
+            config: Server configuration dictionary
+
+        Returns:
+            FastMCP server instance or None if MCP unavailable
+        """
+        return create_mcp_server(config)
+
+    def start_server(
+        self,
+        project_path: str = ".",
+        websocket_port: int | None = None,
+        http_mode: bool = False,
+        http_port: int | None = None,
+    ) -> None:
+        """Start MCP server with specified configuration.
+
+        Args:
+            project_path: Path to project directory
+            websocket_port: Optional WebSocket server port
+            http_mode: Enable HTTP mode instead of STDIO
+            http_port: Optional HTTP server port
+        """
+        main(project_path, websocket_port, http_mode, http_port)
+
+    @property
+    def is_available(self) -> bool:
+        """Check if MCP server functionality is available.
+
+        Returns:
+            True if FastMCP library is installed and available
+        """
+        return MCP_AVAILABLE
+
+
+# Phase 9.1: ACB Integration - Register service with dependency injection system
+with suppress(Exception):
+    depends.set(MCPServerService)

crackerjack/mcp/service_watchdog.py

@@ -3,15 +3,14 @@ import socket
 import subprocess
 import sys
 import time
+from contextlib import suppress
 from typing import Any
 
 import aiohttp
-from rich.console import Console
+from acb import console
+from rich.panel import Panel
 from rich.table import Table
 
-console = Console()
-
-
 watchdog_event_queue: asyncio.Queue[dict[str, Any]] | None = None
 
 
@@ -34,7 +33,7 @@ class ServiceConfig:
         self.max_restarts = max_restarts
         self.restart_window = restart_window
 
-        self.process: subprocess.Popen[bytes] | None = None
+        self.process: subprocess.Popen[str] | None = None
         self.restart_count = 0
         self.restart_timestamps: list[float] = []
         self.last_health_check = 0.0
@@ -125,7 +124,7 @@ class ServiceWatchdog:
         return False
 
     async def _launch_service_process(self, service: ServiceConfig) -> bool:
-        service.process = subprocess.Popen(
+        service.process = subprocess.Popen[str](
             service.command,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
@@ -137,6 +136,8 @@ class ServiceWatchdog:
         return await self._check_process_startup_success(service)
 
     async def _check_process_startup_success(self, service: ServiceConfig) -> bool:
+        if service.process is None:
+            return False
         exit_code = service.process.poll()
         if exit_code is not None:
             return await self._handle_process_died(service, exit_code)
@@ -147,6 +148,8 @@ class ServiceWatchdog:
         service: ServiceConfig,
         exit_code: int,
     ) -> bool:
+        if service.process is None:
+            return False
         stdout, stderr = service.process.communicate()
         error_msg = f"Process died (exit: {exit_code})"
         if stderr and stderr.strip():
@@ -402,7 +405,9 @@ class ServiceWatchdog:
 
             table.add_row(service.name, status, health, restarts, error)
 
-        console.print(table)
+        console.print(
+            Panel(table, title="Crackerjack Service Watchdog", border_style="cyan")
+        )
         console.print("\n[dim]Press Ctrl + C to stop monitoring[/ dim]")
 
     def _create_status_table(self) -> Table:
@@ -441,8 +446,6 @@ class ServiceWatchdog:
         message: str,
     ) -> None:
         if self.event_queue:
-            from contextlib import suppress
-
             with suppress(Exception):
                 event = {
                     "type": event_type,

crackerjack/mcp/task_manager.py

@@ -5,9 +5,9 @@ import typing as t
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 
-from rich.console import Console
+from acb import console
 
-console = Console()
+# console imported from acb
 logger = logging.getLogger(__name__)
 
 

crackerjack/mcp/tools/README.md

@@ -0,0 +1,27 @@
+# MCP Tools
+
+MCP tool definitions and adapters for the Crackerjack MCP server.
+
+## Tool Categories
+
+- **`execution_tools.py`** - Execute crackerjack workflows, get job progress
+- **`monitoring_tools.py`** - System health, status reporting, workflow monitoring
+- **`progress_tools.py`** - Real-time progress tracking for test execution
+- **`semantic_tools.py`** - Semantic search, file indexing, embeddings
+- **`intelligence_tools.py`** - AI agent selection, recommendations, performance analysis
+- **`error_analyzer.py`** - Smart error analysis and pattern detection
+- **`proactive_tools.py`** - Proactive monitoring and preventive quality checks
+- **`utility_tools.py`** - Helper utilities and common operations
+- **`workflow_executor.py`** - Workflow orchestration and execution management
+
+## Core Tools
+
+The MCP server provides these primary capabilities:
+
+1. **Workflow Execution** - Run crackerjack quality checks via MCP
+1. **Job Tracking** - Monitor async job progress and status
+1. **Error Analysis** - Intelligent error detection and root cause analysis
+1. **Semantic Search** - Code search with vector embeddings
+1. **Agent Intelligence** - Smart agent selection based on task context
+
+See parent `mcp/README.md` for server architecture details.

crackerjack/mcp/tools/__init__.py

@@ -4,6 +4,7 @@ from .intelligence_tool_registry import register_intelligence_tools
 from .monitoring_tools import register_monitoring_tools
 from .proactive_tools import register_proactive_tools
 from .progress_tools import register_progress_tools
+from .semantic_tools import register_semantic_tools
 from .utility_tools import register_utility_tools
 
 __all__ = [
@@ -13,5 +14,6 @@ __all__ = [
     "register_monitoring_tools",
     "register_progress_tools",
     "register_proactive_tools",
+    "register_semantic_tools",
     "register_utility_tools",
 ]