0xray 2.1.1 → 2.1.3

package/src/mcps/processor-pipeline.server.ts

@@ -4,15 +4,10 @@
  * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
  */
 
-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 { CodexLoader } from "../enforcement/loaders/codex-loader.js";
 import type { RuleDefinition, RuleValidationContext } from "../enforcement/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface PreProcessorArgs {
   content: string;
@@ -87,8 +82,7 @@ interface FrameworkComplianceResult {
   approved: boolean;
 }
 
-class XrayProcessorPipelineServer {
-  private server: Server;
+class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
   private codexLoader: CodexLoader;
   private codexRules: RuleDefinition[] = [];
   private codexTerms: string[] = [
@@ -104,17 +98,81 @@ class XrayProcessorPipelineServer {
   ];
 
   constructor() {
+    super("processor-pipeline", "2.0.1");
+
     this.codexLoader = new CodexLoader();
-    this.server = new Server(
+
+    this.tools = [
+      {
+        name: "execute-pre-processors",
+        description:
+          "Run pre-execution processors on content with codex validation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            context: { type: "object" },
+            validateCodex: { type: "boolean", default: true },
+            strictMode: { type: "boolean", default: false },
+          },
+          required: ["content"],
+        },
+      },
       {
-        name: "processor-pipeline", version: "2.0.1",
+        name: "execute-post-processors",
+        description:
+          "Run post-execution processors on results with compliance monitoring",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            results: { type: "object" },
+            enforceCompliance: { type: "boolean", default: true },
+            auditTrail: { type: "boolean", default: true },
+          },
+          required: ["content"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "codex-validation",
+        description:
+          "Validate content against Universal Development Codex terms",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            terms: {
+              type: "array",
+              items: { type: "string" },
+              default: ["all"],
+            },
+            strict: { type: "boolean", default: false },
+          },
+          required: ["content"],
         },
       },
-    );
+      {
+        name: "framework-compliance-check",
+        description:
+          "Check framework compliance and generate enforcement actions",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            operation: { type: "string" },
+            context: { type: "object" },
+          },
+          required: ["content", "operation"],
+        },
+      },
+    ];
+
+    this.handlers = {
+      "execute-pre-processors": async (args) => this.handlePreProcessors(args as unknown as PreProcessorArgs),
+      "execute-post-processors": async (args) => this.handlePostProcessors(args as unknown as PostProcessorArgs),
+      "codex-validation": async (args) => this.handleCodexValidation(args as unknown as CodexValidationArgs),
+      "framework-compliance-check": async (args) => this.handleComplianceCheck(args as unknown as ComplianceCheckArgs),
+    };
 
     this.setupToolHandlers();
     this.loadCodexRules();
