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

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

@@ -0,0 +1,101 @@
+"""REST API endpoints for telemetry and health monitoring.
+
+This module provides HTTP endpoints for workflow event telemetry
+and system health metrics.
+"""
+
+import typing as t
+from datetime import datetime
+
+from fastapi import FastAPI
+
+from crackerjack.events import WorkflowEventTelemetry
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+    UnifiedMetrics,
+)
+
+from ..metrics import get_monitoring_current_metrics
+from ..models import (
+    HealthResponseModel,
+    TelemetryEventModel,
+    TelemetryResponseModel,
+    TelemetrySnapshotModel,
+    UnifiedMetricsModel,
+)
+
+
+def register_telemetry_api_endpoints(
+    app: FastAPI,
+    job_manager: t.Any,
+    telemetry: WorkflowEventTelemetry,
+    quality_service: EnhancedQualityBaselineService,
+) -> None:
+    """Register telemetry and dashboard REST endpoints."""
+
+    @app.get(
+        "/monitoring/events",
+        response_model=TelemetryResponseModel,
+        summary="Get workflow telemetry snapshot",
+    )
+    async def get_monitoring_events() -> TelemetryResponseModel:
+        snapshot = await telemetry.snapshot()
+        data = TelemetrySnapshotModel(
+            counts=snapshot.get("counts", {}),
+            recent_events=[
+                TelemetryEventModel.model_validate(event)
+                for event in snapshot.get("recent_events", [])
+            ],
+            last_error=None,  # Adjust based on how last_error is stored in snapshot
+        )
+        return TelemetryResponseModel(
+            status="success",
+            data=data,
+            timestamp=datetime.now(),
+        )
+
+    @app.post(
+        "/monitoring/events/reset",
+        response_model=TelemetryResponseModel,
+        summary="Reset workflow telemetry history",
+    )
+    async def reset_monitoring_events() -> TelemetryResponseModel:
+        await telemetry.reset()
+        snapshot = await telemetry.snapshot()
+        data = TelemetrySnapshotModel(
+            counts=snapshot.get("counts", {}),
+            recent_events=[
+                TelemetryEventModel.model_validate(event)
+                for event in snapshot.get("recent_events", [])
+            ],
+            last_error=None,  # Adjust based on how last_error is stored in snapshot
+        )
+        return TelemetryResponseModel(
+            status="success",
+            data=data,
+            timestamp=datetime.now(),
+        )
+
+    @app.get(
+        "/monitoring/health",
+        response_model=HealthResponseModel,
+        summary="Retrieve aggregated monitoring health metrics",
+    )
+    async def get_monitoring_health() -> HealthResponseModel:
+        unified_metrics = await get_monitoring_current_metrics(
+            quality_service, job_manager
+        )  # Use the function parameters
+        return HealthResponseModel(
+            status=_derive_health_status(unified_metrics),
+            data=UnifiedMetricsModel.from_domain(unified_metrics),
+            timestamp=datetime.now(),
+        )
+
+
+def _derive_health_status(metrics: UnifiedMetrics) -> str:
+    """Derive a coarse health status string from unified metrics."""
+    if metrics.error_count > 5 or metrics.quality_score < 40:
+        return "critical"
+    if metrics.error_count > 0 or metrics.quality_score < 60:
+        return "warning"
+    return "healthy"

crackerjack/mcp/websocket/monitoring/dashboard.py

@@ -0,0 +1,18 @@
+"""Dashboard HTML rendering for monitoring endpoints.
+
+This module provides the HTML dashboard endpoint for the monitoring system.
+"""
+
+from fastapi.responses import HTMLResponse
+
+from crackerjack.ui.dashboard_renderer import render_monitoring_dashboard
+
+
+async def get_dashboard_html() -> HTMLResponse:
+    """Serve the monitoring dashboard HTML."""
+    return HTMLResponse(_get_dashboard_html())
+
+
+def _get_dashboard_html() -> str:
+    """Generate the monitoring dashboard HTML."""
+    return render_monitoring_dashboard()

crackerjack/mcp/websocket/monitoring/factory.py

