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

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

@@ -0,0 +1,126 @@
+"""WebSocket endpoints for dependency analysis.
+
+This module handles real-time dependency graph visualization
+and analysis WebSocket connections.
+"""
+
+import asyncio
+import json
+import typing as t
+from datetime import datetime
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from crackerjack.services.dependency_analyzer import (
+    DependencyAnalyzer,
+    DependencyGraph,
+)
+
+from ..filters import _apply_graph_filters
+from ..websocket_manager import MonitoringWebSocketManager
+
+
+def register_dependency_websockets(
+    app: FastAPI,
+    ws_manager: MonitoringWebSocketManager,
+    dependency_analyzer: DependencyAnalyzer,
+) -> None:
+    """Register dependency-related WebSocket endpoints."""
+
+    @app.websocket("/ws/dependencies/graph")
+    async def websocket_dependency_graph(websocket: WebSocket) -> None:
+        """WebSocket endpoint for dependency graph data."""
+        await _handle_dependency_graph_websocket(
+            websocket, ws_manager, dependency_analyzer
+        )
+
+
+async def _handle_dependency_graph_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    dependency_analyzer: DependencyAnalyzer,
+) -> None:
+    """Handle dependency graph WebSocket connection."""
+    client_id = f"dependencies_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        # Send initial message
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "analysis_started",
+                    "message": "Starting dependency analysis...",
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Generate dependency graph
+        graph = dependency_analyzer.analyze_project()
+
+        # Send the complete graph data
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "graph_data",
+                    "data": graph.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Listen for client requests
+        while True:
+            try:
+                message = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+                data = json.loads(message)
+
+                await _handle_dependency_request(
+                    websocket, dependency_analyzer, graph, data
+                )
+
+            except TimeoutError:
+                await websocket.send_text(
+                    json.dumps(
+                        {
+                            "type": "keepalive",
+                            "timestamp": datetime.now().isoformat(),
+                        }
+                    )
+                )
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_dependency_request(
+    websocket: WebSocket,
+    dependency_analyzer: DependencyAnalyzer,
+    graph: DependencyGraph,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle dependency graph request."""
+    if data.get("type") == "filter_request":
+        filtered_graph = await _apply_graph_filters(graph, data.get("filters", {}))
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "filtered_graph",
+                    "data": filtered_graph.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+    elif data.get("type") == "refresh_request":
+        fresh_graph = dependency_analyzer.analyze_project()
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "graph_data",
+                    "data": fresh_graph.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )

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

@@ -0,0 +1,176 @@
+"""WebSocket endpoints for error heatmap visualization.
+
+This module handles real-time error heatmap streaming for
+file-based, temporal, and function-based error analysis.
+"""
+
+import asyncio
+import json
+import typing as t
+from datetime import datetime
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from crackerjack.services.monitoring.error_pattern_analyzer import (
+    ErrorPatternAnalyzer,
+)
+
+
+def register_heatmap_websockets(
+    app: FastAPI, error_analyzer: ErrorPatternAnalyzer
+) -> None:
+    """Register heatmap-related WebSocket endpoints."""
+
+    @app.websocket("/ws/heatmap/errors")
+    async def websocket_error_heatmap(websocket: WebSocket) -> None:
+        """WebSocket endpoint for real-time error heat map streaming."""
+        await _handle_error_heatmap_websocket(websocket, error_analyzer)
+
+
+async def _handle_error_heatmap_websocket(
+    websocket: WebSocket, error_analyzer: ErrorPatternAnalyzer
+) -> None:
+    """Handle error heatmap WebSocket connection."""
+    await websocket.accept()
+
+    try:
+        # Analyze error patterns and send initial data
+        error_patterns = error_analyzer.analyze_error_patterns(days=30)
+        await _send_initial_heatmap_data(websocket, error_analyzer, error_patterns)
+
+        # Handle client messages
+        while True:
+            try:
+                message = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+                data = json.loads(message)
+
+                await _handle_heatmap_request(websocket, error_analyzer, data)
+
+            except TimeoutError:
+                await websocket.send_text(
+                    json.dumps(
+                        {
+                            "type": "heartbeat",
+                            "timestamp": datetime.now().isoformat(),
+                        }
+                    )
+                )
+
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "error",
+                    "message": str(e),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+
+async def _send_initial_heatmap_data(
+    websocket: WebSocket,
+    error_analyzer: ErrorPatternAnalyzer,
+    error_patterns: list[t.Any],
+) -> None:
+    """Send initial heatmap data to client."""
+    # Send file-based heat map
+    file_heatmap = error_analyzer.generate_file_error_heatmap()
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "file_heatmap",
+                "data": file_heatmap.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+    # Send temporal heat map
+    temporal_heatmap = error_analyzer.generate_temporal_heatmap()
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "temporal_heatmap",
+                "data": temporal_heatmap.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+    # Send function-based heat map
+    function_heatmap = error_analyzer.generate_function_error_heatmap()
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "function_heatmap",
+                "data": function_heatmap.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+    # Send error patterns summary
+    patterns_data = [pattern.to_dict() for pattern in error_patterns]
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "error_patterns",
+                "data": patterns_data,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _handle_heatmap_request(
+    websocket: WebSocket,
+    error_analyzer: ErrorPatternAnalyzer,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle heatmap request from client."""
+    if data.get("type") == "refresh_heatmap":
+        await _handle_heatmap_refresh(websocket, error_analyzer, data)
+    elif data.get("type") == "keepalive":
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "pong",
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+
+async def _handle_heatmap_refresh(
+    websocket: WebSocket,
+    error_analyzer: ErrorPatternAnalyzer,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle heatmap refresh request."""
+    error_analyzer.analyze_error_patterns(days=data.get("days", 30))
+
+    heatmap_type = data.get("heatmap_type", "file")
+
+    if heatmap_type == "file":
+        heatmap = error_analyzer.generate_file_error_heatmap()
+    elif heatmap_type == "temporal":
+        heatmap = error_analyzer.generate_temporal_heatmap(
+            time_buckets=data.get("time_buckets", 24)
+        )
+    elif heatmap_type == "function":
+        heatmap = error_analyzer.generate_function_error_heatmap()
+    else:
+        return
+
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": f"{heatmap_type}_heatmap_refresh",
+                "data": heatmap.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )

crackerjack/mcp/websocket/monitoring/websockets/intelligence.py

@@ -0,0 +1,291 @@
+"""WebSocket endpoints for intelligence features.
+
+This module handles real-time anomaly detection, predictions,
+and pattern analysis WebSocket connections.
+"""
+
+import asyncio
+import json
+import typing as t
+from datetime import datetime
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+from crackerjack.services.quality.quality_intelligence import (
+    QualityIntelligenceService,
+)
+
+from ..websocket_manager import MonitoringWebSocketManager
+
+
+def register_intelligence_websockets(
+    app: FastAPI,
+    ws_manager: MonitoringWebSocketManager,
+    intelligence_service: QualityIntelligenceService,
+) -> None:
+    """Register intelligence-related WebSocket endpoints."""
+
+    @app.websocket("/ws/intelligence/anomalies")
+    async def websocket_anomaly_detection(websocket: WebSocket) -> None:
+        """WebSocket endpoint for real-time anomaly detection."""
+        await _handle_anomaly_detection_websocket(
+            websocket, ws_manager, intelligence_service
+        )
+
+    @app.websocket("/ws/intelligence/predictions")
+    async def websocket_predictions(websocket: WebSocket) -> None:
+        """WebSocket endpoint for quality predictions."""
+        await _handle_predictions_websocket(websocket, ws_manager, intelligence_service)
+
+    @app.websocket("/ws/intelligence/patterns")
+    async def websocket_pattern_analysis(websocket: WebSocket) -> None:
+        """WebSocket endpoint for pattern recognition and correlation analysis."""
+        await _handle_pattern_analysis_websocket(
+            websocket, ws_manager, intelligence_service
+        )
+
+
+async def _handle_anomaly_detection_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    intelligence_service: QualityIntelligenceService,
+) -> None:
+    """Handle anomaly detection WebSocket connection."""
+    client_id = f"anomalies_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        # Send initial anomaly analysis
+        anomalies = intelligence_service.detect_anomalies(days=7)
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "anomalies_initial",
+                    "data": [anomaly.to_dict() for anomaly in anomalies],
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Stream ongoing anomaly detection
+        while True:
+            try:
+                message = await asyncio.wait_for(websocket.receive_text(), timeout=60.0)
+                data = json.loads(message)
+
+                if data.get("type") == "request_analysis":
+                    await _handle_anomaly_request(websocket, intelligence_service, data)
+
+            except TimeoutError:
+                await _send_periodic_anomaly_check(websocket, intelligence_service)
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_anomaly_request(
+    websocket: WebSocket,
+    intelligence_service: QualityIntelligenceService,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle anomaly analysis request."""
+    days = data.get("days", 7)
+    metrics_filter = data.get("metrics")
+
+    anomalies = intelligence_service.detect_anomalies(days=days, metrics=metrics_filter)
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "anomalies_update",
+                "data": [anomaly.to_dict() for anomaly in anomalies],
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _send_periodic_anomaly_check(
+    websocket: WebSocket, intelligence_service: QualityIntelligenceService
+) -> None:
+    """Send periodic anomaly check."""
+    anomalies = intelligence_service.detect_anomalies(days=1)
+    if anomalies:
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "anomalies_alert",
+                    "data": [anomaly.to_dict() for anomaly in anomalies],
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+
+async def _handle_predictions_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    intelligence_service: QualityIntelligenceService,
+) -> None:
+    """Handle predictions WebSocket connection."""
+    client_id = f"predictions_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        # Send initial predictions
+        insights = intelligence_service.generate_comprehensive_insights(days=30)
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "predictions_initial",
+                    "data": insights.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Stream prediction updates
+        while True:
+            try:
+                message = await asyncio.wait_for(
+                    websocket.receive_text(), timeout=300.0
+                )
+                data = json.loads(message)
+
+                if data.get("type") == "request_predictions":
+                    await _handle_prediction_request(
+                        websocket, intelligence_service, data
+                    )
+
+            except TimeoutError:
+                await _send_periodic_prediction_update(websocket, intelligence_service)
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_prediction_request(
+    websocket: WebSocket,
+    intelligence_service: QualityIntelligenceService,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle prediction request."""
+    days = data.get("days", 30)
+    horizon = data.get("horizon", 7)
+
+    insights = intelligence_service.generate_comprehensive_insights(days=days)
+
+    # Generate specific predictions for requested horizon
+    predictions = {}
+    all_predictions = intelligence_service.generate_advanced_predictions(
+        horizon_days=horizon
+    )
+    for metric in ("quality_score", "test_coverage", "hook_duration"):
+        # Find the prediction for this specific metric
+        pred = next((p for p in all_predictions if p.metric_name == metric), None)
+        if pred:
+            predictions[metric] = pred.to_dict()
+
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "predictions_update",
+                "data": {
+                    "insights": insights.to_dict(),
+                    "predictions": predictions,
+                },
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _send_periodic_prediction_update(
+    websocket: WebSocket, intelligence_service: QualityIntelligenceService
+) -> None:
+    """Send periodic predictions update."""
+    insights = intelligence_service.generate_comprehensive_insights(days=7)
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "predictions_periodic",
+                "data": insights.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _handle_pattern_analysis_websocket(
+    websocket: WebSocket,
+    ws_manager: MonitoringWebSocketManager,
+    intelligence_service: QualityIntelligenceService,
+) -> None:
+    """Handle pattern analysis WebSocket connection."""
+    client_id = f"patterns_{datetime.now().timestamp()}"
+    await ws_manager.connect_metrics(websocket, client_id)
+
+    try:
+        # Send initial pattern analysis
+        patterns = intelligence_service.identify_patterns(days=30)
+        await websocket.send_text(
+            json.dumps(
+                {
+                    "type": "patterns_initial",
+                    "data": patterns,
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        )
+
+        # Stream pattern updates
+        while True:
+            try:
+                message = await asyncio.wait_for(
+                    websocket.receive_text(), timeout=180.0
+                )
+                data = json.loads(message)
+
+                if data.get("type") == "request_patterns":
+                    await _handle_pattern_request(websocket, intelligence_service, data)
+
+            except TimeoutError:
+                await _send_periodic_pattern_update(websocket, intelligence_service)
+
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, client_id)
+
+
+async def _handle_pattern_request(
+    websocket: WebSocket,
+    intelligence_service: QualityIntelligenceService,
+    data: dict[str, t.Any],
+) -> None:
+    """Handle pattern analysis request."""
+    days = data.get("days", 30)
+    patterns = intelligence_service.identify_patterns(days=days)
+
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "patterns_update",
+                "data": patterns,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )
+
+
+async def _send_periodic_pattern_update(
+    websocket: WebSocket, intelligence_service: QualityIntelligenceService
+) -> None:
+    """Send periodic pattern analysis update."""
+    patterns = intelligence_service.identify_patterns(days=7)
+    await websocket.send_text(
+        json.dumps(
+            {
+                "type": "patterns_periodic",
+                "data": patterns,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    )