mcp-wordpress 1.2.2 → 1.3.0

package/src/performance/PerformanceMonitor.ts

@@ -18,7 +18,7 @@ export interface PerformanceMetrics {
     p99ResponseTime: number;
   };
 
-  // Cache Performance  
+  // Cache Performance
   cache: {
     hits: number;
     misses: number;
@@ -42,7 +42,7 @@ export interface PerformanceMetrics {
   wordpress: {
     authSuccessRate: number;
     apiVersion: string;
-    siteHealth: 'healthy' | 'warning' | 'critical';
+    siteHealth: "healthy" | "warning" | "critical";
     averageDbResponseTime: number;
     pluginCompatibility: number;
   };
@@ -51,19 +51,22 @@ export interface PerformanceMetrics {
   tools: {
     mostUsedTool: string;
     toolUsageCount: Record<string, number>;
-    toolPerformance: Record<string, {
-      averageTime: number;
-      successRate: number;
-      callCount: number;
-    }>;
+    toolPerformance: Record<
+      string,
+      {
+        averageTime: number;
+        successRate: number;
+        callCount: number;
+      }
+    >;
   };
 }
 
 export interface PerformanceAlert {
   id: string;
   timestamp: number;
-  severity: 'info' | 'warning' | 'error' | 'critical';
-  category: 'performance' | 'cache' | 'system' | 'wordpress';
+  severity: "info" | "warning" | "error" | "critical";
+  category: "performance" | "cache" | "system" | "wordpress";
   message: string;
   metric: string;
   threshold: number;
@@ -108,16 +111,16 @@ export class PerformanceMonitor {
         errorRate: 0.05, // 5%
         cacheHitRate: 0.8, // 80%
         memoryUsage: 80, // 80%
-        cpuUsage: 80 // 80%
+        cpuUsage: 80, // 80%
       },
       enableRealTimeMonitoring: true,
       enableHistoricalData: true,
       enableAlerts: true,
-      ...config
+      ...config,
     };
 
     this.metrics = this.initializeMetrics();
-    
+
     if (this.config.enableRealTimeMonitoring) {
       this.startCollection();
     }
@@ -138,7 +141,7 @@ export class PerformanceMonitor {
         requestsPerSecond: 0,
         p50ResponseTime: 0,
         p95ResponseTime: 0,
-        p99ResponseTime: 0
+        p99ResponseTime: 0,
       },
       cache: {
         hits: 0,
@@ -147,36 +150,40 @@ export class PerformanceMonitor {
         totalSize: 0,
         memoryUsageMB: 0,
         evictions: 0,
-        averageCacheTime: 0
+        averageCacheTime: 0,
       },
       system: {
         cpuUsage: 0,
         memoryUsage: 0,
         uptime: 0,
         activeConnections: 0,
-        concurrentRequests: 0
+        concurrentRequests: 0,
       },
       wordpress: {
         authSuccessRate: 0,
-        apiVersion: 'v2',
-        siteHealth: 'healthy',
+        apiVersion: "v2",
+        siteHealth: "healthy",
         averageDbResponseTime: 0,
-        pluginCompatibility: 100
+        pluginCompatibility: 100,
       },
       tools: {
-        mostUsedTool: '',
+        mostUsedTool: "",
         toolUsageCount: {},
-        toolPerformance: {}
-      }
+        toolPerformance: {},
+      },
     };
   }
 
   /**
    * Record a request performance metric
    */
