0xray 3.0.11 → 3.0.14

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

@@ -5,6 +5,13 @@
  * 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 * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
@@ -14,7 +21,6 @@ import {
   dependencyAnalysis as architectDependencyAnalysis,
   architectureAssessment as architectArchitectureAssessment,
 } from "../architect/architect-tools.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface DirectoryNode {
   name: string;
@@ -29,131 +35,168 @@ interface FileNode {
   extension: string;
 }
 
-class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
+class XrayArchitectToolsServer {
+  private server: Server;
 
   constructor() {
-    super("architect-tools", "2.0.1");
-    this.tools = [
+    this.server = new Server(
       {
-        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: "architect-tools", version: "1.22.67",
       },
       {
-        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"],
+        capabilities: {
+          tools: {},
         },
       },
-      {
-        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",
+    );
+
+    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"],
             },
           },
-          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",
+          {
+            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"],
             },
-            assessmentType: {
-              type: "string",
-              enum: ["quick", "comprehensive"],
-              default: "comprehensive",
-              description: "Type of assessment to perform",
+          },
+          {
+            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"],
             },
-            focusMetrics: {
-              type: "array",
-              items: {
-                type: "string",
-                enum: [
-                  "complexity",
-                  "coupling",
-                  "cohesion",
-                  "testability",
-                  "scalability",
-                ],
+          },
+          {
+            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",
+                },
               },
-              description: "Specific metrics to focus assessment on",
+              required: ["projectRoot"],
             },
           },
-          required: ["projectRoot"],
-        },
+        ],
+      };
+    });
+
+    this.server.setRequestHandler(
+      CallToolRequestSchema,
+      async (request: CallToolRequest) => {
+        const { name, arguments: args } = request.params;
+
+        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.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),
-    };
-    this.setupToolHandlers();
-    frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
+    );
   }
 
   // Tool implementations — delegates to real architect-tools library
@@ -230,11 +273,71 @@ class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
       ],
     };
   }
+
+  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]}`) {
   const server = new XrayArchitectToolsServer();
-  server.run("architect-tools").catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }
 
 export default XrayArchitectToolsServer;

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

@@ -4,11 +4,17 @@
  * 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 { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface AutoFormatArgs {
   files?: string[];
@@ -28,65 +34,113 @@ interface FormatResults {
   changes: Record<string, string[]>;
 }
 
-class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
+class XrayAutoFormatServer {
+  private server: Server;
 
   constructor() {
-    super("auto-format", "2.0.1");
-    this.tools = [
+    this.server = new Server(
       {
-        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: "auto-format", version: "1.22.67",
       },
       {
-        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",
-            },
-          },
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-    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",
+                },
+              },
+            },
+          },
+        ],
+      };
+    });
+
+    // 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) {
     const files = args.files || [];
     const formatters = args.formatters || ["all"];
@@ -458,12 +512,18 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Errors: ${errorCount}
 - 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]}`) {
   const server = new XrayAutoFormatServer();
-  server.run("auto-format").catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }
 
 export { XrayAutoFormatServer };