0xray 2.1.2 → 2.1.4

package/src/mcps/knowledge-skills/project-analysis.server.ts

@@ -5,13 +5,7 @@
  * 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,
-  type CallToolResult,
-} 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";
@@ -136,193 +130,86 @@ interface McpToolResponse {
   content: Array<{ type: "text"; text: string }>;
 }
 
-class ProjectAnalysisServer {
-  private server: Server;
+class ProjectAnalysisServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("project-analysis", "2.0.1");
+    this.tools = [
       {
-        name: "project-analysis", version: "2.0.1",
+        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"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private 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"],
-            },
-          },
-          {
-            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"],
-            },
-          },
-          {
-            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"],
-            },
+      {
+        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): Promise<CallToolResult> => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "analyze-project-structure":
-            return await this.analyzeProjectStructure(args as unknown as AnalyzeProjectStructureArgs) as CallToolResult;
-          case "assess-project-complexity":
-            return await this.assessProjectComplexity(args as unknown as AssessProjectComplexityArgs) as CallToolResult;
-          case "identify-project-patterns":
-            return await this.identifyProjectPatterns(args as unknown as IdentifyProjectPatternsArgs) as CallToolResult;
-          case "analyze-project-health":
-            return await this.analyzeProjectHealth(args as unknown as AnalyzeProjectHealthArgs) as CallToolResult;
-          case "analyze_proposal":
-            return await this.analyzeProposal(args as any) as CallToolResult;
-          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 as unknown as AnalyzeProjectStructureArgs),
+      "assess-project-complexity": async (args) => this.assessProjectComplexity(args as unknown as AssessProjectComplexityArgs),
+      "identify-project-patterns": async (args) => this.identifyProjectPatterns(args as unknown as IdentifyProjectPatternsArgs),
+      "analyze-project-health": async (args) => this.analyzeProjectHealth(args as unknown as AnalyzeProjectHealthArgs),
+      "analyze_proposal": async (args) => this.analyzeProposal(args),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeProjectStructure(args: AnalyzeProjectStructureArgs): Promise<McpToolResponse> {
@@ -1037,75 +924,12 @@ class ProjectAnalysisServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log(
-      "mcp-project-analysis",
-      "server-started",
-      "success",
-    );
-
-    const cleanup = async (signal: string) => {
-      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: unknown) => frameworkLogger.log("mcps/project-analysis", "run", "error", { error: String(error) }));
+  server.run("project-analysis").catch((error: unknown) => frameworkLogger.log("mcps/project-analysis", "run", "error", { error: String(error) }));
 }
 
 export default ProjectAnalysisServer;

package/src/mcps/knowledge-skills/refactoring-strategies.server.ts

@@ -5,15 +5,8 @@
  * modernization, and code improvement patterns
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
 
 interface RefactoringOpportunity {
   type:
@@ -154,167 +147,72 @@ interface RollbackPlan {
   emergencyProcedures: string[];
 }
 
-class XrayRefactoringStrategiesServer {
-  private server: Server;
+class XrayRefactoringStrategiesServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("refactoring-strategies", "2.0.1");
+    this.tools = [
       {
-        name: "refactoring-strategies", version: "2.0.1",
+        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"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        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"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-    // Server initialization - removed unnecessary startup logging
-  }
-
-  private 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"],
-            },
-          },
-          {
-            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"],
-            },
-          },
-          {
-            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"],
-            },
+      {
+        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 as unknown as AnalyzeTechnicalDebtArgs) as CallToolResult;
-        case "suggest_refactoring":
-          return await this.suggestRefactoring(args as unknown as SuggestRefactoringArgs) as CallToolResult;
-        case "generate_refactoring_plan":
-          return await this.generateRefactoringPlan(args as unknown as GenerateRefactoringPlanArgs) as CallToolResult;
-        case "modernize_codebase":
-          return await this.modernizeCodebase(args as unknown as ModernizeCodebaseArgs) as CallToolResult;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
+          required: ["codePath"],
+        },
+      },
+    ];
+    this.handlers = {
+      "analyze_technical_debt": async (args) => this.analyzeTechnicalDebt(args as unknown as AnalyzeTechnicalDebtArgs),
+      "suggest_refactoring": async (args) => this.suggestRefactoring(args as unknown as SuggestRefactoringArgs),
+      "generate_refactoring_plan": async (args) => this.generateRefactoringPlan(args as unknown as GenerateRefactoringPlanArgs),
+      "modernize_codebase": async (args) => this.modernizeCodebase(args as unknown as ModernizeCodebaseArgs),
+    };
+    this.setupToolHandlers();
   }
 
   private async analyzeTechnicalDebt(args: AnalyzeTechnicalDebtArgs) {
@@ -1071,22 +969,12 @@ class XrayRefactoringStrategiesServer {
     return icons[effort as keyof typeof icons] || "❓";
   }
 
-  async run(): Promise<void> {
-    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 };