mcp-wordpress 2.4.2 → 2.5.0

package/src/performance/PerformanceAnalytics.ts

@@ -100,10 +100,7 @@ export class PerformanceAnalytics {
     },
   };
 
-  constructor(
-    collector: MetricsCollector,
-    config: Partial<AnalyticsConfig> = {},
-  ) {
+  constructor(collector: MetricsCollector, config: Partial<AnalyticsConfig> = {}) {
     this.collector = collector;
     this.config = {
       enablePredictiveAnalysis: true,
@@ -123,9 +120,7 @@ export class PerformanceAnalytics {
 
     // 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) {
@@ -163,9 +158,7 @@ export class PerformanceAnalytics {
     trends.push(
       this.analyzeTrend(
         "errorRate",
-        this.historicalData.map((d) =>
-          d.requests.total > 0 ? d.requests.failed / d.requests.total : 0,
-        ),
+        this.historicalData.map((d) => (d.requests.total > 0 ? d.requests.failed / d.requests.total : 0)),
       ),
     );
 
@@ -205,8 +198,7 @@ export class PerformanceAnalytics {
         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.",
+        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"],
@@ -222,8 +214,7 @@ export class PerformanceAnalytics {
         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.",
+        recommendation: "Enable aggressive caching, optimize database queries, or consider upgrading server resources.",
         estimatedImprovement: "50-70% reduction in response times",
         implementationEffort: "medium",
         relatedMetrics: ["responseTime", "cacheHitRate"],
@@ -239,8 +230,7 @@ export class PerformanceAnalytics {
         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.",
+        recommendation: "Increase cache size limits, implement cache eviction policies, or scale server resources.",
         estimatedImprovement: "Improved system stability",
         implementationEffort: "low",
         relatedMetrics: ["memoryUsage", "cacheSize"],
@@ -261,8 +251,7 @@ export class PerformanceAnalytics {
         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.",
+        recommendation: "Create cached workflows or batch operations for frequently used tools.",
         estimatedImprovement: "10-20% reduction in API calls",
         implementationEffort: "high",
         relatedMetrics: ["toolUsage", "requestVolume"],
@@ -271,11 +260,7 @@ export class PerformanceAnalytics {
 
     // Trend-based insights
     const responseTimeTrend = trends.find((t) => t.metric === "responseTime");
-    if (
-      responseTimeTrend &&
-      responseTimeTrend.direction === "declining" &&
-      responseTimeTrend.changeRate > 10
-    ) {
+    if (responseTimeTrend && responseTimeTrend.direction === "declining" && responseTimeTrend.changeRate > 10) {
       insights.push({
         id: "trend-response-time-1",
         category: "alert",
@@ -283,8 +268,7 @@ export class PerformanceAnalytics {
         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.",
+        recommendation: "Investigate recent changes, check WordPress site health, and monitor resource usage.",
         estimatedImprovement: "Prevent further degradation",
         implementationEffort: "medium",
         relatedMetrics: ["responseTime", "errorRate"],
@@ -317,31 +301,19 @@ export class PerformanceAnalytics {
       this.createBenchmarkComparison(
         "Cache Hit Rate",
         currentMetrics.cache.hitRate * 100,
-        Object.fromEntries(
-          Object.entries(this.benchmarks.cacheHitRate).map(([k, v]) => [
-            k,
-            v * 100,
-          ]),
-        ),
+        Object.fromEntries(Object.entries(this.benchmarks.cacheHitRate).map(([k, v]) => [k, v * 100])),
         true, // higher is better
       ),
     );
 
     // Error rate benchmark
     const errorRate =
-      currentMetrics.requests.total > 0
-        ? (currentMetrics.requests.failed / currentMetrics.requests.total) * 100
-        : 0;
+      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,
-          ]),
-        ),
+        Object.fromEntries(Object.entries(this.benchmarks.errorRate).map(([k, v]) => [k, v * 100])),
         false, // lower is better
       ),
     );
@@ -377,7 +349,13 @@ export class PerformanceAnalytics {
     }
 
     const trends = this.analyzeTrends();
-    const predictions: any[] = [];
+    const predictions: Array<{
+      metric: string;
+      currentValue: number;
+      predictedValue: number;
+      confidence: number;
+      trend: "improving" | "declining" | "stable";
+    }> = [];
     const alerts: string[] = [];
 
     for (const trend of trends) {
@@ -393,34 +371,16 @@ export class PerformanceAnalytics {
       });
 
       // Generate alerts for concerning predictions
-      if (
-        trend.metric === "responseTime" &&
-        predictedValue > 2000 &&
-        trend.direction === "declining"
-      ) {
-        alerts.push(
-          `Response times predicted to exceed 2s in ${timeframeMinutes} minutes`,
-        );
+      if (trend.metric === "responseTime" && predictedValue > 2000 && trend.direction === "declining") {
+        alerts.push(`Response times predicted to exceed 2s in ${timeframeMinutes} minutes`);
       }
 
-      if (
-        trend.metric === "cacheHitRate" &&
-        predictedValue < 0.5 &&
-        trend.direction === "declining"
-      ) {
-        alerts.push(
-          `Cache hit rate predicted to drop below 50% in ${timeframeMinutes} minutes`,
-        );
+      if (trend.metric === "cacheHitRate" && predictedValue < 0.5 && trend.direction === "declining") {
+        alerts.push(`Cache hit rate predicted to drop below 50% in ${timeframeMinutes} minutes`);
       }
 
-      if (
-        trend.metric === "memoryUsage" &&
-        predictedValue > 90 &&
-        trend.direction === "declining"
-      ) {
-        alerts.push(
-          `Memory usage predicted to exceed 90% in ${timeframeMinutes} minutes`,
-        );
+      if (trend.metric === "memoryUsage" && predictedValue > 90 && trend.direction === "declining") {
+        alerts.push(`Memory usage predicted to exceed 90% in ${timeframeMinutes} minutes`);
       }
     }
 
@@ -443,14 +403,10 @@ export class PerformanceAnalytics {
     const insights = this.generateInsights();
 
     const quickWins = insights.filter(
-      (i) =>
-        i.implementationEffort === "low" &&
-        ["high", "critical"].includes(i.priority),
+      (i) => i.implementationEffort === "low" && ["high", "critical"].includes(i.priority),
     );
 
-    const mediumTerm = insights.filter(
-      (i) => i.implementationEffort === "medium",
-    );
+    const mediumTerm = insights.filter((i) => i.implementationEffort === "medium");
 
     const longTerm = insights.filter((i) => i.implementationEffort === "high");
 
@@ -468,12 +424,7 @@ export class PerformanceAnalytics {
       longTerm,
       estimatedROI: {
         performanceGain: Math.min(estimatedGain, 80), // Cap at 80%
-        implementationCost:
-          quickWins.length > 2
-            ? "low"
-            : mediumTerm.length > 2
-              ? "medium"
-              : "high",
+        implementationCost: quickWins.length > 2 ? "low" : mediumTerm.length > 2 ? "medium" : "high",
         timeToValue: quickWins.length > 0 ? 1 : mediumTerm.length > 0 ? 7 : 30,
       },
     };
@@ -504,8 +455,14 @@ export class PerformanceAnalytics {
     benchmarks: BenchmarkComparison[];
     insights: PerformanceInsight[];
     anomalies: PerformanceAnomaly[];
-    predictions: any;
-    optimizationPlan: any;
+    predictions: Array<{
+      metric: string;
+      currentValue: number;
+      predictedValue: number;
+      confidence: number;
+      trend: "improving" | "declining" | "stable";
+    }>;
+    optimizationPlan: Record<string, unknown>;
   } {
     const currentMetrics = this.collector.collectCurrentMetrics();
     const performanceScore = this.calculatePerformanceScore(currentMetrics);
@@ -515,16 +472,14 @@ export class PerformanceAnalytics {
       summary: {
         overallHealth: this.calculateOverallHealth(performanceScore),
         keyInsights: this.generatedInsights.length,
-        criticalAlerts: this.generatedInsights.filter(
-          (i) => i.priority === "critical",
-        ).length,
+        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(),
+      predictions: this.predictPerformance().predictions,
       optimizationPlan: this.generateOptimizationPlan(),
     };
   }
@@ -562,9 +517,7 @@ export class PerformanceAnalytics {
 
     // 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 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;
@@ -577,8 +530,7 @@ export class PerformanceAnalytics {
     // 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;
+    const changeRate = Math.abs((currentValue - previousValue) / previousValue) * 100;
 
     let direction: "improving" | "declining" | "stable" = "stable";
     if (Math.abs(slope) > 0.1) {
@@ -626,27 +578,12 @@ export class PerformanceAnalytics {
 
     // 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",
-    );
+    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 currentErrorRate =
-      metrics.requests.total > 0
-        ? metrics.requests.failed / metrics.requests.total
-        : 0;
-    this.checkMetricAnomaly(
-      "errorRate",
-      currentErrorRate,
-      errorRates,
-      "Error rate spike detected",
-    );
+    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");
   }
 
   /**
@@ -660,11 +597,8 @@ export class PerformanceAnalytics {
   ): void {
     if (historicalValues.length < 5) return;
 
-    const mean =
-      historicalValues.reduce((a, b) => a + b, 0) / historicalValues.length;
-    const variance =
-      historicalValues.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) /
-      historicalValues.length;
+    const mean = historicalValues.reduce((a, b) => a + b, 0) / historicalValues.length;
+    const variance = historicalValues.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / historicalValues.length;
     const standardDeviation = Math.sqrt(variance);
 
     // Calculate z-score
@@ -690,10 +624,7 @@ export class PerformanceAnalytics {
         actualValue: currentValue,
         deviation,
         severity,
-        possibleCauses: this.generatePossibleCauses(
-          metricName,
-          currentValue > mean,
-        ),
+        possibleCauses: this.generatePossibleCauses(metricName, currentValue > mean),
       };
 
       this.detectedAnomalies.push(anomaly);
@@ -708,33 +639,15 @@ export class PerformanceAnalytics {
   /**
    * Generate possible causes for anomalies
    */
-  private generatePossibleCauses(
-    metricName: string,
-    isIncrease: boolean,
-  ): string[] {
+  private generatePossibleCauses(metricName: string, isIncrease: boolean): string[] {
     const causes: string[] = [];
 
     if (metricName === "responseTime" && isIncrease) {
-      causes.push(
-        "High server load",
-        "Database performance issues",
-        "Network latency",
-        "Cache miss increase",
-      );
+      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",
-      );
+      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",
-      );
+      causes.push("WordPress site issues", "Authentication problems", "Network connectivity", "Plugin conflicts");
     }
 
     return causes;
@@ -746,39 +659,36 @@ export class PerformanceAnalytics {
   private createBenchmarkComparison(
     category: string,
     currentValue: number,
-    benchmarks: any,
+    benchmarks: Record<string, unknown>,
     higherIsBetter: boolean,
   ): BenchmarkComparison {
-    let status: "excellent" | "good" | "average" | "below_average" | "poor" =
-      "poor";
+    let status: "excellent" | "good" | "average" | "below_average" | "poor" = "poor";
     let percentile = 0;
     let improvement = 0;
 
     if (higherIsBetter) {
-      if (currentValue >= benchmarks.excellent) status = "excellent";
-      else if (currentValue >= benchmarks.good) status = "good";
-      else if (currentValue >= benchmarks.average) status = "average";
-      else if (currentValue >= benchmarks.below_average)
-        status = "below_average";
+      if (currentValue >= (benchmarks.excellent as number)) status = "excellent";
+      else if (currentValue >= (benchmarks.good as number)) status = "good";
+      else if (currentValue >= (benchmarks.average as number)) status = "average";
+      else if (currentValue >= (benchmarks.below_average as number)) status = "below_average";
 
       // Calculate improvement needed
       if (status !== "excellent") {
         const nextTier =
           status === "good"
-            ? benchmarks.excellent
+            ? (benchmarks.excellent as number)
             : status === "average"
-              ? benchmarks.good
+              ? (benchmarks.good as number)
               : status === "below_average"
-                ? benchmarks.average
-                : benchmarks.below_average;
+                ? (benchmarks.average as number)
+                : (benchmarks.below_average as number);
         improvement = nextTier - currentValue;
       }
     } else {
-      if (currentValue <= benchmarks.excellent) status = "excellent";
-      else if (currentValue <= benchmarks.good) status = "good";
-      else if (currentValue <= benchmarks.average) status = "average";
-      else if (currentValue <= benchmarks.below_average)
-        status = "below_average";
+      if (currentValue <= (benchmarks.excellent as number)) status = "excellent";
+      else if (currentValue <= (benchmarks.good as number)) status = "good";
+      else if (currentValue <= (benchmarks.average as number)) status = "average";
+      else if (currentValue <= (benchmarks.below_average as number)) status = "below_average";
 
       // Calculate improvement needed
       if (status !== "excellent") {
@@ -790,7 +700,7 @@ export class PerformanceAnalytics {
               : status === "below_average"
                 ? benchmarks.average
                 : benchmarks.below_average;
-        improvement = currentValue - nextTier;
+        improvement = currentValue - (nextTier as number);
       }
     }
 
@@ -809,7 +719,7 @@ export class PerformanceAnalytics {
     return {
       category,
       currentValue,
-      benchmarkValue: benchmarks.excellent,
+      benchmarkValue: benchmarks.excellent as number,
       percentile,
       status,
       improvement,
@@ -828,9 +738,7 @@ export class PerformanceAnalytics {
       case "cacheHitRate":
         return current.cache.hitRate;
       case "errorRate":
-        return current.requests.total > 0
-          ? current.requests.failed / current.requests.total
-          : 0;
+        return current.requests.total > 0 ? current.requests.failed / current.requests.total : 0;
       case "memoryUsage":
         return current.system.memoryUsage;
       case "requestVolume":
@@ -852,10 +760,7 @@ 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) score -= 15;
     else if (errorRate > 0.01) score -= 5;

package/src/performance/PerformanceMonitor.ts

@@ -3,6 +3,8 @@
  * Collects, analyzes, and reports performance metrics
  */
 
+import { ConfigHelpers } from "../config/Config.js";
+
 export interface PerformanceMetrics {
   // Request Performance
   requests: {
@@ -121,7 +123,8 @@ export class PerformanceMonitor {
 
     this.metrics = this.initializeMetrics();
 
-    if (this.config.enableRealTimeMonitoring) {
+    // Don't start collection in test environment to avoid timer issues
+    if (this.config.enableRealTimeMonitoring && !ConfigHelpers.isTest()) {
       this.startCollection();
     }
   }
@@ -177,11 +180,7 @@ export class PerformanceMonitor {
   /**
    * 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) {
@@ -208,14 +207,14 @@ export class PerformanceMonitor {
   /**
    * Update cache metrics from cache manager
    */
-  updateCacheMetrics(cacheStats: any): void {
+  updateCacheMetrics(cacheStats: Record<string, unknown>): void {
     this.metrics.cache = {
-      hits: cacheStats.hits || 0,
-      misses: cacheStats.misses || 0,
-      hitRate: cacheStats.hitRate || 0,
-      totalSize: cacheStats.totalSize || 0,
-      memoryUsageMB: this.estimateCacheMemoryUsage(cacheStats.totalSize),
-      evictions: cacheStats.evictions || 0,
+      hits: (cacheStats.hits as number) || 0,
+      misses: (cacheStats.misses as number) || 0,
+      hitRate: (cacheStats.hitRate as number) || 0,
+      totalSize: (cacheStats.totalSize as number) || 0,
+      memoryUsageMB: this.estimateCacheMemoryUsage((cacheStats.totalSize as number) || 0),
+      evictions: (cacheStats.evictions as number) || 0,
       averageCacheTime: 0.5, // Sub-millisecond average
     };
   }
@@ -246,10 +245,7 @@ export class PerformanceMonitor {
   /**
    * Get historical performance data
    */
-  getHistoricalData(
-    startTime?: number,
-    endTime?: number,
-  ): PerformanceMetrics[] {
+  getHistoricalData(startTime?: number, endTime?: number): PerformanceMetrics[] {
     if (!this.config.enableHistoricalData) {
       return [];
     }
@@ -317,7 +313,7 @@ export class PerformanceMonitor {
     };
 
     if (format === "csv") {
-      return this.convertToCSV(data);
+      return this.convertToCSV([data] as Record<string, unknown>[]);
     }
 
     return JSON.stringify(data, null, 2);
@@ -325,6 +321,7 @@ export class PerformanceMonitor {
 
   /**
    * Start automatic metric collection
+   * Note: This uses setInterval and is not called in test environments to avoid Jest timer issues
    */
   private startCollection(): void {
     this.collectionTimer = setInterval(() => {
@@ -349,14 +346,9 @@ 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] || 0) + 1;
+    this.metrics.tools.toolUsageCount[toolName] = (this.metrics.tools.toolUsageCount[toolName] || 0) + 1;
 
     // Update performance metrics
     if (!this.metrics.tools.toolPerformance[toolName]) {
@@ -370,12 +362,10 @@ export class PerformanceMonitor {
       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;
@@ -398,8 +388,7 @@ export class PerformanceMonitor {
     const total = this.metrics.requests.total;
 
     this.metrics.requests.averageResponseTime =
-      this.responseTimes.reduce((sum, time) => sum + time, 0) /
-      this.responseTimes.length;
+      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];
@@ -464,8 +453,7 @@ export class PerformanceMonitor {
     }
 
     // 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",
@@ -527,9 +515,7 @@ 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
@@ -560,9 +546,7 @@ export class PerformanceMonitor {
    */
   private generateSummary(metrics: PerformanceMetrics): string {
     const errorRate =
-      metrics.requests.total > 0
-        ? ((metrics.requests.failed / metrics.requests.total) * 100).toFixed(1)
-        : "0";
+      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. ` +
@@ -587,9 +571,7 @@ export class PerformanceMonitor {
     }
 
     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;
@@ -653,9 +635,14 @@ export class PerformanceMonitor {
   /**
    * Convert data to CSV format
    */
-  private convertToCSV(data: any): string {
+  private convertToCSV(data: Record<string, unknown>[]): string {
     // Simplified CSV conversion for metrics
-    const metrics = data.currentMetrics;
+    const reportData = data[0];
+    const metrics = reportData?.currentMetrics as {
+      requests: { total: number; successful: number; failed: number; averageResponseTime: number };
+      cache: { hitRate: number; totalSize: number };
+      system: { memoryUsage: number; uptime: number };
+    };
     const csv = [
       "Metric,Value",
       `Total Requests,${metrics.requests.total}`,
@@ -676,8 +663,6 @@ export class PerformanceMonitor {
    */
   private cleanupOldData(): void {
     const cutoff = Date.now() - this.config.retentionPeriod;
-    this.historicalData = this.historicalData.filter(
-      (data) => data.system.uptime > cutoff,
-    );
+    this.historicalData = this.historicalData.filter((data) => data.system.uptime > cutoff);
   }
 }

package/src/performance/index.ts

@@ -7,17 +7,9 @@ export { PerformanceMonitor } from "./PerformanceMonitor.js";
 export { MetricsCollector } from "./MetricsCollector.js";
 export { PerformanceAnalytics } from "./PerformanceAnalytics.js";
 
-export type {
-  PerformanceMetrics,
-  PerformanceAlert,
-  PerformanceConfig,
-} from "./PerformanceMonitor.js";
+export type { PerformanceMetrics, PerformanceAlert, PerformanceConfig } from "./PerformanceMonitor.js";
 
-export type {
-  CollectorConfig,
-  RequestMetadata,
-  ToolExecutionContext,
-} from "./MetricsCollector.js";
+export type { CollectorConfig, RequestMetadata, ToolExecutionContext } from "./MetricsCollector.js";
 
 export type {
   AnalyticsConfig,