mcp-wordpress 1.2.2 → 1.3.0

package/dist/tools/performance.js

@@ -2,10 +2,10 @@
  * Performance Monitoring MCP Tools for WordPress Server
  * Provides comprehensive performance insights and management
  */
-import { PerformanceMonitor } from '../performance/PerformanceMonitor.js';
-import { MetricsCollector } from '../performance/MetricsCollector.js';
-import { PerformanceAnalytics } from '../performance/PerformanceAnalytics.js';
-import { toolWrapper } from '../utils/toolWrapper.js';
+import { PerformanceMonitor } from "../performance/PerformanceMonitor.js";
+import { MetricsCollector } from "../performance/MetricsCollector.js";
+import { PerformanceAnalytics } from "../performance/PerformanceAnalytics.js";
+import { toolWrapper } from "../utils/toolWrapper.js";
 /**
  * Performance Tools Class
  */
@@ -18,17 +18,17 @@ export default class PerformanceTools {
         this.monitor = new PerformanceMonitor({
             enableRealTimeMonitoring: true,
             enableHistoricalData: true,
-            enableAlerts: true
+            enableAlerts: true,
         });
         this.collector = new MetricsCollector(this.monitor, {
             enableRealTime: true,
             enableToolTracking: true,
-            enableCacheIntegration: true
+            enableCacheIntegration: true,
         });
         this.analytics = new PerformanceAnalytics(this.collector, {
             enablePredictiveAnalysis: true,
             enableAnomalyDetection: true,
-            enableTrendAnalysis: true
+            enableTrendAnalysis: true,
         });
         // Register clients if provided
         if (clients) {
@@ -49,197 +49,197 @@ export default class PerformanceTools {
     getTools() {
         return [
             {
-                name: 'wp_performance_stats',
-                description: 'Get real-time performance statistics and metrics',
+                name: "wp_performance_stats",
+                description: "Get real-time performance statistics and metrics",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'category',
-                        type: 'string',
-                        description: 'Category of metrics to return (overview, requests, cache, system, tools, all)',
-                        required: false
+                        name: "category",
+                        type: "string",
+                        description: "Category of metrics to return (overview, requests, cache, system, tools, all)",
+                        required: false,
                     },
                     {
-                        name: 'format',
-                        type: 'string',
-                        description: 'Detail level of the response (summary, detailed, raw)',
-                        required: false
-                    }
+                        name: "format",
+                        type: "string",
+                        description: "Detail level of the response (summary, detailed, raw)",
+                        required: false,
+                    },
                 ],
-                handler: this.getPerformanceStats.bind(this)
+                handler: this.getPerformanceStats.bind(this),
             },
             {
-                name: 'wp_performance_history',
-                description: 'Get historical performance data and trends',
+                name: "wp_performance_history",
+                description: "Get historical performance data and trends",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'timeframe',
-                        type: 'string',
-                        description: 'Time period for historical data (1h, 6h, 12h, 24h, 7d)',
-                        required: false
+                        name: "timeframe",
+                        type: "string",
+                        description: "Time period for historical data (1h, 6h, 12h, 24h, 7d)",
+                        required: false,
                     },
                     {
-                        name: 'metrics',
-                        type: 'array',
-                        description: 'Specific metrics to include (responseTime, cacheHitRate, errorRate, memoryUsage, requestVolume)',
-                        required: false
+                        name: "metrics",
+                        type: "array",
+                        description: "Specific metrics to include (responseTime, cacheHitRate, errorRate, memoryUsage, requestVolume)",
+                        required: false,
                     },
                     {
-                        name: 'includeTrends',
-                        type: 'boolean',
-                        description: 'Include trend analysis (default: true)',
-                        required: false
-                    }
+                        name: "includeTrends",
+                        type: "boolean",
+                        description: "Include trend analysis (default: true)",
+                        required: false,
+                    },
                 ],
-                handler: this.getPerformanceHistory.bind(this)
+                handler: this.getPerformanceHistory.bind(this),
             },
             {
-                name: 'wp_performance_benchmark',
-                description: 'Compare current performance against industry benchmarks',
+                name: "wp_performance_benchmark",
+                description: "Compare current performance against industry benchmarks",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'category',
-                        type: 'string',
-                        description: 'Benchmark category (response_time, cache_performance, error_rate, system_resources, all)',
-                        required: false
+                        name: "category",
+                        type: "string",
+                        description: "Benchmark category (response_time, cache_performance, error_rate, system_resources, all)",
+                        required: false,
                     },
                     {
-                        name: 'includeRecommendations',
-                        type: 'boolean',
-                        description: 'Include improvement recommendations (default: true)',
-                        required: false
-                    }
+                        name: "includeRecommendations",
+                        type: "boolean",
+                        description: "Include improvement recommendations (default: true)",
+                        required: false,
+                    },
                 ],
