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

crackerjack/mcp/websocket/event_bridge.py

@@ -0,0 +1,188 @@
+"""WebSocket bridge for routing WorkflowEventBus events to connected clients.
+
+This module provides the EventBusWebSocketBridge class that connects the
+WorkflowEventBus to WebSocket clients, enabling real-time workflow progress
+updates without polling.
+
+Phase 7.3: WebSocket Streaming for Real-Time Updates
+"""
+
+from __future__ import annotations
+
+import typing as t
+from collections import defaultdict
+
+from acb.depends import Inject, depends
+
+from crackerjack.events.workflow_bus import WorkflowEvent, WorkflowEventBus
+
+if t.TYPE_CHECKING:
+    from acb.actions.events import Event
+    from fastapi import WebSocket
+
+
+@depends.inject
+class EventBusWebSocketBridge:
+    """Bridges workflow events to WebSocket clients for real-time updates.
+
+    This class subscribes to all WorkflowEvent types from the WorkflowEventBus
+    and routes them to appropriate WebSocket clients based on job_id.
+
+    Architecture:
+        WorkflowActions → WorkflowEventBus → EventBusWebSocketBridge → WebSocket Clients
+
+    Usage:
+        bridge = EventBusWebSocketBridge(event_bus)
+        await bridge.register_client(job_id, websocket)
+        # Events automatically routed to client
+        await bridge.unregister_client(job_id, websocket)
+    """
+
+    def __init__(
+        self,
+        event_bus: Inject[WorkflowEventBus] = None,
+    ) -> None:
+        """Initialize event bridge with WorkflowEventBus.
+
+        Args:
+            event_bus: WorkflowEventBus instance (injected via DI)
+        """
+        self._event_bus = event_bus
+        self._clients: dict[str, list[WebSocket]] = defaultdict(list)
+        self._subscription_ids: list[str] = []
+
+        # Subscribe to all workflow events
+        if self._event_bus:
+            self._subscribe_to_events()
+
+    def _subscribe_to_events(self) -> None:
+        """Subscribe to all WorkflowEvent types for event routing."""
+        for event_type in WorkflowEvent:
+            subscription_id = self._event_bus.subscribe(
+                event_type,
+                self._handle_workflow_event,
+            )
+            self._subscription_ids.append(subscription_id)
+
+    async def _handle_workflow_event(self, event: Event) -> None:
+        """Handle workflow event and route to appropriate clients.
+
+        Args:
+            event: ACB Event object with workflow event data
+        """
+        # Extract job_id from event payload
+        # Events include step_id in format "action_name_timestamp" or "workflow_id"
+        payload = event.payload
+        step_id = payload.get("step_id", "")
+
+        if not step_id:
+            # No step_id in payload, skip routing
+            return
+
+        # For now, broadcast to all connected clients
+        # In future, could parse step_id to extract workflow_id/job_id for filtering
+        all_clients: list[WebSocket] = []
+        for clients in self._clients.values():
+            all_clients.extend(clients)
+
+        if not all_clients:
+            # No clients connected
+            return
+
+        # Transform event to WebSocket message format
+        message = self._transform_event_to_message(event)
+
+        # Send to all clients
+        await self._broadcast_to_clients(all_clients, message)
+
+    def _transform_event_to_message(self, event: Event) -> dict[str, t.Any]:
+        """Transform ACB Event to WebSocket message format.
+
+        Args:
+            event: ACB Event object
+
+        Returns:
+            dict with event_type, data, and timestamp
+        """
+        return {
+            "event_type": event.event_type.value
+            if hasattr(event.event_type, "value")
+            else str(event.event_type),
+            "data": event.payload,
+            "timestamp": event.payload.get("timestamp"),
+        }
+
+    async def _broadcast_to_clients(
+        self,
+        clients: list[WebSocket],
+        message: dict[str, t.Any],
+    ) -> None:
+        """Broadcast message to all clients, removing disconnected ones.
+
+        Args:
+            clients: List of WebSocket clients to send to
+            message: Message data to send
+        """
+        disconnected: list[WebSocket] = []
+
+        for websocket in clients:
+            try:
+                await websocket.send_json(message)
+            except Exception:
+                # Client disconnected, mark for removal
+                disconnected.append(websocket)
+
+        # Remove disconnected clients
+        for websocket in disconnected:
+            clients.remove(websocket)
+
+    async def register_client(self, job_id: str, websocket: WebSocket) -> None:
+        """Register WebSocket client for job-specific event updates.
+
+        Args:
+            job_id: Job identifier to subscribe to
+            websocket: WebSocket connection to send events to
+        """
+        self._clients[job_id].append(websocket)
+
+    async def unregister_client(self, job_id: str, websocket: WebSocket) -> None:
+        """Unregister WebSocket client from event updates.
+
+        Args:
+            job_id: Job identifier to unsubscribe from
+            websocket: WebSocket connection to remove
+        """
+        if job_id in self._clients:
+            with suppress(ValueError):
+                self._clients[job_id].remove(websocket)
+
+            # Clean up empty job client lists
+            if not self._clients[job_id]:
+                del self._clients[job_id]
+
+    def get_active_connections(self) -> int:
+        """Get count of active WebSocket connections.
+
+        Returns:
+            Total number of active WebSocket connections across all jobs
+        """
+        return sum(len(clients) for clients in self._clients.values())
+
+    def get_jobs_with_clients(self) -> list[str]:
+        """Get list of job IDs with active clients.
+
+        Returns:
+            List of job_id strings that have connected clients
+        """
+        return [job_id for job_id, clients in self._clients.items() if clients]
+
+    def cleanup(self) -> None:
+        """Cleanup event subscriptions and client connections."""
+        # Unsubscribe from all events
+        if self._event_bus:
+            for subscription_id in self._subscription_ids:
+                self._event_bus.unsubscribe(subscription_id)
+
+        # Clear client lists
+        self._clients.clear()
+        self._subscription_ids.clear()

