0xray 3.1.0 → 3.2.0

package/dist/mcps/knowledge-skills/refactoring-strategies.server.js

@@ -4,157 +4,132 @@
  * Knowledge skill for code refactoring, technical debt elimination,
  * modernization, and code improvement patterns
  */
-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 XrayRefactoringStrategiesServer {
-    server;
+import * as fs from "fs";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "refactoring-strategies", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze_technical_debt",
-                        description: "Analyze codebase for technical debt and refactoring opportunities",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to code directory to analyze",
-                                },
-                                includeModernization: {
-                                    type: "boolean",
-                                    description: "Include technology modernization suggestions",
-                                    default: true,
-                                },
-                                debtThreshold: {
-                                    type: "number",
-                                    description: "Minimum debt score to report (0-100)",
-                                    default: 20,
-                                },
-                            },
-                            required: ["codePath"],
+        super("refactoring-strategies", "3.1.0");
+        this.tools = [
+            {
+                name: "analyze_technical_debt",
+                description: "Analyze codebase for technical debt and refactoring opportunities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codePath: {
+                            type: "string",
+                            description: "Path to code directory to analyze",
+                        },
+                        includeModernization: {
+                            type: "boolean",
+                            description: "Include technology modernization suggestions",
+                            default: true,
+                        },
+                        debtThreshold: {
+                            type: "number",
+                            description: "Minimum debt score to report (0-100)",
+                            default: 20,
                         },
                     },
-                    {
-                        name: "suggest_refactoring",
-                        description: "Suggest specific refactoring opportunities for improved code quality",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: {
-                                    type: "string",
-                                    description: "Path to specific file to analyze",
-                                },
-                                refactoringTypes: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "extract-method",
-                                            "rename-variable",
-                                            "remove-duplicate",
-                                            "simplify-condition",
-                                            "extract-class",
-                                            "move-method",
-                                        ],
-                                    },
-                                    description: "Types of refactoring to focus on",
-                                },
-                                maxSuggestions: {
-                                    type: "number",
-                                    description: "Maximum number of suggestions to return",
-                                    default: 10,
-                                },
+                    required: ["codePath"],
+                },
+            },
+            {
+                name: "suggest_refactoring",
+                description: "Suggest specific refactoring opportunities for improved code quality",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        filePath: {
+                            type: "string",
+                            description: "Path to specific file to analyze",
+                        },
+                        refactoringTypes: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "extract-method",
+                                    "rename-variable",
+                                    "remove-duplicate",
+                                    "simplify-condition",
+                                    "extract-class",
+                                    "move-method",
+                                ],
                             },
-                            required: ["filePath"],
+                            description: "Types of refactoring to focus on",
+                        },
+                        maxSuggestions: {
+                            type: "number",
+                            description: "Maximum number of suggestions to return",
+                            default: 10,
                         },
                     },
-                    {
-                        name: "generate_refactoring_plan",
-                        description: "Generate a comprehensive refactoring plan with prioritization",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to codebase for refactoring analysis",
-                                },
-                                timeBudget: {
-                                    type: "string",
-                                    enum: ["1-week", "1-month", "3-months", "6-months"],
-                                    description: "Available time for refactoring",
-                                },
-                                riskTolerance: {
-                                    type: "string",
-                                    enum: ["low", "medium", "high"],
-                                    description: "Risk tolerance for changes",
-                                },
-                                priorities: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific priorities (performance, maintainability, security)",
-                                    default: ["maintainability", "performance"],
-                                },
-                            },
-                            required: ["codePath", "timeBudget"],
+                    required: ["filePath"],
+                },
+            },
+            {
+                name: "generate_refactoring_plan",
+                description: "Generate a comprehensive refactoring plan with prioritization",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codePath: {
+                            type: "string",
+                            description: "Path to codebase for refactoring analysis",
+                        },
+                        timeBudget: {
+                            type: "string",
+                            enum: ["1-week", "1-month", "3-months", "6-months"],
+                            description: "Available time for refactoring",
+                        },
+                        riskTolerance: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "Risk tolerance for changes",
+                        },
+                        priorities: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific priorities (performance, maintainability, security)",
+                            default: ["maintainability", "performance"],
                         },
                     },
-                    {
-                        name: "modernize_codebase",
-                        description: "Suggest modernization strategies for outdated code and dependencies",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                codePath: {
-                                    type: "string",
-                                    description: "Path to codebase to analyze",
-                                },
-                                technologies: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific technologies to focus on (node, react, etc.)",
-                                },
-                                safeMode: {
-                                    type: "boolean",
-                                    description: "Only suggest low-risk modernization options",
-                                    default: true,
-                                },
-                            },
-                            required: ["codePath"],
+                    required: ["codePath", "timeBudget"],
+                },
+            },
+            {
+                name: "modernize_codebase",
+                description: "Suggest modernization strategies for outdated code and dependencies",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codePath: {
+                            type: "string",
+                            description: "Path to codebase to analyze",
+                        },
+                        technologies: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific technologies to focus on (node, react, etc.)",
+                        },
+                        safeMode: {
+                            type: "boolean",
+                            description: "Only suggest low-risk modernization options",
+                            default: true,
                         },
                     },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze_technical_debt":
