0xray 3.1.1 → 3.2.0

package/dist/mcps/governance.server.js

@@ -11,11 +11,10 @@
  * It always runs proposals through the three real skill servers
  * and the Dynamo Solar SSOT filter (required by default).
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import * as fs from "fs";
 import { fileURLToPath } from "url";
@@ -24,16 +23,101 @@ import { getGovernanceService } from "../governance/governance-service.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
-class GovernanceServer {
-    server;
+class GovernanceServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "governance", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        super("governance", "3.1.0");
+        this.tools = [
+            {
+                name: "govern_proposals",
+                description: "Run one or more proposals through the full 0xRay governance system. " +
+                    "Internal deliberation via 3 skill MCPs + required Dynamo Solar SSOT filter. " +
+                    "Returns merged structured decisions. " +
+                    "Supports regulatory compliance proposals: AML/KYC, PSD2, GDPR content moderation, " +
+                    "and other compliance-related governance scenarios.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        proposals: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    id: { type: "string" },
+                                    type: {
+                                        type: "string",
+                                        enum: ["fix", "refactor", "guard", "automate", "codify", "strategic", "compliance"],
+                                    },
+                                    title: { type: "string" },
+                                    description: { type: "string" },
+                                    evidence: { type: "array", items: { type: "string" } },
+                                    source: { type: "string" },
+                                    confidence: { type: "number" },
+                                },
+                                required: ["type", "title", "description"],
+                            },
+                            description: "List of proposals to govern",
+                        },
+                        context: {
+                            type: "object",
+                            description: "Optional context about the proposals (project, phase, etc.)",
+                        },
+                        options: {
+                            type: "object",
+                            properties: {
+                                require_external: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Whether external Dynamo/Solar governance is required (default: true)",
+                                },
+                            },
+                        },
+                    },
+                    required: ["proposals"],
+                },
             },
