0xray 3.1.1 → 3.2.0

package/src/mcps/estimation.server.ts

@@ -4,135 +4,84 @@
  * Provides tools for tracking and validating estimates
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { getEstimationValidator } from "../validation/estimation-validator.js";
 
 /**
  * Estimation MCP Server
  * Tracks estimates vs actuals and provides calibrated predictions
  */
-class EstimationServer {
-  private server: Server;
+class EstimationServer extends XrayKnowledgeSkillBase {
   private validator = getEstimationValidator();
 
   constructor() {
-    this.server = new Server(
+    super("estimation-validator", "3.1.0");
+    this.tools = [
       {
-        name: "estimation-validator", version: "3.1.0",
-      },
-      {
-        capabilities: { tools: {} },
-      }
-    );
-
-    this.setupToolHandlers();
-  }
-
-  private setupToolHandlers(): void {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "validate-estimate",
-            description: "Validate an estimate against historical data",
-            inputSchema: {
-              type: "object",
-              properties: {
-                category: {
-                  type: "string",
-                  description: "Task category (e.g., 'refactoring', 'testing', 'documentation')",
-                },
-                estimate: {
-                  type: "number",
-                  description: "Estimated time in minutes",
-                },
-                description: {
-                  type: "string",
-                  description: "Brief description of the task",
-                },
-              },
-              required: ["category", "estimate"],
+        name: "validate-estimate",
+        description: "Validate an estimate against historical data",
+        inputSchema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              description: "Task category (e.g., 'refactoring', 'testing', 'documentation')",
             },
-          },
-          {
-            name: "start-tracking",
-            description: "Start tracking time for a task",
-            inputSchema: {
-              type: "object",
-              properties: {
-                taskId: { type: "string" },
-                category: { type: "string" },
-                estimate: { type: "number" },
-                description: { type: "string" },
-              },
-              required: ["taskId", "category", "estimate"],
+            estimate: {
+              type: "number",
+              description: "Estimated time in minutes",
             },
-          },
-          {
-            name: "complete-tracking",
-            description: "Complete tracking for a task",
-            inputSchema: {
-              type: "object",
-              properties: {
-                taskId: { type: "string" },
-              },
-              required: ["taskId"],
+            description: {
+              type: "string",
+              description: "Brief description of the task",
             },
           },
-          {
-            name: "get-accuracy-report",
-            description: "Get estimation accuracy report",
-            inputSchema: {
-              type: "object",
-              properties: {},
-            },
+          required: ["category", "estimate"],
+        },
+      },
+      {
+        name: "start-tracking",
+        description: "Start tracking time for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string" },
+            category: { type: "string" },
+            estimate: { type: "number" },
+            description: { type: "string" },
           },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params;
-
-        if (args == null) {
-          throw new Error(`Tool '${name}' called with no arguments`);
-        }
-
-        switch (name) {
-          case "validate-estimate":
-            return this.handleValidateEstimate(args as { category: string; estimate: number; description?: string });
-          
-          case "start-tracking":
-            return this.handleStartTracking(args as { taskId: string; category: string; estimate: number; description?: string });
-          
-          case "complete-tracking":
-            return this.handleCompleteTracking(args as { taskId: string });
-          
-          case "get-accuracy-report":
-            return this.handleGetReport();
-          
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
-          }],
-        };
-      }
-    });
+          required: ["taskId", "category", "estimate"],
+        },
+      },
+      {
+        name: "complete-tracking",
+        description: "Complete tracking for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string" },
+          },
+          required: ["taskId"],
+        },
+      },
+      {
+        name: "get-accuracy-report",
+        description: "Get estimation accuracy report",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+    ];
+    this.handlers = {
+      "validate-estimate": async (args) => this.handleValidateEstimate(args as { category: string; estimate: number; description?: string }),
+      "start-tracking": async (args) => this.handleStartTracking(args as { taskId: string; category: string; estimate: number; description?: string }),
+      "complete-tracking": async (args) => this.handleCompleteTracking(args as { taskId: string }),
+      "get-accuracy-report": async () => this.handleGetReport(),
+    };
+    this.setupToolHandlers();
   }
 
   private handleValidateEstimate(args: { category: string; estimate: number; description?: string }): { content: Array<{ type: string; text: string }> } {
@@ -210,21 +159,12 @@ class EstimationServer {
 
     return { content: [{ type: "text", text: response }] };
   }
-
-  async start(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    
-    frameworkLogger.log("estimation-server", "start", "info", {
-      message: "Estimation Validator Server started",
-    });
-  }
 }
 
 // Run if called directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new EstimationServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
 }
 
 export { EstimationServer };