-                    return await this.analyzeTechnicalDebt(args);
-                case "suggest_refactoring":
-                    return await this.suggestRefactoring(args);
-                case "generate_refactoring_plan":
-                    return await this.generateRefactoringPlan(args);
-                case "modernize_codebase":
-                    return await this.modernizeCodebase(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                    required: ["codePath"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze_technical_debt": async (args) => this.analyzeTechnicalDebt(args),
+            "suggest_refactoring": async (args) => this.suggestRefactoring(args),
+            "generate_refactoring_plan": async (args) => this.generateRefactoringPlan(args),
+            "modernize_codebase": async (args) => this.modernizeCodebase(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeTechnicalDebt(args) {
         const { codePath, includeModernization = true, debtThreshold = 20 } = args;
@@ -778,18 +753,9 @@ class XrayRefactoringStrategiesServer {
         const icons = { low: "🟢", medium: "🟡", high: "🔴" };
         return icons[effort] || "❓";
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "refactoring-strategies.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayRefactoringStrategiesServer();
     server.run().catch(() => { });
 }

package/dist/mcps/knowledge-skills/security-audit.server.js

@@ -4,146 +4,28 @@
  * Knowledge skill for comprehensive security analysis, vulnerability assessment,
  * and compliance validation - ensures production-ready security posture
  */
-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";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { tryLLMGovernance } from "../../governance/llm-governance-provider.js";
-class XraySecurityAuditServer {
-    server;
+class XraySecurityAuditServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "security-audit", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("security-audit", "3.1.0");
+        this.tools = [
+            { name: "audit_security", description: "Perform comprehensive security audit on codebase files", inputSchema: { type: "object", properties: { files: { type: "array", items: { type: "string" }, description: "List of file paths to audit" }, includeDependencies: { type: "boolean", description: "Include dependency vulnerability analysis", default: true }, complianceFrameworks: { type: "array", items: { type: "string", enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"] }, description: "Compliance frameworks to check against" } }, required: ["files"] } },
+            { name: "check_vulnerability", description: "Check specific security vulnerability patterns in a file", inputSchema: { type: "object", properties: { filePath: { type: "string", description: "Path to the file to check" }, vulnerabilityType: { type: "string", enum: ["injection", "authentication", "authorization", "cryptography", "xss", "csrf", "secrets", "configuration"] }, severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"], description: "Minimum severity level to report" } }, required: ["filePath", "vulnerabilityType"] } },
+            { name: "generate_security_report", description: "Generate comprehensive security report with remediation steps", inputSchema: { type: "object", properties: { auditResults: { type: "object", description: "Results from audit_security tool" }, format: { type: "string", enum: ["markdown", "json", "html"], default: "markdown" }, includeRemediation: { type: "boolean", default: true } }, required: ["auditResults"] } },
+            { name: "analyze_proposal", description: "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision", inputSchema: { type: "object", properties: { proposalTitle: { type: "string" }, proposalDescription: { type: "string" }, evidence: { type: "array", items: { type: "string" } }, proposalType: { type: "string" } }, required: ["proposalTitle", "proposalDescription"] } },
+        ];
+        this.handlers = {
+            audit_security: async (args) => this.auditSecurity(args),
+            check_vulnerability: async (args) => this.checkVulnerability(args),
+            generate_security_report: async (args) => this.generateSecurityReport(args),
+            analyze_proposal: async (args) => this.analyzeProposal(args),
+        };
         this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "audit_security",
-                        description: "Perform comprehensive security audit on codebase files",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "List of file paths to audit",
-                                },
-                                includeDependencies: {
-                                    type: "boolean",
-                                    description: "Include dependency vulnerability analysis",
-                                    default: true,
-                                },
-                                complianceFrameworks: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: ["owasp-top-10", "nist", "iso-27001", "pci-dss"],
-                                    },
-                                    description: "Compliance frameworks to check against",
-                                },
-                            },
-                            required: ["files"],
-                        },
-                    },
-                    {
-                        name: "check_vulnerability",
-                        description: "Check specific security vulnerability patterns in a file",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                filePath: {
-                                    type: "string",
-                                    description: "Path to the file to check",
-                                },
-                                vulnerabilityType: {
-                                    type: "string",
-                                    enum: [
-                                        "injection",
-                                        "authentication",
-                                        "authorization",
-                                        "cryptography",
-                                        "xss",
-                                        "csrf",
-                                        "secrets",
-                                        "configuration",
-                                    ],
-                                },
-                                severity: {
-                                    type: "string",
-                                    enum: ["critical", "high", "medium", "low", "info"],
-                                    description: "Minimum severity level to report",
-                                },
-                            },
-                            required: ["filePath", "vulnerabilityType"],
-                        },
-                    },
-                    {
-                        name: "generate_security_report",
-                        description: "Generate comprehensive security report with remediation steps",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                auditResults: {
-                                    type: "object",
-                                    description: "Results from audit_security tool",
-                                },
-                                format: {
-                                    type: "string",
-                                    enum: ["markdown", "json", "html"],
-                                    default: "markdown",
-                                },
-                                includeRemediation: {
-                                    type: "boolean",
-                                    default: true,
-                                },
-                            },
-                            required: ["auditResults"],
-                        },
-                    },
-                    {
-                        name: "analyze_proposal",
-                        description: "Analyze an inference proposal (pattern/bug/refactor) from a security perspective and return a structured governance decision",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                proposalTitle: { type: "string" },
-                                proposalDescription: { type: "string" },
-                                evidence: { type: "array", items: { type: "string" } },
-                                proposalType: { type: "string" },
-                            },
-                            required: ["proposalTitle", "proposalDescription"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "audit_security":
-                    return await this.auditSecurity(args);
-                case "check_vulnerability":
-                    return await this.checkVulnerability(args);
-                case "generate_security_report":
-                    return await this.generateSecurityReport(args);
-                case "analyze_proposal":
-                    return await this.analyzeProposal(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
     }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
     async auditSecurity(args) {
         const { files, includeDependencies = true, complianceFrameworks = ["owasp-top-10"], } = args;
         try {
@@ -798,18 +680,9 @@ class XraySecurityAuditServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "security-audit.server",
-            server: this.server,
-        });
-    }
 }
 // Run the server if this file is executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XraySecurityAuditServer();
     server.run().catch(() => { });
 }