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

crackerjack/mcp/websocket/monitoring/metrics.py

@@ -0,0 +1,64 @@
+"""Metrics utilities for the monitoring system.
+
+This module contains functions for collecting, processing, and returning
+current system metrics used by the monitoring endpoints.
+"""
+
+from datetime import datetime
+from typing import Any
+
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+    UnifiedMetrics,
+)
+
+
+async def get_monitoring_current_metrics(
+    quality_service: EnhancedQualityBaselineService, job_manager: Any
+) -> UnifiedMetrics:
+    """Get current system metrics for monitoring API endpoints.
+
+    Args:
+        quality_service: EnhancedQualityBaselineService with the quality data
+        job_manager: Job manager instance to access current job states
+
+    Returns:
+        UnifiedMetrics containing current system metrics
+    """
+    # Get current quality metrics from the service
+    current_baseline = await quality_service.aget_current_baseline()
+
+    # Calculate additional metrics
+    active_jobs = 0
+    error_count = 0
+
+    # Access job manager to get current status if possible
+    try:
+        if hasattr(job_manager, "get_active_jobs"):
+            active_jobs = len(job_manager.get_active_jobs() or [])
+        elif hasattr(job_manager, "active_jobs"):
+            active_jobs = len(job_manager.active_jobs or [])
+
+        if hasattr(job_manager, "get_error_count"):
+            error_count = job_manager.get_error_count()
+        elif hasattr(job_manager, "error_count"):
+            error_count = getattr(job_manager, "error_count", 0)
+    except Exception:
+        # If we can't access job info, use defaults
+        pass
+
+    # Create UnifiedMetrics instance with current data
+    metrics = UnifiedMetrics(
+        timestamp=datetime.now(),
+        quality_score=current_baseline.quality_score if current_baseline else 100,
+        test_coverage=current_baseline.coverage_percent if current_baseline else 0.0,
+        hook_duration=current_baseline.hook_duration if current_baseline else 0.0,
+        active_jobs=active_jobs,
+        error_count=error_count,
+        trend_direction=current_baseline.trend_direction
+        if current_baseline
+        else "stable",
+        predictions=current_baseline.predictions if current_baseline else {},
+    )
+
+    return metrics

crackerjack/mcp/websocket/monitoring/models.py

@@ -0,0 +1,90 @@
+"""Pydantic models for monitoring endpoints.
+
+This module contains all data models used for request/response validation
+and serialization in the monitoring system.
+"""
+
+import typing as t
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    TrendDirection,
+    UnifiedMetrics,
+)
+
+
+class TelemetryEventModel(BaseModel):
+    event_type: str
+    timestamp: datetime
+    source: str | None = None
+    payload: t.Any = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, t.Any]) -> "TelemetryEventModel":
+        return cls(
+            event_type=data.get("event_type", ""),
+            timestamp=datetime.fromisoformat(data.get("timestamp")),
+            source=data.get("source"),
+            payload=data.get("payload"),
+        )
+
+
+class TelemetrySnapshotModel(BaseModel):
+    counts: dict[str, int]
+    recent_events: list[TelemetryEventModel]
+    last_error: TelemetryEventModel | None = None
+
+    @classmethod
+    def from_snapshot(cls, snapshot: dict[str, t.Any]) -> "TelemetrySnapshotModel":
+        events = [
+            TelemetryEventModel.from_dict(event)
+            for event in snapshot.get("recent_events", [])
+        ]
+        last_error = snapshot.get("last_error")
+        return cls(
+            counts=snapshot.get("counts", {}),
+            recent_events=events,
+            last_error=(
+                TelemetryEventModel.from_dict(last_error)
+                if last_error is not None
+                else None
+            ),
+        )
+
+
+class TelemetryResponseModel(BaseModel):
+    status: str
+    data: TelemetrySnapshotModel
+    timestamp: datetime
+
+
+class UnifiedMetricsModel(BaseModel):
+    timestamp: datetime
+    quality_score: int
+    test_coverage: float
+    hook_duration: float
+    active_jobs: int
+    error_count: int
+    trend_direction: TrendDirection
+    predictions: dict[str, t.Any] = {}
+
+    @classmethod
+    def from_domain(cls, metrics: UnifiedMetrics) -> "UnifiedMetricsModel":
+        return cls(
+            timestamp=metrics.timestamp,
+            quality_score=metrics.quality_score,
+            test_coverage=metrics.test_coverage,
+            hook_duration=metrics.hook_duration,
+            active_jobs=metrics.active_jobs,
+            error_count=metrics.error_count,
+            trend_direction=metrics.trend_direction,
+            predictions=metrics.predictions,
+        )
+
+
+class HealthResponseModel(BaseModel):
+    status: str
+    data: UnifiedMetricsModel
+    timestamp: datetime

