0xray 2.1.2 → 2.1.4

package/dist/mcps/knowledge-skills/api-design.server.js

@@ -4,66 +4,43 @@
  * Knowledge skill for API design patterns, RESTful conventions,
  * 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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayApiDesignServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class XrayApiDesignServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "api-design", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    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"],
-                        },
+        super("api-design", "2.0.1");
+        this.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" } },
                     },
-                    {
-                        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"],
-                        },
+                    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" } },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "design-api-endpoints":
-                    return await this.designApiEndpoints(args);
-                case "validate-api-design":
-                    return await this.validateApiDesign(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["endpoints"],
+                },
+            },
+        ];
+        this.handlers = {
+            "design-api-endpoints": async (args) => this.designApiEndpoints(args),
+            "validate-api-design": async (args) => this.validateApiDesign(args),
+        };
+        this.setupToolHandlers();
     }
     async designApiEndpoints(args) {
         const { resource, operations, relationships } = args;
@@ -106,18 +83,9 @@ class XrayApiDesignServer {
             ],
         };
     }
-    async run() {
-        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/dist/mcps/knowledge-skills/architecture-patterns.server.d.ts

@@ -1,15 +1,7 @@
-/**
- * xray Architecture Patterns MCP Server
- *
- * Knowledge skill for architectural pattern recognition,
- * design pattern recommendations, and system architecture guidance
- */
-declare class XrayArchitecturePatternsServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeArchitecture;
     private recommendPatterns;
-    run(): Promise<void>;
 }
 export default XrayArchitecturePatternsServer;

package/dist/mcps/knowledge-skills/architecture-patterns.server.js

@@ -1,73 +1,43 @@
-/**
- * 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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayArchitecturePatternsServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "architecture-patterns", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    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"],
-                        },
+        super("architecture-patterns", "2.0.1");
+        this.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" } },
                     },
-                    {
-                        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"],
-                        },
+                    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"] },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze-architecture":
-                    return await this.analyzeArchitecture(args);
-                case "recommend-patterns":
-                    return await this.recommendPatterns(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["useCase"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze-architecture": async (args) => this.analyzeArchitecture(args),
+            "recommend-patterns": async (args) => this.recommendPatterns(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeArchitecture(args) {
         const { projectRoot, focusPatterns } = args;
-        // Simplified architecture analysis
         const analysis = {
             patterns: ["MVC", "Repository"],
             recommendations: ["Consider microservices for scaling"],
@@ -96,18 +66,9 @@ class XrayArchitecturePatternsServer {
             ],
         };
     }
-    async run() {
-        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;

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

@@ -5,10 +5,9 @@
  * Provides automated root cause analysis, stack trace interpretation,
  * and actionable debugging recommendations.
  */
-declare class BugTriageSpecialistServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class BugTriageSpecialistServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private triageBugs;
     private analyzeStackTrace;
     private suggestFixes;
@@ -28,6 +27,5 @@ declare class BugTriageSpecialistServer {
     private suggestFixFromTrace;
     private calculatePriorityScore;
     private estimateEffort;
-    run(): Promise<void>;
 }
 export { BugTriageSpecialistServer };

package/dist/mcps/knowledge-skills/bug-triage-specialist.server.js

@@ -5,185 +5,170 @@
  * Provides automated root cause analysis, stack trace interpretation,
  * 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 path from "path";
 import { fileURLToPath } from "url";
-class BugTriageSpecialistServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class BugTriageSpecialistServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({ name: "bug-triage-specialist", version: "2.0.1" }, { capabilities: { tools: {} } });
-        this.setupToolHandlers();
-    }
-    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;
-            try {
-                switch (name) {
-                    case "triage_bugs": {
-                        const result = this.triageBugs(params.errorLogs || [], params.context || {});
-                        return {
-                            content: [
-                                { type: "text", text: JSON.stringify(result, null, 2) },
-                            ],
-                        };
-                    }
-                    case "analyze_stack_trace": {
-                        const result = this.analyzeStackTrace(params.stackTrace || "", params.sourceMap);
-                        return {
-                            content: [
-                                { type: "text", text: JSON.stringify(result, null, 2) },
-                            ],
-                        };
-                    }
-                    case "suggest_fixes": {
-                        const result = this.suggestFixes(params.bugId || "", params.language || "typescript", params.existingCode || "");
-                        return {
-                            content: [
-                                { type: "text", text: JSON.stringify(result, null, 2) },
-                            ],
-                        };
-                    }
-                    case "prioritize_issues": {
-                        const result = this.prioritizeIssues(params.bugs || [], params.sprintVelocity || 20);
-                        return {
-                            content: [
-                                { type: "text", text: JSON.stringify(result, null, 2) },
-                            ],
-                        };
-                    }
-                    case "find_related_issues": {
-                        const result = this.findRelatedIssues(params.newBug || "", params.existingBugs || []);
-                        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;
+                const result = this.triageBugs(params.errorLogs || [], params.context || {});
                 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;
+                const result = this.analyzeStackTrace(params.stackTrace || "", params.sourceMap);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            },
+            "suggest_fixes": async (args) => {
+                const params = args;
+                const result = this.suggestFixes(params.bugId || "", params.language || "typescript", params.existingCode || "");
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            },
+            "prioritize_issues": async (args) => {
+                const params = args;
+                const result = this.prioritizeIssues(params.bugs || [], params.sprintVelocity || 20);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            },
+            "find_related_issues": async (args) => {
+                const params = args;
+                const result = this.findRelatedIssues(params.newBug || "", params.existingBugs || []);
+                return {
+                    content: [
+                        { type: "text", text: JSON.stringify(result, null, 2) },
+                    ],
+                };
+            },
+        };
+        this.setupToolHandlers();
     }
     triageBugs(errorLogs, context) {
         const bugs = errorLogs.map((log, idx) => {
@@ -461,14 +446,10 @@ class BugTriageSpecialistServer {
         };
         return effortMap[bug.fixComplexity] || 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 };