0xray 3.0.11 → 3.0.14

package/dist/mcps/estimation.server.js

@@ -3,81 +3,118 @@
  *
  * 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 { frameworkLogger } from "../core/framework-logger.js";
 import { getEstimationValidator } from "../validation/estimation-validator.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 /**
  * Estimation MCP Server
  * Tracks estimates vs actuals and provides calibrated predictions
  */
-class EstimationServer extends XrayKnowledgeSkillBase {
+class EstimationServer {
+    server;
     validator = getEstimationValidator();
     constructor() {
-        super("estimation-validator", "2.0.1");
-        this.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",
+        this.server = new Server({
+            name: "estimation-validator", version: "1.22.67",
+        }, {
+            capabilities: { tools: {} },
+        });
+        this.setupToolHandlers();
+    }
+    setupToolHandlers() {
+        // 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"],
                         },
-                        description: {
-                            type: "string",
-                            description: "Brief description of the task",
+                    },
+                    {
+                        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"],
                         },
                     },
-                    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" },
+                    {
+                        name: "complete-tracking",
+                        description: "Complete tracking for a task",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                            },
+                            required: ["taskId"],
+                        },
                     },
-                    required: ["taskId", "category", "estimate"],
-                },
-            },
-            {
-                name: "complete-tracking",
-                description: "Complete tracking for a task",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        taskId: { type: "string" },
+                    {
+                        name: "get-accuracy-report",
+                        description: "Get estimation accuracy report",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
                     },
-                    required: ["taskId"],
-                },
-            },
-            {
-                name: "get-accuracy-report",
-                description: "Get estimation accuracy report",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                },
-            },
-        ];
-        this.handlers = {
-            "validate-estimate": async (args) => this.handleValidateEstimate(args),
-            "start-tracking": async (args) => this.handleStartTracking(args),
-            "complete-tracking": async (args) => this.handleCompleteTracking(args),
-            "get-accuracy-report": async (args) => this.handleGetReport(),
-        };
-        this.setupToolHandlers();
+                ],
+            };
+        });
+        // 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);
+                    case "start-tracking":
+                        return this.handleStartTracking(args);
+                    case "complete-tracking":
+                        return this.handleCompleteTracking(args);
+                    case "get-accuracy-report":
+                        return this.handleGetReport();
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
     }
     handleValidateEstimate(args) {
         const validation = this.validator.validateEstimate(args.category, args.estimate);
@@ -139,11 +176,17 @@ class EstimationServer extends XrayKnowledgeSkillBase {
         }
         return { content: [{ type: "text", text: response }] };
     }
+    async start() {
+        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://${process.argv[1]}`) {
     const server = new EstimationServer();
-    server.run("estimation-validator").catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
+    server.start().catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
 }
 export { EstimationServer };
-//# sourceMappingURL=estimation.server.js.map

package/dist/mcps/framework-compliance-audit.server.js

@@ -3,65 +3,89 @@
  *
  * 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 { frameworkLogger } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayFrameworkComplianceAuditServer extends XrayKnowledgeSkillBase {
+class XrayFrameworkComplianceAuditServer {
+    server;
     constructor() {
-        super("framework-compliance-audit", "2.0.1");
-        this.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",
-                        },
-                    },
-                },
+        this.server = new Server({
+            name: "framework-compliance-audit", version: "1.22.67",
+        }, {
+            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)",
+        });
+        this.setupToolHandlers();
+        void frameworkLogger.log("framework-compliance-audit.server", "compliance-audit-init", "info", { message: "0xRay Framework Compliance Audit MCP Server initialized" });
+    }
+    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",
+                                },
+                            },
                         },
-                        strict: {
-                            type: "boolean",
-                            default: true,
-                            description: "Enforce strict compliance",
+                    },
+                    {
+                        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),
-            "codex-validation": async (args) => this.handleCodexValidation(args),
-        };
-        this.setupToolHandlers();
-        void frameworkLogger.log("framework-compliance-audit.server", "compliance-audit-init", "info", { message: "0xRay Framework Compliance Audit MCP Server initialized" });
+                ],
+            };
+        });
+        // 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);
+                case "codex-validation":
+                    return await this.handleCodexValidation(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
     }
     async handleFrameworkComplianceAudit(args) {
         const scope = args.scope || "full";
@@ -462,11 +486,15 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n")}
         details += `- Status: ${results.complianceScores.performance_thresholds || "Not checked"}\n\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
 if (import.meta.url === `file://${process.argv[1]}`) {
     const server = new XrayFrameworkComplianceAuditServer();
-    server.run("framework-compliance-audit").catch((error) => frameworkLogger.log("mcps/framework-compliance-audit", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/framework-compliance-audit", "run", "error", { error: String(error) }));
 }
 export { XrayFrameworkComplianceAuditServer };
-//# sourceMappingURL=framework-compliance-audit.server.js.map

package/dist/mcps/framework-help.server.js

@@ -1,74 +1,107 @@
-import { ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+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 { frameworkLogger } from "../core/framework-logger.js";
 import { AGENT_REGISTRY } from "../agents/registry.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class FrameworkHelpServer extends XrayKnowledgeSkillBase {
+class FrameworkHelpServer {
+    server;
     constructor() {
-        super("xray/framework-help", "2.0.1");
-        this.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",
+        this.server = new Server({
+            name: "xray/framework-help", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+    }
+    setupToolHandlers() {
+        // List available tools - required MCP protocol handler for tool discovery
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "strray_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: [],
                         },
                     },
-                    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",
+                    {
+                        name: "strray_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: [],
                         },
                     },
-                    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",
+                    {
+                        name: "strray_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"],
                         },
                     },
-                    required: ["capability"],
-                },
-            },
-        ];
-        this.handlers = {
-            "xray_get_capabilities": async (args) => this.handleGetCapabilities(args),
-            "xray_get_commands": async (args) => this.handleGetCommands(args),
-            "xray_explain_capability": async (args) => this.handleExplainCapability(args),
-        };
-        this.setupToolHandlers();
+                ],
+            };
+        });
+        // Handle tool calls - required MCP protocol handler for tool execution
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "strray_get_capabilities":
+                        return this.handleGetCapabilities(args);
+                    case "strray_get_commands":
+                        return this.handleGetCommands(args);
+                    case "strray_explain_capability":
+                        return this.handleExplainCapability(args);
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                frameworkLogger.log("mcps/framework-help", "tool-call", "error", { tool: name, error: String(error) });
+                throw new McpError(ErrorCode.InternalError, `Tool "${name}" execution failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
     }
     getActiveAgentEntries() {
         return Object.values(AGENT_REGISTRY).filter((e) => e.status === "active");
@@ -353,11 +386,15 @@ ${items.map(([name, desc]) => `- **${name}**: ${desc}`).join("\n")}
 **Total:** ${items.length} ${category}
     `.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://${process.argv[1]}`) {
     const server = new FrameworkHelpServer();
-    server.run("xray/framework-help").catch((error) => frameworkLogger.log("mcps/framework-help", "run", "error", { error: String(error) }));
+    server.start().catch((error) => frameworkLogger.log("mcps/framework-help", "run", "error", { error: String(error) }));
 }
 export { FrameworkHelpServer };
-//# sourceMappingURL=framework-help.server.js.map