crackerjack/mcp/websocket/jobs.py

@@ -5,15 +5,23 @@ import typing as t
 import uuid
 from contextlib import suppress
 from pathlib import Path
-from typing import Any
+from typing import Any, Final
+from uuid import UUID, uuid4
 
-from rich.console import Console
+from acb import console
+from acb.depends import depends
 
 from crackerjack.core.timeout_manager import TimeoutStrategy, get_timeout_manager
 from crackerjack.services.input_validator import get_input_validator
 from crackerjack.services.secure_path_utils import SecurePathValidator
 
-console = Console()
+# Phase 9.3: ACB Integration - Module registration for dependency injection
+# Note: Currently using file-based JSON storage for job tracking
+# Future enhancement: Consider ACB SQL adapter for scalability if needed
+MODULE_ID: Final[UUID] = uuid4()
+MODULE_STATUS: Final[str] = "stable"
+
+# console imported from acb
 
 
 class JobManager:
@@ -380,4 +388,19 @@ class JobManager:
 
     def cleanup(self) -> None:
         self.is_running = False
-        console.print("[blue]Job manager cleanup completed[/ blue]")
+        console.print("[blue]Job manager cleanup completed[/blue]")
+
+    @property
+    def module_id(self) -> UUID:
+        """Reference to module-level MODULE_ID for ACB integration."""
+        return MODULE_ID
+
+    @property
+    def module_status(self) -> str:
+        """Module status for ACB integration."""
+        return MODULE_STATUS
+
+
+# Phase 9.3: ACB Integration - Register JobManager with dependency injection system
+with suppress(Exception):
+    depends.set(JobManager)

crackerjack/mcp/websocket/monitoring/__init__.py

@@ -0,0 +1,25 @@
+"""Monitoring endpoints module.
+
+This module provides WebSocket and REST API endpoints for real-time
+monitoring, metrics streaming, intelligence features, and error analysis.
+"""
+
+from .factory import create_monitoring_endpoints
+from .models import (
+    HealthResponseModel,
+    TelemetryEventModel,
+    TelemetryResponseModel,
+    TelemetrySnapshotModel,
+    UnifiedMetricsModel,
+)
+from .websocket_manager import MonitoringWebSocketManager
+
+__all__ = [
+    "create_monitoring_endpoints",
+    "MonitoringWebSocketManager",
+    "TelemetryEventModel",
+    "TelemetrySnapshotModel",
+    "TelemetryResponseModel",
+    "UnifiedMetricsModel",
+    "HealthResponseModel",
+]

crackerjack/mcp/websocket/monitoring/api/__init__.py

