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

crackerjack/services/{quality_baseline_enhanced.py → quality/quality_baseline_enhanced.py}

@@ -8,7 +8,10 @@ from enum import Enum
 from pathlib import Path
 
 from crackerjack.services.cache import CrackerjackCache
-from crackerjack.services.quality_baseline import QualityBaselineService, QualityMetrics
+from crackerjack.services.quality.quality_baseline import (
+    QualityBaselineService,
+    QualityMetrics,
+)
 
 
 class TrendDirection(str, Enum):

crackerjack/services/{quality_intelligence.py → quality/quality_intelligence.py}

@@ -10,7 +10,9 @@ from pathlib import Path
 import numpy as np
 from scipy import stats
 
-from crackerjack.services.quality_baseline_enhanced import (
+from crackerjack.models.protocols import QualityIntelligenceProtocol
+
+from .quality_baseline_enhanced import (
     AlertSeverity,
     EnhancedQualityBaselineService,
     TrendDirection,
@@ -152,7 +154,7 @@ class QualityInsights:
         }
 
 
-class QualityIntelligenceService:
+class QualityIntelligenceService(QualityIntelligenceProtocol):
     """Advanced ML-based quality intelligence service."""
 
     def __init__(
@@ -168,7 +170,7 @@ class QualityIntelligenceService:
     def detect_anomalies(
         self, days: int = 30, metrics: list[str] | None = None
     ) -> list[QualityAnomaly]:
-        """Detect anomalies in quality metrics using statistical analysis."""
+        """Detect anomalies in quality metrics using statistical analysis (sync version)."""
         metrics = self._get_default_metrics() if metrics is None else metrics
 
         baselines = self.quality_service.get_recent_baselines(limit=days * 2)
@@ -182,6 +184,23 @@ class QualityIntelligenceService:
 
         return anomalies
 
+    async def detect_anomalies_async(
+        self, days: int = 30, metrics: list[str] | None = None
+    ) -> list[QualityAnomaly]:
+        """Detect anomalies in quality metrics using statistical analysis (async version)."""
+        metrics = self._get_default_metrics() if metrics is None else metrics
+
+        baselines = await self.quality_service.aget_recent_baselines(limit=days * 2)
+        if len(baselines) < self.min_data_points:
+            return []
+
+        anomalies = []
+        for metric_name in metrics:
+            metric_anomalies = self._detect_metric_anomalies(metric_name, baselines)
+            anomalies.extend(metric_anomalies)
+
+        return anomalies
+
     def _get_default_metrics(self) -> list[str]:
         """Get default metrics list[t.Any] for anomaly detection."""
         return [
@@ -264,7 +283,7 @@ class QualityIntelligenceService:
         metric_name: str,
         values: list[float],
         timestamps: list[t.Any],
-        stats_data: dict[str, float],
+        stats_data: dict[str, t.Any],
     ) -> list[QualityAnomaly]:
         """Identify outlier anomalies based on z-scores."""
         anomalies = []
@@ -339,7 +358,7 @@ class QualityIntelligenceService:
         return anomaly_type, severity
 
     def identify_patterns(self, days: int = 60) -> list[QualityPattern]:
-        """Identify patterns in quality metrics using correlation and trend analysis."""
+        """Identify patterns in quality metrics using correlation and trend analysis (sync version)."""
         baselines = self.quality_service.get_recent_baselines(limit=days * 2)
         if len(baselines) < self.min_data_points:
             return []
@@ -347,6 +366,15 @@ class QualityIntelligenceService:
         metrics_data = self._extract_metrics_data(baselines)
         return self._find_correlation_patterns(metrics_data, days)
 
+    async def identify_patterns_async(self, days: int = 60) -> list[QualityPattern]:
+        """Identify patterns in quality metrics using correlation and trend analysis (async version)."""
+        baselines = await self.quality_service.aget_recent_baselines(limit=days * 2)
+        if len(baselines) < self.min_data_points:
+            return []
+
+        metrics_data = self._extract_metrics_data(baselines)
+        return self._find_correlation_patterns(metrics_data, days)
+
     def _extract_metrics_data(self, baselines: list[t.Any]) -> dict[str, list[float]]:
         """Extract metric data from baselines for correlation analysis."""
         metrics_data = {
@@ -399,7 +427,17 @@ class QualityIntelligenceService:
         if len(values1) < self.min_data_points:
             return None
 
-        correlation, p_value = stats.pearsonr(values1, values2)
+        # Handle constant input arrays that would cause correlation warnings
+        try:
+            # Check for constant arrays (all values the same)
+            if 0 in (np.var(values1), np.var(values2)):
+                # Cannot calculate correlation for constant arrays
+                return None
+
+            correlation, p_value = stats.pearsonr(values1, values2)
+        except (ValueError, RuntimeWarning):
+            # Handle any other correlation calculation issues
+            return None
 
         # Strong correlation threshold
         if abs(correlation) > 0.7 and p_value < 0.05:
@@ -624,16 +662,12 @@ class QualityIntelligenceService:
             return "medium"
         return "low"
 
-    def generate_ml_recommendations(
-        self,
-        anomalies: list[QualityAnomaly],
-        patterns: list[QualityPattern],
-        predictions: list[QualityPrediction],
+    def _generate_anomaly_recommendations(
+        self, anomalies: list[QualityAnomaly]
     ) -> list[str]:
-        """Generate intelligent recommendations based on ML analysis."""
+        """Generate recommendations based on anomalies."""
         recommendations = []
 
-        # Anomaly-based recommendations
         critical_anomalies = [
             a for a in anomalies if a.severity == AlertSeverity.CRITICAL
         ]
@@ -652,7 +686,14 @@ class QualityIntelligenceService:
                 "📉 Quality score drops detected - review recent commits and implement quality gates"
             )
 
-        # Pattern-based recommendations
+        return recommendations
+
+    def _generate_pattern_recommendations(
+        self, patterns: list[QualityPattern]
+    ) -> list[str]:
+        """Generate recommendations based on patterns."""
+        recommendations = []
+
         declining_correlations = [
             p for p in patterns if p.trend_direction == TrendDirection.DECLINING
         ]
@@ -667,7 +708,14 @@ class QualityIntelligenceService:
                 "📊 Strong quality patterns detected - leverage insights for predictive quality management"
             )
 
-        # Prediction-based recommendations
+        return recommendations
+
+    def _generate_prediction_recommendations(
+        self, predictions: list[QualityPrediction]
+    ) -> list[str]:
+        """Generate recommendations based on predictions."""
+        recommendations = []
+
         high_risk_predictions = [
             p for p in predictions if p.risk_assessment in ("high", "critical")
         ]
@@ -685,12 +733,35 @@ class QualityIntelligenceService:
                 "📈 Wide prediction intervals detected - increase data collection frequency for better forecasting"
             )
 
-        # General ML insights
+        return recommendations
+
+    def _generate_general_ml_insights(
+        self, anomalies: list[QualityAnomaly]
+    ) -> list[str]:
+        """Generate general ML insights."""
+        recommendations = []
+
         if len(anomalies) > 5:
             recommendations.append(
                 f"🤖 High anomaly frequency ({len(anomalies)}) suggests systemic quality issues - consider ML-based automated quality monitoring"
             )
 
+        return recommendations
+
+    def generate_ml_recommendations(
+        self,
+        anomalies: list[QualityAnomaly],
+        patterns: list[QualityPattern],
+        predictions: list[QualityPrediction],
+    ) -> list[str]:
+        """Generate intelligent recommendations based on ML analysis."""
+        recommendations = []
+
+        recommendations.extend(self._generate_anomaly_recommendations(anomalies))
+        recommendations.extend(self._generate_pattern_recommendations(patterns))
+        recommendations.extend(self._generate_prediction_recommendations(predictions))
+        recommendations.extend(self._generate_general_ml_insights(anomalies))
+
         if not recommendations:
             recommendations.append(
                 "✅ Quality metrics show stable patterns with no significant anomalies detected - maintain current practices"
@@ -783,3 +854,96 @@ class QualityIntelligenceService:
         """Export quality insights to JSON file."""
         with output_path.open("w") as f:
             json.dump(insights.to_dict(), f, indent=2, default=str)
+
+    # Protocol methods required by QualityIntelligenceProtocol
+    def analyze_quality_trends(self) -> dict[str, t.Any]:
+        """Analyze quality trends."""
+        # Use existing identify_patterns method to analyze trends
+        patterns = self.identify_patterns()
+        trend_analysis = {
+            "total_patterns": len(patterns),
+            "patterns_by_type": {
+                "cyclic": len(
+                    [p for p in patterns if p.pattern_type == PatternType.CYCLIC]
+                ),
+                "seasonal": len(
+                    [p for p in patterns if p.pattern_type == PatternType.SEASONAL]
+                ),
+                "correlation": len(
+                    [p for p in patterns if p.pattern_type == PatternType.CORRELATION]
+                ),
+                "regression": len(
+                    [p for p in patterns if p.pattern_type == PatternType.REGRESSION]
+                ),
+                "improvement": len(
+                    [p for p in patterns if p.pattern_type == PatternType.IMPROVEMENT]
+                ),
+            },
+            "trend_directions": {
+                "improving": len(
+                    [
+                        p
+                        for p in patterns
+                        if p.trend_direction == TrendDirection.IMPROVING
+                    ]
+                ),
+                "declining": len(
+                    [
+                        p
+                        for p in patterns
+                        if p.trend_direction == TrendDirection.DECLINING
+                    ]
+                ),
+                "stable": len(
+                    [p for p in patterns if p.trend_direction == TrendDirection.STABLE]
+                ),
+                "volatile": len(
+                    [
+                        p
+                        for p in patterns
+                        if p.trend_direction == TrendDirection.VOLATILE
+                    ]
+                ),
+            },
+            "generated_at": datetime.now().isoformat(),
+        }
+        return trend_analysis
+
+    def predict_quality_issues(self) -> list[dict[str, t.Any]]:
+        """Predict potential quality issues."""
+        predictions = self.generate_advanced_predictions()
+
+        return [
+            {
+                "metric": pred.metric_name,
+                "predicted_value": pred.predicted_value,
+                "risk_level": pred.risk_assessment,
+                "confidence_interval": {
+                    "lower": pred.confidence_lower,
+                    "upper": pred.confidence_upper,
+                },
+                "prediction_horizon": pred.prediction_horizon_days,
+                "factors": pred.factors,
+            }
+            for pred in predictions
+            if pred.risk_assessment in ("high", "critical")
+        ]
+
+    def recommend_improvements(self) -> list[dict[str, t.Any]]:
+        """Recommend quality improvements."""
+        # Generate basic analysis to get data for recommendations
+        anomalies = self.detect_anomalies()
+        patterns = self.identify_patterns()
+        predictions = self.generate_advanced_predictions()
+
+        recommendations = self.generate_ml_recommendations(
+            anomalies, patterns, predictions
+        )
+
+        # Convert to required format
+        return [{"message": rec} for rec in recommendations]
+
+    def get_intelligence_report(self) -> dict[str, t.Any]:
+        """Get quality intelligence report."""
+        insights = self.generate_comprehensive_insights()
+        return insights.to_dict()