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

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))

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