0xray 3.1.0 → 3.2.0

package/src/mcps/architect-tools.server.ts

@@ -5,13 +5,8 @@
  * Provides contextual analysis capabilities via MCP protocol
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolRequest,
-} from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema } 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";
@@ -35,168 +30,149 @@ interface FileNode {
   extension: string;
 }
 
-class XrayArchitectToolsServer {
-  private server: Server;
+class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("architect-tools", "3.1.0");
+
+    this.tools = [
       {
-        name: "architect-tools", version: "1.22.67",
+        name: "context-analysis",
+        description:
+          "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: {
+              type: "string",
+              description: "Root directory of the project to analyze",
+            },
+            depth: {
+              type: "string",
+              enum: ["overview", "detailed", "comprehensive"],
+              default: "detailed",
+              description: "Analysis depth level",
+            },
+            includeFiles: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific files to include in analysis",
+            },
+          },
+          required: ["projectRoot"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "codebase-structure",
+        description:
+          "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: {
+              type: "string",
+              description: "Root directory of the project",
+            },
+            includeMetrics: {
+              type: "boolean",
+              default: true,
+              description: "Include detailed metrics",
+            },
+            maxDepth: {
+              type: "number",
+              default: 10,
+              description: "Maximum directory depth to analyze",
+            },
+          },
+          required: ["projectRoot"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-    frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "context-analysis",
-            description:
-              "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: {
-                  type: "string",
-                  description: "Root directory of the project to analyze",
-                },
-                depth: {
-                  type: "string",
-                  enum: ["overview", "detailed", "comprehensive"],
-                  default: "detailed",
-                  description: "Analysis depth level",
-                },
-                includeFiles: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Specific files to include in analysis",
-                },
-              },
-              required: ["projectRoot"],
+      {
+        name: "dependency-analysis",
+        description:
+          "Map component dependencies, identify coupling patterns, and assess architectural relationships",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: {
+              type: "string",
+              description: "Root directory of the project",
             },
-          },
-          {
-            name: "codebase-structure",
-            description:
-              "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: {
-                  type: "string",
-                  description: "Root directory of the project",
-                },
-                includeMetrics: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include detailed metrics",
-                },
-                maxDepth: {
-                  type: "number",
-                  default: 10,
-                  description: "Maximum directory depth to analyze",
-                },
-              },
-              required: ["projectRoot"],
+            focusAreas: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific areas to focus dependency analysis on",
             },
-          },
-          {
-            name: "dependency-analysis",
-            description:
-              "Map component dependencies, identify coupling patterns, and assess architectural relationships",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: {
-                  type: "string",
-                  description: "Root directory of the project",
-                },
-                focusAreas: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Specific areas to focus dependency analysis on",
-                },
-                includeGraphs: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include dependency graphs in output",
-                },
-              },
-              required: ["projectRoot"],
+            includeGraphs: {
+              type: "boolean",
+              default: true,
+              description: "Include dependency graphs in output",
             },
           },
-          {
-            name: "architecture-assessment",
-            description:
-              "Evaluate overall architectural health with scores, issues, and improvement recommendations",
-            inputSchema: {
-              type: "object",
-              properties: {
-                projectRoot: {
-                  type: "string",
-                  description: "Root directory of the project",
-                },
-                assessmentType: {
-                  type: "string",
-                  enum: ["quick", "comprehensive"],
-                  default: "comprehensive",
-                  description: "Type of assessment to perform",
-                },
-                focusMetrics: {
-                  type: "array",
-                  items: {
-                    type: "string",
-                    enum: [
-                      "complexity",
-                      "coupling",
-                      "cohesion",
-                      "testability",
-                      "scalability",
-                    ],
-                  },
-                  description: "Specific metrics to focus assessment on",
-                },
+          required: ["projectRoot"],
+        },
+      },
+      {
+        name: "architecture-assessment",
+        description:
+          "Evaluate overall architectural health with scores, issues, and improvement recommendations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            projectRoot: {
+              type: "string",
+              description: "Root directory of the project",
+            },
+            assessmentType: {
+              type: "string",
+              enum: ["quick", "comprehensive"],
+              default: "comprehensive",
+              description: "Type of assessment to perform",
+            },
+            focusMetrics: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: [
+                  "complexity",
+                  "coupling",
+                  "cohesion",
+                  "testability",
+                  "scalability",
+                ],
               },
-              required: ["projectRoot"],
+              description: "Specific metrics to focus assessment on",
             },
           },
-        ],
-      };
-    });
+          required: ["projectRoot"],
+        },
+      },
+    ];
 
-    this.server.setRequestHandler(
-      CallToolRequestSchema,
-      async (request: CallToolRequest) => {
-        const { name, arguments: args } = request.params;
+    this.handlers = {
+      "context-analysis": async (args) => this.contextAnalysis(args as Record<string, unknown> | undefined),
+      "codebase-structure": async (args) => this.codebaseStructure(args as Record<string, unknown> | undefined),
+      "dependency-analysis": async (args) => this.dependencyAnalysis(args as Record<string, unknown> | undefined),
+      "architecture-assessment": async (args) => this.architectureAssessment(args as Record<string, unknown> | undefined),
+    };
 
-        try {
-          switch (name) {
-            case "context-analysis":
-              return await this.contextAnalysis(args);
-            case "codebase-structure":
-              return await this.codebaseStructure(args);
-            case "dependency-analysis":
-              return await this.dependencyAnalysis(args);
-            case "architecture-assessment":
-              return await this.architectureAssessment(args);
-            default:
-              throw new Error(`Unknown tool: ${name}`);
-          }
-        } catch (error) {
-          frameworkLogger.log("mcps/architect-tools", "tool", "error", { tool: name, error: String(error) });
-          throw error;
-        }
-      },
-    );
+    this.setupToolHandlers();
+    frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
+  }
+
+  override setupToolHandlers(): void {
+    this.setupListToolsHandler();
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const handler = this.handlers[name];
+      if (!handler) throw new Error(`Unknown tool: ${name}`);
+      try {
+        return await handler(args);
+      } catch (error) {
+        frameworkLogger.log("mcps/architect-tools", "tool", "error", { tool: name, error: String(error) });
+        throw error;
+      }
+    });
   }
 
   // Tool implementations — delegates to real architect-tools library
