mcp-wordpress 1.2.2 → 1.3.0

package/src/performance/PerformanceAnalytics.ts

@@ -3,20 +3,20 @@
  * Provides insights, predictions, and optimization recommendations
  */
 
-import { PerformanceMetrics } from './PerformanceMonitor.js';
-import { MetricsCollector } from './MetricsCollector.js';
+import { PerformanceMetrics } from "./PerformanceMonitor.js";
+import { MetricsCollector } from "./MetricsCollector.js";
 
 export interface AnalyticsConfig {
   enablePredictiveAnalysis: boolean;
   enableAnomalyDetection: boolean;
   enableTrendAnalysis: boolean;
   lookbackPeriod: number; // in milliseconds
-  sensitivityLevel: 'low' | 'medium' | 'high';
+  sensitivityLevel: "low" | "medium" | "high";
 }
 
 export interface PerformanceTrend {
   metric: string;
-  direction: 'improving' | 'declining' | 'stable';
+  direction: "improving" | "declining" | "stable";
   changeRate: number; // percentage change
   confidence: number; // 0-1
   prediction: {
@@ -32,20 +32,20 @@ export interface PerformanceAnomaly {
   expectedValue: number;
   actualValue: number;
   deviation: number; // percentage
-  severity: 'minor' | 'moderate' | 'major' | 'critical';
+  severity: "minor" | "moderate" | "major" | "critical";
   possibleCauses: string[];
 }
 
 export interface PerformanceInsight {
   id: string;
-  category: 'optimization' | 'scaling' | 'maintenance' | 'alert';
-  priority: 'low' | 'medium' | 'high' | 'critical';
+  category: "optimization" | "scaling" | "maintenance" | "alert";
+  priority: "low" | "medium" | "high" | "critical";
   title: string;
   description: string;
-  impact: 'performance' | 'reliability' | 'cost' | 'user_experience';
+  impact: "performance" | "reliability" | "cost" | "user_experience";
   recommendation: string;
   estimatedImprovement: string;
-  implementationEffort: 'low' | 'medium' | 'high';
+  implementationEffort: "low" | "medium" | "high";
   relatedMetrics: string[];
 }
 
@@ -54,7 +54,7 @@ export interface BenchmarkComparison {
   currentValue: number;
   benchmarkValue: number;
   percentile: number; // Where current performance ranks (0-100)
-  status: 'excellent' | 'good' | 'average' | 'below_average' | 'poor';
+  status: "excellent" | "good" | "average" | "below_average" | "poor";
   improvement: number; // How much improvement needed to reach next tier
 }
 
@@ -71,44 +71,47 @@ export class PerformanceAnalytics {
   // Performance benchmarks (based on industry standards)
   private benchmarks = {
     responseTime: {
-      excellent: 200,   // <200ms
-      good: 500,        // 200-500ms
-      average: 1000,    // 500ms-1s
+      excellent: 200, // <200ms
+      good: 500, // 200-500ms
+      average: 1000, // 500ms-1s
       below_average: 2000, // 1-2s
-      poor: Infinity    // >2s
+      poor: Infinity, // >2s
     },
     cacheHitRate: {
-      excellent: 0.95,  // >95%
-      good: 0.85,       // 85-95%
-      average: 0.70,    // 70-85%
-      below_average: 0.50, // 50-70%
-      poor: 0          // <50%
+      excellent: 0.95, // >95%
+      good: 0.85, // 85-95%
+      average: 0.7, // 70-85%
+      below_average: 0.5, // 50-70%
+      poor: 0, // <50%
     },
     errorRate: {
       excellent: 0.001, // <0.1%
-      good: 0.01,       // 0.1-1%
-      average: 0.02,    // 1-2%
+      good: 0.01, // 0.1-1%
+      average: 0.02, // 1-2%
       below_average: 0.05, // 2-5%
-      poor: Infinity    // >5%
+      poor: Infinity, // >5%
     },
     memoryUsage: {
-      excellent: 50,    // <50%
-      good: 70,         // 50-70%
-      average: 80,      // 70-80%
+      excellent: 50, // <50%
+      good: 70, // 50-70%
+      average: 80, // 70-80%
       below_average: 90, // 80-90%
-      poor: 100         // >90%
-    }
+      poor: 100, // >90%
+    },
   };
 
-  constructor(collector: MetricsCollector, config: Partial<AnalyticsConfig> = {}) {
+  constructor(
+    collector: MetricsCollector,
+    config: Partial<AnalyticsConfig> = {},
+  ) {
     this.collector = collector;
     this.config = {
       enablePredictiveAnalysis: true,
       enableAnomalyDetection: true,
       enableTrendAnalysis: true,
       lookbackPeriod: 24 * 60 * 60 * 1000, // 24 hours
-      sensitivityLevel: 'medium',
-      ...config
+      sensitivityLevel: "medium",
+      ...config,
     };
   }
 
@@ -117,11 +120,11 @@ export class PerformanceAnalytics {
    */
   addDataPoint(metrics: PerformanceMetrics): void {
     this.historicalData.push(metrics);
-    
+
     // Limit historical data to lookback period
     const cutoff = Date.now() - this.config.lookbackPeriod;
     this.historicalData = this.historicalData.filter(
-      data => data.system.uptime > cutoff
+      (data) => data.system.uptime > cutoff,
     );
 
     // Run analysis on new data
@@ -139,38 +142,48 @@ export class PerformanceAnalytics {
     }
 
     const trends: PerformanceTrend[] = [];
-    
+
     // Analyze response time trend
-    trends.push(this.analyzeTrend(
-      'responseTime',
-      this.historicalData.map(d => d.requests.averageResponseTime)
-    ));
+    trends.push(
+      this.analyzeTrend(
+        "responseTime",
+        this.historicalData.map((d) => d.requests.averageResponseTime),
+      ),
+    );
 
     // Analyze cache hit rate trend
-    trends.push(this.analyzeTrend(
-      'cacheHitRate',
-      this.historicalData.map(d => d.cache.hitRate)
-    ));
+    trends.push(
+      this.analyzeTrend(
+        "cacheHitRate",
+        this.historicalData.map((d) => d.cache.hitRate),
+      ),
+    );
 
     // Analyze error rate trend
-    trends.push(this.analyzeTrend(
-      'errorRate',
-      this.historicalData.map(d => 
-        d.requests.total > 0 ? d.requests.failed / d.requests.total : 0
-      )
-    ));
+    trends.push(
+      this.analyzeTrend(
+        "errorRate",
+        this.historicalData.map((d) =>
+          d.requests.total > 0 ? d.requests.failed / d.requests.total : 0,
+        ),
+      ),
+    );
 
     // Analyze memory usage trend
-    trends.push(this.analyzeTrend(
-      'memoryUsage',
-      this.historicalData.map(d => d.system.memoryUsage)
-    ));
+    trends.push(
+      this.analyzeTrend(
+        "memoryUsage",
+        this.historicalData.map((d) => d.system.memoryUsage),
+      ),
+    );
 
     // Analyze request volume trend
-    trends.push(this.analyzeTrend(
-      'requestVolume',
-      this.historicalData.map(d => d.requests.requestsPerSecond)
-    ));
+    trends.push(
+      this.analyzeTrend(
+        "requestVolume",
+        this.historicalData.map((d) => d.requests.requestsPerSecond),
+      ),
+    );
 
     return trends;
   }
@@ -186,48 +199,51 @@ export class PerformanceAnalytics {
     // Cache optimization insights
     if (currentMetrics.cache.hitRate < 0.8) {
       insights.push({
-        id: 'cache-optimization-1',
-        category: 'optimization',
-        priority: 'high',
-        title: 'Improve Cache Hit Rate',
+        id: "cache-optimization-1",
+        category: "optimization",
+        priority: "high",
+        title: "Improve Cache Hit Rate",
         description: `Current cache hit rate is ${(currentMetrics.cache.hitRate * 100).toFixed(1)}%, which is below optimal performance.`,
-        impact: 'performance',
-        recommendation: 'Implement cache warming strategies and optimize TTL values for frequently accessed data.',
-        estimatedImprovement: '20-40% reduction in response times',
-        implementationEffort: 'medium',
-        relatedMetrics: ['cacheHitRate', 'responseTime']
+        impact: "performance",
+        recommendation:
+          "Implement cache warming strategies and optimize TTL values for frequently accessed data.",
+        estimatedImprovement: "20-40% reduction in response times",
+        implementationEffort: "medium",
+        relatedMetrics: ["cacheHitRate", "responseTime"],
       });
     }
 
     // Response time insights
     if (currentMetrics.requests.averageResponseTime > 1000) {
       insights.push({
-        id: 'response-time-1',
-        category: 'optimization',
-        priority: 'high',
-        title: 'Reduce Response Times',
+        id: "response-time-1",
+        category: "optimization",
+        priority: "high",
+        title: "Reduce Response Times",
         description: `Average response time of ${currentMetrics.requests.averageResponseTime.toFixed(0)}ms is above recommended threshold.`,
-        impact: 'user_experience',
-        recommendation: 'Enable aggressive caching, optimize database queries, or consider upgrading server resources.',
-        estimatedImprovement: '50-70% reduction in response times',
-        implementationEffort: 'medium',
-        relatedMetrics: ['responseTime', 'cacheHitRate']
+        impact: "user_experience",
+        recommendation:
+          "Enable aggressive caching, optimize database queries, or consider upgrading server resources.",
+        estimatedImprovement: "50-70% reduction in response times",
+        implementationEffort: "medium",
+        relatedMetrics: ["responseTime", "cacheHitRate"],
       });
     }
 
     // Memory usage insights
     if (currentMetrics.system.memoryUsage > 80) {
       insights.push({
-        id: 'memory-usage-1',
-        category: 'scaling',
-        priority: 'medium',
-        title: 'Memory Usage Optimization',
+        id: "memory-usage-1",
+        category: "scaling",
+        priority: "medium",
+        title: "Memory Usage Optimization",
         description: `Memory usage at ${currentMetrics.system.memoryUsage}% is approaching limits.`,
-        impact: 'reliability',
-        recommendation: 'Increase cache size limits, implement cache eviction policies, or scale server resources.',
-        estimatedImprovement: 'Improved system stability',
-        implementationEffort: 'low',
-        relatedMetrics: ['memoryUsage', 'cacheSize']
+        impact: "reliability",
+        recommendation:
+          "Increase cache size limits, implement cache eviction policies, or scale server resources.",
+        estimatedImprovement: "Improved system stability",
+        implementationEffort: "low",
+        relatedMetrics: ["memoryUsage", "cacheSize"],
       });
     }
 
@@ -235,37 +251,43 @@ export class PerformanceAnalytics {
     const toolMetrics = currentMetrics.tools;
     if (Object.keys(toolMetrics.toolUsageCount).length > 0) {
       const mostUsed = Object.entries(toolMetrics.toolUsageCount)
-        .sort(([,a], [,b]) => b - a)
+        .sort(([, a], [, b]) => b - a)
         .slice(0, 3);
 
       insights.push({
-        id: 'tool-usage-1',
-        category: 'optimization',
-        priority: 'low',
-        title: 'Optimize Frequently Used Tools',
-        description: `Most used tools: ${mostUsed.map(([tool]) => tool).join(', ')}. Consider optimizing these workflows.`,
-        impact: 'performance',
-        recommendation: 'Create cached workflows or batch operations for frequently used tools.',
-        estimatedImprovement: '10-20% reduction in API calls',
-        implementationEffort: 'high',
-        relatedMetrics: ['toolUsage', 'requestVolume']
+        id: "tool-usage-1",
+        category: "optimization",
+        priority: "low",
+        title: "Optimize Frequently Used Tools",
+        description: `Most used tools: ${mostUsed.map(([tool]) => tool).join(", ")}. Consider optimizing these workflows.`,
+        impact: "performance",
+        recommendation:
+          "Create cached workflows or batch operations for frequently used tools.",
+        estimatedImprovement: "10-20% reduction in API calls",
+        implementationEffort: "high",
+        relatedMetrics: ["toolUsage", "requestVolume"],
       });
     }
 
     // Trend-based insights
-    const responseTimeTrend = trends.find(t => t.metric === 'responseTime');
-    if (responseTimeTrend && responseTimeTrend.direction === 'declining' && responseTimeTrend.changeRate > 10) {
+    const responseTimeTrend = trends.find((t) => t.metric === "responseTime");
+    if (
+      responseTimeTrend &&
+      responseTimeTrend.direction === "declining" &&
+      responseTimeTrend.changeRate > 10
+    ) {
       insights.push({
-        id: 'trend-response-time-1',
-        category: 'alert',
-        priority: 'high',
-        title: 'Response Time Degradation Detected',
+        id: "trend-response-time-1",
+        category: "alert",
+        priority: "high",
+        title: "Response Time Degradation Detected",
         description: `Response times are declining at ${responseTimeTrend.changeRate.toFixed(1)}% rate.`,
-        impact: 'performance',
-        recommendation: 'Investigate recent changes, check WordPress site health, and monitor resource usage.',
-        estimatedImprovement: 'Prevent further degradation',
-        implementationEffort: 'medium',
-        relatedMetrics: ['responseTime', 'errorRate']
+        impact: "performance",
+        recommendation:
+          "Investigate recent changes, check WordPress site health, and monitor resource usage.",
+        estimatedImprovement: "Prevent further degradation",
+        implementationEffort: "medium",
+        relatedMetrics: ["responseTime", "errorRate"],
       });
     }
 
@@ -281,43 +303,58 @@ export class PerformanceAnalytics {
     const comparisons: BenchmarkComparison[] = [];
 
     // Response time benchmark
-    comparisons.push(this.createBenchmarkComparison(
-      'Response Time',
-      currentMetrics.requests.averageResponseTime,
-      this.benchmarks.responseTime,
-      false // lower is better
-    ));
+    comparisons.push(
+      this.createBenchmarkComparison(
+        "Response Time",
+        currentMetrics.requests.averageResponseTime,
+        this.benchmarks.responseTime,
+        false, // lower is better
+      ),
+    );
 
     // Cache hit rate benchmark
-    comparisons.push(this.createBenchmarkComparison(
-      'Cache Hit Rate',
-      currentMetrics.cache.hitRate * 100,
-      Object.fromEntries(
-        Object.entries(this.benchmarks.cacheHitRate).map(([k, v]) => [k, v * 100])
+    comparisons.push(
+      this.createBenchmarkComparison(
+        "Cache Hit Rate",
+        currentMetrics.cache.hitRate * 100,
+        Object.fromEntries(
+          Object.entries(this.benchmarks.cacheHitRate).map(([k, v]) => [
+            k,
+            v * 100,
+          ]),
+        ),
+        true, // higher is better
       ),
-      true // higher is better
-    ));
+    );
 
     // Error rate benchmark
-    const errorRate = currentMetrics.requests.total > 0 
-      ? (currentMetrics.requests.failed / currentMetrics.requests.total) * 100
-      : 0;
-    comparisons.push(this.createBenchmarkComparison(
-      'Error Rate',
-      errorRate,
-      Object.fromEntries(
-        Object.entries(this.benchmarks.errorRate).map(([k, v]) => [k, v * 100])
+    const errorRate =
+      currentMetrics.requests.total > 0
+        ? (currentMetrics.requests.failed / currentMetrics.requests.total) * 100
+        : 0;
+    comparisons.push(
+      this.createBenchmarkComparison(
+        "Error Rate",
+        errorRate,
+        Object.fromEntries(
+          Object.entries(this.benchmarks.errorRate).map(([k, v]) => [
+            k,
+            v * 100,
+          ]),
+        ),
+        false, // lower is better
       ),
-      false // lower is better
-    ));
+    );
 
     // Memory usage benchmark
-    comparisons.push(this.createBenchmarkComparison(
-      'Memory Usage',
-      currentMetrics.system.memoryUsage,
-      this.benchmarks.memoryUsage,
-      false // lower is better
-    ));
+    comparisons.push(
+      this.createBenchmarkComparison(
+        "Memory Usage",
+        currentMetrics.system.memoryUsage,
+        this.benchmarks.memoryUsage,
+        false, // lower is better
+      ),
+    );
 
     return comparisons;
   }
@@ -331,7 +368,7 @@ export class PerformanceAnalytics {
       currentValue: number;
       predictedValue: number;
       confidence: number;
-      trend: 'improving' | 'declining' | 'stable';
+      trend: "improving" | "declining" | "stable";
     }>;
     alerts: string[];
   } {
@@ -346,26 +383,44 @@ export class PerformanceAnalytics {
     for (const trend of trends) {
       const _timeframeMs = timeframeMinutes * 60 * 1000;
       const predictedValue = trend.prediction.nextValue;
-      
+
       predictions.push({
         metric: trend.metric,
         currentValue: this.getCurrentMetricValue(trend.metric),
         predictedValue,
         confidence: trend.confidence,
-        trend: trend.direction
+        trend: trend.direction,
       });
 
       // Generate alerts for concerning predictions
-      if (trend.metric === 'responseTime' && predictedValue > 2000 && trend.direction === 'declining') {
-        alerts.push(`Response times predicted to exceed 2s in ${timeframeMinutes} minutes`);
+      if (
+        trend.metric === "responseTime" &&
+        predictedValue > 2000 &&
+        trend.direction === "declining"
+      ) {
+        alerts.push(
+          `Response times predicted to exceed 2s in ${timeframeMinutes} minutes`,
+        );
       }
 
-      if (trend.metric === 'cacheHitRate' && predictedValue < 0.5 && trend.direction === 'declining') {
-        alerts.push(`Cache hit rate predicted to drop below 50% in ${timeframeMinutes} minutes`);
+      if (
+        trend.metric === "cacheHitRate" &&
+        predictedValue < 0.5 &&
+        trend.direction === "declining"
+      ) {
+        alerts.push(
+          `Cache hit rate predicted to drop below 50% in ${timeframeMinutes} minutes`,
+        );
       }
 
-      if (trend.metric === 'memoryUsage' && predictedValue > 90 && trend.direction === 'declining') {
-        alerts.push(`Memory usage predicted to exceed 90% in ${timeframeMinutes} minutes`);
+      if (
+        trend.metric === "memoryUsage" &&
+        predictedValue > 90 &&
+        trend.direction === "declining"
+      ) {
+        alerts.push(
+          `Memory usage predicted to exceed 90% in ${timeframeMinutes} minutes`,
+        );
       }
     }
 
@@ -381,28 +436,28 @@ export class PerformanceAnalytics {
     longTerm: PerformanceInsight[];
     estimatedROI: {
       performanceGain: number; // percentage
-      implementationCost: 'low' | 'medium' | 'high';
+      implementationCost: "low" | "medium" | "high";
       timeToValue: number; // days
     };
     } {
     const insights = this.generateInsights();
-    
+
     const quickWins = insights.filter(
-      i => i.implementationEffort === 'low' && ['high', 'critical'].includes(i.priority)
+      (i) =>
+        i.implementationEffort === "low" &&
+        ["high", "critical"].includes(i.priority),
     );
-    
+
     const mediumTerm = insights.filter(
-      i => i.implementationEffort === 'medium'
-    );
-    
-    const longTerm = insights.filter(
-      i => i.implementationEffort === 'high'
+      (i) => i.implementationEffort === "medium",
     );
 
+    const longTerm = insights.filter((i) => i.implementationEffort === "high");
+
     // Estimate ROI based on current performance issues
     const currentMetrics = this.collector.collectCurrentMetrics();
     let estimatedGain = 0;
-    
+
     if (currentMetrics.cache.hitRate < 0.8) estimatedGain += 30;
     if (currentMetrics.requests.averageResponseTime > 1000) estimatedGain += 40;
     if (currentMetrics.system.memoryUsage > 80) estimatedGain += 20;
@@ -413,9 +468,14 @@ export class PerformanceAnalytics {
       longTerm,
       estimatedROI: {
         performanceGain: Math.min(estimatedGain, 80), // Cap at 80%
-        implementationCost: quickWins.length > 2 ? 'low' : mediumTerm.length > 2 ? 'medium' : 'high',
-        timeToValue: quickWins.length > 0 ? 1 : mediumTerm.length > 0 ? 7 : 30
-      }
+        implementationCost:
+          quickWins.length > 2
+            ? "low"
+            : mediumTerm.length > 2
+              ? "medium"
+              : "high",
+        timeToValue: quickWins.length > 0 ? 1 : mediumTerm.length > 0 ? 7 : 30,
+      },
     };
   }
 
@@ -424,7 +484,7 @@ export class PerformanceAnalytics {
    */
   getAnomalies(severity?: string): PerformanceAnomaly[] {
     if (severity) {
-      return this.detectedAnomalies.filter(a => a.severity === severity);
+      return this.detectedAnomalies.filter((a) => a.severity === severity);
     }
     return [...this.detectedAnomalies];
   }
@@ -449,21 +509,23 @@ export class PerformanceAnalytics {
     } {
     const currentMetrics = this.collector.collectCurrentMetrics();
     const performanceScore = this.calculatePerformanceScore(currentMetrics);
-    
+
     return {
       timestamp: new Date().toISOString(),
       summary: {
         overallHealth: this.calculateOverallHealth(performanceScore),
         keyInsights: this.generatedInsights.length,
-        criticalAlerts: this.generatedInsights.filter(i => i.priority === 'critical').length,
-        performanceScore
+        criticalAlerts: this.generatedInsights.filter(
+          (i) => i.priority === "critical",
+        ).length,
+        performanceScore,
       },
       trends: this.analyzeTrends(),
       benchmarks: this.benchmarkPerformance(),
       insights: this.generateInsights(),
       anomalies: this.getAnomalies(),
       predictions: this.predictPerformance(),
-      optimizationPlan: this.generateOptimizationPlan()
+      optimizationPlan: this.generateOptimizationPlan(),
     };
   }
 
@@ -474,10 +536,14 @@ export class PerformanceAnalytics {
     if (values.length < 3) {
       return {
         metric: metricName,
-        direction: 'stable',
+        direction: "stable",
         changeRate: 0,
         confidence: 0,
-        prediction: { nextValue: values[values.length - 1] || 0, timeframe: 0, confidence: 0 }
+        prediction: {
+          nextValue: values[values.length - 1] || 0,
+          timeframe: 0,
+          confidence: 0,
+        },
       };
     }
 
@@ -485,44 +551,49 @@ export class PerformanceAnalytics {
     const n = values.length;
     const x = Array.from({ length: n }, (_, i) => i);
     const y = values;
-    
+
     const sumX = x.reduce((a, b) => a + b, 0);
     const sumY = y.reduce((a, b) => a + b, 0);
     const sumXY = x.map((xi, i) => xi * y[i]).reduce((a, b) => a + b, 0);
-    const sumXX = x.map(xi => xi * xi).reduce((a, b) => a + b, 0);
-    
+    const sumXX = x.map((xi) => xi * xi).reduce((a, b) => a + b, 0);
+
     const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
     const intercept = (sumY - slope * sumX) / n;
-    
+
     // Calculate R-squared for confidence
     const yMean = sumY / n;
-    const totalSumSquares = y.map(yi => Math.pow(yi - yMean, 2)).reduce((a, b) => a + b, 0);
-    const residualSumSquares = y.map((yi, i) => {
-      const predicted = slope * x[i] + intercept;
-      return Math.pow(yi - predicted, 2);
-    }).reduce((a, b) => a + b, 0);
-    
-    const rSquared = 1 - (residualSumSquares / totalSumSquares);
-    
+    const totalSumSquares = y
+      .map((yi) => Math.pow(yi - yMean, 2))
+      .reduce((a, b) => a + b, 0);
+    const residualSumSquares = y
+      .map((yi, i) => {
+        const predicted = slope * x[i] + intercept;
+        return Math.pow(yi - predicted, 2);
+      })
+      .reduce((a, b) => a + b, 0);
+
+    const rSquared = 1 - residualSumSquares / totalSumSquares;
+
     // Determine direction and change rate
     const currentValue = values[values.length - 1];
     const previousValue = values[values.length - 2];
-    const changeRate = Math.abs((currentValue - previousValue) / previousValue) * 100;
-    
-    let direction: 'improving' | 'declining' | 'stable' = 'stable';
+    const changeRate =
+      Math.abs((currentValue - previousValue) / previousValue) * 100;
+
+    let direction: "improving" | "declining" | "stable" = "stable";
     if (Math.abs(slope) > 0.1) {
       // For metrics where lower is better (response time, error rate)
-      if (['responseTime', 'errorRate', 'memoryUsage'].includes(metricName)) {
-        direction = slope < 0 ? 'improving' : 'declining';
+      if (["responseTime", "errorRate", "memoryUsage"].includes(metricName)) {
+        direction = slope < 0 ? "improving" : "declining";
       } else {
         // For metrics where higher is better (cache hit rate)
-        direction = slope > 0 ? 'improving' : 'declining';
+        direction = slope > 0 ? "improving" : "declining";
       }
     }
 
     // Predict next value
     const nextValue = slope * n + intercept;
-    
+
     return {
       metric: metricName,
       direction,
@@ -531,8 +602,8 @@ export class PerformanceAnalytics {
       prediction: {
         nextValue: Math.max(0, nextValue),
         timeframe: 30 * 60 * 1000, // 30 minutes
-        confidence: Math.max(0, Math.min(1, rSquared * 0.8)) // Slightly lower confidence for predictions
-      }
+        confidence: Math.max(0, Math.min(1, rSquared * 0.8)), // Slightly lower confidence for predictions
+      },
     };
   }
 
@@ -543,37 +614,38 @@ export class PerformanceAnalytics {
     if (this.historicalData.length < 10) return; // Need historical context
 
     const recentData = this.historicalData.slice(-10);
-    
+
     // Check response time anomalies
-    const responseTimes = recentData.map(d => d.requests.averageResponseTime);
+    const responseTimes = recentData.map((d) => d.requests.averageResponseTime);
     this.checkMetricAnomaly(
-      'responseTime',
+      "responseTime",
       metrics.requests.averageResponseTime,
       responseTimes,
-      'Response time spike detected'
+      "Response time spike detected",
     );
 
     // Check cache hit rate anomalies
-    const hitRates = recentData.map(d => d.cache.hitRate);
+    const hitRates = recentData.map((d) => d.cache.hitRate);
     this.checkMetricAnomaly(
-      'cacheHitRate',
+      "cacheHitRate",
       metrics.cache.hitRate,
       hitRates,
-      'Cache hit rate drop detected'
+      "Cache hit rate drop detected",
     );
 
     // Check error rate anomalies
-    const errorRates = recentData.map(d => 
-      d.requests.total > 0 ? d.requests.failed / d.requests.total : 0
+    const errorRates = recentData.map((d) =>
+      d.requests.total > 0 ? d.requests.failed / d.requests.total : 0,
     );
-    const currentErrorRate = metrics.requests.total > 0 
-      ? metrics.requests.failed / metrics.requests.total 
-      : 0;
+    const currentErrorRate =
+      metrics.requests.total > 0
+        ? metrics.requests.failed / metrics.requests.total
+        : 0;
     this.checkMetricAnomaly(
-      'errorRate',
+      "errorRate",
       currentErrorRate,
       errorRates,
-      'Error rate spike detected'
+      "Error rate spike detected",
     );
   }
 
@@ -584,29 +656,32 @@ export class PerformanceAnalytics {
     metricName: string,
     currentValue: number,
     historicalValues: number[],
-    description: string
+    description: string,
   ): void {
     if (historicalValues.length < 5) return;
 
-    const mean = historicalValues.reduce((a, b) => a + b, 0) / historicalValues.length;
-    const variance = historicalValues.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / historicalValues.length;
+    const mean =
+      historicalValues.reduce((a, b) => a + b, 0) / historicalValues.length;
+    const variance =
+      historicalValues.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) /
+      historicalValues.length;
     const standardDeviation = Math.sqrt(variance);
 
     // Calculate z-score
     const zScore = Math.abs((currentValue - mean) / standardDeviation);
-    
+
     // Determine sensitivity threshold
     let threshold = 2; // Default for medium sensitivity
-    if (this.config.sensitivityLevel === 'low') threshold = 3;
-    if (this.config.sensitivityLevel === 'high') threshold = 1.5;
+    if (this.config.sensitivityLevel === "low") threshold = 3;
+    if (this.config.sensitivityLevel === "high") threshold = 1.5;
 
     if (zScore > threshold) {
       const deviation = ((currentValue - mean) / mean) * 100;
-      
-      let severity: 'minor' | 'moderate' | 'major' | 'critical' = 'minor';
-      if (zScore > 4) severity = 'critical';
-      else if (zScore > 3) severity = 'major';
-      else if (zScore > 2.5) severity = 'moderate';
+
+      let severity: "minor" | "moderate" | "major" | "critical" = "minor";
+      if (zScore > 4) severity = "critical";
+      else if (zScore > 3) severity = "major";
+      else if (zScore > 2.5) severity = "moderate";
 
       const anomaly: PerformanceAnomaly = {
         timestamp: Date.now(),
@@ -615,11 +690,14 @@ export class PerformanceAnalytics {
         actualValue: currentValue,
         deviation,
         severity,
-        possibleCauses: this.generatePossibleCauses(metricName, currentValue > mean)
+        possibleCauses: this.generatePossibleCauses(
+          metricName,
+          currentValue > mean,
+        ),
       };
 
       this.detectedAnomalies.push(anomaly);
-      
+
       // Limit anomaly history
       if (this.detectedAnomalies.length > 100) {
         this.detectedAnomalies = this.detectedAnomalies.slice(-50);
@@ -630,15 +708,33 @@ export class PerformanceAnalytics {
   /**
    * Generate possible causes for anomalies
    */
-  private generatePossibleCauses(metricName: string, isIncrease: boolean): string[] {
+  private generatePossibleCauses(
+    metricName: string,
+    isIncrease: boolean,
+  ): string[] {
     const causes: string[] = [];
 
-    if (metricName === 'responseTime' && isIncrease) {
-      causes.push('High server load', 'Database performance issues', 'Network latency', 'Cache miss increase');
-    } else if (metricName === 'cacheHitRate' && !isIncrease) {
-      causes.push('Cache invalidation event', 'New data requests', 'Cache size limit reached', 'TTL expiration');
-    } else if (metricName === 'errorRate' && isIncrease) {
-      causes.push('WordPress site issues', 'Authentication problems', 'Network connectivity', 'Plugin conflicts');
+    if (metricName === "responseTime" && isIncrease) {
+      causes.push(
+        "High server load",
+        "Database performance issues",
+        "Network latency",
+        "Cache miss increase",
+      );
+    } else if (metricName === "cacheHitRate" && !isIncrease) {
+      causes.push(
+        "Cache invalidation event",
+        "New data requests",
+        "Cache size limit reached",
+        "TTL expiration",
+      );
+    } else if (metricName === "errorRate" && isIncrease) {
+      causes.push(
+        "WordPress site issues",
+        "Authentication problems",
+        "Network connectivity",
+        "Plugin conflicts",
+      );
     }
 
     return causes;
@@ -651,47 +747,64 @@ export class PerformanceAnalytics {
     category: string,
     currentValue: number,
     benchmarks: any,
-    higherIsBetter: boolean
+    higherIsBetter: boolean,
   ): BenchmarkComparison {
-    let status: 'excellent' | 'good' | 'average' | 'below_average' | 'poor' = 'poor';
+    let status: "excellent" | "good" | "average" | "below_average" | "poor" =
+      "poor";
     let percentile = 0;
     let improvement = 0;
 
     if (higherIsBetter) {
-      if (currentValue >= benchmarks.excellent) status = 'excellent';
-      else if (currentValue >= benchmarks.good) status = 'good';
-      else if (currentValue >= benchmarks.average) status = 'average';
-      else if (currentValue >= benchmarks.below_average) status = 'below_average';
-      
+      if (currentValue >= benchmarks.excellent) status = "excellent";
+      else if (currentValue >= benchmarks.good) status = "good";
+      else if (currentValue >= benchmarks.average) status = "average";
+      else if (currentValue >= benchmarks.below_average)
+        status = "below_average";
+
       // Calculate improvement needed
-      if (status !== 'excellent') {
-        const nextTier = status === 'good' ? benchmarks.excellent :
-          status === 'average' ? benchmarks.good :
-            status === 'below_average' ? benchmarks.average :
-              benchmarks.below_average;
+      if (status !== "excellent") {
+        const nextTier =
+          status === "good"
+            ? benchmarks.excellent
+            : status === "average"
+              ? benchmarks.good
+              : status === "below_average"
+                ? benchmarks.average
+                : benchmarks.below_average;
         improvement = nextTier - currentValue;
       }
     } else {
-      if (currentValue <= benchmarks.excellent) status = 'excellent';
-      else if (currentValue <= benchmarks.good) status = 'good';
-      else if (currentValue <= benchmarks.average) status = 'average';
-      else if (currentValue <= benchmarks.below_average) status = 'below_average';
-      
+      if (currentValue <= benchmarks.excellent) status = "excellent";
+      else if (currentValue <= benchmarks.good) status = "good";
+      else if (currentValue <= benchmarks.average) status = "average";
+      else if (currentValue <= benchmarks.below_average)
+        status = "below_average";
+
       // Calculate improvement needed
-      if (status !== 'excellent') {
-        const nextTier = status === 'good' ? benchmarks.excellent :
-          status === 'average' ? benchmarks.good :
-            status === 'below_average' ? benchmarks.average :
-              benchmarks.below_average;
+      if (status !== "excellent") {
+        const nextTier =
+          status === "good"
+            ? benchmarks.excellent
+            : status === "average"
+              ? benchmarks.good
+              : status === "below_average"
+                ? benchmarks.average
+                : benchmarks.below_average;
         improvement = currentValue - nextTier;
       }
     }
 
     // Calculate percentile (simplified)
-    percentile = status === 'excellent' ? 95 :
-      status === 'good' ? 80 :
-        status === 'average' ? 60 :
-          status === 'below_average' ? 30 : 10;
+    percentile =
+      status === "excellent"
+        ? 95
+        : status === "good"
+          ? 80
+          : status === "average"
+            ? 60
+            : status === "below_average"
+              ? 30
+              : 10;
 
     return {
       category,
@@ -699,7 +812,7 @@ export class PerformanceAnalytics {
       benchmarkValue: benchmarks.excellent,
       percentile,
       status,
-      improvement
+      improvement,
     };
   }
 
@@ -708,14 +821,22 @@ export class PerformanceAnalytics {
    */
   private getCurrentMetricValue(metricName: string): number {
     const current = this.collector.collectCurrentMetrics();
-    
+
     switch (metricName) {
-    case 'responseTime': return current.requests.averageResponseTime;
-    case 'cacheHitRate': return current.cache.hitRate;
-    case 'errorRate': return current.requests.total > 0 ? current.requests.failed / current.requests.total : 0;
-    case 'memoryUsage': return current.system.memoryUsage;
-    case 'requestVolume': return current.requests.requestsPerSecond;
-    default: return 0;
+    case "responseTime":
+      return current.requests.averageResponseTime;
+    case "cacheHitRate":
+      return current.cache.hitRate;
+    case "errorRate":
+      return current.requests.total > 0
+        ? current.requests.failed / current.requests.total
+        : 0;
+    case "memoryUsage":
+      return current.system.memoryUsage;
+    case "requestVolume":
+      return current.requests.requestsPerSecond;
+    default:
+      return 0;
     }
   }
 
@@ -724,28 +845,31 @@ export class PerformanceAnalytics {
    */
   private calculatePerformanceScore(metrics: PerformanceMetrics): number {
     let score = 100;
-    
+
     // Response time (30% weight)
     if (metrics.requests.averageResponseTime > 2000) score -= 30;
     else if (metrics.requests.averageResponseTime > 1000) score -= 15;
     else if (metrics.requests.averageResponseTime > 500) score -= 5;
-    
+
     // Error rate (25% weight)
-    const errorRate = metrics.requests.total > 0 ? metrics.requests.failed / metrics.requests.total : 0;
+    const errorRate =
+      metrics.requests.total > 0
+        ? metrics.requests.failed / metrics.requests.total
+        : 0;
     if (errorRate > 0.05) score -= 25;
     else if (errorRate > 0.02) score -= 15;
     else if (errorRate > 0.01) score -= 5;
-    
+
     // Cache performance (25% weight)
     if (metrics.cache.hitRate < 0.5) score -= 25;
     else if (metrics.cache.hitRate < 0.7) score -= 15;
     else if (metrics.cache.hitRate < 0.85) score -= 5;
-    
+
     // System resources (20% weight)
     if (metrics.system.memoryUsage > 90) score -= 20;
     else if (metrics.system.memoryUsage > 80) score -= 10;
     else if (metrics.system.memoryUsage > 70) score -= 5;
-    
+
     return Math.max(0, score);
   }
 
@@ -753,10 +877,10 @@ export class PerformanceAnalytics {
    * Calculate overall health status
    */
   private calculateOverallHealth(score: number): string {
-    if (score >= 90) return 'excellent';
-    if (score >= 75) return 'good';
-    if (score >= 60) return 'fair';
-    if (score >= 40) return 'poor';
-    return 'critical';
+    if (score >= 90) return "excellent";
+    if (score >= 75) return "good";
+    if (score >= 60) return "fair";
+    if (score >= 40) return "poor";
+    return "critical";
   }
 }