-                handler: this.getBenchmarkComparison.bind(this)
+                handler: this.getBenchmarkComparison.bind(this),
             },
             {
-                name: 'wp_performance_alerts',
-                description: 'Get performance alerts and anomaly detection results',
+                name: "wp_performance_alerts",
+                description: "Get performance alerts and anomaly detection results",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'severity',
-                        type: 'string',
-                        description: 'Filter alerts by severity level (info, warning, error, critical)',
-                        required: false
+                        name: "severity",
+                        type: "string",
+                        description: "Filter alerts by severity level (info, warning, error, critical)",
+                        required: false,
                     },
                     {
-                        name: 'category',
-                        type: 'string',
-                        description: 'Filter alerts by category (performance, cache, system, wordpress)',
-                        required: false
+                        name: "category",
+                        type: "string",
+                        description: "Filter alerts by category (performance, cache, system, wordpress)",
+                        required: false,
                     },
                     {
-                        name: 'limit',
-                        type: 'number',
-                        description: 'Maximum number of alerts to return (default: 20)',
-                        required: false
+                        name: "limit",
+                        type: "number",
+                        description: "Maximum number of alerts to return (default: 20)",
+                        required: false,
                     },
                     {
-                        name: 'includeAnomalies',
-                        type: 'boolean',
-                        description: 'Include detected anomalies (default: true)',
-                        required: false
-                    }
+                        name: "includeAnomalies",
+                        type: "boolean",
+                        description: "Include detected anomalies (default: true)",
+                        required: false,
+                    },
                 ],
-                handler: this.getPerformanceAlerts.bind(this)
+                handler: this.getPerformanceAlerts.bind(this),
             },
             {
-                name: 'wp_performance_optimize',
-                description: 'Get optimization recommendations and insights',
+                name: "wp_performance_optimize",
+                description: "Get optimization recommendations and insights",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'focus',
-                        type: 'string',
-                        description: 'Optimization focus area (speed, reliability, efficiency, scaling)',
-                        required: false
+                        name: "focus",
+                        type: "string",
+                        description: "Optimization focus area (speed, reliability, efficiency, scaling)",
+                        required: false,
                     },
                     {
-                        name: 'priority',
-                        type: 'string',
-                        description: 'Implementation timeline (quick_wins, medium_term, long_term, all)',
-                        required: false
+                        name: "priority",
+                        type: "string",
+                        description: "Implementation timeline (quick_wins, medium_term, long_term, all)",
+                        required: false,
                     },
                     {
-                        name: 'includeROI',
-                        type: 'boolean',
-                        description: 'Include ROI estimates (default: true)',
-                        required: false
+                        name: "includeROI",
+                        type: "boolean",
+                        description: "Include ROI estimates (default: true)",
+                        required: false,
                     },
                     {
-                        name: 'includePredictions',
-                        type: 'boolean',
-                        description: 'Include performance predictions (default: true)',
-                        required: false
-                    }
+                        name: "includePredictions",
+                        type: "boolean",
+                        description: "Include performance predictions (default: true)",
+                        required: false,
+                    },
                 ],
-                handler: this.getOptimizationRecommendations.bind(this)
+                handler: this.getOptimizationRecommendations.bind(this),
             },
             {
-                name: 'wp_performance_export',
-                description: 'Export comprehensive performance report',
+                name: "wp_performance_export",
+                description: "Export comprehensive performance report",
                 parameters: [
                     {
-                        name: 'site',
-                        type: 'string',
-                        description: 'Specific site ID for multi-site setups (optional for single site)',
-                        required: false
+                        name: "site",
+                        type: "string",
+                        description: "Specific site ID for multi-site setups (optional for single site)",
+                        required: false,
                     },
                     {
-                        name: 'format',
-                        type: 'string',
-                        description: 'Export format (json, csv, summary)',
-                        required: false
+                        name: "format",
+                        type: "string",
+                        description: "Export format (json, csv, summary)",
+                        required: false,
                     },
                     {
-                        name: 'includeHistorical',
-                        type: 'boolean',
-                        description: 'Include historical data (default: true)',
-                        required: false
+                        name: "includeHistorical",
+                        type: "boolean",
+                        description: "Include historical data (default: true)",
+                        required: false,
                     },
                     {
-                        name: 'includeAnalytics',
-                        type: 'boolean',
-                        description: 'Include analytics and insights (default: true)',
-                        required: false
+                        name: "includeAnalytics",
+                        type: "boolean",
+                        description: "Include analytics and insights (default: true)",
+                        required: false,
                     },
                     {
-                        name: 'timeRange',
-                        type: 'string',
-                        description: 'Time range for data export (1h, 6h, 24h, 7d, 30d)',
-                        required: false
-                    }
+                        name: "timeRange",
+                        type: "string",
+                        description: "Time range for data export (1h, 6h, 24h, 7d, 30d)",
+                        required: false,
+                    },
                 ],