package/src/mcps/framework-compliance-audit.server.ts

@@ -4,15 +4,10 @@
  * Comprehensive validation of all framework components and Universal Development Codex compliance
  */
 
-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 fs from "fs";
 import path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface FrameworkComplianceAuditArgs {
   scope?: string;
@@ -33,20 +28,64 @@ interface AuditResults {
   summary: string;
 }
 
-class XrayFrameworkComplianceAuditServer {
-  private server: Server;
-
+class XrayFrameworkComplianceAuditServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("framework-compliance-audit", "3.1.0");
+
+    this.tools = [
       {
-        name: "framework-compliance-audit", version: "3.1.0",
+        name: "framework-compliance-audit",
+        description:
+          "Comprehensive validation of all framework components and Universal Development Codex compliance",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: {
+              type: "string",
+              enum: [
+                "full",
+                "codex",
+                "configuration",
+                "agents",
+                "performance",
+              ],
+              default: "full",
+              description: "Scope of compliance audit",
+            },
+            detailed: {
+              type: "boolean",
+              default: false,
+              description: "Include detailed findings and recommendations",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "codex-validation",
+        description:
+          "Validate compliance with Universal Development Codex v1.2.0",
+        inputSchema: {
+          type: "object",
+          properties: {
+            terms: {
+              type: "array",
+              items: { type: "number", minimum: 1, maximum: 43 },
+              description: "Specific codex terms to validate (1-43)",
+            },
+            strict: {
+              type: "boolean",
+              default: true,
+              description: "Enforce strict compliance",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "framework-compliance-audit": async (args) => this.handleFrameworkComplianceAudit(args as FrameworkComplianceAuditArgs),
+      "codex-validation": async (args) => this.handleCodexValidation(args as CodexValidationArgs),
+    };
 
     this.setupToolHandlers();
     void frameworkLogger.log(
@@ -57,77 +96,6 @@ class XrayFrameworkComplianceAuditServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "framework-compliance-audit",
-            description:
-              "Comprehensive validation of all framework components and Universal Development Codex compliance",
-            inputSchema: {
-              type: "object",
-              properties: {
-                scope: {
-                  type: "string",
-                  enum: [
-                    "full",
-                    "codex",
-                    "configuration",
-                    "agents",
-                    "performance",
-                  ],
-                  default: "full",
-                  description: "Scope of compliance audit",
-                },
-                detailed: {
-                  type: "boolean",
-                  default: false,
-                  description: "Include detailed findings and recommendations",
-                },
-              },
-            },
-          },
-          {
-            name: "codex-validation",
-            description:
-              "Validate compliance with Universal Development Codex v1.2.0",
-            inputSchema: {
-              type: "object",
-              properties: {
-                terms: {
-                  type: "array",
-                  items: { type: "number", minimum: 1, maximum: 43 },
-                  description: "Specific codex terms to validate (1-43)",
-                },
-                strict: {
-                  type: "boolean",
-                  default: true,
-                  description: "Enforce strict compliance",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "framework-compliance-audit":
-          return await this.handleFrameworkComplianceAudit(args as unknown as FrameworkComplianceAuditArgs);
-        case "codex-validation":
-          return await this.handleCodexValidation(args as unknown as CodexValidationArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handleFrameworkComplianceAudit(args: FrameworkComplianceAuditArgs) {
     const scope = args.scope || "full";
     const detailed = args.detailed || false;
@@ -614,16 +582,6 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n")}
     return details;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    void frameworkLogger.log(
-      "framework-compliance-audit.server",
-      "compliance-audit-startup",
-      "info",
-      { message: "0xRay Framework Compliance Audit MCP Server started" },
-    );
-  }
 }
 
 // Start the server if run directly

package/src/mcps/framework-help.server.ts

@@ -1,11 +1,9 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
   ErrorCode,
-  ListToolsRequestSchema,
   McpError,
 } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { AGENT_REGISTRY, getActiveAgents } from "../agents/registry.js";
@@ -17,107 +15,92 @@ interface CapabilitiesMap {
   reporting: { [key: string]: string };
 }
 
-class FrameworkHelpServer {
-  private server: Server;
+class FrameworkHelpServer extends XrayKnowledgeSkillBase {
 
   constructor() {
-    this.server = new Server(
+    super("xray/framework-help", "3.1.0");
+
+    this.tools = [
       {
-        name: "xray/framework-help", version: "3.1.0",
+        name: "xray_get_capabilities",
+        description:
+          "Get comprehensive list of all 0xRay framework capabilities, commands, and available tools",
+        inputSchema: {
+          type: "object",
+          properties: {
+            category: {
+              type: "string",
+              enum: ["all", "agents", "skills", "commands", "reporting"],
+              description: "Filter capabilities by category",
+              default: "all",
+            },
+            format: {
+              type: "string",
+              enum: ["summary", "detailed", "commands"],
+              description: "Output format",
+              default: "summary",
+            },
+          },
+          required: [],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "xray_get_commands",
+        description:
+          "Get list of available 0xRay commands and their usage",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: [
+                "agent-commands",
+                "system-commands",
+                "reporting-commands",
+              ],
+              description: "Type of commands to list",
+              default: "agent-commands",
+            },
+          },
+          required: [],
         },
       },
-    );
+      {
+        name: "xray_explain_capability",
+        description:
+          "Get detailed explanation of a specific 0xRay capability",
+        inputSchema: {
+          type: "object",
+          properties: {
+            capability: {
+              type: "string",
+              description: "Name of the capability to explain",
+            },
+          },
+          required: ["capability"],
+        },
+      },
+    ];
+
+    this.handlers = {
+      "xray_get_capabilities": async (args) => this.handleGetCapabilities(args as Record<string, unknown> | undefined),
+      "xray_get_commands": async (args) => this.handleGetCommands(args as Record<string, unknown> | undefined),
+      "xray_explain_capability": async (args) => this.handleExplainCapability(args as Record<string, unknown> | undefined),
+    };
 
     this.setupToolHandlers();
   }
 
-  private setupToolHandlers() {
-    // List available tools - required MCP protocol handler for tool discovery
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "xray_get_capabilities",
-            description:
-              "Get comprehensive list of all 0xRay framework capabilities, commands, and available tools",
-            inputSchema: {
-              type: "object",
-              properties: {
-                category: {
-                  type: "string",
-                  enum: ["all", "agents", "skills", "commands", "reporting"],
-                  description: "Filter capabilities by category",
-                  default: "all",
-                },
-                format: {
-                  type: "string",
-                  enum: ["summary", "detailed", "commands"],
-                  description: "Output format",
-                  default: "summary",
-                },
-              },
-              required: [],
-            },
-          },
-          {
-            name: "xray_get_commands",
-            description:
-              "Get list of available 0xRay commands and their usage",
-            inputSchema: {
-              type: "object",
-              properties: {
-                type: {
-                  type: "string",
-                  enum: [
-                    "agent-commands",
-                    "system-commands",
-                    "reporting-commands",
-                  ],
-                  description: "Type of commands to list",
-                  default: "agent-commands",
-                },
-              },
-              required: [],
-            },
-          },
-          {
-            name: "xray_explain_capability",
-            description:
-              "Get detailed explanation of a specific 0xRay capability",
-            inputSchema: {
-              type: "object",
-              properties: {
-                capability: {
-                  type: "string",
-                  description: "Name of the capability to explain",
-                },
-              },
-              required: ["capability"],
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls - required MCP protocol handler for tool execution
+  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 McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
       try {
-        switch (name) {
-          case "xray_get_capabilities":
-            return this.handleGetCapabilities(args);
-          case "xray_get_commands":
-            return this.handleGetCommands(args);
-          case "xray_explain_capability":
-            return this.handleExplainCapability(args);
-          default:
-            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-        }
+        return await handler(args);
       } catch (error) {
         if (error instanceof McpError) {
           throw error;
@@ -452,17 +435,12 @@ ${items.map(([name, desc]) => `- **${name}**: ${desc}`).join("\n")}
     `.trim();
   }
 
-  async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/framework-help", "start", "info", { message: "0xRay Framework Help Server started" });
-  }
 }
 
 // Auto-start if this file is run directly - conditional server initialization for development/testing
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new FrameworkHelpServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/framework-help", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/framework-help", "run", "error", { error: String(error) }));
 }
 
 export { FrameworkHelpServer };