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

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

@@ -0,0 +1,199 @@
+"""REST API endpoints for quality intelligence features.
+
+This module provides HTTP endpoints for anomaly detection, predictions,
+insights, and pattern analysis.
+"""
+
+import typing as t
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from crackerjack.services.quality.quality_intelligence import (
+    QualityIntelligenceService,
+)
+
+
+def register_intelligence_api_endpoints(
+    app: FastAPI, intelligence_service: QualityIntelligenceService
+) -> None:
+    """Register intelligence-related REST API endpoints."""
+
+    @app.get("/api/intelligence/anomalies")
+    async def get_anomalies(days: int = 7, metrics: str = None) -> None:
+        """Get anomaly detection results."""
+        return await _handle_anomalies_request(intelligence_service, days, metrics)
+
+    @app.get("/api/intelligence/predictions/{metric}")
+    async def get_metric_prediction(metric: str, horizon_days: int = 7) -> None:
+        """Get prediction for a specific metric."""
+        return await _handle_metric_prediction_request(
+            intelligence_service, metric, horizon_days
+        )
+
+    @app.get("/api/intelligence/insights")
+    async def get_quality_insights(days: int = 30) -> None:
+        """Get comprehensive quality insights."""
+        return await _handle_quality_insights_request(intelligence_service, days)
+
+    @app.get("/api/intelligence/patterns")
+    async def get_pattern_analysis(days: int = 30) -> None:
+        """Get pattern recognition analysis."""
+        return await _handle_pattern_analysis_request(intelligence_service, days)
+
+    @app.post("/api/intelligence/analyze")
+    async def run_comprehensive_analysis(request: dict) -> None:
+        """Run comprehensive intelligence analysis."""
+        return await _handle_comprehensive_analysis_request(
+            intelligence_service, request
+        )
+
+
+async def _handle_anomalies_request(
+    intelligence_service: QualityIntelligenceService, days: int, metrics: str | None
+) -> JSONResponse:
+    """Handle anomalies API request."""
+    try:
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        metrics_list = metrics.split(",") if metrics else None
+        anomalies = intelligence_service.detect_anomalies(
+            days=days, metrics=metrics_list
+        )
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": [anomaly.to_dict() for anomaly in anomalies],
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_metric_prediction_request(
+    intelligence_service: QualityIntelligenceService, metric: str, horizon_days: int
+) -> JSONResponse:
+    """Handle metric prediction API request."""
+    try:
+        if horizon_days > 30:
+            raise HTTPException(status_code=400, detail="Horizon too far in the future")
+
+        all_predictions = intelligence_service.generate_advanced_predictions(
+            horizon_days
+        )
+        prediction = next((p for p in all_predictions if p.metric_name == metric), None)
+        if not prediction:
+            raise HTTPException(status_code=404, detail="Prediction not available")
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": prediction.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_quality_insights_request(
+    intelligence_service: QualityIntelligenceService, days: int
+) -> JSONResponse:
+    """Handle quality insights API request."""
+    try:
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        insights = intelligence_service.generate_comprehensive_insights(days=days)
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": insights.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_pattern_analysis_request(
+    intelligence_service: QualityIntelligenceService, days: int
+) -> JSONResponse:
+    """Handle pattern analysis API request."""
+    try:
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        patterns = intelligence_service.identify_patterns(days=days)
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": patterns,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_comprehensive_analysis_request(
+    intelligence_service: QualityIntelligenceService, request: dict
+) -> JSONResponse:
+    """Handle comprehensive analysis API request."""
+    try:
+        days = request.get("days", 30)
+
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        results = await _build_comprehensive_analysis_results(
+            intelligence_service, request, days
+        )
+
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": results,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _build_comprehensive_analysis_results(
+    intelligence_service: QualityIntelligenceService, request: dict, days: int
+) -> dict[str, t.Any]:
+    """Build comprehensive analysis results based on request parameters."""
+    results = {}
+
+    if request.get("include_anomalies", True):
+        results["anomalies"] = [
+            anomaly.to_dict()
+            for anomaly in intelligence_service.detect_anomalies(days=days)
+        ]
+
+    if request.get("include_predictions", True):
+        insights = intelligence_service.generate_comprehensive_insights(days=days)
+        results["insights"] = insights.to_dict()
+
+        # Generate specific predictions
+        predictions = {}
+        for metric in ("quality_score", "test_coverage", "hook_duration"):
+            pred = intelligence_service.generate_advanced_predictions(
+                metric, horizon_days=7
+            )
+            if pred:
+                predictions[metric] = pred.to_dict()
+        results["predictions"] = predictions
+
+    if request.get("include_patterns", True):
+        results["patterns"] = intelligence_service.identify_patterns(days=days)
+
+    return results

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