-                handler: this.exportPerformanceReport.bind(this)
-            }
+                handler: this.exportPerformanceReport.bind(this),
+            },
         ];
     }
     /**
@@ -247,7 +247,7 @@ export default class PerformanceTools {
      */
     async getPerformanceStats(params) {
         return toolWrapper(async () => {
-            const { site, category = 'overview', format = 'summary' } = params;
+            const { site, category = "overview", format = "summary" } = params;
             // Get current metrics
             const metrics = this.collector.collectCurrentMetrics();
             // Get site-specific metrics if requested
@@ -257,7 +257,7 @@ export default class PerformanceTools {
             }
             // Filter by category
             const result = {};
-            if (category === 'overview' || category === 'all') {
+            if (category === "overview" || category === "all") {
                 result.overview = {
                     overallHealth: this.calculateHealthStatus(metrics),
                     performanceScore: this.calculatePerformanceScore(metrics),
@@ -265,35 +265,35 @@ export default class PerformanceTools {
                     averageResponseTime: `${metrics.requests.averageResponseTime.toFixed(0)}ms`,
                     cacheHitRate: `${(metrics.cache.hitRate * 100).toFixed(1)}%`,
                     errorRate: `${((metrics.requests.failed / Math.max(metrics.requests.total, 1)) * 100).toFixed(2)}%`,
-                    uptime: this.formatUptime(metrics.system.uptime)
+                    uptime: this.formatUptime(metrics.system.uptime),
                 };
             }
-            if (category === 'requests' || category === 'all') {
+            if (category === "requests" || category === "all") {
                 result.requests = {
                     ...metrics.requests,
                     requestsPerSecond: metrics.requests.requestsPerSecond.toFixed(2),
                     p50ResponseTime: `${metrics.requests.p50ResponseTime}ms`,
                     p95ResponseTime: `${metrics.requests.p95ResponseTime}ms`,
-                    p99ResponseTime: `${metrics.requests.p99ResponseTime}ms`
+                    p99ResponseTime: `${metrics.requests.p99ResponseTime}ms`,
                 };
             }
-            if (category === 'cache' || category === 'all') {
+            if (category === "cache" || category === "all") {
                 result.cache = {
                     ...metrics.cache,
                     hitRate: `${(metrics.cache.hitRate * 100).toFixed(1)}%`,
                     memoryUsage: `${metrics.cache.memoryUsageMB.toFixed(1)}MB`,
-                    efficiency: this.calculateCacheEfficiency(metrics.cache)
+                    efficiency: this.calculateCacheEfficiency(metrics.cache),
                 };
             }
-            if (category === 'system' || category === 'all') {
+            if (category === "system" || category === "all") {
                 result.system = {
                     ...metrics.system,
                     memoryUsage: `${metrics.system.memoryUsage}%`,
                     cpuUsage: `${metrics.system.cpuUsage}%`,
-                    uptime: this.formatUptime(metrics.system.uptime)
+                    uptime: this.formatUptime(metrics.system.uptime),
                 };
             }
-            if (category === 'tools' || category === 'all') {
+            if (category === "tools" || category === "all") {
                 result.tools = {
                     mostUsedTool: metrics.tools.mostUsedTool,
                     totalToolCalls: Object.values(metrics.tools.toolUsageCount).reduce((sum, count) => sum + count, 0),
@@ -301,7 +301,7 @@ export default class PerformanceTools {
                         .sort(([, a], [, b]) => b - a)
                         .slice(0, 5)
                         .map(([tool, count]) => ({ tool, count })),
-                    toolPerformance: format === 'detailed' ? metrics.tools.toolPerformance : undefined
+                    toolPerformance: format === "detailed" ? metrics.tools.toolPerformance : undefined,
                 };
             }
             // Add site-specific data if requested
@@ -309,7 +309,7 @@ export default class PerformanceTools {
                 result.siteSpecific = {
                     siteId: site,
                     cache: siteMetrics.cache,
-                    client: siteMetrics.client
+                    client: siteMetrics.client,
                 };
             }
             // Add metadata
@@ -317,12 +317,12 @@ export default class PerformanceTools {
                 timestamp: new Date().toISOString(),
                 category,
                 format,
-                site: site || 'all',
-                monitoringEnabled: true
+                site: site || "all",
+                monitoringEnabled: true,
             };
             return {
                 success: true,
-                data: result
+                data: result,
             };
         });
     }
@@ -331,7 +331,7 @@ export default class PerformanceTools {
      */
     async getPerformanceHistory(params) {
         return toolWrapper(async () => {
-            const { site, timeframe = '24h', metrics: requestedMetrics, includeTrends = true } = params;
+            const { site, timeframe = "24h", metrics: requestedMetrics, includeTrends = true, } = params;
             // Convert timeframe to milliseconds
             const timeframMs = this.parseTimeframe(timeframe);
             const startTime = Date.now() - timeframMs;
@@ -345,7 +345,7 @@ export default class PerformanceTools {
                 trends = this.analytics.analyzeTrends();
                 // Filter trends by requested metrics
                 if (requestedMetrics && Array.isArray(requestedMetrics)) {
-                    trends = trends.filter(trend => requestedMetrics.includes(trend.metric));
+                    trends = trends.filter((trend) => requestedMetrics.includes(trend.metric));
                 }
             }
             // Process historical data for charting
@@ -358,17 +358,17 @@ export default class PerformanceTools {
                     historicalData: chartData,
                     trends: trends || [],
                     summary: {
-                        averageResponseTime: this.calculateAverage(historicalData.map(d => d.requests.averageResponseTime)),
-                        averageCacheHitRate: this.calculateAverage(historicalData.map(d => d.cache.hitRate)),
-                        averageErrorRate: this.calculateAverage(historicalData.map(d => d.requests.total > 0 ? d.requests.failed / d.requests.total : 0)),
-                        totalRequests: historicalData.reduce((sum, d) => sum + d.requests.total, 0)
+                        averageResponseTime: this.calculateAverage(historicalData.map((d) => d.requests.averageResponseTime)),
+                        averageCacheHitRate: this.calculateAverage(historicalData.map((d) => d.cache.hitRate)),
+                        averageErrorRate: this.calculateAverage(historicalData.map((d) => d.requests.total > 0 ? d.requests.failed / d.requests.total : 0)),
+                        totalRequests: historicalData.reduce((sum, d) => sum + d.requests.total, 0),
                     },
                     metadata: {
                         timestamp: new Date().toISOString(),
-                        site: site || 'all',
-                        requestedMetrics: requestedMetrics || ['all']
-                    }
-                }
+                        site: site || "all",
+                        requestedMetrics: requestedMetrics || ["all"],
+                    },
+                },
             };
         });
     }
@@ -377,21 +377,21 @@ export default class PerformanceTools {
      */
     async getBenchmarkComparison(params) {
         return toolWrapper(async () => {
-            const { site, category = 'all', includeRecommendations = true } = params;
+            const { site, category = "all", includeRecommendations = true } = params;
             // Get benchmark comparisons
             const benchmarks = this.analytics.benchmarkPerformance();
             // Filter by category if specified
             let filteredBenchmarks = benchmarks;
-            if (category !== 'all') {
+            if (category !== "all") {
                 const categoryMap = {
-                    'response_time': 'Response Time',
-                    'cache_performance': 'Cache Hit Rate',
-                    'error_rate': 'Error Rate',
-                    'system_resources': 'Memory Usage'
+                    response_time: "Response Time",
+                    cache_performance: "Cache Hit Rate",
+                    error_rate: "Error Rate",
+                    system_resources: "Memory Usage",
                 };
                 const targetCategory = categoryMap[category];
                 if (targetCategory) {
-                    filteredBenchmarks = benchmarks.filter(b => b.category === targetCategory);
+                    filteredBenchmarks = benchmarks.filter((b) => b.category === targetCategory);
                 }
             }
             // Get recommendations if requested
@@ -399,35 +399,37 @@ export default class PerformanceTools {
             if (includeRecommendations) {
                 const insights = this.analytics.generateInsights();
                 recommendations = insights
-                    .filter(insight => insight.category === 'optimization')
-                    .map(insight => ({
+                    .filter((insight) => insight.category === "optimization")
+                    .map((insight) => ({
                     title: insight.title,
                     description: insight.description,
                     priority: insight.priority,
                     estimatedImprovement: insight.estimatedImprovement,
-                    implementationEffort: insight.implementationEffort
+                    implementationEffort: insight.implementationEffort,
                 }));
             }
             return {
                 success: true,
                 data: {
-                    benchmarks: filteredBenchmarks.map(benchmark => ({
+                    benchmarks: filteredBenchmarks.map((benchmark) => ({
                         ...benchmark,
                         status: this.formatBenchmarkStatus(benchmark.status),
-                        improvement: benchmark.improvement > 0 ? {
-                            needed: benchmark.improvement,
-                            description: this.getBenchmarkImprovementDescription(benchmark)
-                        } : null
+                        improvement: benchmark.improvement > 0
+                            ? {
+                                needed: benchmark.improvement,
+                                description: this.getBenchmarkImprovementDescription(benchmark),
+                            }
+                            : null,
                     })),
                     overallRanking: this.calculateOverallRanking(benchmarks),
                     recommendations: recommendations || [],
                     metadata: {
                         timestamp: new Date().toISOString(),
                         category,
-                        site: site || 'all',
-                        benchmarkVersion: '2024-industry-standards'
-                    }
-                }
+                        site: site || "all",
+                        benchmarkVersion: "2024-industry-standards",
+                    },
+                },
             };
         });
     }
@@ -436,12 +438,12 @@ export default class PerformanceTools {
      */
     async getPerformanceAlerts(params) {
         return toolWrapper(async () => {
-            const { site, severity, category, limit = 20, includeAnomalies = true } = params;
+            const { site, severity, category, limit = 20, includeAnomalies = true, } = params;
             // Get alerts from monitor
             let alerts = this.monitor.getAlerts(severity);
             // Filter by category if specified
             if (category) {
-                alerts = alerts.filter(alert => alert.category === category);
+                alerts = alerts.filter((alert) => alert.category === category);
             }
             // Limit results
             alerts = alerts.slice(-limit);
@@ -453,42 +455,42 @@ export default class PerformanceTools {
             // Calculate alert summary
             const alertSummary = {
                 total: alerts.length,
-                critical: alerts.filter(a => a.severity === 'critical').length,
-                error: alerts.filter(a => a.severity === 'error').length,
-                warning: alerts.filter(a => a.severity === 'warning').length,
-                info: alerts.filter(a => a.severity === 'info').length
+                critical: alerts.filter((a) => a.severity === "critical").length,
+                error: alerts.filter((a) => a.severity === "error").length,
+                warning: alerts.filter((a) => a.severity === "warning").length,
+                info: alerts.filter((a) => a.severity === "info").length,
             };
             const anomalySummary = {
                 total: anomalies.length,
-                critical: anomalies.filter(a => a.severity === 'critical').length,
-                major: anomalies.filter(a => a.severity === 'major').length,
-                moderate: anomalies.filter(a => a.severity === 'moderate').length,
-                minor: anomalies.filter(a => a.severity === 'minor').length
+                critical: anomalies.filter((a) => a.severity === "critical").length,
+                major: anomalies.filter((a) => a.severity === "major").length,
+                moderate: anomalies.filter((a) => a.severity === "moderate").length,
+                minor: anomalies.filter((a) => a.severity === "minor").length,
             };
             return {
                 success: true,
                 data: {
-                    alerts: alerts.map(alert => ({
+                    alerts: alerts.map((alert) => ({
                         ...alert,
                         timestamp: new Date(alert.timestamp).toISOString(),
-                        formattedMessage: this.formatAlertMessage(alert)
+                        formattedMessage: this.formatAlertMessage(alert),
                     })),
-                    anomalies: anomalies.map(anomaly => ({
+                    anomalies: anomalies.map((anomaly) => ({
                         ...anomaly,
                         timestamp: new Date(anomaly.timestamp).toISOString(),
-                        formattedDescription: this.formatAnomalyDescription(anomaly)
+                        formattedDescription: this.formatAnomalyDescription(anomaly),
                     })),
                     summary: {
                         alerts: alertSummary,
                         anomalies: anomalySummary,
-                        overallStatus: this.calculateAlertStatus(alertSummary, anomalySummary)
+                        overallStatus: this.calculateAlertStatus(alertSummary, anomalySummary),
                     },
                     metadata: {
                         timestamp: new Date().toISOString(),
-                        filters: { severity, category, site: site || 'all' },
-                        limit
-                    }
-                }
+                        filters: { severity, category, site: site || "all" },
+                        limit,
+                    },
+                },
             };
         });
     }
@@ -497,29 +499,38 @@ export default class PerformanceTools {
      */
     async getOptimizationRecommendations(params) {
         return toolWrapper(async () => {
-            const { site, focus = 'speed', priority = 'all', includeROI = true, includePredictions = true } = params;
+            const { site, focus = "speed", priority = "all", includeROI = true, includePredictions = true, } = params;
             // Generate optimization plan
             const optimizationPlan = this.analytics.generateOptimizationPlan();
             // Filter by priority
             let recommendations = [];
-            if (priority === 'quick_wins' || priority === 'all') {
-                recommendations.push(...optimizationPlan.quickWins.map(r => ({ ...r, timeline: 'quick_wins' })));
+            if (priority === "quick_wins" || priority === "all") {
+                recommendations.push(...optimizationPlan.quickWins.map((r) => ({
+                    ...r,
+                    timeline: "quick_wins",
+                })));
             }
-            if (priority === 'medium_term' || priority === 'all') {
-                recommendations.push(...optimizationPlan.mediumTerm.map(r => ({ ...r, timeline: 'medium_term' })));
+            if (priority === "medium_term" || priority === "all") {
+                recommendations.push(...optimizationPlan.mediumTerm.map((r) => ({
+                    ...r,
+                    timeline: "medium_term",
+                })));
             }
-            if (priority === 'long_term' || priority === 'all') {
-                recommendations.push(...optimizationPlan.longTerm.map(r => ({ ...r, timeline: 'long_term' })));
+            if (priority === "long_term" || priority === "all") {
+                recommendations.push(...optimizationPlan.longTerm.map((r) => ({
+                    ...r,
+                    timeline: "long_term",
+                })));
             }
             // Filter by focus area
-            if (focus !== 'speed') {
+            if (focus !== "speed") {
                 const focusMap = {
-                    reliability: ['reliability'],
-                    efficiency: ['cost', 'performance'],
-                    scaling: ['performance', 'reliability']
+                    reliability: ["reliability"],
+                    efficiency: ["cost", "performance"],
+                    scaling: ["performance", "reliability"],
                 };
                 const targetImpacts = focusMap[focus] || [];
-                recommendations = recommendations.filter(r => targetImpacts.includes(r.impact));
+                recommendations = recommendations.filter((r) => targetImpacts.includes(r.impact));
             }
             // Get predictions if requested
             let predictions = null;
@@ -529,10 +540,10 @@ export default class PerformanceTools {
             return {
                 success: true,
                 data: {
-                    recommendations: recommendations.map(rec => ({
+                    recommendations: recommendations.map((rec) => ({
                         ...rec,
                         formattedPriority: this.formatPriority(rec.priority),
-                        formattedEffort: this.formatEffort(rec.implementationEffort)
+                        formattedEffort: this.formatEffort(rec.implementationEffort),
                     })),
                     roi: includeROI ? optimizationPlan.estimatedROI : null,
                     predictions: predictions || null,
@@ -541,15 +552,15 @@ export default class PerformanceTools {
                         quickWins: optimizationPlan.quickWins.length,
                         mediumTerm: optimizationPlan.mediumTerm.length,
                         longTerm: optimizationPlan.longTerm.length,
-                        estimatedImpact: this.calculateEstimatedImpact(recommendations)
+                        estimatedImpact: this.calculateEstimatedImpact(recommendations),
                     },
                     metadata: {
                         timestamp: new Date().toISOString(),
                         focus,
                         priority,
-                        site: site || 'all'
-                    }
-                }
+                        site: site || "all",
+                    },
+                },
             };
         });
     }
@@ -558,20 +569,20 @@ export default class PerformanceTools {
      */
     async exportPerformanceReport(params) {
         return toolWrapper(async () => {
-            const { site, format = 'json', includeHistorical = true, includeAnalytics = true, timeRange = '24h' } = params;
+            const { site, format = "json", includeHistorical = true, includeAnalytics = true, timeRange = "24h", } = params;
             // Generate comprehensive analytics report
             const report = this.analytics.exportAnalyticsReport();
             // Add additional data based on parameters
             const exportData = {
                 metadata: {
                     generatedAt: new Date().toISOString(),
-                    site: site || 'all',
+                    site: site || "all",
                     timeRange,
                     format,
-                    version: '1.0.0'
+                    version: "1.0.0",
                 },
                 summary: report.summary,
-                currentMetrics: this.collector.collectCurrentMetrics()
+                currentMetrics: this.collector.collectCurrentMetrics(),
             };
             if (includeHistorical) {
                 const timeframMs = this.parseTimeframe(timeRange);
@@ -585,13 +596,13 @@ export default class PerformanceTools {
                     insights: report.insights,
                     anomalies: report.anomalies,
                     predictions: report.predictions,
-                    optimizationPlan: report.optimizationPlan
+                    optimizationPlan: report.optimizationPlan,
                 };
             }
             // Add aggregated statistics
             exportData.aggregatedStats = {
                 cache: this.collector.getAggregatedCacheStats(),
-                client: this.collector.getAggregatedClientStats()
+                client: this.collector.getAggregatedClientStats(),
             };
             // Add site comparison if multi-site
             if (!site) {
@@ -599,10 +610,10 @@ export default class PerformanceTools {
             }
             // Format output based on requested format
             let formattedOutput;
-            if (format === 'csv') {
+            if (format === "csv") {
                 formattedOutput = this.convertToCSV(exportData);
             }
-            else if (format === 'summary') {
+            else if (format === "summary") {
                 formattedOutput = this.createSummaryReport(exportData);
             }
             else {
@@ -615,8 +626,8 @@ export default class PerformanceTools {
                     timestamp: new Date().toISOString(),
                     format,
                     dataSize: JSON.stringify(exportData).length,
-                    site: site || 'all'
-                }
+                    site: site || "all",
+                },
             };
         });
     }
@@ -639,14 +650,14 @@ export default class PerformanceTools {
         if (metrics.system.memoryUsage > 85)
             score -= 15;
         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";
     }
     calculatePerformanceScore(metrics) {
         let score = 100;
@@ -680,16 +691,16 @@ export default class PerformanceTools {
         return Math.max(0, Math.min(100, score));
     }
     calculateCacheEfficiency(cacheMetrics) {
-        const efficiency = (cacheMetrics.hitRate * 100) +
+        const efficiency = cacheMetrics.hitRate * 100 +
             (cacheMetrics.totalSize > 0 ? 10 : 0) -
             (cacheMetrics.evictions > 100 ? 10 : 0);
         if (efficiency >= 95)
-            return 'Excellent';
+            return "Excellent";
         if (efficiency >= 85)
-            return 'Good';
+            return "Good";
         if (efficiency >= 70)
-            return 'Fair';
-        return 'Poor';
+            return "Fair";
+        return "Poor";
     }
     formatUptime(uptimeMs) {
         const seconds = Math.floor(uptimeMs / 1000);
@@ -706,38 +717,51 @@ export default class PerformanceTools {
     }
     parseTimeframe(timeframe) {
         const map = {
-            '1h': 60 * 60 * 1000,
-            '6h': 6 * 60 * 60 * 1000,
-            '12h': 12 * 60 * 60 * 1000,
-            '24h': 24 * 60 * 60 * 1000,
-            '7d': 7 * 24 * 60 * 60 * 1000,
-            '30d': 30 * 24 * 60 * 60 * 1000
+            "1h": 60 * 60 * 1000,
+            "6h": 6 * 60 * 60 * 1000,
+            "12h": 12 * 60 * 60 * 1000,
+            "24h": 24 * 60 * 60 * 1000,
+            "7d": 7 * 24 * 60 * 60 * 1000,
+            "30d": 30 * 24 * 60 * 60 * 1000,
         };
-        return map[timeframe] || map['24h'];
+        return map[timeframe] || map["24h"];
     }
     processHistoricalDataForChart(data, requestedMetrics) {
         if (!data.length)
             return {};
-        const allMetrics = ['responseTime', 'cacheHitRate', 'errorRate', 'memoryUsage', 'requestVolume'];
+        const allMetrics = [
+            "responseTime",
+            "cacheHitRate",
+            "errorRate",
+            "memoryUsage",
+            "requestVolume",
+        ];
         const metricsToProcess = requestedMetrics || allMetrics;
         const result = {};
         for (const metric of metricsToProcess) {
             result[metric] = data.map((point, index) => ({
                 timestamp: point.system.uptime,
                 value: this.extractMetricValue(point, metric),
-                index
+                index,
             }));
         }
         return result;
     }
     extractMetricValue(dataPoint, metric) {
         switch (metric) {
-            case 'responseTime': return dataPoint.requests.averageResponseTime;
-            case 'cacheHitRate': return dataPoint.cache.hitRate * 100;
-            case 'errorRate': return (dataPoint.requests.failed / Math.max(dataPoint.requests.total, 1)) * 100;
-            case 'memoryUsage': return dataPoint.system.memoryUsage;
-            case 'requestVolume': return dataPoint.requests.requestsPerSecond;
-            default: return 0;
+            case "responseTime":
+                return dataPoint.requests.averageResponseTime;
+            case "cacheHitRate":
+                return dataPoint.cache.hitRate * 100;
+            case "errorRate":
+                return ((dataPoint.requests.failed / Math.max(dataPoint.requests.total, 1)) *
+                    100);
+            case "memoryUsage":
+                return dataPoint.system.memoryUsage;
+            case "requestVolume":
+                return dataPoint.requests.requestsPerSecond;
+            default:
+                return 0;
         }
     }
     calculateAverage(values) {
@@ -747,97 +771,97 @@ export default class PerformanceTools {
     }
     formatBenchmarkStatus(status) {
         const statusMap = {
-            'excellent': '🟢 Excellent',
-            'good': '🟡 Good',
-            'average': '🟠 Average',
-            'below_average': '🔴 Below Average',
-            'poor': '⚫ Poor'
+            excellent: "🟢 Excellent",
+            good: "🟡 Good",
+            average: "🟠 Average",
+            below_average: "🔴 Below Average",
+            poor: "⚫ Poor",
         };
         return statusMap[status] || status;
     }
     getBenchmarkImprovementDescription(benchmark) {
         const improvements = {
-            'Response Time': `Reduce by ${benchmark.improvement.toFixed(0)}ms`,
-            'Cache Hit Rate': `Increase by ${benchmark.improvement.toFixed(1)}%`,
-            'Error Rate': `Reduce by ${benchmark.improvement.toFixed(2)}%`,
-            'Memory Usage': `Reduce by ${benchmark.improvement.toFixed(0)}%`
+            "Response Time": `Reduce by ${benchmark.improvement.toFixed(0)}ms`,
+            "Cache Hit Rate": `Increase by ${benchmark.improvement.toFixed(1)}%`,
+            "Error Rate": `Reduce by ${benchmark.improvement.toFixed(2)}%`,
+            "Memory Usage": `Reduce by ${benchmark.improvement.toFixed(0)}%`,
         };
-        return improvements[benchmark.category] || `Improve by ${benchmark.improvement}`;
+        return (improvements[benchmark.category] || `Improve by ${benchmark.improvement}`);
     }
     calculateOverallRanking(benchmarks) {
-        const statuses = benchmarks.map(b => b.status);
-        const excellentCount = statuses.filter(s => s === 'excellent').length;
-        const goodCount = statuses.filter(s => s === 'good').length;
+        const statuses = benchmarks.map((b) => b.status);
+        const excellentCount = statuses.filter((s) => s === "excellent").length;
+        const goodCount = statuses.filter((s) => s === "good").length;
         const percentile = ((excellentCount + goodCount * 0.8) / statuses.length) * 100;
-        let status = 'Needs Improvement';
+        let status = "Needs Improvement";
         if (percentile >= 90)
-            status = 'Top Performer';
+            status = "Top Performer";
         else if (percentile >= 75)
-            status = 'Above Average';
+            status = "Above Average";
         else if (percentile >= 50)
-            status = 'Average';
+            status = "Average";
         return { percentile: Math.round(percentile), status };
     }
     formatAlertMessage(alert) {
         return `${alert.severity.toUpperCase()}: ${alert.message} (${alert.metric}: ${alert.actualValue} vs threshold: ${alert.threshold})`;
     }
     formatAnomalyDescription(anomaly) {
-        const direction = anomaly.actualValue > anomaly.expectedValue ? 'higher' : 'lower';
+        const direction = anomaly.actualValue > anomaly.expectedValue ? "higher" : "lower";
         return `${anomaly.metric} is ${Math.abs(anomaly.deviation).toFixed(1)}% ${direction} than expected (${anomaly.expectedValue.toFixed(2)} vs ${anomaly.actualValue.toFixed(2)})`;
     }
     calculateAlertStatus(alertSummary, anomalySummary) {
         const critical = alertSummary.critical + anomalySummary.critical;
         const high = alertSummary.error + anomalySummary.major;
         if (critical > 0)
-            return 'Critical Issues Detected';
+            return "Critical Issues Detected";
         if (high > 2)
-            return 'High Priority Issues';
+            return "High Priority Issues";
         if (alertSummary.warning + anomalySummary.moderate > 5)
-            return 'Performance Warnings';
-        return 'System Healthy';
+            return "Performance Warnings";
+        return "System Healthy";
     }
     formatPriority(priority) {
         const map = {
-            'critical': '🔴 Critical',
-            'high': '🟠 High',
-            'medium': '🟡 Medium',
-            'low': '🟢 Low'
+            critical: "🔴 Critical",
+            high: "🟠 High",
+            medium: "🟡 Medium",
+            low: "🟢 Low",
         };
         return map[priority] || priority;
     }
     formatEffort(effort) {
         const map = {
-            'low': '⚡ Low Effort',
-            'medium': '⚖️ Medium Effort',
-            'high': '🏋️ High Effort'
+            low: "⚡ Low Effort",
+            medium: "⚖️ Medium Effort",
+            high: "🏋️ High Effort",
         };
         return map[effort] || effort;
     }
     calculateEstimatedImpact(recommendations) {
-        const highImpact = recommendations.filter(r => ['critical', 'high'].includes(r.priority)).length;
+        const highImpact = recommendations.filter((r) => ["critical", "high"].includes(r.priority)).length;
         const totalImpact = recommendations.length;
         if (highImpact >= 3)
-            return 'Significant Performance Gains Expected';
+            return "Significant Performance Gains Expected";
         if (totalImpact >= 5)
-            return 'Moderate Performance Improvements';
+            return "Moderate Performance Improvements";
         if (totalImpact > 0)
-            return 'Minor Performance Optimizations';
-        return 'System Already Optimized';
+            return "Minor Performance Optimizations";
+        return "System Already Optimized";
     }
     convertToCSV(data) {
         // Simplified CSV conversion for current metrics
         const metrics = data.currentMetrics;
         const csv = [
-            'Metric,Value,Unit',
+            "Metric,Value,Unit",
             `Total Requests,${metrics.requests.total},count`,
             `Average Response Time,${metrics.requests.averageResponseTime.toFixed(0)},ms`,
             `Success Rate,${((metrics.requests.successful / Math.max(metrics.requests.total, 1)) * 100).toFixed(1)},%`,
             `Cache Hit Rate,${(metrics.cache.hitRate * 100).toFixed(1)},%`,
             `Cache Size,${metrics.cache.totalSize},entries`,
             `Memory Usage,${metrics.system.memoryUsage},percent`,
-            `Uptime,${metrics.system.uptime},ms`
+            `Uptime,${metrics.system.uptime},ms`,
         ];
-        return csv.join('\n');
+        return csv.join("\n");
     }
     createSummaryReport(data) {
         const metrics = data.currentMetrics;
@@ -848,10 +872,10 @@ export default class PerformanceTools {
                 averageResponseTime: `${metrics.requests.averageResponseTime.toFixed(0)}ms`,
                 cacheEfficiency: `${(metrics.cache.hitRate * 100).toFixed(1)}%`,
                 systemLoad: `${metrics.system.memoryUsage}%`,
-                errorRate: `${((metrics.requests.failed / Math.max(metrics.requests.total, 1)) * 100).toFixed(2)}%`
+                errorRate: `${((metrics.requests.failed / Math.max(metrics.requests.total, 1)) * 100).toFixed(2)}%`,
             },
             recommendations: data.analytics?.insights?.slice(0, 3) || [],
-            nextSteps: 'Review detailed metrics and implement high-priority optimizations'
+            nextSteps: "Review detailed metrics and implement high-priority optimizations",
         };
     }
     startHistoricalDataCollection() {