0xray 3.0.12 → 3.1.0

package/dist/mcps/processor-pipeline.server.js

@@ -3,10 +3,13 @@
  *
  * 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 { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
+class XrayProcessorPipelineServer {
+    server;
     codexLoader;
     codexRules = [];
     codexTerms = [
@@ -21,74 +24,14 @@ class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
         "Test Coverage >85%",
     ];
     constructor() {
-        super("processor-pipeline", "2.0.1");
         this.codexLoader = new CodexLoader();
-        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: "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"],
-                },
+        this.server = new Server({
+            name: "processor-pipeline", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
             },
-        ];
-        this.handlers = {
-            "execute-pre-processors": async (args) => this.handlePreProcessors(args),
-            "execute-post-processors": async (args) => this.handlePostProcessors(args),
-            "codex-validation": async (args) => this.handleCodexValidation(args),
-            "framework-compliance-check": async (args) => this.handleComplianceCheck(args),
-        };
+        });
         this.setupToolHandlers();
         this.loadCodexRules();
         // Server initialized silently - use frameworkLogger for important events
@@ -104,6 +47,89 @@ class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
             await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-load-failed", "warning", { message: `Failed to load codex rules: ${error instanceof Error ? error.message : String(error)}` });
         }
     }
+    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);
+                case "execute-post-processors":
+                    return await this.handlePostProcessors(args);
+                case "codex-validation":
+                    return await this.handleCodexValidation(args);
+                case "framework-compliance-check":
+                    return await this.handleComplianceCheck(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
+    }
     async handlePreProcessors(args) {
         const content = args.content;
         const context = args.context || {};
@@ -521,11 +547,15 @@ ${complianceResults.actions.map((a) => `• 🔧 ${a}`).join("\n") || "None requ
         }
         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("processor-pipeline").catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }
 export { XrayProcessorPipelineServer };
-//# sourceMappingURL=processor-pipeline.server.js.map

package/dist/mcps/protocol/protocol-constants.js

@@ -44,4 +44,3 @@ export const ERROR_CODES = {
     INTERNAL_ERROR: -32603,
     SERVER_ERROR: -32000,
 };
-//# sourceMappingURL=protocol-constants.js.map

package/dist/mcps/registry.json

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

package/dist/mcps/researcher.server.js

@@ -7,97 +7,122 @@
  * NOTE: Class is named XrayLibrarianServer but the MCP server name is
  * "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, } 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";
-class XrayLibrarianServer extends XrayKnowledgeSkillBase {
+import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+class XrayLibrarianServer {
+    server;
     constructor() {
-        super("researcher", "2.0.1");
-        this.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.server = new Server({
+            name: "researcher", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
             },
-            {
-                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')",
+        });
+        this.setupToolHandlers();
+    }
+    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"],
                         },
                     },
-                    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: "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"],
                         },
-                        includeExamples: {
-                            type: "boolean",
-                            description: "Include usage examples",
-                            default: true,
+                    },
+                    {
+                        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: ["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" },
+                    {
+                        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"],
+                        },
                     },
-                    required: ["proposalTitle", "proposalDescription"],
-                },
-            },
-        ];
-        this.handlers = {
-            "search_codebase": async (args) => this.searchCodebase(args),
-            "find_implementation": async (args) => this.findImplementation(args),
-            "get_documentation": async (args) => this.getDocumentation(args),
-            "analyze_proposal": async (args) => this.analyzeProposal(args),
-        };
-        this.setupToolHandlers();
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "search_codebase":
+                    return await this.searchCodebase(args);
+                case "find_implementation":
+                    return await this.findImplementation(args);
+                case "get_documentation":
+                    return await this.getDocumentation(args);
+                case "analyze_proposal":
+                    return await this.analyzeProposal(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
     }
     async searchCodebase(args) {
         const { query, fileExtension = ".ts", maxResults = 10 } = args;
@@ -376,57 +401,79 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
      */
     async analyzeProposal(args) {
         const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args || {};
-        const text = `${proposalTitle} ${proposalDescription} ${(evidence || []).join(" ")}`.toLowerCase();
-        let decision = "approve";
-        let confidence = 0.80;
-        let reasoning = "From a project-wide analysis perspective, the proposal aligns with observed recurring patterns and has supporting evidence in the corpus.";
-        if (text.includes("aml") || text.includes("kyc") || text.includes("anti-money")) {
-            decision = "approve";
-            confidence = 0.86;
-            reasoning = "AML/KYC compliance integration is a recurring pattern across financial services codebases. The corpus shows that automated transaction monitoring reduces regulatory incident frequency by approximately 60% when properly integrated with sanction list APIs.";
-        }
-        else if (text.includes("psd2") || text.includes("strong customer authentication") || text.includes("payment initiation")) {
-            decision = "approve";
-            confidence = 0.88;
-            reasoning = "PSD2 SCA patterns are well-established in the corpus across multiple implementations. The Berlin Group standards provide a reliable reference architecture, and existing integrations show consistent compliance with EBA regulatory technical standards.";
-        }
-        else if (text.includes("gdpr") || text.includes("right to erasure") || text.includes("data protection")) {
-            decision = "approve";
-            confidence = 0.91;
-            reasoning = "GDPR data erasure pipeline patterns appear in approximately 35% of enterprise codebases in the corpus. The most successful implementations use the saga pattern with compensating transactions for cross-system consistency.";
-        }
-        else if (text.includes("extract method")) {
-            decision = "approve";
-            confidence = 0.89;
-            reasoning = "The Extract Method pattern is a core refactoring technique that improves modularity; the corpus shows consistent positive outcomes when applied to repeated logic across many sessions.";
-        }
-        else if (text.includes("test coverage")) {
-            decision = "approve";
-            confidence = 0.94;
-            reasoning = "Test coverage expansion is one of the highest-leverage improvements for long-term project health, directly reducing regression incidents across 100+ sessions in the historical data.";
-        }
-        else if (text.includes("technical debt")) {
-            decision = "approve";
-            confidence = 0.85;
-            reasoning = "Systematic technical debt reduction is strongly supported by historical data showing fewer critical violations and faster feature delivery in low-debt modules.";
-        }
-        if (proposalType === "fix" && !text.includes("pattern") && !text.includes("recurring")) {
-            confidence = Math.max(0.68, confidence - 0.10);
+        const vote = await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", evidence || [], proposalType || "");
+        if (!vote) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser",
+                    },
+                ],
+            };
         }
         return {
             content: [
                 {
                     type: "text",
-                    text: `DECISION: ${decision}\nCONFIDENCE: ${confidence.toFixed(2)}\nREASONING: ${reasoning}`,
+                    text: `DECISION: ${vote.decision}\nCONFIDENCE: ${vote.confidence.toFixed(2)}\nREASONING: ${vote.reasoning}`,
                 },
             ],
         };
     }
+    async run() {
+        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/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("researcher").catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
 }
 export { XrayLibrarianServer };
-//# sourceMappingURL=researcher.server.js.map