crackerjack/mcp/websocket/monitoring/utils.py

@@ -0,0 +1,171 @@
+"""Utility functions for monitoring endpoints.
+
+This module contains helper functions for metrics aggregation, health checks,
+and data filtering.
+"""
+
+import asyncio
+import typing as t
+from datetime import datetime
+
+from crackerjack.services.dependency_analyzer import DependencyGraph
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+    SystemHealthStatus,
+    TrendDirection,
+    UnifiedMetrics,
+)
+
+
+async def get_current_metrics(
+    quality_service: EnhancedQualityBaselineService, job_manager: t.Any
+) -> UnifiedMetrics:
+    """Get current unified metrics."""
+    try:
+        # Get baseline from quality service
+        baseline = await quality_service.aget_baseline()
+        if not baseline:
+            # Return default metrics if no baseline exists
+            return UnifiedMetrics(
+                timestamp=datetime.now(),
+                quality_score=0,
+                test_coverage=0.0,
+                hook_duration=0.0,
+                active_jobs=len(job_manager.active_connections),
+                error_count=0,
+                trend_direction=TrendDirection.STABLE,
+                predictions={},
+            )
+
+        # Create metrics dict from baseline
+        current_metrics = {
+            "coverage_percent": baseline.coverage_percent,
+            "test_count": baseline.test_count,
+            "test_pass_rate": baseline.test_pass_rate,
+            "hook_failures": baseline.hook_failures,
+            "complexity_violations": baseline.complexity_violations,
+            "security_issues": baseline.security_issues,
+            "type_errors": baseline.type_errors,
+            "linting_issues": baseline.linting_issues,
+            "hook_duration": 0.0,  # Would need to be tracked separately
+        }
+
+        unified = await asyncio.to_thread(
+            quality_service.create_unified_metrics,
+            current_metrics,
+            len(job_manager.active_connections)
+            if hasattr(job_manager, "active_connections")
+            else 0,
+        )
+        return unified
+    except Exception:
+        # Fallback to basic metrics if service fails
+        return UnifiedMetrics(
+            timestamp=datetime.now(),
+            quality_score=0,
+            test_coverage=0.0,
+            hook_duration=0.0,
+            active_jobs=len(job_manager.active_connections)
+            if hasattr(job_manager, "active_connections")
+            else 0,
+            error_count=0,
+            trend_direction=TrendDirection.STABLE,
+            predictions={},
+        )
+
+
+async def get_system_health_status(
+    quality_service: EnhancedQualityBaselineService,
+) -> SystemHealthStatus:
+    """Get system health status."""
+    return await asyncio.to_thread(quality_service.get_system_health)
+
+
+def _filter_nodes_by_criteria(
+    nodes: list[t.Any], filter_type: str | None, include_external: bool
+) -> list[t.Any]:
+    """Filter nodes by type and external criteria."""
+    filtered = nodes
+
+    # Filter by type if specified
+    if filter_type:
+        filtered = [node for node in filtered if node.type == filter_type]
+
+    # Filter external dependencies if not included
+    if not include_external:
+        filtered = [
+            node
+            for node in filtered
+            if not node.file_path or "site-packages" not in node.file_path
+        ]
+
+    return filtered
+
+
+def _prioritize_and_limit_nodes(
+    nodes: list[t.Any], graph: DependencyGraph, max_nodes: int
+) -> list[t.Any]:
+    """Prioritize nodes and limit to max count."""
+    if len(nodes) <= max_nodes:
+        return nodes
+
+    def node_priority(node: t.Any) -> int:
+        edge_count = sum(
+            1 for edge in graph.edges if node.id in (edge.source, edge.target)
+        )
+        return int(node.complexity * edge_count)
+
+    nodes.sort(key=node_priority, reverse=True)
+    return nodes[:max_nodes]
+
+
+def _build_filtered_clusters(
+    graph: DependencyGraph, node_ids: set[str]
+) -> dict[str, list[str]]:
+    """Build filtered clusters containing only included nodes."""
+    filtered_clusters = {}
+    for cluster_name, cluster_nodes in graph.clusters.items():
+        filtered_cluster_nodes = [
+            node_id for node_id in cluster_nodes if node_id in node_ids
+        ]
+        if filtered_cluster_nodes:
+            filtered_clusters[cluster_name] = filtered_cluster_nodes
+    return filtered_clusters
+
+
+async def _apply_graph_filters(
+    graph: DependencyGraph, filters: dict[str, t.Any]
+) -> DependencyGraph:
+    """Apply filters to dependency graph."""
+    filtered_graph = DependencyGraph(
+        generated_at=graph.generated_at,
+        metrics=graph.metrics.copy(),
+        clusters=graph.clusters.copy(),
+    )
+
+    # Extract filter parameters
+    filter_type = filters.get("type")
+    max_nodes = filters.get("max_nodes", 1000)
+    include_external = filters.get("include_external", False)
+
+    # Apply filters to nodes
+    candidate_nodes = list(graph.nodes.values())
+    candidate_nodes = _filter_nodes_by_criteria(
+        candidate_nodes, filter_type, include_external
+    )
+    candidate_nodes = _prioritize_and_limit_nodes(candidate_nodes, graph, max_nodes)
+
+    # Build filtered graph
+    node_ids = {node.id for node in candidate_nodes}
+    for node in candidate_nodes:
+        filtered_graph.nodes[node.id] = node
+
+    # Add edges between filtered nodes
+    for edge in graph.edges:
+        if edge.source in node_ids and edge.target in node_ids:
+            filtered_graph.edges.append(edge)
+
+    # Update clusters
+    filtered_graph.clusters = _build_filtered_clusters(graph, node_ids)
+
+    return filtered_graph

