0xray 3.1.1 → 3.2.0

package/dist/mcps/knowledge-skills/tech-writer.server.js

@@ -4,193 +4,27 @@
  * Knowledge skill for automated documentation creation, API docs generation,
  * code documentation maintenance, and technical writing assistance
  */
-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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayDocumentationGenerationServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class XrayDocumentationGenerationServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "documentation-generation", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("documentation-generation", "3.1.0");
+        this.tools = [
+            { name: "analyze_documentation", description: "Analyze existing documentation for completeness, quality, and gaps", inputSchema: { type: "object", properties: { docsPath: { type: "string", description: "Path to documentation directory or files" }, codePath: { type: "string", description: "Path to corresponding code for comparison" }, docTypes: { type: "array", items: { type: "string", enum: ["readme", "api", "code", "architecture", "deployment", "user-guide"] }, description: "Types of documentation to analyze" } }, required: ["docsPath"] } },
+            { name: "generate_api_docs", description: "Generate comprehensive API documentation from code analysis", inputSchema: { type: "object", properties: { codePath: { type: "string", description: "Path to API code files" }, framework: { type: "string", enum: ["express", "fastify", "koa", "nestjs", "spring", "django", "flask", "fastapi"], description: "API framework being used" }, format: { type: "string", enum: ["openapi", "markdown", "html", "postman"], description: "Output documentation format", default: "openapi" }, includeExamples: { type: "boolean", description: "Include request/response examples", default: true } }, required: ["codePath", "framework"] } },
+            { name: "generate_code_documentation", description: "Generate inline code documentation and improve existing docs", inputSchema: { type: "object", properties: { codePath: { type: "string", description: "Path to code files to document" }, language: { type: "string", enum: ["typescript", "javascript", "python", "java", "csharp", "go", "rust"], description: "Programming language" }, style: { type: "string", enum: ["jsdoc", "docstring", "xml", "markdown"], description: "Documentation comment style", default: "jsdoc" }, includePrivate: { type: "boolean", description: "Include documentation for private members", default: false } }, required: ["codePath", "language"] } },
+            { name: "generate_readme", description: "Generate or improve project README documentation", inputSchema: { type: "object", properties: { projectPath: { type: "string", description: "Path to project root directory" }, projectType: { type: "string", enum: ["library", "application", "api", "cli", "framework"], description: "Type of project" }, includeSections: { type: "array", items: { type: "string" }, description: "Specific sections to include", default: ["installation", "usage", "api", "contributing", "license"] }, existingReadme: { type: "string", description: "Path to existing README to improve" } }, required: ["projectPath", "projectType"] } },
+        ];
+        this.handlers = {
+            analyze_documentation: async (args) => this.analyzeDocumentation(args),
+            generate_api_docs: async (args) => this.generateAPIDocs(args),
+            generate_code_documentation: async (args) => this.generateCodeDocumentation(args),
+            generate_readme: async (args) => this.generateReadme(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_documentation",
-                        description: "Analyze existing documentation for completeness, quality, and gaps",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                docsPath: {
-                                    type: "string",
-                                    description: "Path to documentation directory or files",
-                                },
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to corresponding code for comparison",
-                                },
-                                docTypes: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "readme",
-                                            "api",
-                                            "code",
-                                            "architecture",
-                                            "deployment",
-                                            "user-guide",
-                                        ],
-                                    },
-                                    description: "Types of documentation to analyze",
-                                },
-                            },
-                            required: ["docsPath"],
-                        },
-                    },
-                    {
-                        name: "generate_api_docs",
-                        description: "Generate comprehensive API documentation from code analysis",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to API code files",
-                                },
-                                framework: {
-                                    type: "string",
-                                    enum: [
-                                        "express",
-                                        "fastify",
-                                        "koa",
-                                        "nestjs",
-                                        "spring",
-                                        "django",
-                                        "flask",
-                                        "fastapi",
-                                    ],
-                                    description: "API framework being used",
-                                },
-                                format: {
-                                    type: "string",
-                                    enum: ["openapi", "markdown", "html", "postman"],
-                                    description: "Output documentation format",
-                                    default: "openapi",
-                                },
-                                includeExamples: {
-                                    type: "boolean",
-                                    description: "Include request/response examples",
-                                    default: true,
-                                },
-                            },
-                            required: ["codePath", "framework"],
-                        },
-                    },
-                    {
-                        name: "generate_code_documentation",
-                        description: "Generate inline code documentation and improve existing docs",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to code files to document",
-                                },
-                                language: {
-                                    type: "string",
-                                    enum: [
-                                        "typescript",
-                                        "javascript",
-                                        "python",
-                                        "java",
-                                        "csharp",
-                                        "go",
-                                        "rust",
-                                    ],
-                                    description: "Programming language",
-                                },
-                                style: {
-                                    type: "string",
-                                    enum: ["jsdoc", "docstring", "xml", "markdown"],
-                                    description: "Documentation comment style",
-                                    default: "jsdoc",
-                                },
-                                includePrivate: {
-                                    type: "boolean",
-                                    description: "Include documentation for private members",
-                                    default: false,
-                                },
-                            },
-                            required: ["codePath", "language"],
-                        },
-                    },
-                    {
-                        name: "generate_readme",
-                        description: "Generate or improve project README documentation",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectPath: {
-                                    type: "string",
-                                    description: "Path to project root directory",
-                                },
-                                projectType: {
-                                    type: "string",
-                                    enum: ["library", "application", "api", "cli", "framework"],
-                                    description: "Type of project",
-                                },
-                                includeSections: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific sections to include",
-                                    default: [
-                                        "installation",
-                                        "usage",
-                                        "api",
-                                        "contributing",
-                                        "license",
-                                    ],
-                                },
-                                existingReadme: {
-                                    type: "string",
-                                    description: "Path to existing README to improve",
-                                },
-                            },
-                            required: ["projectPath", "projectType"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_documentation":
-                    return await this.analyzeDocumentation(args);
-                case "generate_api_docs":
-                    return await this.generateAPIDocs(args);
-                case "generate_code_documentation":
-                    return await this.generateCodeDocumentation(args);
-                case "generate_readme":
-                    return await this.generateReadme(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async analyzeDocumentation(args) {
         const { docsPath, codePath, docTypes = ["readme", "api", "code"] } = args;
         try {
@@ -1173,15 +1007,6 @@ class XrayDocumentationGenerationServer {
         };
         return icons[severity] || "❓";
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "tech-writer.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/knowledge-skills/testing-best-practices.server.js

@@ -4,192 +4,28 @@
  * Knowledge skill for comprehensive testing strategies, TDD/BDD implementation,
  * test coverage optimization, and automated testing workflows
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as fs from "fs";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-class XrayTestingBestPracticesServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class XrayTestingBestPracticesServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "testing-best-practices", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("testing-best-practices", "3.1.0");
+        this.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: "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"] } },
+            { 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: [] } },
+            { 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"] } },
+            { 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: ["ciPlatform", "testTypes"] } },
+        ];
+        this.handlers = {
+            analyze_test_coverage: async (args) => this.analyzeTestCoverage(args),
+            design_test_strategy: async (args) => this.designTestStrategy(args),
+            implement_tdd_workflow: async (args) => this.implementTDDWorkflow(args),
+            optimize_test_performance: async (args) => this.optimizeTestPerformance(args),
+            setup_ci_cd_testing: async (args) => this.setupCICDTesting(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    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: "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"],
-                        },
-                    },
-                    {
-                        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: [],
-                        },
-                    },
-                    {
-                        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"],
-                        },
-                    },
-                    {
-                        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: ["ciPlatform", "testTypes"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_test_coverage":
-                    return await this.analyzeTestCoverage(args);
-                case "design_test_strategy":
-                    return await this.designTestStrategy(args);
-                case "implement_tdd_workflow":
-                    return await this.implementTDDWorkflow(args);
-                case "optimize_test_performance":
-                    return await this.optimizeTestPerformance(args);
-                case "setup_ci_cd_testing":
-                    return await this.setupCICDTesting(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async analyzeTestCoverage(args) {
         const { codePath, testFramework = "auto-detect", coverageThreshold = 80, } = args;
         try {
@@ -849,15 +685,6 @@ class XrayTestingBestPracticesServer {
         };
         return icons[type] || "🧪";
     }
-    async run() {
-        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://${fs.realpathSync(process.argv[1])}`) {

package/dist/mcps/knowledge-skills/testing-strategy.server.js

@@ -4,160 +4,31 @@
  * Knowledge skill for test planning, coverage optimization,
  * 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 * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
-class XrayTestingStrategyServer {
-    server;
+class XrayTestingStrategyServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "testing-strategy", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("testing-strategy", "3.1.0");
+        this.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: "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"] } },
+            { 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"] } },
+        ];
+        this.handlers = {
+            "analyze-test-coverage": async (args) => this.analyzeTestCoverage(args),
+            "design-test-strategy": async (args) => this.designTestStrategy(args),
+            "identify-test-gaps": async (args) => this.identifyTestGaps(args),
+            "optimize-test-coverage": async (args) => this.optimizeTestCoverage(args),
+            "generate-test-file": async (args) => this.generateTestFile(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    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: "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"],
-                        },
-                    },
-                    {
-                        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",
-                            ],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "analyze-test-coverage":
-                        return await this.analyzeTestCoverage(args);
-                    case "design-test-strategy":
-                        return await this.designTestStrategy(args);
-                    case "identify-test-gaps":
-                        return await this.identifyTestGaps(args);
-                    case "optimize-test-coverage":
-                        return await this.optimizeTestCoverage(args);
-                    case "generate-test-file":
-                        return await this.generateTestFile(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("mcps/testing-strategy", "tool", "error", { tool: name, error: String(error) });
-                throw error;
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async analyzeTestCoverage(args) {
         const { projectRoot, includeBreakdown = true, coverageThreshold = 80, } = args;
         const analysis = this.performTestCoverageAnalysis(projectRoot);
@@ -809,15 +680,6 @@ describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
         ];
         return ignorePatterns.some((pattern) => pattern.test(filePath));
     }
-    async run() {
-        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://${fs.realpathSync(process.argv[1])}`) {