@@ -0,0 +1,203 @@
+"""REST API endpoints for metrics and quality analysis.
+
+This module provides HTTP endpoints for metrics summaries, quality trends,
+alert configuration, and data export.
+"""
+
+import asyncio
+import csv
+import typing as t
+from datetime import datetime
+from io import StringIO
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse, Response
+
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+)
+
+from ..metrics import get_monitoring_current_metrics
+
+
+def register_metrics_api_endpoints(
+    app: FastAPI, job_manager: t.Any, quality_service: EnhancedQualityBaselineService
+) -> None:
+    """Register metrics-related REST API endpoints."""
+
+    @app.get("/api/metrics/summary")
+    async def get_metrics_summary() -> None:
+        """Get current system summary."""
+        try:
+            current_metrics = await get_monitoring_current_metrics(
+                quality_service, job_manager
+            )
+            return JSONResponse(
+                {
+                    "status": "success",
+                    "data": current_metrics.to_dict(),
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.get("/api/trends/quality")
+    async def get_quality_trends(days: int = 30) -> None:
+        """Get quality trend analysis."""
+        return await _handle_quality_trends_request(quality_service, days)
+
+    @app.get("/api/alerts/configure")
+    async def get_alert_configuration() -> None:
+        """Get current alert configuration."""
+        return await _handle_get_alert_configuration(quality_service)
+
+    @app.post("/api/alerts/configure")
+    async def update_alert_configuration(config: dict) -> None:
+        """Update alert configuration."""
+        return await _handle_update_alert_configuration(quality_service, config)
+
+    @app.get("/api/export/data")
+    async def export_data(days: int = 30, format: str = "json") -> None:
+        """Export historical data for external analysis."""
+        return await _handle_export_data_request(quality_service, days, format)
+
+
+async def _handle_quality_trends_request(
+    quality_service: EnhancedQualityBaselineService, days: int
+) -> JSONResponse:
+    """Handle quality trends API request."""
+    try:
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        trends = await asyncio.to_thread(
+            quality_service.analyze_quality_trend,
+            days,
+        )
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": trends.to_dict(),
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_get_alert_configuration(
+    quality_service: EnhancedQualityBaselineService,
+) -> JSONResponse:
+    """Handle get alert configuration API request."""
+    try:
+        config = quality_service.get_alert_thresholds()
+        return JSONResponse(
+            {
+                "status": "success",
+                "data": config,
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_update_alert_configuration(
+    quality_service: EnhancedQualityBaselineService, config: dict
+) -> JSONResponse:
+    """Handle update alert configuration API request."""
+    try:
+        # Update individual thresholds
+        for metric, threshold in config.items():
+            quality_service.set_alert_threshold(metric, threshold)
+        return JSONResponse(
+            {
+                "status": "success",
+                "message": "Alert configuration updated",
+                "timestamp": datetime.now().isoformat(),
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def _handle_export_data_request(
+    quality_service: EnhancedQualityBaselineService, days: int, format_type: str
+) -> JSONResponse | t.Any:
+    """Handle export data API request."""
+    try:
+        if days > 365:
+            raise HTTPException(status_code=400, detail="Days parameter too large")
+
+        if format_type not in ("json", "csv"):
+            raise HTTPException(
+                status_code=400, detail="Format must be 'json' or 'csv'"
+            )
+
+        historical_baselines = await quality_service.aget_recent_baselines(limit=days)
+
+        if format_type == "csv":
+            return _export_csv_data(historical_baselines, days)
+        else:
+            data = [baseline.to_dict() for baseline in historical_baselines]
+            return JSONResponse(
+                {
+                    "status": "success",
+                    "data": data,
+                    "timestamp": datetime.now().isoformat(),
+                }
+            )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+def _export_csv_data(historical_baselines: list[t.Any], days: int) -> t.Any:
+    """Export data in CSV format."""
+    output = StringIO()
+    writer = csv.writer(output)
+
+    # Write header
+    writer.writerow(
+        [
+            "timestamp",
+            "git_hash",
+            "quality_score",
+            "coverage_percent",
+            "test_count",
+            "test_pass_rate",
+            "hook_failures",
+            "complexity_violations",
+            "security_issues",
+            "type_errors",
+            "linting_issues",
+        ]
+    )
+
+    # Write data
+    for baseline in historical_baselines:
+        writer.writerow(
+            [
+                baseline.timestamp.isoformat(),
+                baseline.git_hash,
+                baseline.quality_score,
+                baseline.coverage_percent,
+                baseline.test_count,
+                baseline.test_pass_rate,
+                baseline.hook_failures,
+                baseline.complexity_violations,
+                baseline.security_issues,
+                baseline.type_errors,
+                baseline.linting_issues,
+            ]
+        )
+
+    return Response(
+        content=output.getvalue(),
+        media_type="text/csv",
+        headers={
+            "Content-Disposition": (
+                f"attachment; filename=crackerjack_metrics_{days}d.csv"
+            )
+        },
+    )

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