crackerjack/mcp/websocket/monitoring/websocket_manager.py

@@ -0,0 +1,78 @@
+"""WebSocket connection manager for real-time monitoring.
+
+This module manages WebSocket connections for metrics streaming and alert notifications.
+"""
+
+import json
+from datetime import datetime
+
+from fastapi import WebSocket
+
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    QualityAlert,
+    UnifiedMetrics,
+)
+
+
+class MonitoringWebSocketManager:
+    """Manages WebSocket connections for real-time monitoring."""
+
+    def __init__(self) -> None:
+        self.active_connections: dict[str, WebSocket] = {}
+        self.metrics_subscribers: set[WebSocket] = set()
+        self.alerts_subscribers: set[WebSocket] = set()
+
+    async def connect_metrics(self, websocket: WebSocket, client_id: str) -> None:
+        """Connect a client for metrics streaming."""
+        await websocket.accept()
+        self.active_connections[client_id] = websocket
+        self.metrics_subscribers.add(websocket)
+
+    async def connect_alerts(self, websocket: WebSocket, client_id: str) -> None:
+        """Connect a client for alert notifications."""
+        await websocket.accept()
+        self.active_connections[client_id] = websocket
+        self.alerts_subscribers.add(websocket)
+
+    def disconnect(self, websocket: WebSocket, client_id: str) -> None:
+        """Disconnect a client."""
+        if client_id in self.active_connections:
+            del self.active_connections[client_id]
+        self.metrics_subscribers.discard(websocket)
+        self.alerts_subscribers.discard(websocket)
+
+    async def broadcast_metrics(self, metrics: UnifiedMetrics) -> None:
+        """Broadcast metrics to all connected metrics subscribers."""
+        message = {
+            "type": "metrics_update",
+            "data": metrics.to_dict(),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        disconnected = []
+        for websocket in self.metrics_subscribers:
+            try:
+                await websocket.send_text(json.dumps(message))
+            except Exception:
+                disconnected.append(websocket)
+
+        # Clean up disconnected clients
+        self.metrics_subscribers.difference_update(disconnected)
+
+    async def broadcast_alert(self, alert: QualityAlert) -> None:
+        """Broadcast alert to all connected alert subscribers."""
+        message = {
+            "type": "alert",
+            "data": alert.to_dict(),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        disconnected = []
+        for websocket in self.alerts_subscribers:
+            try:
+                await websocket.send_text(json.dumps(message))
+            except Exception:
+                disconnected.append(websocket)
+
+        # Clean up disconnected clients
+        self.alerts_subscribers.difference_update(disconnected)

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

@@ -0,0 +1,17 @@
+"""WebSocket endpoint registration.
+
+This module provides registration functions for all WebSocket endpoints
+including metrics, intelligence, dependencies, and heatmap streaming.
+"""
+
+from .dependencies import register_dependency_websockets
+from .heatmap import register_heatmap_websockets
+from .intelligence import register_intelligence_websockets
+from .metrics import register_metrics_websockets
+
+__all__ = [
+    "register_metrics_websockets",
+    "register_intelligence_websockets",
+    "register_dependency_websockets",
+    "register_heatmap_websockets",
+]

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(),
+                }
+            )
+        )