0xray 2.1.2 → 2.1.3

package/dist/mcps/knowledge-skills/project-analysis.server.js

@@ -4,187 +4,89 @@
  * Knowledge skill for project structure analysis, complexity assessment,
  * and pattern recognition - provides deep project intelligence
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../../core/framework-logger.js";
-class ProjectAnalysisServer {
-    server;
+class ProjectAnalysisServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "project-analysis", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Server initialization - removed unnecessary startup logging
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze-project-structure",
-                        description: "Analyze complete project structure including file organization, directory hierarchy, and module distribution",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project to analyze",
-                                },
-                                includeMetrics: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include detailed metrics in analysis",
-                                },
-                                maxDepth: {
-                                    type: "number",
-                                    default: 10,
-                                    description: "Maximum directory depth to analyze",
-                                },
-                            },
-                            required: ["projectRoot"],
-                        },
+        super("project-analysis", "2.0.1");
+        this.tools = [
+            {
+                name: "analyze-project-structure",
+                description: "Analyze complete project structure including file organization, directory hierarchy, and module distribution",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: { type: "string", description: "Root directory of the project to analyze" },
+                        includeMetrics: { type: "boolean", default: true, description: "Include detailed metrics in analysis" },
+                        maxDepth: { type: "number", default: 10, description: "Maximum directory depth to analyze" },
                     },
-                    {
-                        name: "assess-project-complexity",
-                        description: "Assess overall project complexity including code metrics, maintainability, and technical debt indicators",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                includeBreakdown: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include per-file complexity breakdown",
-                                },
-                                focusAreas: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: ["functions", "classes", "imports", "dependencies"],
-                                    },
-                                    description: "Specific areas to focus complexity analysis on",
-                                },
-                            },
-                            required: ["projectRoot"],
-                        },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "assess-project-complexity",
+                description: "Assess overall project complexity including code metrics, maintainability, and technical debt indicators",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: { type: "string", description: "Root directory of the project" },
+                        includeBreakdown: { type: "boolean", default: true, description: "Include per-file complexity breakdown" },
+                        focusAreas: { type: "array", items: { type: "string", enum: ["functions", "classes", "imports", "dependencies"] }, description: "Specific areas to focus complexity analysis on" },
                     },
-                    {
-                        name: "identify-project-patterns",
-                        description: "Identify architectural patterns, code patterns, and structural patterns in the project",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                patternTypes: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "architectural",
-                                            "code",
-                                            "structural",
-                                            "anti-patterns",
-                                        ],
-                                    },
-                                    description: "Types of patterns to identify",
-                                },
-                                confidenceThreshold: {
-                                    type: "number",
-                                    default: 0.7,
-                                    description: "Minimum confidence for pattern detection",
-                                },
-                            },
-                            required: ["projectRoot"],
-                        },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "identify-project-patterns",
+                description: "Identify architectural patterns, code patterns, and structural patterns in the project",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: { type: "string", description: "Root directory of the project" },
+                        patternTypes: { type: "array", items: { type: "string", enum: ["architectural", "code", "structural", "anti-patterns"] }, description: "Types of patterns to identify" },
+                        confidenceThreshold: { type: "number", default: 0.7, description: "Minimum confidence for pattern detection" },
                     },
-                    {
-                        name: "analyze-project-health",
-                        description: "Provide comprehensive project health assessment including quality metrics and improvement recommendations",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: {
-                                    type: "string",
-                                    description: "Root directory of the project",
-                                },
-                                includeTrends: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Include historical trend analysis",
-                                },
-                                focusMetrics: {
-                                    type: "array",
-                                    items: {
-                                        type: "string",
-                                        enum: [
-                                            "complexity",
-                                            "coverage",
-                                            "maintainability",
-                                            "dependencies",
-                                            "patterns",
-                                        ],
-                                    },
-                                    description: "Specific health metrics to focus on",
-                                },
-                            },
-                            required: ["projectRoot"],
-                        },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "analyze-project-health",
+                description: "Provide comprehensive project health assessment including quality metrics and improvement recommendations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: { type: "string", description: "Root directory of the project" },
+                        includeTrends: { type: "boolean", default: false, description: "Include historical trend analysis" },
+                        focusMetrics: { type: "array", items: { type: "string", enum: ["complexity", "coverage", "maintainability", "dependencies", "patterns"] }, description: "Specific health metrics to focus on" },
                     },
