0xray 2.1.1 → 2.1.3

package/src/mcps/knowledge-skills/testing-best-practices.server.ts

@@ -5,15 +5,8 @@
  * test coverage optimization, and automated testing workflows
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
 
 interface TestStrategy {
   type:
@@ -203,197 +196,165 @@ interface McpToolResponse {
   data?: Record<string, unknown>;
 }
 
-class XrayTestingBestPracticesServer {
-  private server: Server;
-
+class XrayTestingBestPracticesServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("testing-best-practices", "2.0.1");
+    this.tools = [
       {
-        name: "testing-best-practices", version: "2.0.1",
+        name: "analyze_test_coverage",
+        description: "Analyze current test coverage and identify gaps",
+        inputSchema: {
+          type: "object",
+          properties: {
+            codePath: {
+              type: "string",
+              description: "Path to codebase to analyze",
+            },
+            testFramework: {
+              type: "string",
+              description:
+                "Testing framework used (jest, vitest, mocha, etc.)",
+              default: "auto-detect",
+            },
+            coverageThreshold: {
+              type: "number",
+              description: "Minimum coverage threshold (0-100)",
+              default: 80,
+            },
+          },
+          required: ["codePath"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "design_test_strategy",
+        description: "Design comprehensive testing strategy for a project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectType: {
+              type: "string",
+              enum: ["web-app", "api", "library", "mobile", "desktop"],
+              description: "Type of project",
+            },
+            techStack: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Technologies used (react, node, typescript, etc.)",
+            },
+            teamSize: {
+              type: "string",
+              enum: ["solo", "small", "medium", "large"],
+              description: "Development team size",
+            },
+            timeline: {
+              type: "string",
+              enum: ["rapid", "balanced", "thorough"],
+              description: "Development timeline priority",
+            },
+          },
+          required: ["projectType"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "analyze_test_coverage",
-            description: "Analyze current test coverage and identify gaps",
-            inputSchema: {
-              type: "object",
-              properties: {
-                codePath: {
-                  type: "string",
-                  description: "Path to codebase to analyze",
-                },
-                testFramework: {
-                  type: "string",
-                  description:
-                    "Testing framework used (jest, vitest, mocha, etc.)",
-                  default: "auto-detect",
-                },
-                coverageThreshold: {
-                  type: "number",
-                  description: "Minimum coverage threshold (0-100)",
-                  default: 80,
-                },
-              },
-              required: ["codePath"],
+      {
+        name: "implement_tdd_workflow",
+        description:
+          "Implement Test-Driven Development workflow and practices",
+        inputSchema: {
+          type: "object",
+          properties: {
+            language: {
+              type: "string",
+              description: "Programming language",
+              default: "typescript",
             },
-          },
-          {
-            name: "design_test_strategy",
-            description: "Design comprehensive testing strategy for a project",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectType: {
-                  type: "string",
-                  enum: ["web-app", "api", "library", "mobile", "desktop"],
-                  description: "Type of project",
-                },
-                techStack: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Technologies used (react, node, typescript, etc.)",
-                },
-                teamSize: {
-                  type: "string",
-                  enum: ["solo", "small", "medium", "large"],
-                  description: "Development team size",
-                },
-                timeline: {
-                  type: "string",
-                  enum: ["rapid", "balanced", "thorough"],
-                  description: "Development timeline priority",
-                },
-              },
-              required: ["projectType"],
+            framework: {
+              type: "string",
+              description: "Preferred testing framework",
+              default: "jest",
             },
-          },
-          {
-            name: "implement_tdd_workflow",
-            description:
-              "Implement Test-Driven Development workflow and practices",
-            inputSchema: {
-              type: "object",
-              properties: {
-                language: {
-                  type: "string",
-                  description: "Programming language",
-                  default: "typescript",
-                },
-                framework: {
-                  type: "string",
-                  description: "Preferred testing framework",
-                  default: "jest",
-                },
-                existingTests: {
-                  type: "boolean",
-                  description: "Whether tests already exist",
-                  default: false,
-                },
-              },
-              required: [],
+            existingTests: {
+              type: "boolean",
+              description: "Whether tests already exist",
+              default: false,
             },
           },
-          {
-            name: "optimize_test_performance",
-            description: "Analyze and optimize test execution performance",
-            inputSchema: {
-              type: "object",
-              properties: {
-                testResults: {
-                  type: "string",
-                  description: "Path to test results or current execution time",
-                },
-                targetRuntime: {
-                  type: "number",
-                  description: "Target test execution time in seconds",
-                  default: 300,
-                },
-                parallelExecution: {
-                  type: "boolean",
-                  description: "Whether parallel execution is supported",
-                  default: true,
-                },
-              },
-              required: ["testResults"],
+          required: [],
+        },
+      },
+      {
+        name: "optimize_test_performance",
+        description: "Analyze and optimize test execution performance",
+        inputSchema: {
+          type: "object",
+          properties: {
+            testResults: {
+              type: "string",
+              description: "Path to test results or current execution time",
+            },
+            targetRuntime: {
+              type: "number",
+              description: "Target test execution time in seconds",
+              default: 300,
+            },
+            parallelExecution: {
+              type: "boolean",
+              description: "Whether parallel execution is supported",
+              default: true,
             },
           },
-          {
-            name: "setup_ci_cd_testing",
-            description: "Set up comprehensive CI/CD testing pipeline",
-            inputSchema: {
-              type: "object",
-              properties: {
-                ciPlatform: {
-                  type: "string",
-                  enum: [
-                    "github-actions",
-                    "gitlab-ci",
-                    "jenkins",
-                    "circle-ci",
-                    "travis-ci",
-                  ],
-                  description: "CI/CD platform",
-                },
-                testTypes: {
-                  type: "array",
-                  items: {
-                    type: "string",
-                    enum: [
-                      "unit",
-                      "integration",
-                      "e2e",
-                      "performance",
-                      "security",
-                    ],
-                  },
-                  description: "Types of tests to include",
-                },
-                coverageReporting: {
-                  type: "boolean",
-                  description: "Enable coverage reporting",
-                  default: true,
-                },
+          required: ["testResults"],
+        },
+      },
+      {
+        name: "setup_ci_cd_testing",
+        description: "Set up comprehensive CI/CD testing pipeline",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ciPlatform: {
+              type: "string",
+              enum: [
+                "github-actions",
+                "gitlab-ci",
+                "jenkins",
+                "circle-ci",
+                "travis-ci",
+              ],
+              description: "CI/CD platform",
+            },
+            testTypes: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "unit",
+                  "integration",
+                  "e2e",
+                  "performance",
+                  "security",
+                ],
               },
-              required: ["ciPlatform", "testTypes"],
+              description: "Types of tests to include",
+            },
+            coverageReporting: {
+              type: "boolean",
+              description: "Enable coverage reporting",
+              default: true,
             },
           },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "analyze_test_coverage":
-          return await this.analyzeTestCoverage(args as unknown as AnalyzeTestCoverageArgs) as CallToolResult;
-        case "design_test_strategy":
-          return await this.designTestStrategy(args as unknown as DesignTestStrategyArgs) as CallToolResult;
-        case "implement_tdd_workflow":
-          return await this.implementTDDWorkflow(args as unknown as ImplementTDDWorkflowArgs) as CallToolResult;
-        case "optimize_test_performance":
-          return await this.optimizeTestPerformance(args as unknown as OptimizeTestPerformanceArgs) as CallToolResult;
-        case "setup_ci_cd_testing":
-          return await this.setupCICDTesting(args as unknown as SetupCICDTestingArgs) as CallToolResult;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
+          required: ["ciPlatform", "testTypes"],
+        },
+      },
+    ];
+    this.handlers = {
+      "analyze_test_coverage": async (args) => this.analyzeTestCoverage(args as unknown as AnalyzeTestCoverageArgs),
+      "design_test_strategy": async (args) => this.designTestStrategy(args as unknown as DesignTestStrategyArgs),
+      "implement_tdd_workflow": async (args) => this.implementTDDWorkflow(args as unknown as ImplementTDDWorkflowArgs),
+      "optimize_test_performance": async (args) => this.optimizeTestPerformance(args as unknown as OptimizeTestPerformanceArgs),
+      "setup_ci_cd_testing": async (args) => this.setupCICDTesting(args as unknown as SetupCICDTestingArgs),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeTestCoverage(args: AnalyzeTestCoverageArgs): Promise<McpToolResponse> {
@@ -1211,22 +1172,12 @@ class XrayTestingBestPracticesServer {
     return icons[type as keyof typeof icons] || "🧪";
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "testing-best-practices.server",
-      server: this.server,
-    });
-  }
 }
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayTestingBestPracticesServer();
-  server.run().catch(() => {});
+  server.run("testing-best-practices").catch((err) => { frameworkLogger.log("testing-best-practices", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export { XrayTestingBestPracticesServer };

package/src/mcps/knowledge-skills/testing-strategy.server.ts

@@ -5,16 +5,10 @@
  * and testing methodology 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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.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";
 import {
   detectProjectLanguage,
   LANGUAGE_CONFIGS,
@@ -129,159 +123,89 @@ interface BaseTestCounts {
   security: number;
 }
 
-class XrayTestingStrategyServer {
-  private server: Server;
+class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("testing-strategy", "2.0.1");
+    this.tools = [
       {
-        name: "testing-strategy", version: "2.0.1",
+        name: "analyze-test-coverage",
+        description: "Analyze current test coverage and identify gaps",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string" },
+            includeBreakdown: { type: "boolean", default: true },
+            coverageThreshold: { type: "number", default: 80 },
+          },
+          required: ["projectRoot"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "design-test-strategy",
+        description: "Design comprehensive testing strategy for the project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string" },
+            projectType: { type: "string", enum: ["web", "api", "mobile", "desktop"] },
+            complexity: { type: "string", enum: ["simple", "medium", "complex"] },
+            timeline: { type: "string", enum: ["agile", "waterfall", "continuous"] },
+          },
+          required: ["projectRoot"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "analyze-test-coverage",
-            description: "Analyze current test coverage and identify gaps",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string" },
-                includeBreakdown: { type: "boolean", default: true },
-                coverageThreshold: { type: "number", default: 80 },
-              },
-              required: ["projectRoot"],
-            },
-          },
-          {
-            name: "design-test-strategy",
-            description:
-              "Design comprehensive testing strategy for the project",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string" },
-                projectType: {
-                  type: "string",
-                  enum: ["web", "api", "mobile", "desktop"],
-                },
-                complexity: {
-                  type: "string",
-                  enum: ["simple", "medium", "complex"],
-                },
-                timeline: {
-                  type: "string",
-                  enum: ["agile", "waterfall", "continuous"],
-                },
-              },
-              required: ["projectRoot"],
-            },
-          },
-          {
-            name: "identify-test-gaps",
-            description: "Identify untested code and recommend test cases",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string" },
-                sourceFiles: { type: "array", items: { type: "string" } },
-                existingTests: { type: "array", items: { type: "string" } },
-              },
-              required: ["projectRoot"],
-            },
+      {
+        name: "identify-test-gaps",
+        description: "Identify untested code and recommend test cases",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string" },
+            sourceFiles: { type: "array", items: { type: "string" } },
+            existingTests: { type: "array", items: { type: "string" } },
           },
-          {
-            name: "optimize-test-coverage",
-            description: "Analyze and optimize test coverage patterns",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: { type: "string" },
-                currentCoverage: { type: "number" },
-                targetCoverage: { type: "number", default: 85 },
-                focusAreas: { type: "array", items: { type: "string" } },
-              },
-              required: ["projectRoot"],
-            },
+          required: ["projectRoot"],
+        },
+      },
+      {
+        name: "optimize-test-coverage",
+        description: "Analyze and optimize test coverage patterns",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: { type: "string" },
+            currentCoverage: { type: "number" },
+            targetCoverage: { type: "number", default: 85 },
+            focusAreas: { type: "array", items: { type: "string" } },
           },