@@ -0,0 +1,19 @@
+"""REST API endpoint registration.
+
+This module provides registration functions for all REST API endpoints
+including telemetry, metrics, intelligence, dependencies, and heatmap analysis.
+"""
+
+from .dependencies import register_dependency_api_endpoints
+from .heatmap import register_heatmap_api_endpoints
+from .intelligence import register_intelligence_api_endpoints
+from .metrics import register_metrics_api_endpoints
+from .telemetry import register_telemetry_api_endpoints
+
+__all__ = [
+    "register_telemetry_api_endpoints",
+    "register_metrics_api_endpoints",
+    "register_intelligence_api_endpoints",
+    "register_dependency_api_endpoints",
+    "register_heatmap_api_endpoints",
+]

crackerjack/mcp/websocket/monitoring/api/dependencies.py

@@ -0,0 +1,141 @@
+"""REST API endpoints for dependency analysis.
+
+This module provides HTTP endpoints for dependency graph visualization,
+metrics, clustering, and analysis triggers.
+"""
+
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from crackerjack.services.dependency_analyzer import (
+    DependencyAnalyzer,
+    DependencyGraph,
+)
+
+from ..filters import _apply_graph_filters
+
+
+def register_dependency_api_endpoints(
+    app: FastAPI, dependency_analyzer: DependencyAnalyzer
+) -> None:
+    """Register dependency-related REST API endpoints."""
+
+    @app.get("/api/dependencies/graph")
+    async def get_dependency_graph(
+        filter_type: str = None,
+        max_nodes: int = 1000,
+        include_external: bool = False,
+    ) -> None:
+        """Get dependency graph data."""
+        return await _handle_dependency_graph_request(
+            dependency_analyzer, filter_type, max_nodes, include_external
+        )
+
+    @app.get("/api/dependencies/metrics")
+    async def get_dependency_metrics() -> None:
+        """Get dependency graph metrics."""
+        return await _handle_dependency_metrics_request(dependency_analyzer)
+
+    @app.get("/api/dependencies/clusters")
+    async def get_dependency_clusters() -> None:
+        """Get dependency graph clusters."""
+        return await _handle_dependency_clusters_request(dependency_analyzer)
+
+    @app.post("/api/dependencies/analyze")
+    async def trigger_dependency_analysis(request: dict) -> None:
+        """Trigger fresh dependency analysis."""
+        return await _handle_dependency_analysis_request(dependency_analyzer, request)
+
+
+async def _handle_dependency_graph_request(
+    dependency_analyzer: DependencyAnalyzer,
+    filter_type: str | None,
+    max_nodes: int,
+    include_external: bool,
+) -> JSONResponse:
+    """Handle dependency graph API request."""
+    try:
+        graph = dependency_analyzer.analyze_project()
+
+        # Apply filters if requested
+        if filter_type or max_nodes < len(graph.nodes):
+            filters = {
+                "type": filter_type,
+                "max_nodes": max_nodes,
+                "include_external": include_external,
+            }
+            graph = await _apply_graph_filters(graph, filters)
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": graph.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_dependency_metrics_request(
+    dependency_analyzer: DependencyAnalyzer,
+) -> JSONResponse:
+    """Handle dependency metrics API request."""
+    try:
+        graph = dependency_analyzer.analyze_project()
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": graph.metrics,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_dependency_clusters_request(
+    dependency_analyzer: DependencyAnalyzer,
+) -> JSONResponse:
+    """Handle dependency clusters API request."""
+    try:
+        graph = dependency_analyzer.analyze_project()
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": graph.clusters,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_dependency_analysis_request(
+    dependency_analyzer: DependencyAnalyzer, request: dict
+) -> JSONResponse:
+    """Handle dependency analysis trigger API request."""
+    try:
+        # Reset analyzer for fresh analysis
+        dependency_analyzer.dependency_graph = DependencyGraph()
+        graph = dependency_analyzer.analyze_project()
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "message": "Dependency analysis completed",
+                "data": {
+                    "nodes": len(graph.nodes),
+                    "edges": len(graph.edges),
+                    "clusters": len(graph.clusters),
+                    "metrics": graph.metrics,
+                },
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

crackerjack/mcp/websocket/monitoring/api/heatmap.py

