0xray 2.1.2 → 2.1.3

package/src/mcps/knowledge-skills/performance-optimization.server.ts

@@ -5,14 +5,8 @@
  * profiling, benchmarking, memory analysis, and Core Web Vitals measurement
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger, generateJobId } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 import fs from "fs";
 import path from "path";
 import os from "os";
@@ -217,144 +211,101 @@ interface McpToolResponse {
   data?: Record<string, unknown>;
 }
 
-class XrayPerformanceOptimizationServer {
-  private server: Server;
-  private startTime: number;
-
+class XrayPerformanceOptimizationServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("performance-optimization", "2.0.1");
+    this.tools = [
       {
-        name: "performance-optimization", version: "2.0.1",
+        name: "profile-application",
+        description: "Run comprehensive performance profiling on the codebase to identify bottlenecks and hot paths",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string", description: "Path to the project root directory" },
+            scope: {
+              type: "string",
+              enum: ["full", "runtime", "build", "memory"],
+              default: "full",
+              description: "Scope of profiling analysis"
+            },
+            duration: { type: "number", default: 30, description: "Profiling duration in seconds" },
+            includeHotPaths: { type: "boolean", default: true, description: "Include hot path analysis" }
+          },
+          required: ["projectRoot"]
+        }
       },
       {
-        capabilities: {
-          tools: {},
-        },
-      },
-    );
-
-    this.startTime = Date.now();
-    this.setupToolHandlers();
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "profile-application",
-            description: "Run comprehensive performance profiling on the codebase to identify bottlenecks and hot paths",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string", description: "Path to the project root directory" },
-                scope: {
-                  type: "string",
-                  enum: ["full", "runtime", "build", "memory"],
-                  default: "full",
-                  description: "Scope of profiling analysis"
-                },
-                duration: { type: "number", default: 30, description: "Profiling duration in seconds" },
-                includeHotPaths: { type: "boolean", default: true, description: "Include hot path analysis" }
-              },
-              required: ["projectRoot"]
-            }
+        name: "analyze-memory",
+        description: "Perform memory leak detection and heap analysis to identify memory issues",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string", description: "Path to the project root directory" },
+            heapSnapshot: { type: "boolean", default: true, description: "Generate heap snapshot analysis" },
+            gcAnalysis: { type: "boolean", default: true, description: "Analyze garbage collection patterns" },
+            leakDetection: { type: "boolean", default: true, description: "Detect potential memory leaks" }
           },
-          {
-            name: "analyze-memory",
-            description: "Perform memory leak detection and heap analysis to identify memory issues",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string", description: "Path to the project root directory" },
-                heapSnapshot: { type: "boolean", default: true, description: "Generate heap snapshot analysis" },
-                gcAnalysis: { type: "boolean", default: true, description: "Analyze garbage collection patterns" },
-                leakDetection: { type: "boolean", default: true, description: "Detect potential memory leaks" }
-              },
-              required: ["projectRoot"]
-            }
+          required: ["projectRoot"]
+        }
+      },
+      {
+        name: "benchmark-code",
+        description: "Execute and compare benchmark results for code performance measurement",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string", description: "Path to the project root directory" },
+            testFile: { type: "string", description: "Specific benchmark test file to run" },
+            iterations: { type: "number", default: 100, description: "Number of benchmark iterations" },
+            warmupRuns: { type: "number", default: 10, description: "Number of warmup runs" },
+            compareBaseline: { type: "boolean", default: false, description: "Compare results against baseline" }
           },
-          {
-            name: "benchmark-code",
-            description: "Execute and compare benchmark results for code performance measurement",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string", description: "Path to the project root directory" },
-                testFile: { type: "string", description: "Specific benchmark test file to run" },
-                iterations: { type: "number", default: 100, description: "Number of benchmark iterations" },
-                warmupRuns: { type: "number", default: 10, description: "Number of warmup runs" },
-                compareBaseline: { type: "boolean", default: false, description: "Compare results against baseline" }
-              },
-              required: ["projectRoot"]
-            }
+          required: ["projectRoot"]
+        }
+      },
+      {
+        name: "suggest-optimizations",
+        description: "Generate specific, actionable optimization suggestions based on code analysis",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string", description: "Path to the project root directory" },
+            focus: {
+              type: "string",
+              enum: ["cpu", "memory", "network", "io", "all"],
+              default: "all",
+              description: "Focus area for optimizations"
+            },
+            threshold: { type: "number", default: 100, description: "Performance threshold in ms" }
           },
