0xray 2.1.2 → 2.1.4

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

@@ -4,161 +4,136 @@
  * Knowledge skill for database architecture, schema optimization,
  * query performance analysis, and data modeling best practices
  */
-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 { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayDatabaseDesignServer {
-    server;
+class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "database-design", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_schema",
-                        description: "Analyze database schema for optimization opportunities and best practices",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                schemaFile: {
-                                    type: "string",
-                                    description: "Path to schema definition file (SQL, migration, or ORM model)",
-                                },
-                                databaseType: {
-                                    type: "string",
-                                    enum: ["postgresql", "mysql", "sqlite", "mongodb", "redis"],
-                                    description: "Database type for specific optimizations",
-                                },
-                                includeIndexes: {
-                                    type: "boolean",
-                                    description: "Include index recommendations in analysis",
-                                    default: true,
-                                },
-                            },
-                            required: ["schemaFile"],
+        super("database-design", "2.0.1");
+        this.tools = [
+            {
+                name: "analyze_schema",
+                description: "Analyze database schema for optimization opportunities and best practices",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        schemaFile: {
+                            type: "string",
+                            description: "Path to schema definition file (SQL, migration, or ORM model)",
+                        },
+                        databaseType: {
+                            type: "string",
+                            enum: ["postgresql", "mysql", "sqlite", "mongodb", "redis"],
+                            description: "Database type for specific optimizations",
+                        },
+                        includeIndexes: {
+                            type: "boolean",
+                            description: "Include index recommendations in analysis",
+                            default: true,
                         },
                     },
-                    {
-                        name: "optimize_query",
-                        description: "Analyze and optimize SQL queries for better performance",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                query: {
-                                    type: "string",
-                                    description: "SQL query to analyze and optimize",
-                                },
-                                schemaContext: {
-                                    type: "string",
-                                    description: "Schema context or file path for better analysis",
-                                },
-                                databaseType: {
-                                    type: "string",
-                                    enum: ["postgresql", "mysql", "sqlite"],
-                                    description: "Database type for query optimization",
-                                },
-                            },
-                            required: ["query"],
+                    required: ["schemaFile"],
+                },
+            },
+            {
+                name: "optimize_query",
+                description: "Analyze and optimize SQL queries for better performance",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "SQL query to analyze and optimize",
+                        },
+                        schemaContext: {
+                            type: "string",
+                            description: "Schema context or file path for better analysis",
+                        },
+                        databaseType: {
+                            type: "string",
+                            enum: ["postgresql", "mysql", "sqlite"],
+                            description: "Database type for query optimization",
                         },
                     },
-                    {
-                        name: "design_data_model",
-                        description: "Design optimal data model for given requirements",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                requirements: {
-                                    type: "string",
-                                    description: "Business requirements and data access patterns",
-                                },
-                                entities: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "List of main entities/business objects",
-                                },
-                                relationships: {
-                                    type: "array",
-                                    items: {
-                                        type: "object",
-                                        properties: {
-                                            from: { type: "string" },
-                                            to: { type: "string" },
-                                            type: {
-                                                type: "string",
-                                                enum: ["one-to-one", "one-to-many", "many-to-many"],
-                                            },
-                                        },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "design_data_model",
+                description: "Design optimal data model for given requirements",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        requirements: {
+                            type: "string",
+                            description: "Business requirements and data access patterns",
+                        },
+                        entities: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of main entities/business objects",
+                        },
+                        relationships: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    from: { type: "string" },
+                                    to: { type: "string" },
+                                    type: {
+                                        type: "string",
+                                        enum: ["one-to-one", "one-to-many", "many-to-many"],
                                     },
-                                    description: "Entity relationships",
-                                },
-                                databaseType: {
-                                    type: "string",
-                                    enum: ["postgresql", "mysql", "mongodb", "redis"],
-                                    description: "Target database type",
                                 },
                             },
-                            required: ["requirements", "entities"],
+                            description: "Entity relationships",
+                        },
+                        databaseType: {
+                            type: "string",
+                            enum: ["postgresql", "mysql", "mongodb", "redis"],
+                            description: "Target database type",
                         },
                     },