@@ -0,0 +1,154 @@
+"""REST API endpoints for error heatmap analysis.
+
+This module provides HTTP endpoints for file-based, temporal, and
+function-based error heatmap visualization and pattern analysis.
+"""
+
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from crackerjack.services.cache import CrackerjackCache
+from crackerjack.services.monitoring.error_pattern_analyzer import (
+    ErrorPatternAnalyzer,
+)
+
+
+def register_heatmap_api_endpoints(
+    app: FastAPI, error_analyzer: ErrorPatternAnalyzer, cache: CrackerjackCache
+) -> None:
+    """Register heatmap-related REST API endpoints."""
+
+    @app.get("/api/heatmap/file_errors")
+    async def get_file_error_heatmap() -> None:
+        """Get error heat map by file."""
+        return await _handle_file_error_heatmap_request(error_analyzer)
+
+    @app.get("/api/heatmap/temporal_errors")
+    async def get_temporal_error_heatmap(time_buckets: int = 24) -> None:
+        """Get error heat map over time."""
+        return await _handle_temporal_error_heatmap_request(
+            error_analyzer, time_buckets
+        )
+
+    @app.get("/api/heatmap/function_errors")
+    async def get_function_error_heatmap() -> None:
+        """Get error heat map by function."""
+        return await _handle_function_error_heatmap_request(error_analyzer)
+
+    @app.get("/api/error_patterns")
+    async def get_error_patterns(
+        days: int = 30, min_occurrences: int = 2, severity: str | None = None
+    ) -> None:
+        """Get analyzed error patterns."""
+        return await _handle_error_patterns_request(
+            error_analyzer, days, min_occurrences, severity
+        )
+
+    @app.post("/api/trigger_error_analysis")
+    async def trigger_error_analysis(request: dict) -> None:
+        """Trigger fresh error pattern analysis."""
+        return await _handle_trigger_error_analysis_request(
+            error_analyzer, cache, request
+        )
+
+
+async def _handle_file_error_heatmap_request(
+    error_analyzer: ErrorPatternAnalyzer,
+) -> JSONResponse:
+    """Handle file error heatmap API request."""
+    try:
+        error_analyzer.analyze_error_patterns(days=30)
+        heatmap = error_analyzer.generate_file_error_heatmap()
+        return JSONResponse(heatmap.to_dict())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_temporal_error_heatmap_request(
+    error_analyzer: ErrorPatternAnalyzer, time_buckets: int
+) -> JSONResponse:
+    """Handle temporal error heatmap API request."""
+    try:
+        error_analyzer.analyze_error_patterns(days=30)
+        heatmap = error_analyzer.generate_temporal_heatmap(time_buckets=time_buckets)
+        return JSONResponse(heatmap.to_dict())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_function_error_heatmap_request(
+    error_analyzer: ErrorPatternAnalyzer,
+) -> JSONResponse:
+    """Handle function error heatmap API request."""
+    try:
+        error_analyzer.analyze_error_patterns(days=30)
+        heatmap = error_analyzer.generate_function_error_heatmap()
+        return JSONResponse(heatmap.to_dict())
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_error_patterns_request(
+    error_analyzer: ErrorPatternAnalyzer,
+    days: int,
+    min_occurrences: int,
+    severity: str | None,
+) -> JSONResponse:
+    """Handle error patterns API request."""
+    try:
+        patterns = error_analyzer.analyze_error_patterns(
+            days=days, min_occurrences=min_occurrences
+        )
+
+        # Filter by severity if specified
+        if severity:
+            patterns = [p for p in patterns if p.severity == severity]
+
+        return JSONResponse(
+            {
+                "patterns": [pattern.to_dict() for pattern in patterns],
+                "total_count": len(patterns),
+                "analysis_period_days": days,
+                "generated_at": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_trigger_error_analysis_request(
+    error_analyzer: ErrorPatternAnalyzer, cache: CrackerjackCache, request: dict
+) -> JSONResponse:
+    """Handle trigger error analysis API request."""
+    try:
+        days = request.get("days", 30)
+        min_occurrences = request.get("min_occurrences", 2)
+
+        # Perform fresh analysis
+        patterns = error_analyzer.analyze_error_patterns(
+            days=days, min_occurrences=min_occurrences
+        )
+
+        # Store results in cache
+        cache_key = f"error_patterns_{days}d"
+        cache.set(cache_key, [p.to_dict() for p in patterns], ttl_seconds=1800)
+
+        severity_breakdown = {
+            severity: len([p for p in patterns if p.severity == severity])
+            for severity in ("low", "medium", "high", "critical")
+        }
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "message": "Error pattern analysis completed",
+                "patterns_found": len(patterns),
+                "analysis_period_days": days,
+                "severity_breakdown": severity_breakdown,
+                "generated_at": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))