-          {
-            name: "generate-test-file",
-            description: "Generate test file for a source file with exports",
-            inputSchema: {
-              type: "object",
-              properties: {
-                sourceFile: {
-                  type: "string",
-                  description: "Path to source file",
-                },
-                sourceContent: {
-                  type: "string",
-                  description: "Source file content",
-                },
-                exports: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    properties: {
-                      name: { type: "string" },
-                      type: { type: "string" },
-                    },
-                  },
-                  description: "Exported functions/classes to test",
-                },
-                testFilePath: {
-                  type: "string",
-                  description: "Path for generated test file",
-                },
-                directory: { type: "string", description: "Project directory" },
-              },
-              required: [
-                "sourceFile",
-                "sourceContent",
-                "exports",
-                "testFilePath",
-              ],
-            },
+          required: ["projectRoot"],
+        },
+      },
+      {
+        name: "generate-test-file",
+        description: "Generate test file for a source file with exports",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceFile: { type: "string", description: "Path to source file" },
+            sourceContent: { type: "string", description: "Source file content" },
+            exports: { type: "array", items: { type: "object", properties: { name: { type: "string" }, type: { type: "string" } } }, description: "Exported functions/classes to test" },
+            testFilePath: { type: "string", description: "Path for generated test file" },
+            directory: { type: "string", description: "Project directory" },
           },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "analyze-test-coverage":