-                    {
-                        name: "migrate_schema",
-                        description: "Generate migration scripts for schema changes",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                currentSchema: {
-                                    type: "string",
-                                    description: "Current schema definition",
-                                },
-                                targetSchema: {
-                                    type: "string",
-                                    description: "Target schema definition",
-                                },
-                                databaseType: {
-                                    type: "string",
-                                    enum: ["postgresql", "mysql", "sqlite"],
-                                    description: "Database type for migration",
-                                },
-                                safeMode: {
-                                    type: "boolean",
-                                    description: "Generate rollback scripts and safety checks",
-                                    default: true,
-                                },
-                            },
-                            required: ["currentSchema", "targetSchema"],
+                    required: ["requirements", "entities"],
+                },
+            },
+            {
+                name: "migrate_schema",
+                description: "Generate migration scripts for schema changes",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        currentSchema: {
+                            type: "string",
+                            description: "Current schema definition",
+                        },
+                        targetSchema: {
+                            type: "string",
+                            description: "Target schema definition",
+                        },
+                        databaseType: {
+                            type: "string",
+                            enum: ["postgresql", "mysql", "sqlite"],
+                            description: "Database type for migration",
+                        },
+                        safeMode: {
+                            type: "boolean",
+                            description: "Generate rollback scripts and safety checks",
+                            default: true,
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_schema":
-                    return await this.analyzeSchema(args);
-                case "optimize_query":
-                    return await this.optimizeQuery(args);
-                case "design_data_model":
-                    return await this.designDataModel(args);
-                case "migrate_schema":
-                    return await this.migrateSchema(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["currentSchema", "targetSchema"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze_schema": async (args) => this.analyzeSchema(args),
+            "optimize_query": async (args) => this.optimizeQuery(args),
+            "design_data_model": async (args) => this.designDataModel(args),
+            "migrate_schema": async (args) => this.migrateSchema(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeSchema(args) {
         const { schemaFile, databaseType = "postgresql", includeIndexes = true, } = args;
@@ -804,19 +779,10 @@ class XrayDatabaseDesignServer {
         };
         return icons[severity] || "❓";
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "database-design.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayDatabaseDesignServer();
-    server.run().catch(() => { });
+    server.run("database-design").catch((err) => { frameworkLogger.log("database-design", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { XrayDatabaseDesignServer };

package/dist/mcps/knowledge-skills/devops-deployment.server.d.ts

@@ -4,10 +4,9 @@
  * Knowledge skill for DevOps practices, deployment strategies,
  * CI/CD pipeline design, and infrastructure automation
  */
-declare class XrayDevOpsDeploymentServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeCICDPipeline;
     private designDeploymentStrategy;
     private generateInfrastructureCode;
@@ -38,6 +37,5 @@ declare class XrayDevOpsDeploymentServer {
     private analyzeStageDistribution;
     private identifyPipelineOptimizations;
     private getInfrastructureLanguage;
-    run(): Promise<void>;
 }
 export { XrayDevOpsDeploymentServer };

package/dist/mcps/knowledge-skills/devops-deployment.server.js

@@ -4,169 +4,89 @@
  * Knowledge skill for DevOps practices, deployment strategies,
  * CI/CD pipeline design, and infrastructure automation
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-class XrayDevOpsDeploymentServer {
-    server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class XrayDevOpsDeploymentServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "devops-deployment", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
+        super("devops-deployment", "2.0.1");
+        this.tools = [
+            {
+                name: "analyze_ci_cd_pipeline",
+                description: "Analyze CI/CD pipeline configuration and suggest optimizations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        pipelineConfig: { type: "string", description: "CI/CD pipeline configuration (YAML/JSON)" },
+                        platform: { type: "string", enum: ["github-actions", "gitlab-ci", "jenkins", "circle-ci", "azure-devops"], description: "CI/CD platform being used" },
+                        includeSecurity: { type: "boolean", description: "Include security gate analysis", default: true },
+                    },
+                    required: ["pipelineConfig", "platform"],
+                },
             },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_ci_cd_pipeline",
-                        description: "Analyze CI/CD pipeline configuration and suggest optimizations",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                pipelineConfig: {
-                                    type: "string",
-                                    description: "CI/CD pipeline configuration (YAML/JSON)",
-                                },
-                                platform: {
-                                    type: "string",
-                                    enum: [
-                                        "github-actions",
-                                        "gitlab-ci",
-                                        "jenkins",
-                                        "circle-ci",
-                                        "azure-devops",
-                                    ],
-                                    description: "CI/CD platform being used",
-                                },
-                                includeSecurity: {
-                                    type: "boolean",
-                                    description: "Include security gate analysis",
-                                    default: true,
-                                },
-                            },
-                            required: ["pipelineConfig", "platform"],
-                        },
+            {
+                name: "design_deployment_strategy",
+                description: "Design optimal deployment strategy for application requirements",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        applicationType: { type: "string", enum: ["web-app", "api", "mobile", "microservices", "monolith"], description: "Type of application" },
+                        scale: { type: "string", enum: ["small", "medium", "large", "enterprise"], description: "Expected scale/traffic" },
+                        availability: { type: "string", enum: ["basic", "high", "critical"], description: "Required availability level" },
+                        budget: { type: "string", enum: ["cost-optimized", "balanced", "performance-optimized"], description: "Budget considerations" },
                     },
-                    {
-                        name: "design_deployment_strategy",
-                        description: "Design optimal deployment strategy for application requirements",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                applicationType: {
-                                    type: "string",
-                                    enum: [
-                                        "web-app",
-                                        "api",
-                                        "mobile",
-                                        "microservices",
-                                        "monolith",
-                                    ],
-                                    description: "Type of application",
-                                },
-                                scale: {
-                                    type: "string",
-                                    enum: ["small", "medium", "large", "enterprise"],
-                                    description: "Expected scale/traffic",
-                                },
-                                availability: {
-                                    type: "string",
-                                    enum: ["basic", "high", "critical"],
-                                    description: "Required availability level",
-                                },
-                                budget: {
-                                    type: "string",
-                                    enum: ["cost-optimized", "balanced", "performance-optimized"],
-                                    description: "Budget considerations",
-                                },
-                            },
-                            required: ["applicationType", "scale"],
-                        },
+                    required: ["applicationType", "scale"],
+                },
+            },
+            {
+                name: "generate_infrastructure_code",
+                description: "Generate infrastructure as code for deployment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        platform: { type: "string", enum: ["aws", "azure", "gcp", "kubernetes"], description: "Target cloud platform" },
+                        services: { type: "array", items: { type: "string" }, description: "Required services (database, cache, storage, etc.)" },
+                        environment: { type: "string", enum: ["development", "staging", "production"], description: "Deployment environment" },
+                        scaling: { type: "boolean", description: "Include auto-scaling configuration", default: true },
                     },
-                    {
-                        name: "generate_infrastructure_code",
-                        description: "Generate infrastructure as code for deployment",
-                        inputSchema: {
+                    required: ["platform", "services"],
+                },
+            },
+            {
+                name: "optimize_deployment_performance",
+                description: "Analyze and optimize deployment performance and reliability",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        currentMetrics: {
                             type: "object",
                             properties: {
-                                platform: {
-                                    type: "string",
-                                    enum: ["aws", "azure", "gcp", "kubernetes"],
-                                    description: "Target cloud platform",
-                                },
-                                services: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Required services (database, cache, storage, etc.)",
-                                },
-                                environment: {
-                                    type: "string",
-                                    enum: ["development", "staging", "production"],
-                                    description: "Deployment environment",
-                                },
-                                scaling: {
-                                    type: "boolean",
-                                    description: "Include auto-scaling configuration",
-                                    default: true,
-                                },
+                                deployTime: { type: "number" },
+                                failureRate: { type: "number" },
+                                rollbackTime: { type: "number" },
                             },
-                            required: ["platform", "services"],
+                            description: "Current deployment metrics",
                         },
-                    },
-                    {
-                        name: "optimize_deployment_performance",
-                        description: "Analyze and optimize deployment performance and reliability",
-                        inputSchema: {
+                        constraints: {
                             type: "object",
                             properties: {
-                                currentMetrics: {
-                                    type: "object",
-                                    properties: {
-                                        deployTime: { type: "number" },
-                                        failureRate: { type: "number" },
-                                        rollbackTime: { type: "number" },
-                                    },
-                                    description: "Current deployment metrics",
-                                },
-                                constraints: {
-                                    type: "object",
-                                    properties: {
-                                        maxDowntime: { type: "number" },
-                                        budget: { type: "number" },
-                                        teamSize: { type: "number" },
-                                    },
-                                    description: "Business and technical constraints",
-                                },
+                                maxDowntime: { type: "number" },
+                                budget: { type: "number" },
+                                teamSize: { type: "number" },
                             },
-                            required: ["currentMetrics"],
+                            description: "Business and technical constraints",
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_ci_cd_pipeline":
-                    return await this.analyzeCICDPipeline(args);
-                case "design_deployment_strategy":
-                    return await this.designDeploymentStrategy(args);
-                case "generate_infrastructure_code":
-                    return await this.generateInfrastructureCode(args);
-                case "optimize_deployment_performance":
-                    return await this.optimizeDeploymentPerformance(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["currentMetrics"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze_ci_cd_pipeline": async (args) => this.analyzeCICDPipeline(args),
+            "design_deployment_strategy": async (args) => this.designDeploymentStrategy(args),
+            "generate_infrastructure_code": async (args) => this.generateInfrastructureCode(args),
+            "optimize_deployment_performance": async (args) => this.optimizeDeploymentPerformance(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeCICDPipeline(args) {
         const { pipelineConfig, platform, includeSecurity = true } = args;
@@ -1162,19 +1082,10 @@ spec:
                 return "json";
         }
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "devops-deployment.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayDevOpsDeploymentServer();
-    server.run().catch(() => { });
+    server.run("devops-deployment").catch((err) => { frameworkLogger.log("devops-deployment", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { XrayDevOpsDeploymentServer };

package/dist/mcps/knowledge-skills/git-workflow.server.d.ts

@@ -4,12 +4,10 @@
  * Knowledge skill for version control strategies, branching models,
  * and collaborative development workflows
  */
-declare class XrayGitWorkflowServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayGitWorkflowServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeGitHistory;
     private recommendBranchingStrategy;
-    run(): Promise<void>;
 }
 export default XrayGitWorkflowServer;