@@ -0,0 +1,109 @@
+"""Factory module for monitoring endpoint registration.
+
+This module orchestrates the initialization of all monitoring services
+and registration of WebSocket and REST API endpoints.
+"""
+
+import typing as t
+from pathlib import Path
+
+from acb.depends import depends
+from fastapi import FastAPI
+
+from crackerjack.events import WorkflowEventTelemetry
+from crackerjack.services.cache import CrackerjackCache
+from crackerjack.services.dependency_analyzer import DependencyAnalyzer
+from crackerjack.services.monitoring.error_pattern_analyzer import (
+    ErrorPatternAnalyzer,
+)
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+)
+from crackerjack.services.quality.quality_intelligence import (
+    QualityIntelligenceService,
+)
+
+from .api.dependencies import register_dependency_api_endpoints
+from .api.heatmap import register_heatmap_api_endpoints
+from .api.intelligence import register_intelligence_api_endpoints
+from .api.metrics import register_metrics_api_endpoints
+from .api.telemetry import register_telemetry_api_endpoints
+from .dashboard import get_dashboard_html
+from .websocket_manager import MonitoringWebSocketManager
+from .websockets.dependencies import register_dependency_websockets
+from .websockets.heatmap import register_heatmap_websockets
+from .websockets.intelligence import register_intelligence_websockets
+from .websockets.metrics import register_metrics_websockets
+
+
+def create_monitoring_endpoints(
+    app: FastAPI,
+    job_manager: t.Any,
+    progress_dir: Path,
+    ws_manager: MonitoringWebSocketManager,
+) -> None:
+    """Add monitoring endpoints to the FastAPI app."""
+    services = _initialize_monitoring_services(progress_dir)
+
+    _register_websocket_endpoints(app, job_manager, ws_manager, services)
+    _register_rest_api_endpoints(app, job_manager, services)
+    _register_dashboard_endpoint(app)
+
+
+def _initialize_monitoring_services(progress_dir: Path) -> dict[str, t.Any]:
+    """Initialize all monitoring services."""
+    cache = CrackerjackCache()
+    quality_service = EnhancedQualityBaselineService(cache=cache)
+    intelligence_service = QualityIntelligenceService(quality_service)
+    dependency_analyzer = DependencyAnalyzer(progress_dir.parent)
+    error_analyzer = ErrorPatternAnalyzer(progress_dir.parent)
+    try:
+        telemetry = depends.get_sync(WorkflowEventTelemetry)
+    except Exception:
+        telemetry = WorkflowEventTelemetry()
+
+    return {
+        "cache": cache,
+        "quality_service": quality_service,
+        "intelligence_service": intelligence_service,
+        "dependency_analyzer": dependency_analyzer,
+        "error_analyzer": error_analyzer,
+        "telemetry": telemetry,
+    }
+
+
+def _register_websocket_endpoints(
+    app: FastAPI,
+    job_manager: t.Any,
+    ws_manager: MonitoringWebSocketManager,
+    services: dict[str, t.Any],
+) -> None:
+    """Register all WebSocket endpoints."""
+    register_metrics_websockets(
+        app, job_manager, ws_manager, services["quality_service"]
+    )
+    register_intelligence_websockets(app, ws_manager, services["intelligence_service"])
+    register_dependency_websockets(app, ws_manager, services["dependency_analyzer"])
+    register_heatmap_websockets(app, services["error_analyzer"])
+
+
+def _register_rest_api_endpoints(
+    app: FastAPI, job_manager: t.Any, services: dict[str, t.Any]
+) -> None:
+    """Register all REST API endpoints."""
+    register_telemetry_api_endpoints(
+        app, job_manager, services["telemetry"], services["quality_service"]
+    )
+    register_metrics_api_endpoints(app, job_manager, services["quality_service"])
+    register_intelligence_api_endpoints(app, services["intelligence_service"])
+    register_dependency_api_endpoints(app, services["dependency_analyzer"])
+    register_heatmap_api_endpoints(app, services["error_analyzer"], services["cache"])
+
+
+def _register_dashboard_endpoint(app: FastAPI) -> None:
+    """Register the dashboard HTML endpoint."""
+
+    @app.get("/dashboard")
+    async def dashboard_endpoint() -> None:
+        """Serve the monitoring dashboard HTML."""
+        return await get_dashboard_html()

crackerjack/mcp/websocket/monitoring/filters.py

@@ -0,0 +1,10 @@
+"""Filter utilities for monitoring system.
+
+This module contains functions for applying various filters to monitoring data.
+"""
+
+
+def _apply_graph_filters(graph, filters):
+    """Apply graph filters for monitoring purposes."""
+    # Implementation of graph filter functionality
+    return graph

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",
+]