-            return await this.analyzeTestCoverage(args as unknown as AnalyzeTestCoverageArgs);
-          case "design-test-strategy":
-            return await this.designTestStrategy(args as unknown as DesignTestStrategyArgs);
-          case "identify-test-gaps":
-            return await this.identifyTestGaps(args as unknown as IdentifyTestGapsArgs);
-          case "optimize-test-coverage":
-            return await this.optimizeTestCoverage(args as unknown as OptimizeTestCoverageArgs);
-          case "generate-test-file":
-            return await this.generateTestFile(args as unknown as GenerateTestFileArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        frameworkLogger.log("mcps/testing-strategy", "tool", "error", { tool: name, error: String(error) });
-        throw error;
-      }
-    });
+          required: ["sourceFile", "sourceContent", "exports", "testFilePath"],
+        },
+      },
+    ];
+    this.handlers = {
+      "analyze-test-coverage": async (args) => this.analyzeTestCoverage(args as unknown as AnalyzeTestCoverageArgs),
+      "design-test-strategy": async (args) => this.designTestStrategy(args as unknown as DesignTestStrategyArgs),
+      "identify-test-gaps": async (args) => this.identifyTestGaps(args as unknown as IdentifyTestGapsArgs),
+      "optimize-test-coverage": async (args) => this.optimizeTestCoverage(args as unknown as OptimizeTestCoverageArgs),
+      "generate-test-file": async (args) => this.generateTestFile(args as unknown as GenerateTestFileArgs),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeTestCoverage(args: AnalyzeTestCoverageArgs) {
@@ -1151,22 +1075,12 @@ describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
     return ignorePatterns.some((pattern) => pattern.test(filePath));
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    // Use centralized shutdown handler
-    createGracefulShutdown({
-      serverName: "testing-strategy.server",
-      server: this.server,
-    });
-  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayTestingStrategyServer();
-  server.run().catch(() => {});
+  server.run("testing-strategy").catch((err) => { frameworkLogger.log("testing-strategy", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 
 export default XrayTestingStrategyServer;