mcp-wordpress 1.2.3 → 1.3.0

package/dist/performance/PerformanceAnalytics.js

@@ -18,29 +18,29 @@ export class PerformanceAnalytics {
             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%
+            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%
             below_average: 0.05, // 2-5%
-            poor: Infinity // >5%
+            poor: Infinity, // >5%
         },
         memoryUsage: {
             excellent: 50, // <50%
             good: 70, // 50-70%
             average: 80, // 70-80%
             below_average: 90, // 80-90%
-            poor: 100 // >90%
-        }
+            poor: 100, // >90%
+        },
     };
     constructor(collector, config = {}) {
         this.collector = collector;
@@ -49,8 +49,8 @@ export class PerformanceAnalytics {
             enableAnomalyDetection: true,
             enableTrendAnalysis: true,
             lookbackPeriod: 24 * 60 * 60 * 1000, // 24 hours
-            sensitivityLevel: 'medium',
-            ...config
+            sensitivityLevel: "medium",
+            ...config,
         };
     }
     /**
@@ -60,7 +60,7 @@ export class PerformanceAnalytics {
         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);
+        this.historicalData = this.historicalData.filter((data) => data.system.uptime > cutoff);
         // Run analysis on new data
         if (this.config.enableAnomalyDetection) {
             this.detectAnomalies(metrics);
@@ -75,15 +75,15 @@ export class PerformanceAnalytics {
         }
         const trends = [];
         // 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;
     }
     /**
@@ -96,46 +96,46 @@ 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"],
             });
         }
         // Tool usage insights
@@ -145,32 +145,34 @@ export class PerformanceAnalytics {
                 .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"],
             });
         }
         this.generatedInsights = insights;
@@ -183,20 +185,22 @@ export class PerformanceAnalytics {
         const currentMetrics = this.collector.collectCurrentMetrics();
         const comparisons = [];
         // 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));
         // 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])), true // higher is better
-        ));
+        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));
         // 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])), false // lower is better
-        ));
+        comparisons.push(this.createBenchmarkComparison("Error Rate", errorRate, Object.fromEntries(Object.entries(this.benchmarks.errorRate).map(([k, v]) => [
+            k,
+            v * 100,
+        ])), false));
         // 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));
         return comparisons;
     }
     /**
@@ -217,16 +221,22 @@ export class PerformanceAnalytics {
                 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') {
+            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') {
+            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') {
+            if (trend.metric === "memoryUsage" &&
+                predictedValue > 90 &&
+                trend.direction === "declining") {
                 alerts.push(`Memory usage predicted to exceed 90% in ${timeframeMinutes} minutes`);
             }
         }
@@ -237,9 +247,10 @@ export class PerformanceAnalytics {
      */
     generateOptimizationPlan() {
         const insights = this.generateInsights();
-        const quickWins = insights.filter(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');
+        const quickWins = insights.filter((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");
         // Estimate ROI based on current performance issues
         const currentMetrics = this.collector.collectCurrentMetrics();
         let estimatedGain = 0;
@@ -255,9 +266,13 @@ 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,
+            },
         };
     }
     /**
@@ -265,7 +280,7 @@ export class PerformanceAnalytics {
      */
     getAnomalies(severity) {
         if (severity) {
-            return this.detectedAnomalies.filter(a => a.severity === severity);
+            return this.detectedAnomalies.filter((a) => a.severity === severity);
         }
         return [...this.detectedAnomalies];
     }
@@ -280,15 +295,15 @@ export class PerformanceAnalytics {
             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(),
         };
     }
     /**
@@ -298,10 +313,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,
+                },
             };
         }
         // Calculate linear regression
@@ -311,30 +330,34 @@ export class PerformanceAnalytics {
         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 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);
+        })
+            .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 = 'stable';
+        let direction = "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
@@ -347,8 +370,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
+            },
         };
     }
     /**
@@ -359,17 +382,17 @@ export class PerformanceAnalytics {
             return; // Need historical context
         const recentData = this.historicalData.slice(-10);
         // Check response time anomalies
-        const responseTimes = recentData.map(d => d.requests.averageResponseTime);
-        this.checkMetricAnomaly('responseTime', metrics.requests.averageResponseTime, responseTimes, 'Response time spike detected');
+        const responseTimes = recentData.map((d) => d.requests.averageResponseTime);
+        this.checkMetricAnomaly("responseTime", metrics.requests.averageResponseTime, responseTimes, "Response time spike detected");
         // Check cache hit rate anomalies
-        const hitRates = recentData.map(d => d.cache.hitRate);
-        this.checkMetricAnomaly('cacheHitRate', metrics.cache.hitRate, hitRates, 'Cache hit rate drop detected');
+        const hitRates = recentData.map((d) => d.cache.hitRate);
+        this.checkMetricAnomaly("cacheHitRate", metrics.cache.hitRate, hitRates, "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;
-        this.checkMetricAnomaly('errorRate', currentErrorRate, errorRates, 'Error rate spike detected');
+        this.checkMetricAnomaly("errorRate", currentErrorRate, errorRates, "Error rate spike detected");
     }
     /**
      * Check if a metric value is anomalous
@@ -378,25 +401,26 @@ export class PerformanceAnalytics {
         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 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')
+        if (this.config.sensitivityLevel === "low")
             threshold = 3;
-        if (this.config.sensitivityLevel === 'high')
+        if (this.config.sensitivityLevel === "high")
             threshold = 1.5;
         if (zScore > threshold) {
             const deviation = ((currentValue - mean) / mean) * 100;
-            let severity = 'minor';
+            let severity = "minor";
             if (zScore > 4)
-                severity = 'critical';
+                severity = "critical";
             else if (zScore > 3)
-                severity = 'major';
+                severity = "major";
             else if (zScore > 2.5)
-                severity = 'moderate';
+                severity = "moderate";
             const anomaly = {
                 timestamp: Date.now(),
                 metric: metricName,
@@ -404,7 +428,7 @@ 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
@@ -418,14 +442,14 @@ export class PerformanceAnalytics {
      */
     generatePossibleCauses(metricName, isIncrease) {
         const causes = [];
-        if (metricName === 'responseTime' && isIncrease) {
-            causes.push('High server load', 'Database performance issues', 'Network latency', 'Cache miss increase');
+        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 === "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');
+        else if (metricName === "errorRate" && isIncrease) {
+            causes.push("WordPress site issues", "Authentication problems", "Network connectivity", "Plugin conflicts");
         }
         return causes;
     }
@@ -433,57 +457,69 @@ export class PerformanceAnalytics {
      * Create benchmark comparison
      */
     createBenchmarkComparison(category, currentValue, benchmarks, higherIsBetter) {
-        let status = 'poor';
+        let status = "poor";
         let percentile = 0;
         let improvement = 0;
         if (higherIsBetter) {
             if (currentValue >= benchmarks.excellent)
-                status = 'excellent';
+                status = "excellent";
             else if (currentValue >= benchmarks.good)
-                status = 'good';
+                status = "good";
             else if (currentValue >= benchmarks.average)
-                status = 'average';
+                status = "average";
             else if (currentValue >= benchmarks.below_average)
-                status = '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';
+                status = "excellent";
             else if (currentValue <= benchmarks.good)
-                status = 'good';
+                status = "good";
             else if (currentValue <= benchmarks.average)
-                status = 'average';
+                status = "average";
             else if (currentValue <= benchmarks.below_average)
-                status = '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,
             currentValue,
             benchmarkValue: benchmarks.excellent,
             percentile,
             status,
-            improvement
+            improvement,
         };
     }
     /**
@@ -492,12 +528,20 @@ export class PerformanceAnalytics {
     getCurrentMetricValue(metricName) {
         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;
         }
     }
     /**
@@ -513,7 +557,9 @@ export class PerformanceAnalytics {
         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)
@@ -541,14 +587,14 @@ export class PerformanceAnalytics {
      */
     calculateOverallHealth(score) {
         if (score >= 90)
-            return 'excellent';
+            return "excellent";
         if (score >= 75)
-            return 'good';
+            return "good";
         if (score >= 60)
-            return 'fair';
+            return "fair";
         if (score >= 40)
-            return 'poor';
-        return 'critical';
+            return "poor";
+        return "critical";
     }
 }
 //# sourceMappingURL=PerformanceAnalytics.js.map