-  recordRequest(responseTime: number, success: boolean, toolName?: string): void {
+  recordRequest(
+    responseTime: number,
+    success: boolean,
+    toolName?: string,
+  ): void {
     this.metrics.requests.total++;
-    
+
     if (success) {
       this.metrics.requests.successful++;
     } else {
@@ -209,7 +216,7 @@ export class PerformanceMonitor {
       totalSize: cacheStats.totalSize || 0,
       memoryUsageMB: this.estimateCacheMemoryUsage(cacheStats.totalSize),
       evictions: cacheStats.evictions || 0,
-      averageCacheTime: 0.5 // Sub-millisecond average
+      averageCacheTime: 0.5, // Sub-millisecond average
     };
   }
 
@@ -218,13 +225,13 @@ export class PerformanceMonitor {
    */
   updateSystemMetrics(): void {
     const memUsage = process.memoryUsage();
-    
+
     this.metrics.system = {
       cpuUsage: this.getCpuUsage(),
       memoryUsage: Math.round((memUsage.heapUsed / memUsage.heapTotal) * 100),
       uptime: Date.now() - this.startTime,
       activeConnections: 1, // Will be updated by connection manager
-      concurrentRequests: 0 // Will be updated by request manager
+      concurrentRequests: 0, // Will be updated by request manager
     };
   }
 
@@ -240,23 +247,23 @@ export class PerformanceMonitor {
    * Get historical performance data
    */
   getHistoricalData(
-    startTime?: number, 
-    endTime?: number
+    startTime?: number,
+    endTime?: number,
   ): PerformanceMetrics[] {
     if (!this.config.enableHistoricalData) {
       return [];
     }
 
     let data = [...this.historicalData];
-    
+
     if (startTime) {
-      data = data.filter(m => m.system.uptime >= startTime);
+      data = data.filter((m) => m.system.uptime >= startTime);
     }
-    
+
     if (endTime) {
-      data = data.filter(m => m.system.uptime <= endTime);
+      data = data.filter((m) => m.system.uptime <= endTime);
     }
-    
+
     return data;
   }
 
@@ -265,7 +272,7 @@ export class PerformanceMonitor {
    */
   getAlerts(severity?: string): PerformanceAlert[] {
     if (severity) {
-      return this.alerts.filter(alert => alert.severity === severity);
+      return this.alerts.filter((alert) => alert.severity === severity);
     }
     return [...this.alerts];
   }
@@ -284,35 +291,35 @@ export class PerformanceMonitor {
     summary: string;
     recommendations: string[];
     trends: string[];
-    health: 'excellent' | 'good' | 'warning' | 'critical';
+    health: "excellent" | "good" | "warning" | "critical";
     } {
     const current = this.getMetrics();
     const health = this.calculateOverallHealth(current);
-    
+
     return {
       summary: this.generateSummary(current),
       recommendations: this.generateRecommendations(current),
       trends: this.generateTrends(),
-      health
+      health,
     };
   }
 
   /**
    * Export performance data
    */
-  exportData(format: 'json' | 'csv' = 'json'): string {
+  exportData(format: "json" | "csv" = "json"): string {
     const data = {
       currentMetrics: this.getMetrics(),
       historicalData: this.getHistoricalData(),
       alerts: this.getAlerts(),
       config: this.config,
-      generatedAt: new Date().toISOString()
+      generatedAt: new Date().toISOString(),
     };
 
-    if (format === 'csv') {
+    if (format === "csv") {
       return this.convertToCSV(data);
     }
-    
+
     return JSON.stringify(data, null, 2);
   }
 
@@ -322,7 +329,7 @@ export class PerformanceMonitor {
   private startCollection(): void {
     this.collectionTimer = setInterval(() => {
       const snapshot = this.getMetrics();
-      
+
       if (this.config.enableHistoricalData) {
         this.historicalData.push(snapshot);
         this.cleanupOldData();
@@ -342,9 +349,13 @@ export class PerformanceMonitor {
   /**
    * Record tool usage and performance
    */
-  private recordToolUsage(toolName: string, responseTime: number, success: boolean): void {
+  private recordToolUsage(
+    toolName: string,
+    responseTime: number,
+    success: boolean,
+  ): void {
     // Update usage count
-    this.metrics.tools.toolUsageCount[toolName] = 
+    this.metrics.tools.toolUsageCount[toolName] =
       (this.metrics.tools.toolUsageCount[toolName] || 0) + 1;
 
     // Update performance metrics
@@ -352,26 +363,29 @@ export class PerformanceMonitor {
       this.metrics.tools.toolPerformance[toolName] = {
         averageTime: responseTime,
         successRate: success ? 1 : 0,
-        callCount: 1
+        callCount: 1,
       };
     } else {
       const perf = this.metrics.tools.toolPerformance[toolName];
       const totalCalls = perf.callCount + 1;
-      
+
       // Update average time
-      perf.averageTime = (perf.averageTime * perf.callCount + responseTime) / totalCalls;
-      
+      perf.averageTime =
+        (perf.averageTime * perf.callCount + responseTime) / totalCalls;
+
       // Update success rate
-      const totalSuccess = perf.successRate * perf.callCount + (success ? 1 : 0);
+      const totalSuccess =
+        perf.successRate * perf.callCount + (success ? 1 : 0);
       perf.successRate = totalSuccess / totalCalls;
-      
+
       perf.callCount = totalCalls;
     }
 
     // Update most used tool
     const usageCounts = this.metrics.tools.toolUsageCount;
-    this.metrics.tools.mostUsedTool = Object.keys(usageCounts)
-      .reduce((a, b) => usageCounts[a] > usageCounts[b] ? a : b);
+    this.metrics.tools.mostUsedTool = Object.keys(usageCounts).reduce((a, b) =>
+      usageCounts[a] > usageCounts[b] ? a : b,
+    );
   }
 
   /**
@@ -382,22 +396,23 @@ export class PerformanceMonitor {
 
     const sorted = [...this.responseTimes].sort((a, b) => a - b);
     const total = this.metrics.requests.total;
-    
-    this.metrics.requests.averageResponseTime = 
-      this.responseTimes.reduce((sum, time) => sum + time, 0) / this.responseTimes.length;
-    
+
+    this.metrics.requests.averageResponseTime =
+      this.responseTimes.reduce((sum, time) => sum + time, 0) /
+      this.responseTimes.length;
+
     this.metrics.requests.minResponseTime = sorted[0];
     this.metrics.requests.maxResponseTime = sorted[sorted.length - 1];
-    
+
     // Calculate percentiles
     this.metrics.requests.p50ResponseTime = this.getPercentile(sorted, 0.5);
     this.metrics.requests.p95ResponseTime = this.getPercentile(sorted, 0.95);
     this.metrics.requests.p99ResponseTime = this.getPercentile(sorted, 0.99);
-    
+
     // Calculate requests per second
     const uptime = (Date.now() - this.startTime) / 1000;
     this.metrics.requests.requestsPerSecond = total / uptime;
-    
+
     // Limit response time history to prevent memory growth
     if (this.responseTimes.length > 10000) {
       this.responseTimes = this.responseTimes.slice(-5000);
@@ -434,33 +449,45 @@ export class PerformanceMonitor {
    */
   private checkPerformanceAlerts(): void {
     const thresholds = this.config.alertThresholds;
-    
+
     // Response time alert
     if (this.metrics.requests.averageResponseTime > thresholds.responseTime) {
-      this.addAlert('warning', 'performance', 
+      this.addAlert(
+        "warning",
+        "performance",
         `High response time: ${this.metrics.requests.averageResponseTime}ms`,
-        'averageResponseTime', thresholds.responseTime, 
+        "averageResponseTime",
+        thresholds.responseTime,
         this.metrics.requests.averageResponseTime,
-        'Consider enabling caching or optimizing queries'
+        "Consider enabling caching or optimizing queries",
       );
     }
 
     // Error rate alert
-    const errorRate = this.metrics.requests.failed / this.metrics.requests.total;
+    const errorRate =
+      this.metrics.requests.failed / this.metrics.requests.total;
     if (errorRate > thresholds.errorRate) {
-      this.addAlert('error', 'performance',
+      this.addAlert(
+        "error",
+        "performance",
         `High error rate: ${Math.round(errorRate * 100)}%`,
-        'errorRate', thresholds.errorRate, errorRate,
-        'Check WordPress connectivity and authentication'
+        "errorRate",
+        thresholds.errorRate,
+        errorRate,
+        "Check WordPress connectivity and authentication",
       );
     }
 
     // Cache hit rate alert
     if (this.metrics.cache.hitRate < thresholds.cacheHitRate) {
-      this.addAlert('warning', 'cache',
+      this.addAlert(
+        "warning",
+        "cache",
         `Low cache hit rate: ${Math.round(this.metrics.cache.hitRate * 100)}%`,
-        'cacheHitRate', thresholds.cacheHitRate, this.metrics.cache.hitRate,
-        'Consider cache warming or adjusting TTL values'
+        "cacheHitRate",
+        thresholds.cacheHitRate,
+        this.metrics.cache.hitRate,
+        "Consider cache warming or adjusting TTL values",
       );
     }
   }
@@ -469,13 +496,13 @@ export class PerformanceMonitor {
    * Add performance alert
    */
   private addAlert(
-    severity: 'info' | 'warning' | 'error' | 'critical',
-    category: 'performance' | 'cache' | 'system' | 'wordpress',
+    severity: "info" | "warning" | "error" | "critical",
+    category: "performance" | "cache" | "system" | "wordpress",
     message: string,
     metric: string,
     threshold: number,
     actualValue: number,
-    suggestion?: string
+    suggestion?: string,
   ): void {
     const alert: PerformanceAlert = {
       id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -486,11 +513,11 @@ export class PerformanceMonitor {
       metric,
       threshold,
       actualValue,
-      ...(suggestion && { suggestion })
+      ...(suggestion && { suggestion }),
     };
 
     this.alerts.push(alert);
-    
+
     // Limit alert history
     if (this.alerts.length > 1000) {
       this.alerts = this.alerts.slice(-500);
@@ -500,44 +527,49 @@ export class PerformanceMonitor {
   /**
    * Calculate overall system health
    */
-  private calculateOverallHealth(metrics: PerformanceMetrics): 'excellent' | 'good' | 'warning' | 'critical' {
+  private calculateOverallHealth(
+    metrics: PerformanceMetrics,
+  ): "excellent" | "good" | "warning" | "critical" {
     let score = 100;
-    
+
     // Response time impact
     if (metrics.requests.averageResponseTime > 3000) score -= 30;
     else if (metrics.requests.averageResponseTime > 1000) score -= 15;
-    
+
     // Error rate impact
     const errorRate = metrics.requests.failed / metrics.requests.total;
     if (errorRate > 0.1) score -= 40;
     else if (errorRate > 0.05) score -= 20;
-    
+
     // Cache performance impact
     if (metrics.cache.hitRate < 0.5) score -= 25;
     else if (metrics.cache.hitRate < 0.8) score -= 10;
-    
+
     // System resource impact
     if (metrics.system.memoryUsage > 90) score -= 20;
     else if (metrics.system.memoryUsage > 80) score -= 10;
-    
-    if (score >= 90) return 'excellent';
-    if (score >= 75) return 'good';
-    if (score >= 50) return 'warning';
-    return 'critical';
+
+    if (score >= 90) return "excellent";
+    if (score >= 75) return "good";
+    if (score >= 50) return "warning";
+    return "critical";
   }
 
   /**
    * Generate performance summary
    */
   private generateSummary(metrics: PerformanceMetrics): string {
-    const errorRate = metrics.requests.total > 0 
-      ? (metrics.requests.failed / metrics.requests.total * 100).toFixed(1)
-      : '0';
-    
-    return `Performance Summary: ${metrics.requests.total} requests processed with ${errorRate}% error rate. ` +
-           `Average response time: ${metrics.requests.averageResponseTime.toFixed(0)}ms. ` +
-           `Cache hit rate: ${(metrics.cache.hitRate * 100).toFixed(1)}%. ` +
-           `System uptime: ${Math.round(metrics.system.uptime / 1000 / 60)} minutes.`;
+    const errorRate =
+      metrics.requests.total > 0
+        ? ((metrics.requests.failed / metrics.requests.total) * 100).toFixed(1)
+        : "0";
+
+    return (
+      `Performance Summary: ${metrics.requests.total} requests processed with ${errorRate}% error rate. ` +
+      `Average response time: ${metrics.requests.averageResponseTime.toFixed(0)}ms. ` +
+      `Cache hit rate: ${(metrics.cache.hitRate * 100).toFixed(1)}%. ` +
+      `System uptime: ${Math.round(metrics.system.uptime / 1000 / 60)} minutes.`
+    );
   }
 
   /**
@@ -545,24 +577,26 @@ export class PerformanceMonitor {
    */
   private generateRecommendations(metrics: PerformanceMetrics): string[] {
     const recommendations: string[] = [];
-    
+
     if (metrics.requests.averageResponseTime > 1000) {
-      recommendations.push('Enable caching to reduce response times');
+      recommendations.push("Enable caching to reduce response times");
     }
-    
+
     if (metrics.cache.hitRate < 0.8) {
-      recommendations.push('Warm cache with frequently accessed data');
+      recommendations.push("Warm cache with frequently accessed data");
     }
-    
+
     if (metrics.system.memoryUsage > 80) {
-      recommendations.push('Consider increasing memory allocation or cache size limits');
+      recommendations.push(
+        "Consider increasing memory allocation or cache size limits",
+      );
     }
-    
+
     const errorRate = metrics.requests.failed / metrics.requests.total;
     if (errorRate > 0.05) {
-      recommendations.push('Review error logs and improve error handling');
+      recommendations.push("Review error logs and improve error handling");
     }
-    
+
     return recommendations;
   }
 
@@ -571,28 +605,28 @@ export class PerformanceMonitor {
    */
   private generateTrends(): string[] {
     if (this.historicalData.length < 2) {
-      return ['Insufficient data for trend analysis'];
+      return ["Insufficient data for trend analysis"];
     }
-    
+
     const trends: string[] = [];
     const recent = this.historicalData.slice(-5);
-    
+
     // Response time trend
-    const responseTimes = recent.map(d => d.requests.averageResponseTime);
+    const responseTimes = recent.map((d) => d.requests.averageResponseTime);
     if (this.isIncreasing(responseTimes)) {
-      trends.push('Response times are increasing');
+      trends.push("Response times are increasing");
     } else if (this.isDecreasing(responseTimes)) {
-      trends.push('Response times are improving');
+      trends.push("Response times are improving");
     }
-    
+
     // Cache hit rate trend
-    const hitRates = recent.map(d => d.cache.hitRate);
+    const hitRates = recent.map((d) => d.cache.hitRate);
     if (this.isIncreasing(hitRates)) {
-      trends.push('Cache performance is improving');
+      trends.push("Cache performance is improving");
     } else if (this.isDecreasing(hitRates)) {
-      trends.push('Cache performance is declining');
+      trends.push("Cache performance is declining");
     }
-    
+
     return trends;
   }
 
@@ -623,7 +657,7 @@ export class PerformanceMonitor {
     // Simplified CSV conversion for metrics
     const metrics = data.currentMetrics;
     const csv = [
-      'Metric,Value',
+      "Metric,Value",
       `Total Requests,${metrics.requests.total}`,
       `Successful Requests,${metrics.requests.successful}`,
       `Failed Requests,${metrics.requests.failed}`,
@@ -631,10 +665,10 @@ export class PerformanceMonitor {
       `Cache Hit Rate,${metrics.cache.hitRate}`,
       `Cache Size,${metrics.cache.totalSize}`,
       `Memory Usage,${metrics.system.memoryUsage}%`,
-      `Uptime,${metrics.system.uptime}ms`
+      `Uptime,${metrics.system.uptime}ms`,
     ];
-    
-    return csv.join('\n');
+
+    return csv.join("\n");
   }
 
   /**
@@ -643,7 +677,7 @@ export class PerformanceMonitor {
   private cleanupOldData(): void {
     const cutoff = Date.now() - this.config.retentionPeriod;
     this.historicalData = this.historicalData.filter(
-      data => data.system.uptime > cutoff
+      (data) => data.system.uptime > cutoff,
     );
   }
 }

package/src/performance/index.ts

@@ -3,26 +3,26 @@
  * Central export point for all performance monitoring components
  */
 
-export { PerformanceMonitor } from './PerformanceMonitor.js';
-export { MetricsCollector } from './MetricsCollector.js';
-export { PerformanceAnalytics } from './PerformanceAnalytics.js';
+export { PerformanceMonitor } from "./PerformanceMonitor.js";
+export { MetricsCollector } from "./MetricsCollector.js";
+export { PerformanceAnalytics } from "./PerformanceAnalytics.js";
 
 export type {
   PerformanceMetrics,
   PerformanceAlert,
-  PerformanceConfig
-} from './PerformanceMonitor.js';
+  PerformanceConfig,
+} from "./PerformanceMonitor.js";
 
 export type {
   CollectorConfig,
   RequestMetadata,
-  ToolExecutionContext
-} from './MetricsCollector.js';
+  ToolExecutionContext,
+} from "./MetricsCollector.js";
 
 export type {
   AnalyticsConfig,
   PerformanceTrend,
   PerformanceAnomaly,
   PerformanceInsight,
-  BenchmarkComparison
-} from './PerformanceAnalytics.js';
+  BenchmarkComparison,
+} from "./PerformanceAnalytics.js";