@@ -142,96 +200,6 @@ class XrayProcessorPipelineServer {
     }
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "execute-pre-processors",
-            description:
-              "Run pre-execution processors on content with codex validation",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                context: { type: "object" },
-                validateCodex: { type: "boolean", default: true },
-                strictMode: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "execute-post-processors",
-            description:
-              "Run post-execution processors on results with compliance monitoring",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                results: { type: "object" },
-                enforceCompliance: { type: "boolean", default: true },
-                auditTrail: { type: "boolean", default: true },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "codex-validation",
-            description:
-              "Validate content against Universal Development Codex terms",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                terms: {
-                  type: "array",
-                  items: { type: "string" },
-                  default: ["all"],
-                },
-                strict: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "framework-compliance-check",
-            description:
-              "Check framework compliance and generate enforcement actions",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                operation: { type: "string" },
-                context: { type: "object" },
-              },
-              required: ["content", "operation"],
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "execute-pre-processors":
-          return await this.handlePreProcessors(args as unknown as PreProcessorArgs);
-        case "execute-post-processors":
-          return await this.handlePostProcessors(args as unknown as PostProcessorArgs);
-        case "codex-validation":
-          return await this.handleCodexValidation(args as unknown as CodexValidationArgs);
-        case "framework-compliance-check":
-          return await this.handleComplianceCheck(args as unknown as ComplianceCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handlePreProcessors(args: PreProcessorArgs) {
     const content = args.content;
     const context = args.context || {};
@@ -761,18 +729,12 @@ ${complianceResults.actions.map((a: string) => `• 🔧 ${a}`).join("\n") || "N
 
     return results;
   }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    // Silent start - no console output
-  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayProcessorPipelineServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
+  server.run("processor-pipeline").catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }
 
 export { XrayProcessorPipelineServer };

package/src/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

package/src/mcps/researcher.server.ts

@@ -8,16 +8,11 @@
  * "researcher" for backwards compatibility with existing tool references.
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface SearchResult {
   file: string;
@@ -48,128 +43,101 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class XrayLibrarianServer {
-  private server: Server;
-
+class XrayLibrarianServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "researcher", version: "2.0.1",
-      },
+    super("researcher", "2.0.1");
+
+    this.tools = [
       {
-        capabilities: {
-          tools: {},
+        name: "search_codebase",
+        description:
+          "Search the codebase for specific patterns, functions, or implementations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query (function name, pattern, keyword)",
+            },
+            fileExtension: {
+              type: "string",
+              description: "File extension to search (e.g., '.ts', '.js')",
+              default: ".ts",
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of results to return",
+              default: 10,
+            },
+          },
+          required: ["query"],
         },
       },
-    );
-
-    this.setupToolHandlers();
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "search_codebase",
-            description:
-              "Search the codebase for specific patterns, functions, or implementations",
-            inputSchema: {
-              type: "object",
-              properties: {
-                query: {
-                  type: "string",
-                  description: "Search query (function name, pattern, keyword)",
-                },
-                fileExtension: {
-                  type: "string",
-                  description: "File extension to search (e.g., '.ts', '.js')",
-                  default: ".ts",
-                },
-                maxResults: {
-                  type: "number",
-                  description: "Maximum number of results to return",
-                  default: 10,
-                },
-              },
-              required: ["query"],
+      {
+        name: "find_implementation",
+        description:
+          "Find implementation examples for a specific pattern or feature",
+        inputSchema: {
+          type: "object",
+          properties: {
+            feature: {
+              type: "string",
+              description: "Feature name to find implementations for",
             },
-          },
-          {
-            name: "find_implementation",
-            description:
-              "Find implementation examples for a specific pattern or feature",
-            inputSchema: {
-              type: "object",
-              properties: {
-                feature: {
-                  type: "string",
-                  description: "Feature name to find implementations for",
-                },
-                context: {
-                  type: "string",
-                  description:
-                    "Additional context (e.g., 'MCP', 'testing', 'agent')",
-                },
-              },
-              required: ["feature"],
+            context: {
+              type: "string",
+              description:
+                "Additional context (e.g., 'MCP', 'testing', 'agent')",
             },
           },
-          {
-            name: "get_documentation",
-            description:
-              "Get documentation for a specific module, class, or function",
-            inputSchema: {
-              type: "object",
-              properties: {
-                target: {
-                  type: "string",
-                  description: "Module, class, or function name",
-                },
-                includeExamples: {
-                  type: "boolean",
-                  description: "Include usage examples",
-                  default: true,
-                },
-              },
-              required: ["target"],
+          required: ["feature"],
+        },
+      },
+      {
+        name: "get_documentation",
+        description:
+          "Get documentation for a specific module, class, or function",
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: "Module, class, or function name",
             },
-          },
-          {
-            name: "analyze_proposal",
-            description:
-              "Analyze an inference proposal from a researcher / project-librarian perspective using corpus patterns, historical evidence, and architecture knowledge",
-            inputSchema: {
-              type: "object",
-              properties: {
-                proposalTitle: { type: "string" },
-                proposalDescription: { type: "string" },
-                evidence: { type: "array", items: { type: "string" } },
-                proposalType: { type: "string" },
-              },
-              required: ["proposalTitle", "proposalDescription"],
+            includeExamples: {
+              type: "boolean",
+              description: "Include usage examples",
+              default: true,
             },
           },
-        ],
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "search_codebase":
-          return await this.searchCodebase(args as unknown as SearchCodebaseArgs);
-        case "find_implementation":
-          return await this.findImplementation(args as unknown as FindImplementationArgs);
-        case "get_documentation":
-          return await this.getDocumentation(args as unknown as GetDocumentationArgs);
-        case "analyze_proposal":
-          return await this.analyzeProposal(args as AnalyzeProposalArgs) as CallToolResult;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
+          required: ["target"],
+        },
+      },
+      {
+        name: "analyze_proposal",
+        description:
+          "Analyze an inference proposal from a researcher / project-librarian perspective using corpus patterns, historical evidence, and architecture knowledge",
+        inputSchema: {
+          type: "object",
+          properties: {
+            proposalTitle: { type: "string" },
+            proposalDescription: { type: "string" },
+            evidence: { type: "array", items: { type: "string" } },
+            proposalType: { type: "string" },
+          },
+          required: ["proposalTitle", "proposalDescription"],
+        },
+      },
+    ];
+
+    this.handlers = {
+      "search_codebase": async (args) => this.searchCodebase(args as unknown as SearchCodebaseArgs),
+      "find_implementation": async (args) => this.findImplementation(args as unknown as FindImplementationArgs),
+      "get_documentation": async (args) => this.getDocumentation(args as unknown as GetDocumentationArgs),
+      "analyze_proposal": async (args) => this.analyzeProposal(args as unknown as AnalyzeProposalArgs),
+    };
+
+    this.setupToolHandlers();
   }
 
   private async searchCodebase(args: SearchCodebaseArgs) {
@@ -527,69 +495,12 @@ class XrayLibrarianServer {
       ],
     };
   }
-
-  async run(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-
-    let parentCheckTimer: ReturnType<typeof setTimeout> | null = null;
-
-    const cleanup = async (signal: string) => {
-      if (parentCheckTimer !== null) {
-        clearTimeout(parentCheckTimer);
-        parentCheckTimer = null;
-      }
-
-      const timeout = setTimeout(() => {
-        frameworkLogger.log("mcps/researcher", "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/researcher", "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/researcher", "uncaughtException", "error", { message: `Uncaught Exception: ${String(error)}` });
-      cleanup("uncaughtException");
-    });
-
-    process.on("unhandledRejection", (reason, promise) => {
-      frameworkLogger.log("mcps/researcher", "unhandledRejection", "error", { message: `Unhandled Rejection: ${String(reason)}` });
-      cleanup("unhandledRejection");
-    });
-  }
 }
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XrayLibrarianServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
+  server.run("researcher").catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
 }
 
 export { XrayLibrarianServer };