-        });
+            {
+                name: "govern_reflection",
+                description: "Parse a reflection (or reflection file) and run its extracted proposals through the full governance system. " +
+                    "This is the primary way to govern outcomes from reflection-based workflows.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        reflectionPath: {
+                            type: "string",
+                            description: "Path to a reflection .md file (alternative to reflectionContent)",
+                        },
+                        reflectionContent: {
+                            type: "string",
+                            description: "Raw reflection content (alternative to reflectionPath)",
+                        },
+                        context: { type: "object" },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "get_active_codex",
+                description: "Get the currently active Codex (SSOT) — returns metadata about the loaded codex terms, " +
+                    "including version, term count, source path, and governance status. " +
+                    "Optionally include the full raw codex data with includeRaw=true.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        includeRaw: {
+                            type: "boolean",
+                            description: "Whether to include the full raw codex data in the response",
+                            default: false,
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+        this.handlers = {
+            "govern_proposals": async (args) => this.handleGovernProposals(this.validateGovernProposalsArgs(args)),
+            "govern_reflection": async (args) => this.handleGovernReflection(this.validateGovernReflectionArgs(args)),
+            "get_active_codex": async (args) => this.handleGetActiveCodex(args),
+        };
         this.setupToolHandlers();
     }
     validateGovernProposalsArgs(value) {
@@ -68,97 +152,7 @@ class GovernanceServer {
         return value;
     }
     setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "govern_proposals",
-                        description: "Run one or more proposals through the full 0xRay governance system. " +
-                            "Internal deliberation via 3 skill MCPs + required Dynamo Solar SSOT filter. " +
-                            "Returns merged structured decisions. " +
-                            "Supports regulatory compliance proposals: AML/KYC, PSD2, GDPR content moderation, " +
-                            "and other compliance-related governance scenarios.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                proposals: {
-                                    type: "array",
-                                    items: {
-                                        type: "object",
-                                        properties: {
-                                            id: { type: "string" },
-                                            type: {
-                                                type: "string",
-                                                enum: ["fix", "refactor", "guard", "automate", "codify", "strategic", "compliance"],
-                                            },
-                                            title: { type: "string" },
-                                            description: { type: "string" },
-                                            evidence: { type: "array", items: { type: "string" } },
-                                            source: { type: "string" },
-                                            confidence: { type: "number" },
-                                        },
-                                        required: ["type", "title", "description"],
-                                    },
-                                    description: "List of proposals to govern",
-                                },
-                                context: {
-                                    type: "object",
-                                    description: "Optional context about the proposals (project, phase, etc.)",
-                                },
-                                options: {
-                                    type: "object",
-                                    properties: {
-                                        require_external: {
-                                            type: "boolean",
-                                            default: true,
-                                            description: "Whether external Dynamo/Solar governance is required (default: true)",
-                                        },
-                                    },
-                                },
-                            },
-                            required: ["proposals"],
-                        },
-                    },
-                    {
-                        name: "govern_reflection",
-                        description: "Parse a reflection (or reflection file) and run its extracted proposals through the full governance system. " +
-                            "This is the primary way to govern outcomes from reflection-based workflows.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                reflectionPath: {
-                                    type: "string",
-                                    description: "Path to a reflection .md file (alternative to reflectionContent)",
-                                },
-                                reflectionContent: {
-                                    type: "string",
-                                    description: "Raw reflection content (alternative to reflectionPath)",
-                                },
-                                context: { type: "object" },
-                            },
-                            required: [],
-                        },
-                    },
-                    {
-                        name: "get_active_codex",
-                        description: "Get the currently active Codex (SSOT) — returns metadata about the loaded codex terms, " +
-                            "including version, term count, source path, and governance status. " +
-                            "Optionally include the full raw codex data with includeRaw=true.",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                includeRaw: {
-                                    type: "boolean",
-                                    description: "Whether to include the full raw codex data in the response",
-                                    default: false,
-                                },
-                            },
-                            required: [],
-                        },
-                    },
-                ],
-            };
-        });
+        this.setupListToolsHandler();
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             try {
@@ -338,53 +332,7 @@ class GovernanceServer {
     }
     async run() {
         await this.initializeGovernance();
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        let parentCheckTimer = null;
-        const cleanup = async (signal) => {
-            if (parentCheckTimer !== null) {
-                clearTimeout(parentCheckTimer);
-                parentCheckTimer = null;
-            }
-            const timeout = setTimeout(() => {
-                frameworkLogger.log("mcps/governance", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
-                process.exit(1);
-            }, 5000);
-            try {
-                if (this.server && typeof this.server.close === "function") {
-                    await this.server.close();
-                }
-                clearTimeout(timeout);
-                process.exit(0);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                frameworkLogger.log("mcps/governance", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
-                process.exit(1);
-            }
-        };
-        process.on("SIGINT", () => cleanup("SIGINT"));
-        process.on("SIGTERM", () => cleanup("SIGTERM"));
-        process.on("SIGHUP", () => cleanup("SIGHUP"));
-        const checkParent = () => {
-            try {
-                process.kill(process.ppid, 0);
-                parentCheckTimer = setTimeout(checkParent, 1000);
-            }
-            catch (error) {
-                parentCheckTimer = null;
-                cleanup("parent-process-death");
-            }
-        };
-        parentCheckTimer = setTimeout(checkParent, 2000);
-        process.on("uncaughtException", (error) => {
-            frameworkLogger.log("mcps/governance", "uncaughtException", "error", { message: `Uncaught Exception: ${String(error)}` });
-            cleanup("uncaughtException");
-        });
-        process.on("unhandledRejection", (reason) => {
-            frameworkLogger.log("mcps/governance", "unhandledRejection", "error", { message: `Unhandled Rejection: ${String(reason)}` });
-            cleanup("unhandledRejection");
-        });
+        await super.run();
     }
     async connect(transport) {
         await this.server.connect(transport);

package/dist/mcps/knowledge-skills/api-design.server.js

@@ -4,68 +4,45 @@
  * Knowledge skill for API design patterns, RESTful conventions,
  * GraphQL schema design, and API documentation standards
  */
-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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import * as fs from "fs";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayApiDesignServer {
-    server;
+class XrayApiDesignServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "api-design", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        super("api-design", "3.1.0");
+        this.tools = [
+            {
+                name: "design-api-endpoints",
+                description: "Design RESTful API endpoints with proper resource modeling",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        resource: { type: "string" },
+                        operations: { type: "array", items: { type: "string" } },
+                        relationships: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["resource"],
+                },
+            },
+            {
+                name: "validate-api-design",
+                description: "Validate API design against RESTful principles and best practices",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        endpoints: { type: "array", items: { type: "string" } },
+                        standards: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["endpoints"],
+                },
             },
-        });
+        ];
+        this.handlers = {
+            "design-api-endpoints": async (args) => this.designApiEndpoints(args),
+            "validate-api-design": async (args) => this.validateApiDesign(args),
+        };
         this.setupToolHandlers();
         // Server initialization - removed unnecessary startup logging
     }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "design-api-endpoints",