-          {
-            name: "suggest-optimizations",
-            description: "Generate specific, actionable optimization suggestions based on code analysis",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string", description: "Path to the project root directory" },
-                focus: {
-                  type: "string",
-                  enum: ["cpu", "memory", "network", "io", "all"],
-                  default: "all",
-                  description: "Focus area for optimizations"
-                },
-                threshold: { type: "number", default: 100, description: "Performance threshold in ms" }
-              },
-              required: ["projectRoot"]
-            }
+          required: ["projectRoot"]
+        }
+      },
+      {
+        name: "measure-core-web-vitals",
+        description: "Analyze Core Web Vitals metrics (LCP, INP, CLS) for web application performance",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string", description: "Path to the project root directory" },
+            analyzeBundle: { type: "boolean", default: true, description: "Analyze JavaScript bundle" },
+            checkAccessibility: { type: "boolean", default: true, description: "Check accessibility factors affecting CLS" },
+            measureLCP: { type: "boolean", default: true, description: "Measure Largest Contentful Paint" },
+            measureINP: { type: "boolean", default: true, description: "Measure Interaction to Next Paint" },
+            measureCLS: { type: "boolean", default: true, description: "Measure Cumulative Layout Shift" }
           },
-          {
-            name: "measure-core-web-vitals",
-            description: "Analyze Core Web Vitals metrics (LCP, INP, CLS) for web application performance",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string", description: "Path to the project root directory" },
-                analyzeBundle: { type: "boolean", default: true, description: "Analyze JavaScript bundle" },
-                checkAccessibility: { type: "boolean", default: true, description: "Check accessibility factors affecting CLS" },
-                measureLCP: { type: "boolean", default: true, description: "Measure Largest Contentful Paint" },
-                measureINP: { type: "boolean", default: true, description: "Measure Interaction to Next Paint" },
-                measureCLS: { type: "boolean", default: true, description: "Measure Cumulative Layout Shift" }
-              },
-              required: ["projectRoot"]
-            }
-          }
-        ]
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "profile-application":
-            return await this.handleProfileApplication(args as unknown as ProfileApplicationArgs) as never;
-          case "analyze-memory":
-            return await this.handleAnalyzeMemory(args as unknown as AnalyzeMemoryArgs) as never;
-          case "benchmark-code":
-            return await this.handleBenchmarkCode(args as unknown as BenchmarkCodeArgs) as never;
-          case "suggest-optimizations":
-            return await this.handleSuggestOptimizations(args as unknown as SuggestOptimizationsArgs) as never;
-          case "measure-core-web-vitals":
-            return await this.handleMeasureCoreWebVitals(args as unknown as MeasureCoreWebVitalsArgs) as never;
-          default:
-            throw new Error(`Unknown tool: ${name}`);
+          required: ["projectRoot"]
         }
-      } catch (error) {
-        frameworkLogger.log("mcp/performance-optimization", "tool-handler", "error", { tool: name, error: String(error) });
-        return {
-          content: [{
-            type: "text",
-            text: `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`
-          }]
-        };
       }
