0xray 2.1.2 → 2.1.4

package/src/mcps/knowledge-skills/bug-triage-specialist.server.ts

@@ -6,15 +6,11 @@
  * and actionable debugging recommendations.
  */
 
-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 * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
 
 interface BugReport {
   id: string;
@@ -76,208 +72,188 @@ interface PrioritizedBug {
   [key: string]: unknown;
 }
 
-class BugTriageSpecialistServer {
-  private server: Server;
-
+class BugTriageSpecialistServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      { name: "bug-triage-specialist", version: "2.0.1" },
-      { capabilities: { tools: {} } },
-    );
-    this.setupToolHandlers();
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        {
-          name: "triage_bugs",
-          description:
-            "Analyze and triage bug reports, errors, or crash logs to identify root causes and prioritize fixes",
-          inputSchema: {
-            type: "object",
-            properties: {
-              errorLogs: {
-                type: "array",
-                items: { type: "string" },
-                description:
-                  "Error messages, stack traces, or bug descriptions to analyze",
-              },
-              context: {
-                type: "object",
-                properties: {
-                  projectType: {
-                    type: "string",
-                    description: "Type of project (node, browser, etc.)",
-                  },
-                  framework: {
-                    type: "string",
-                    description: "Framework being used",
-                  },
-                  recentChanges: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Recent code changes",
-                  },
+    super("bug-triage-specialist", "2.0.1");
+    this.tools = [
+      {
+        name: "triage_bugs",
+        description:
+          "Analyze and triage bug reports, errors, or crash logs to identify root causes and prioritize fixes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            errorLogs: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Error messages, stack traces, or bug descriptions to analyze",
+            },
+            context: {
+              type: "object",
+              properties: {
+                projectType: {
+                  type: "string",
+                  description: "Type of project (node, browser, etc.)",
+                },
+                framework: {
+                  type: "string",
+                  description: "Framework being used",
+                },
+                recentChanges: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Recent code changes",
                 },
-                description: "Additional context about the project",
               },
+              description: "Additional context about the project",
             },
-            required: ["errorLogs"],
           },
+          required: ["errorLogs"],
         },
-        {
-          name: "analyze_stack_trace",
-          description:
-            "Parse and analyze stack traces to identify the exact location and cause of errors",
-          inputSchema: {
-            type: "object",
-            properties: {
-              stackTrace: {
-                type: "string",
-                description: "Stack trace to analyze",
-              },
-              sourceMap: {
-                type: "object",
-                description: "Optional source map for minified code",
-              },
+      },
+      {
+        name: "analyze_stack_trace",
+        description:
+          "Parse and analyze stack traces to identify the exact location and cause of errors",
+        inputSchema: {
+          type: "object",
+          properties: {
+            stackTrace: {
+              type: "string",
+              description: "Stack trace to analyze",
+            },
+            sourceMap: {
+              type: "object",
+              description: "Optional source map for minified code",
             },
-            required: ["stackTrace"],
           },
+          required: ["stackTrace"],
         },
-        {
-          name: "suggest_fixes",
-          description:
-            "Generate specific code fixes for identified bugs with explanations",
-          inputSchema: {
-            type: "object",
-            properties: {
-              bugId: { type: "string", description: "ID of the bug to fix" },
-              language: {
-                type: "string",
-                description: "Programming language",
-                default: "typescript",
-              },
-              existingCode: {
-                type: "string",
-                description: "The buggy code snippet",
-              },
+      },
+      {
+        name: "suggest_fixes",
+        description:
+          "Generate specific code fixes for identified bugs with explanations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            bugId: { type: "string", description: "ID of the bug to fix" },
+            language: {
+              type: "string",
+              description: "Programming language",
+              default: "typescript",
+            },
+            existingCode: {
+              type: "string",
+              description: "The buggy code snippet",
             },
-            required: ["bugId", "existingCode"],
           },
+          required: ["bugId", "existingCode"],
         },
-        {
-          name: "prioritize_issues",
-          description:
-            "Prioritize bug fixes based on severity, impact, and effort",
-          inputSchema: {
-            type: "object",
-            properties: {
-              bugs: {
-                type: "array",
-                items: { type: "object" },
-                description: "Array of bug objects to prioritize",
-              },
-              sprintVelocity: {
-                type: "number",
-                description: "Available story points",
-              },
+      },
+      {
+        name: "prioritize_issues",
+        description:
+          "Prioritize bug fixes based on severity, impact, and effort",
+        inputSchema: {
+          type: "object",
+          properties: {
+            bugs: {
+              type: "array",
+              items: { type: "object" },
+              description: "Array of bug objects to prioritize",
+            },
+            sprintVelocity: {
+              type: "number",
+              description: "Available story points",
             },
-            required: ["bugs"],
           },
+          required: ["bugs"],
         },
-        {
-          name: "find_related_issues",
-          description:
-            "Find related or duplicate bugs based on error patterns and symptoms",
-          inputSchema: {
-            type: "object",
-            properties: {
-              newBug: { type: "string", description: "Description of new bug" },
-              existingBugs: {
-                type: "array",
-                items: { type: "string" },
-                description: "List of existing bug IDs",
-              },
+      },
+      {
+        name: "find_related_issues",
+        description:
+          "Find related or duplicate bugs based on error patterns and symptoms",
+        inputSchema: {
+          type: "object",
+          properties: {
+            newBug: { type: "string", description: "Description of new bug" },
+            existingBugs: {
+              type: "array",
+              items: { type: "string" },
+              description: "List of existing bug IDs",
             },
-            required: ["newBug"],
           },
+          required: ["newBug"],
         },
-      ],
-    }));
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args = {} } = request.params;
-      const params = args as Record<string, unknown>;
-
-      try {
-        switch (name) {
-          case "triage_bugs": {
-            const result = this.triageBugs(
-              (params.errorLogs as string[]) || [],
-              (params.context as Record<string, unknown>) || {},
-            );
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(result, null, 2) },
-              ],
-            };
-          }
-          case "analyze_stack_trace": {
-            const result = this.analyzeStackTrace(
-              (params.stackTrace as string) || "",
-              params.sourceMap as Record<string, unknown> | undefined,
-            );
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(result, null, 2) },
-              ],
-            };
-          }
-          case "suggest_fixes": {
-            const result = this.suggestFixes(
-              (params.bugId as string) || "",
-              (params.language as string) || "typescript",
-              (params.existingCode as string) || "",
-            );
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(result, null, 2) },
-              ],
-            };
-          }
-          case "prioritize_issues": {
-            const result = this.prioritizeIssues(
-              (params.bugs as Array<Record<string, unknown>>) || [],
-              (params.sprintVelocity as number) || 20,
-            );
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(result, null, 2) },
-              ],
-            };
-          }
-          case "find_related_issues": {
-            const result = this.findRelatedIssues(
-              (params.newBug as string) || "",
-              (params.existingBugs as string[]) || [],
-            );
-            return {
-              content: [
-                { type: "text", text: JSON.stringify(result, null, 2) },
-              ],
-            };
-          }
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
+      },
+    ];
+    this.handlers = {
+      "triage_bugs": async (args) => {
+        const params = args as Record<string, unknown>;
+        const result = this.triageBugs(
+          (params.errorLogs as string[]) || [],
+          (params.context as Record<string, unknown>) || {},
+        );
         return {
-          content: [{ type: "text", text: `Error: ${error}` }],
-          isError: true,
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+          ],
         };
-      }
-    });
+      },
+      "analyze_stack_trace": async (args) => {
+        const params = args as Record<string, unknown>;
+        const result = this.analyzeStackTrace(
+          (params.stackTrace as string) || "",
+          params.sourceMap as Record<string, unknown> | undefined,
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+          ],
+        };
+      },
+      "suggest_fixes": async (args) => {
+        const params = args as Record<string, unknown>;
+        const result = this.suggestFixes(
+          (params.bugId as string) || "",
+          (params.language as string) || "typescript",
+          (params.existingCode as string) || "",
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+          ],
+        };
+      },
+      "prioritize_issues": async (args) => {
+        const params = args as Record<string, unknown>;
+        const result = this.prioritizeIssues(
+          (params.bugs as Array<Record<string, unknown>>) || [],
+          (params.sprintVelocity as number) || 20,
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+          ],
+        };
+      },
+      "find_related_issues": async (args) => {
+        const params = args as Record<string, unknown>;
+        const result = this.findRelatedIssues(
+          (params.newBug as string) || "",
+          (params.existingBugs as string[]) || [],
+        );
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) },
+          ],
+        };
+      },
+    };
+    this.setupToolHandlers();
   }
 
   private triageBugs(errorLogs: string[], context: Record<string, unknown>): TriageResult {
@@ -609,16 +585,12 @@ class BugTriageSpecialistServer {
     return effortMap[bug.fixComplexity as string] || 3;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-  }
 }
 
 const entryPoint = path.resolve(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
   const server = new BugTriageSpecialistServer();
-  server.run();
+  server.run("bug-triage-specialist").catch((err) => { frameworkLogger.log("bug-triage-specialist", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export { BugTriageSpecialistServer };

package/src/mcps/knowledge-skills/code-analyzer.server.ts

@@ -10,16 +10,10 @@
  * Use project-analysis for project-level (structure, health).
  */
 
-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 } from "../../core/framework-logger.js";
 import * as fs from "fs";
 import * as path from "path";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 
 interface Tool {
   name: string;
@@ -64,9 +58,8 @@ interface FileTreeNode {
   size?: number;
 }
 
-class CodeAnalyzerServer {
-  private server: Server;
-  private tools: Tool[] = [
+class CodeAnalyzerServer extends XrayKnowledgeSkillBase {
+  private toolDefinitions: Tool[] = [
     // ===== CODE ANALYSIS =====
     {
       name: "analyze_code",
@@ -302,39 +295,21 @@ class CodeAnalyzerServer {
   ];
 
   constructor() {
-    this.server = new Server(
-      { name: "code-analyzer", version: "2.0.1" },
-      { capabilities: { tools: {} } },
-    );
-
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: this.tools,
-    }));
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args = {} } = request.params;
-
-      try {
-        switch (name) {
-          case "analyze_code": return this.handleAnalyzeCode(args);
-          case "calculate_complexity": return this.handleCalculateComplexity(args);
-          case "detect_code_smells": return this.handleDetectCodeSmells(args);
-          case "extract_metrics": return this.handleExtractMetrics(args);
-          case "explore_codebase": return this.handleExploreCodebase(args);
-          case "find_patterns": return this.handleFindPatterns(args);
-          case "find_function": return this.handleFindFunction(args);
-          case "get_file_structure": return this.handleGetFileStructure(args);
-          case "analyze_dependencies": return this.handleAnalyzeDependencies(args);
-          case "find_duplicates": return this.handleFindDuplicates(args);
-          default: throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
-          isError: true,
-        };
-      }
-    });
+    super("code-analyzer", "2.0.1");
+    this.tools = this.toolDefinitions;
+    this.handlers = {
+      "analyze_code": async (args) => this.handleAnalyzeCode(args),
+      "calculate_complexity": async (args) => this.handleCalculateComplexity(args),
+      "detect_code_smells": async (args) => this.handleDetectCodeSmells(args),
+      "extract_metrics": async (args) => this.handleExtractMetrics(args),
+      "explore_codebase": async (args) => this.handleExploreCodebase(args),
+      "find_patterns": async (args) => this.handleFindPatterns(args),
+      "find_function": async (args) => this.handleFindFunction(args),
+      "get_file_structure": async (args) => this.handleGetFileStructure(args),
+      "analyze_dependencies": async (args) => this.handleAnalyzeDependencies(args),
+      "find_duplicates": async (args) => this.handleFindDuplicates(args),
+    };
+    this.setupToolHandlers();
   }
 
   private handleAnalyzeCode(args: unknown) {
@@ -575,17 +550,7 @@ class CodeAnalyzerServer {
     return { content: [{ type: "text", text: JSON.stringify({ totalDuplicates: duplicates.length, duplicates }, null, 2) }] };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "code-analyzer.server",
-      server: this.server,
-    });
-  }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) { new CodeAnalyzerServer().run().catch(() => {}); }
+if (import.meta.url === `file://${process.argv[1]}`) { new CodeAnalyzerServer().run("code-analyzer.server").catch((err) => { frameworkLogger.log("code-analyzer", "run", "error", { error: err instanceof Error ? err.message : String(err) }); }); }
 export default CodeAnalyzerServer;