-                    {
-                        name: "analyze_proposal",
-                        description: "Analyze an inference proposal from a research / codebase pattern 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"],
-                        },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "analyze_proposal",
+                description: "Analyze an inference proposal from a research / codebase pattern 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" },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "analyze-project-structure":
-                        return await this.analyzeProjectStructure(args);
-                    case "assess-project-complexity":
-                        return await this.assessProjectComplexity(args);
-                    case "identify-project-patterns":
-                        return await this.identifyProjectPatterns(args);
-                    case "analyze-project-health":
-                        return await this.analyzeProjectHealth(args);
-                    case "analyze_proposal":
-                        return await this.analyzeProposal(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                frameworkLogger.log("mcps/project-analysis", "tool", "error", { tool: name, error: String(error) });
-                throw error;
-            }
-        });
+                    required: ["proposalTitle", "proposalDescription"],
+                },
+            },
+        ];
+        this.handlers = {
+            "analyze-project-structure": async (args) => this.analyzeProjectStructure(args),
+            "assess-project-complexity": async (args) => this.assessProjectComplexity(args),
+            "identify-project-patterns": async (args) => this.identifyProjectPatterns(args),
+            "analyze-project-health": async (args) => this.analyzeProjectHealth(args),
+            "analyze_proposal": async (args) => this.analyzeProposal(args),
+        };
+        this.setupToolHandlers();
     }
     async analyzeProjectStructure(args) {
         const { projectRoot, includeMetrics = true, maxDepth = 10 } = args;
@@ -749,63 +651,10 @@ class ProjectAnalysisServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await frameworkLogger.log("mcp-project-analysis", "server-started", "success");
-        const cleanup = async (signal) => {
-            frameworkLogger.log("mcps/project-analysis", "shutdown", "info", { signal });
-            // Set a timeout to force exit if graceful shutdown fails
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/project-analysis", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000); // 5 second timeout
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/project-analysis", "shutdown", "success");
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/project-analysis", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        // Handle multiple shutdown signals
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        // Monitor parent process (opencode) and shutdown if it dies
-        const checkParent = () => {
-            try {
-                process.kill(process.ppid, 0); // Check if parent is alive
-                setTimeout(checkParent, 1000); // Check again in 1 second
-            }
-            catch (error) {
-                // Parent process died, shut down gracefully
-                frameworkLogger.log("mcps/project-analysis", "parent-death", "info");
-                cleanup("parent-process-death");
-            }
-        };
-        // Start monitoring parent process
-        setTimeout(checkParent, 2000); // Start checking after 2 seconds
-        // Handle uncaught exceptions and unhandled rejections
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/project-analysis", "uncaughtException", "error", { error: String(error) });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason, promise) => {
-            frameworkLogger.log("mcps/project-analysis", "unhandledRejection", "error", { error: String(reason) });
-            cleanup("unhandledRejection");
-        });
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new ProjectAnalysisServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/project-analysis", "run", "error", { error: String(error) }));
+    server.run("project-analysis").catch((error) => frameworkLogger.log("mcps/project-analysis", "run", "error", { error: String(error) }));
 }
 export default ProjectAnalysisServer;

package/dist/mcps/knowledge-skills/refactoring-strategies.server.d.ts

@@ -4,10 +4,9 @@
  * Knowledge skill for code refactoring, technical debt elimination,
  * modernization, and code improvement patterns
  */
-declare class XrayRefactoringStrategiesServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeTechnicalDebt;
     private suggestRefactoring;
     private generateRefactoringPlan;
@@ -28,6 +27,5 @@ declare class XrayRefactoringStrategiesServer {
     private getImpactIcon;
     private getRefactoringIcon;
     private getMigrationIcon;
-    run(): Promise<void>;
 }
 export { XrayRefactoringStrategiesServer };

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

@@ -4,157 +4,73 @@
  * 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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "refactoring-strategies", version: "2.0.1",
-        }, {
-            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", "2.0.1");
+        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: ["filePath"],
-                        },
+                    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"] }, 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,19 +694,10 @@ 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]}`) {
     const server = new XrayRefactoringStrategiesServer();
-    server.run().catch(() => { });
+    server.run("refactoring-strategies").catch((err) => { frameworkLogger.log("refactoring-strategies", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { XrayRefactoringStrategiesServer };

package/dist/mcps/knowledge-skills/security-audit.server.d.ts

@@ -4,16 +4,15 @@
  * Knowledge skill for comprehensive security analysis, vulnerability assessment,
  * and compliance validation - ensures production-ready security posture
  */
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 interface AnalyzeProposalArgs {
     proposalTitle?: string;
     proposalDescription?: string;
     evidence?: string[];
     proposalType?: string;
 }
-declare class XraySecurityAuditServer {
-    private server;
+declare class XraySecurityAuditServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private auditSecurity;
     private checkVulnerability;
     private generateSecurityReport;
@@ -43,6 +42,5 @@ declare class XraySecurityAuditServer {
             text: string;
         }[];
     }>;
-    run(): Promise<void>;
 }
 export { XraySecurityAuditServer };