-    });
+    ];
+    this.handlers = {
+      "profile-application": async (args) => this.handleProfileApplication(args as unknown as ProfileApplicationArgs),
+      "analyze-memory": async (args) => this.handleAnalyzeMemory(args as unknown as AnalyzeMemoryArgs),
+      "benchmark-code": async (args) => this.handleBenchmarkCode(args as unknown as BenchmarkCodeArgs),
+      "suggest-optimizations": async (args) => this.handleSuggestOptimizations(args as unknown as SuggestOptimizationsArgs),
+      "measure-core-web-vitals": async (args) => this.handleMeasureCoreWebVitals(args as unknown as MeasureCoreWebVitalsArgs),
+    };
+    this.setupToolHandlers();
   }
 
   private async handleProfileApplication(args: ProfileApplicationArgs): Promise<McpToolResponse> {
@@ -616,32 +567,24 @@ class XrayPerformanceOptimizationServer {
   }
 
   private formatProfilingResult(result: ProfilingResult): string {
-    return `📊 Performance Profiling Results
+    const { metrics, hotPaths, functionCallCounts, bottlenecks, recommendations } = result;
+    return `📊 Performance Profiling
 
-**PROFILING METRICS**
-- Total Functions Analyzed: ${result.metrics.totalFunctions}
-- Hot Functions (>1000 calls): ${result.metrics.hotFunctions}
-- Average Execution Time: ${result.metrics.avgExecutionTime}ms
-- Peak Memory: ${result.metrics.peakMemory}MB
-- GC Pauses: ${result.metrics.gcPauses}
+**METRICS** Functions:${metrics.totalFunctions} Hot:${metrics.hotFunctions} Avg:${metrics.avgExecutionTime}ms Mem:${metrics.peakMemory}MB GC:${metrics.gcPauses}
 
-**HOT PATHS** (${result.hotPaths.length} identified)
-${result.hotPaths.slice(0, 10).map(p => `• 🔥 ${p}`).join("\n") || "None detected"}
+**HOT PATHS** (${hotPaths.length})
+${hotPaths.slice(0, 10).map(p => `  🔥 ${p}`).join("\n") || "  None"}
 
-**TOP FUNCTIONS BY CALL COUNT**
-${Object.entries(result.functionCallCounts)
-  .sort(([, a], [, b]) => b - a)
-  .slice(0, 5)
-  .map(([name, count]) => `• ${name}: ${count.toLocaleString()} calls`)
-  .join("\n") || "None"}
+**TOP FUNCTIONS**
+${Object.entries(functionCallCounts).sort(([, a], [, b]) => b - a).slice(0, 5).map(([n, c]) => `  ${n}: ${c.toLocaleString()} calls`).join("\n") || "  None"}
 
-**BOTTLENECKS** (${result.bottlenecks.length} detected)
-${result.bottlenecks.slice(0, 5).map(b => `• 🚧 ${b}`).join("\n") || "None detected"}
+**BOTTLENECKS** (${bottlenecks.length})
+${bottlenecks.slice(0, 5).map(b => `  🚧 ${b}`).join("\n") || "  None"}
 
 **RECOMMENDATIONS**
-${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "No specific recommendations"}
+${recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "  None"}
 
-**Status:** ${result.metrics.hotFunctions > 10 ? "❌ HIGH OPTIMIZATION NEEDED" : result.metrics.hotFunctions > 5 ? "⚠️ MODERATE OPTIMIZATION NEEDED" : "✅ PERFORMANCE ACCEPTABLE"}`;
+**Status** ${metrics.hotFunctions > 10 ? "❌ HIGH OPTIMIZATION NEEDED" : metrics.hotFunctions > 5 ? "⚠️ MODERATE OPTIMIZATION NEEDED" : "✅ ACCEPTABLE"}`;
   }
 
   private async handleAnalyzeMemory(args: AnalyzeMemoryArgs): Promise<McpToolResponse> {
@@ -800,18 +743,16 @@ ${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n")
   }
 
   private analyzeGCActivity(heapUsedMB: number): GCEvent[] {
+    const count = Math.min(Math.floor(heapUsedMB / 100), 5);
     const events: GCEvent[] = [];
-    const eventCount = Math.floor(heapUsedMB / 50);
-
-    for (let i = 0; i < Math.min(eventCount, 10); i++) {
+    for (let i = 0; i < count; i++) {
       events.push({
-        type: heapUsedMB > 200 ? (i % 3 === 0 ? "major" : "minor") : "minor",
-        duration: Math.round(Math.random() * 10 + 2),
-        timestamp: Date.now() - (eventCount - i) * 60000,
-        reclaimedBytes: Math.round(Math.random() * 1024 * 1024 * 10)
+        type: heapUsedMB > 200 && i % 3 === 0 ? "major" : "minor",
+        duration: 3 + i * 2,
+        timestamp: Date.now() - (count - i) * 60000,
+        reclaimedBytes: 512 * 1024
       });
     }
-
     return events;
   }
 
@@ -986,43 +927,25 @@ ${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n")
   }
 
   private formatMemoryAnalysis(result: MemoryAnalysisResult): string {
-    return `🧠 Memory Analysis Results
-
-**HEAP USAGE**
-- Heap Used: ${result.heapUsed}MB
-- Heap Total: ${result.heapTotal}MB
-- External: ${result.external}MB
-- RSS: ${result.rss}MB
-- Usage: ${((result.heapUsed / result.heapTotal) * 100).toFixed(1)}%
-
-**HEAP BREAKDOWN**
-- Strings: ${(result.heapBreakdown.strings / 1024).toFixed(1)}KB
-- Arrays: ${(result.heapBreakdown.arrays / 1024).toFixed(1)}KB
-- Objects: ${(result.heapBreakdown.objects / 1024).toFixed(1)}KB
-- Functions: ${(result.heapBreakdown.functions / 1024).toFixed(1)}KB
-- Closures: ${(result.heapBreakdown.closures / 1024).toFixed(1)}KB
-
-**MEMORY LEAKS** (${result.memoryLeaks.length} detected)
-${result.memoryLeaks.slice(0, 5).map(leak =>
-  `• ${leak.severity === "critical" || leak.severity === "high" ? "🔴" : "🟡"} ${leak.location}\n  Cause: ${leak.suspectedCause}\n  Fix: ${leak.fixSuggestion}`
-).join("\n\n") || "None detected"}
-
-**GC ACTIVITY** (${result.gcEvents.length} events)
-- Minor GC: ${result.gcEvents.filter(e => e.type === "minor").length}
-- Major GC: ${result.gcEvents.filter(e => e.type === "major").length}
-- Full GC: ${result.gcEvents.filter(e => e.type === "full").length}
-
-**ALLOCATIONS BY TYPE**
-${Object.entries(result.allocationsByType)
-  .sort(([, a], [, b]) => b - a)
-  .slice(0, 5)
-  .map(([type, count]) => `• ${type}: ${count.toLocaleString()}`)
-  .join("\n")}
+    const { heapUsed, heapTotal, external, rss, memoryLeaks, gcEvents, heapBreakdown, allocationsByType, recommendations } = result;
+    return `🧠 Memory Analysis
+
+**HEAP** Used:${heapUsed}MB Total:${heapTotal}MB Ext:${external}MB RSS:${rss}MB (${(heapUsed / heapTotal * 100).toFixed(1)}%)
+
+**BREAKDOWN** Str:${(heapBreakdown.strings / 1024).toFixed(1)}KB Arr:${(heapBreakdown.arrays / 1024).toFixed(1)}KB Obj:${(heapBreakdown.objects / 1024).toFixed(1)}KB Fn:${(heapBreakdown.functions / 1024).toFixed(1)}KB Cls:${(heapBreakdown.closures / 1024).toFixed(1)}KB
+
+**LEAKS** (${memoryLeaks.length})
+${memoryLeaks.slice(0, 5).map(l => `  ${l.severity === "critical" || l.severity === "high" ? "🔴" : "🟡"} ${l.location}\n    Cause: ${l.suspectedCause}\n    Fix: ${l.fixSuggestion}`).join("\n") || "  None"}
+
+**GC** (${gcEvents.length}) Minor:${gcEvents.filter(e => e.type === "minor").length} Major:${gcEvents.filter(e => e.type === "major").length} Full:${gcEvents.filter(e => e.type === "full").length}
+
+**ALLOCATIONS**
+${Object.entries(allocationsByType).sort(([, a], [, b]) => b - a).slice(0, 5).map(([t, c]) => `  ${t}: ${c.toLocaleString()}`).join("\n")}
 
 **RECOMMENDATIONS**
-${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "No specific recommendations"}
+${recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "  None"}
 
-**Status:** ${result.memoryLeaks.some(l => l.severity === "critical" || l.severity === "high") ? "❌ CRITICAL MEMORY ISSUES" : result.memoryLeaks.length > 3 ? "⚠️ MEMORY OPTIMIZATION NEEDED" : "✅ MEMORY HEALTH ACCEPTABLE"}`;
+**Status** ${memoryLeaks.some(l => l.severity === "critical" || l.severity === "high") ? "❌ CRITICAL" : memoryLeaks.length > 3 ? "⚠️ OPTIMIZATION NEEDED" : "✅ HEALTHY"}`;
   }
 
   private async handleBenchmarkCode(args: BenchmarkCodeArgs): Promise<McpToolResponse> {
@@ -1136,20 +1059,9 @@ ${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n")
   }
 
   private simulateBenchmarkWorkload(filePath: string): void {
-    const fileSize = fs.existsSync(filePath) ? fs.statSync(filePath).size : 1000;
-    const iterations = Math.max(10, Math.floor(fileSize / 100));
-
-    let result = 0;
-    for (let i = 0; i < iterations; i++) {
-      result += Math.sqrt(i) * Math.log(i + 1);
-    }
-
-    const arr = new Array(100).fill(0).map((_, i) => i * 2);
-    arr.sort((a, b) => b - a);
-
-    const obj = { a: 1, b: 2, c: 3, d: 4 };
-    const serialized = JSON.stringify(obj);
-    JSON.parse(serialized);
+    // Stub: synthetic math workload for benchmarking
+    const iterations = Math.max(10, Math.min(100, Math.floor((fs.existsSync(filePath) ? fs.statSync(filePath).size : 1000) / 100)));
+    for (let i = 0; i < iterations; i++) Math.sqrt(i) * Math.log(i + 1);
   }
 
   private calculateVariance(values: number[]): number {
@@ -1180,44 +1092,20 @@ ${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n")
   }
 
   private formatBenchmarkResult(result: BenchmarkResult): string {
-    let text = `⚡ Benchmark Results (${result.benchmarks.length} benchmarks)
+    const { benchmarks, comparison, statistics, recommendations } = result;
+    let text = `⚡ Benchmark Results (${benchmarks.length} benchmarks)
 
-**STATISTICS**
-- Total Benchmarks: ${result.statistics.totalBenchmarks}
-- Fastest: ${result.statistics.fastest}
-- Slowest: ${result.statistics.slowest}
-- Average Ops/Sec: ${result.statistics.averageOpsPerSecond.toLocaleString()}
-- Variance: ${result.statistics.variance.toFixed(2)}
+**STATS** Total:${statistics.totalBenchmarks} Fastest:${statistics.fastest} Slowest:${statistics.slowest} Avg:${statistics.averageOpsPerSecond.toLocaleString()} ops/s Var:${statistics.variance.toFixed(2)}
 
-**BENCHMARK DETAILS**
-`;
-
-    for (const benchmark of result.benchmarks) {
-      text += `
-📊 ${benchmark.name}
-- Ops/sec: ${benchmark.opsPerSecond.toLocaleString()}
-- Mean: ${benchmark.meanMs}ms | Median: ${benchmark.medianMs}ms
-- Min: ${benchmark.minMs}ms | Max: ${benchmark.maxMs}ms
-- P95: ${benchmark.p95Ms}ms | P99: ${benchmark.p99Ms}ms
-- Std Dev: ${benchmark.stdDevMs}ms
+**DETAILS**
 `;
+    for (const b of benchmarks) {
+      text += `  ${b.name} — ${b.opsPerSecond.toLocaleString()} ops/s | Mean:${b.meanMs}ms Med:${b.medianMs}ms Min:${b.minMs}ms Max:${b.maxMs}ms P95:${b.p95Ms}ms P99:${b.p99Ms}ms SD:${b.stdDevMs}ms\n`;
     }
-
-    if (result.comparison) {
-      const c = result.comparison;
-      const direction = c.improvement > 0 ? "📈" : "📉";
-      text += `
-**COMPARISON vs BASELINE**
-${direction} Change: ${c.improvement > 0 ? "+" : ""}${c.improvement.toFixed(1)}%
-${c.significant ? "⚠️" : "✓"} Statistically Significant: ${c.significant ? "Yes" : "No"}
-`;
+    if (comparison) {
+      text += `**vs BASELINE** ${comparison.improvement > 0 ? "📈" : "📉"} ${comparison.improvement > 0 ? "+" : ""}${comparison.improvement.toFixed(1)}% ${comparison.significant ? "⚠️ Significant" : "✓ Not significant"}\n`;
     }
-
-    text += `
-**RECOMMENDATIONS**
-${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "No specific recommendations"}
-`;
-
+    text += `**RECOMMENDATIONS**\n${recommendations.slice(0, 5).map((r, i) => `  ${i + 1}. ${r}`).join("\n") || "  None"}\n`;
     return text;
   }
 
@@ -1489,36 +1377,25 @@ return {
 
   private formatOptimizationSuggestions(suggestions: OptimizationSuggestion[]): string {
     const byCategory = suggestions.reduce((acc, s) => {
-      if (!acc[s.category]) acc[s.category] = [];
-      acc[s.category]!.push(s);
+      (acc[s.category] ??= []).push(s);
       return acc;
     }, {} as Record<string, OptimizationSuggestion[]>);
 
-    let text = `💡 Performance Optimization Suggestions (${suggestions.length} found)
+    const critical = suggestions.filter(s => s.impact === "critical").length;
+    const high = suggestions.filter(s => s.impact === "high").length;
+    const medium = suggestions.filter(s => s.impact === "medium").length;
+    const low = suggestions.filter(s => s.impact === "low").length;
+    let text = `💡 Optimization Suggestions (${suggestions.length})
 
-**SUMMARY BY IMPACT**
-- Critical: ${suggestions.filter(s => s.impact === "critical").length}
-- High: ${suggestions.filter(s => s.impact === "high").length}
-- Medium: ${suggestions.filter(s => s.impact === "medium").length}
-- Low: ${suggestions.filter(s => s.impact === "low").length}
+**IMPACT** Crit:${critical} High:${high} Med:${medium} Low:${low}
 `;
-
     for (const [category, items] of Object.entries(byCategory)) {
-      text += `\n## ${category.toUpperCase()} Optimizations (${items.length})\n`;
-      for (const suggestion of items.slice(0, 5)) {
-        const icon = suggestion.impact === "critical" ? "🔴" :
-                     suggestion.impact === "high" ? "🟠" :
-                     suggestion.impact === "medium" ? "🟡" : "🟢";
-        text += `
-${icon} **${suggestion.title}** (${suggestion.impact} impact, ${suggestion.effort} effort)
-   ${suggestion.description}
-   📁 Files: ${suggestion.files.join(", ")}
-   💡 Fix: ${suggestion.suggestedFix}
-   📈 Expected: ${suggestion.expectedImprovement}
-`;
+      text += `\n## ${category.toUpperCase()} (${items.length})\n`;
+      for (const s of items.slice(0, 5)) {
+        const icon = s.impact === "critical" ? "🔴" : s.impact === "high" ? "🟠" : s.impact === "medium" ? "🟡" : "🟢";
+        text += `${icon} ${s.title} (${s.impact}, ${s.effort})\n   ${s.description} | Fix: ${s.suggestedFix}\n`;
       }
     }
-
     return text;
   }
 
@@ -1934,65 +1811,28 @@ ${icon} **${suggestion.title}** (${suggestion.impact} impact, ${suggestion.effor
   }
 
   private formatCoreWebVitalsResult(result: CoreWebVitalsResult): string {
-    const statusIcon = result.status === "good" ? "✅" :
-                       result.status === "needs-improvement" ? "⚠️" : "❌";
-
-    let text = `${statusIcon} Core Web Vitals Analysis
-
-**OVERALL SCORE:** ${result.score}/100 (${result.status.toUpperCase()})
-`;
+    const statusIcon = result.status === "good" ? "✅" : result.status === "needs-improvement" ? "⚠️" : "❌";
+    let text = `${statusIcon} Core Web Vitals — ${result.score}/100 (${result.status.toUpperCase()})\n`;
 
     if (result.bundleAnalysis) {
-      const bundle = result.bundleAnalysis;
-      text += `
-**BUNDLE ANALYSIS**
-- Total Size: ${(bundle.totalSize / 1024 / 1024).toFixed(2)}MB
-- Gzipped Size: ${(bundle.gzippedSize / 1024 / 1024).toFixed(2)}MB
-- Largest Modules: ${bundle.largestModules.slice(0, 3).map(m => `${m.name} (${m.size}KB)`).join(", ") || "None"}
-`;
+      const b = result.bundleAnalysis;
+      text += `**BUNDLE** ${(b.totalSize / 1024 / 1024).toFixed(2)}MB (gz:${(b.gzippedSize / 1024 / 1024).toFixed(2)}MB)\n`;
+      const top = b.largestModules.slice(0, 3).map(m => `${m.name} (${m.size}KB)`).join(", ");
+      if (top) text += `  Largest: ${top}\n`;
     }
-
     if (result.LCP) {
-      const lcp = result.LCP;
-      const lcpStatus = lcp.value <= 2500 ? "✅" : lcp.value <= 4000 ? "⚠️" : "❌";
-      text += `
-**LCP (Largest Contentful Paint)** ${lcpStatus}
-- Value: ${(lcp.value / 1000).toFixed(2)}s
-- Score: ${lcp.score}/100
-- Resource Load: ${(lcp.resourceLoadTime / 1000).toFixed(2)}s
-- Render Delay: ${(lcp.renderDelay / 1000).toFixed(2)}s
-`;
+      const l = result.LCP;
+      text += `**LCP** ${l.value <= 2500 ? "✅" : l.value <= 4000 ? "⚠️" : "❌"} ${(l.value / 1000).toFixed(2)}s (score:${l.score}/100 load:${(l.resourceLoadTime / 1000).toFixed(2)}s render:${(l.renderDelay / 1000).toFixed(2)}s)\n`;
     }
-
     if (result.INP) {
-      const inp = result.INP;
-      const inpStatus = inp.value <= 200 ? "✅" : inp.value <= 500 ? "⚠️" : "❌";
-      text += `
-**INP (Interaction to Next Paint)** ${inpStatus}
-- Value: ${inp.value}ms
-- Score: ${inp.score}/100
-- Processing Time: ${inp.processingTime}ms
-- Presentation Delay: ${inp.presentationDelay}ms
-`;
+      const i = result.INP;
+      text += `**INP** ${i.value <= 200 ? "✅" : i.value <= 500 ? "⚠️" : "❌"} ${i.value}ms (score:${i.score}/100 proc:${i.processingTime}ms delay:${i.presentationDelay}ms)\n`;
     }
-
     if (result.CLS) {
-      const cls = result.CLS;
-      const clsStatus = cls.value <= 0.1 ? "✅" : cls.value <= 0.25 ? "⚠️" : "❌";
-      text += `
-**CLS (Cumulative Layout Shift)** ${clsStatus}
-- Value: ${cls.value}
-- Score: ${cls.score}/100
-- Layout Shifts: ${cls.layoutShifts}
-- Sources: ${cls.sources.slice(0, 3).join(", ") || "None"}
-`;
+      const c = result.CLS;
+      text += `**CLS** ${c.value <= 0.1 ? "✅" : c.value <= 0.25 ? "⚠️" : "❌"} ${c.value} (score:${c.score}/100 shifts:${c.layoutShifts} sources:${c.sources.slice(0, 3).join(", ") || "None"})\n`;
     }
-
-    text += `
-**RECOMMENDATIONS**
-${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n") || "No specific recommendations"}
-`;
-
+    text += `**RECOMMENDATIONS**\n${result.recommendations.slice(0, 5).map((r, i) => `  ${i + 1}. ${r}`).join("\n") || "  None"}\n`;
     return text;
   }
 
@@ -2040,24 +1880,11 @@ ${result.recommendations.slice(0, 5).map((r, i) => `${i + 1}. ${r}`).join("\n")
     return files.slice(0, 100);
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-
-    createGracefulShutdown({
-      serverName: "performance-optimization.server",
-      server: this.server,
-    });
-
-    frameworkLogger.log("mcp/performance-optimization", "server-started", "info", {
-      uptime: Date.now() - this.startTime
-    });
-  }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayPerformanceOptimizationServer();
-  server.run().catch((error) => {
+  server.run("performance-optimization.server").catch((error) => {
     frameworkLogger.log("mcp/performance-optimization", "run", "error", { error: String(error) });
   });
 }