-                        description: "Design RESTful API endpoints with proper resource modeling",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                resource: { type: "string" },
-                                operations: { type: "array", items: { type: "string" } },
-                                relationships: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["resource"],
-                        },
-                    },
-                    {
-                        name: "validate-api-design",
-                        description: "Validate API design against RESTful principles and best practices",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                endpoints: { type: "array", items: { type: "string" } },
-                                standards: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["endpoints"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "design-api-endpoints":
-                    return await this.designApiEndpoints(args);
-                case "validate-api-design":
-                    return await this.validateApiDesign(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async designApiEndpoints(args) {
         const { resource, operations, relationships } = args;
         const design = {
@@ -107,15 +84,6 @@ class XrayApiDesignServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "api-design.server",
-            server: this.server,
-        });
-    }
 }
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayApiDesignServer();

package/dist/mcps/knowledge-skills/architecture-patterns.server.js

@@ -4,68 +4,45 @@
  * Knowledge skill for architectural pattern recognition,
  * design pattern recommendations, and system architecture guidance
  */
-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 { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
 import * as fs from "fs";
-import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
-class XrayArchitecturePatternsServer {
-    server;
+class XrayArchitecturePatternsServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "architecture-patterns", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        super("architecture-patterns", "3.1.0");
+        this.tools = [
+            {
+                name: "analyze-architecture",
+                description: "Analyze current system architecture and identify patterns",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectRoot: { type: "string" },
+                        focusPatterns: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["projectRoot"],
+                },
+            },
+            {
+                name: "recommend-patterns",
+                description: "Recommend architectural patterns for specific use cases",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        useCase: { type: "string" },
+                        constraints: { type: "array", items: { type: "string" } },
+                        scale: { type: "string", enum: ["small", "medium", "large"] },
+                    },
+                    required: ["useCase"],
+                },
             },
-        });
+        ];
+        this.handlers = {
+            "analyze-architecture": async (args) => this.analyzeArchitecture(args),
+            "recommend-patterns": async (args) => this.recommendPatterns(args),
+        };
         this.setupToolHandlers();
         // Server initialization - removed unnecessary startup logging
     }
-    setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "analyze-architecture",
-                        description: "Analyze current system architecture and identify patterns",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                projectRoot: { type: "string" },
-                                focusPatterns: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["projectRoot"],
-                        },
-                    },
-                    {
-                        name: "recommend-patterns",
-                        description: "Recommend architectural patterns for specific use cases",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                useCase: { type: "string" },
-                                constraints: { type: "array", items: { type: "string" } },
-                                scale: { type: "string", enum: ["small", "medium", "large"] },
-                            },
-                            required: ["useCase"],
-                        },
-                    },
-                ],
-            };
-        });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "analyze-architecture":
-                    return await this.analyzeArchitecture(args);
-                case "recommend-patterns":
-                    return await this.recommendPatterns(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async analyzeArchitecture(args) {
         const { projectRoot, focusPatterns } = args;
         // Simplified architecture analysis
@@ -97,15 +74,6 @@ class XrayArchitecturePatternsServer {
             ],
         };
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Use centralized shutdown handler
-        createGracefulShutdown({
-            serverName: "architecture-patterns.server",
-            server: this.server,
-        });
-    }
 }
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayArchitecturePatternsServer();