0xray 2.1.2 → 2.1.4

package/src/mcps/knowledge-skills/api-design.server.ts

@@ -5,14 +5,8 @@
  * GraphQL schema design, and API documentation standards
  */
 
-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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 
 interface DesignApiEndpointsArgs {
   resource: string;
@@ -25,72 +19,43 @@ interface ValidateApiDesignArgs {
   standards?: string[];
 }
 
-class XrayApiDesignServer {
-  private server: Server;
-
+class XrayApiDesignServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("api-design", "2.0.1");
+    this.tools = [
       {
-        name: "api-design", version: "2.0.1",
+        name: "design-api-endpoints",
+        description:
+          "Design RESTful API endpoints with proper resource modeling",
+        inputSchema: {
+          type: "object",
+          properties: {
+            resource: { type: "string" },
+            operations: { type: "array", items: { type: "string" } },
+            relationships: { type: "array", items: { type: "string" } },
+          },
+          required: ["resource"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "validate-api-design",
+        description:
+          "Validate API design against RESTful principles and best practices",
+        inputSchema: {
+          type: "object",
+          properties: {
+            endpoints: { type: "array", items: { type: "string" } },
+            standards: { type: "array", items: { type: "string" } },
+          },
+          required: ["endpoints"],
         },
       },
-    );
-
+    ];
+    this.handlers = {
+      "design-api-endpoints": async (args) => this.designApiEndpoints(args as unknown as DesignApiEndpointsArgs),
+      "validate-api-design": async (args) => this.validateApiDesign(args as unknown as ValidateApiDesignArgs),
+    };
     this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "design-api-endpoints",
-            description:
-              "Design RESTful API endpoints with proper resource modeling",
-            inputSchema: {
-              type: "object",
-              properties: {
-                resource: { type: "string" },
-                operations: { type: "array", items: { type: "string" } },
-                relationships: { type: "array", items: { type: "string" } },
-              },
-              required: ["resource"],
-            },
-          },
-          {
-            name: "validate-api-design",
-            description:
-              "Validate API design against RESTful principles and best practices",
-            inputSchema: {
-              type: "object",
-              properties: {
-                endpoints: { type: "array", items: { type: "string" } },
-                standards: { type: "array", items: { type: "string" } },
-              },
-              required: ["endpoints"],
-            },
-          },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "design-api-endpoints":
-          return await this.designApiEndpoints(args as unknown as DesignApiEndpointsArgs);
-        case "validate-api-design":
-          return await this.validateApiDesign(args as unknown as ValidateApiDesignArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
   }
 
   private async designApiEndpoints(args: DesignApiEndpointsArgs) {
@@ -140,21 +105,11 @@ class XrayApiDesignServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "api-design.server",
-      server: this.server,
-    });
-  }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayApiDesignServer();
-  server.run().catch(() => {});
+  server.run("api-design").catch((err) => { frameworkLogger.log("api-design", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export default XrayApiDesignServer;

package/src/mcps/knowledge-skills/architecture-patterns.server.ts

@@ -1,20 +1,7 @@
-/**
- * xray Architecture Patterns MCP Server
- *
- * Knowledge skill for architectural pattern recognition,
- * design pattern recommendations, and system architecture guidance
- */
-
-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 AnalyzeArchitectureArgs {
   projectRoot: string;
@@ -27,78 +14,46 @@ interface RecommendPatternsArgs {
   scale?: string;
 }
 
-class XrayArchitecturePatternsServer {
-  private server: Server;
-
+class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("architecture-patterns", "2.0.1");
+    this.tools = [
       {
-        name: "architecture-patterns", version: "2.0.1",
+        name: "analyze-architecture",
+        description: "Analyze current system architecture and identify patterns",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string" },
+            focusPatterns: { type: "array", items: { type: "string" } },
+          },
+          required: ["projectRoot"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "recommend-patterns",
+        description: "Recommend architectural patterns for specific use cases",
+        inputSchema: {
+          type: "object",
+          properties: {
+            useCase: { type: "string" },
+            constraints: { type: "array", items: { type: "string" } },
+            scale: { type: "string", enum: ["small", "medium", "large"] },
+          },
+          required: ["useCase"],
         },
       },
-    );
-
+    ];
+    this.handlers = {
+      "analyze-architecture": async (args) => this.analyzeArchitecture(args as unknown as AnalyzeArchitectureArgs),
+      "recommend-patterns": async (args) => this.recommendPatterns(args as unknown as RecommendPatternsArgs),
+    };
     this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "analyze-architecture",
-            description:
-              "Analyze current system architecture and identify patterns",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string" },
-                focusPatterns: { type: "array", items: { type: "string" } },
-              },
-              required: ["projectRoot"],
-            },
-          },
-          {
-            name: "recommend-patterns",
-            description:
-              "Recommend architectural patterns for specific use cases",
-            inputSchema: {
-              type: "object",
-              properties: {
-                useCase: { type: "string" },
-                constraints: { type: "array", items: { type: "string" } },
-                scale: { type: "string", enum: ["small", "medium", "large"] },
-              },
-              required: ["useCase"],
-            },
-          },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "analyze-architecture":
-          return await this.analyzeArchitecture(args as unknown as AnalyzeArchitectureArgs);
-        case "recommend-patterns":
-          return await this.recommendPatterns(args as unknown as RecommendPatternsArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
   }
 
   private async analyzeArchitecture(args: AnalyzeArchitectureArgs) {
     const { projectRoot, focusPatterns } = args;
 
-    // Simplified architecture analysis
     const analysis = {
       patterns: ["MVC", "Repository"],
       recommendations: ["Consider microservices for scaling"],
@@ -131,22 +86,11 @@ class XrayArchitecturePatternsServer {
       ],
     };
   }
-
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "architecture-patterns.server",
-      server: this.server,
-    });
-  }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayArchitecturePatternsServer();
-  server.run().catch(() => {});
+  server.run("architecture-patterns.server").catch((err) => { frameworkLogger.log("architecture-patterns", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export default XrayArchitecturePatternsServer;