@@ -274,68 +250,10 @@ class XrayArchitectToolsServer {
     };
   }
 
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/architect-tools", "start", "info");
-
-    const cleanup = async (signal: string) => {
-      frameworkLogger.log("mcps/architect-tools", "shutdown", "info", { signal });
 
-      // Set a timeout to force exit if graceful shutdown fails
-      const timeout = setTimeout(() => {
-        frameworkLogger.log("mcps/architect-tools", "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/architect-tools", "shutdown", "success");
-        process.exit(0);
-      } catch (error) {
-        clearTimeout(timeout);
-        frameworkLogger.log("mcps/architect-tools", "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/architect-tools", "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/architect-tools", "uncaughtException", "error", { error: String(error) });
-      cleanup("uncaughtException");
-    });
-
-    process.on("unhandledRejection", (reason, promise) => {
-      frameworkLogger.log("mcps/architect-tools", "unhandledRejection", "error", { error: String(reason) });
-      cleanup("unhandledRejection");
-    });
-  }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayArchitectToolsServer();
   server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }

package/src/mcps/auto-format.server.ts

@@ -4,13 +4,8 @@
  * Automated code formatting hook with Prettier and framework-specific formatters
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolRequest,
-} from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
@@ -34,111 +29,92 @@ interface FormatResults {
   changes: Record<string, string[]>;
 }
 
-class XrayAutoFormatServer {
-  private server: Server;
+class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("auto-format", "3.1.0");
+
+    this.tools = [
       {
-        name: "auto-format", version: "1.22.67",
+        name: "auto-format",
+        description:
+          "Automated code formatting hook with Prettier and framework-specific formatters",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific files to format (optional - formats all if empty)",
+            },
+            formatters: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: ["prettier", "eslint", "typescript", "all"],
+              },
+              default: ["all"],
+              description: "Formatters to apply",
+            },
+            checkOnly: {
+              type: "boolean",
+              default: false,
+              description: "Only check formatting without applying changes",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "format-check",
+        description:
+          "Check if code is properly formatted without making changes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Files to check formatting for",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "auto-format": async (args) => this.handleAutoFormat(args as unknown as AutoFormatArgs),
+      "format-check": async (args) => this.handleFormatCheck(args as unknown as FormatCheckArgs),
+    };
 
     this.setupToolHandlers();
     frameworkLogger.log("mcps/auto-format", "initialize", "info");
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "auto-format",
-            description:
-              "Automated code formatting hook with Prettier and framework-specific formatters",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific files to format (optional - formats all if empty)",
-                },
-                formatters: {
-                  type: "array",
-                  items: {
-                    type: "string",
-                    enum: ["prettier", "eslint", "typescript", "all"],
-                  },
-                  default: ["all"],
-                  description: "Formatters to apply",
-                },
-                checkOnly: {
-                  type: "boolean",
-                  default: false,
-                  description: "Only check formatting without applying changes",
-                },
-              },
-            },
-          },
-          {
-            name: "format-check",
-            description:
-              "Check if code is properly formatted without making changes",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Files to check formatting for",
-                },
-              },
+  override setupToolHandlers(): void {
+    this.setupListToolsHandler();
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      const handler = this.handlers[name];
+      if (!handler) throw new Error(`Unknown tool: ${name}`);
+      try {
+        return await handler(args);
+      } catch (error) {
+        frameworkLogger.log("mcps/auto-format", "tool-call", "error", {
+          tool: name,
+          error: String(error),
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`,
             },
-          },
-        ],
-      };
+          ],
+          isError: true,
+        };
+      }
     });
-
-    // Handle tool calls
-    this.server.setRequestHandler(
-      CallToolRequestSchema,
-      async (request: CallToolRequest) => {
-        const { name, arguments: args } = request.params;
-
-        try {
-          switch (name) {
-            case "auto-format":
-              return await this.handleAutoFormat(args as unknown as AutoFormatArgs);
-            case "format-check":
-              return await this.handleFormatCheck(args as unknown as FormatCheckArgs);
-            default:
-              throw new Error(`Unknown tool: ${name}`);
-          }
-        } catch (error) {
-          frameworkLogger.log("mcps/auto-format", "tool-call", "error", {
-            tool: name,
-            error: String(error),
-          });
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`,
-              },
-            ],
-            isError: true,
-          };
-        }
-      },
-    );
   }
 
   private async handleAutoFormat(args: AutoFormatArgs) {
@@ -513,15 +489,10 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Formatters Applied: ${Object.keys(results.changes).length}`;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/auto-format", "start", "info");
-  }
 }
 
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayAutoFormatServer();
   server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }