0xray 3.1.1 → 3.3.0

package/dist/mcps/orchestrator/server.js

@@ -14,6 +14,7 @@ import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-age
 import { TaskHandler } from './handlers/task-handler.js';
 import { ComplexityHandler } from './handlers/complexity-handler.js';
 import { StatusHandler } from './handlers/status-handler.js';
+import { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, extractGovernanceObservations, } from './aside-context.js';
 /**
  * Orchestrator MCP Server
  * Enterprise-grade orchestration with advanced task management and agent coordination
@@ -203,14 +204,55 @@ export class OrchestratorServer {
             try {
                 const { name, arguments: args } = request.params;
                 switch (name) {
-                    case 'orchestrate-task':
-                        return await this.taskHandler.handleOrchestrateTask(args, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-                    case 'analyze-complexity':
-                        return await this.complexityHandler.handleAnalyzeComplexity(args);
+                    case 'orchestrate-task': {
+                        const orchArgs = args;
+                        const aside = await spawnAside({
+                            description: `Orchestration: ${orchArgs.description}`,
+                            ...(orchArgs.sessionId ? { sessionId: orchArgs.sessionId } : {}),
+                            inheritedContext: { taskCount: orchArgs.tasks?.length ?? 0, executionMode: orchArgs.executionMode ?? 'optimized' },
+                        });
+                        try {
+                            const result = await this.taskHandler.handleOrchestrateTask(orchArgs, { taskHistory: this.taskHistory, activeTasks: this.activeTasks, asideId: aside.asideId });
+                            return result;
+                        }
+                        finally {
+                            closeAside(aside.asideId);
+                        }
+                    }
+                    case 'analyze-complexity': {
+                        const complexityArgs = args;
+                        const aside = await spawnAside({
+                            description: `Complexity analysis: ${complexityArgs.tasks.length} tasks`,
+                        });
+                        try {
+                            return await this.complexityHandler.handleAnalyzeComplexity(complexityArgs, aside.asideId);
+                        }
+                        finally {
+                            closeAside(aside.asideId);
+                        }
+                    }
                     case 'get-orchestration-status':
-                        return await this.statusHandler.handleGetOrchestrationStatus(args, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-                    case 'cancel-orchestration':
-                        return await this.statusHandler.handleCancelOrchestration(args, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
+                        return await this.statusHandler.handleGetOrchestrationStatus(args, {
+                            taskHistory: this.taskHistory,
+                            activeTasks: this.activeTasks,
+                            asideCount: getActiveAsideCount(),
+                            asideIds: getActiveAsideIds(),
+                        });
+                    case 'cancel-orchestration': {
+                        const cancelArgs = args;
+                        if (cancelArgs.force || (!cancelArgs.sessionId && !cancelArgs.taskId)) {
+                            closeAllAsides();
+                        }
+                        else if (cancelArgs.sessionId) {
+                            const asideIds = getActiveAsideIds().filter((id) => getAsideState(id)?.sessionId === cancelArgs.sessionId);
+                            for (const id of asideIds)
+                                closeAside(id);
+                        }
+                        return await this.statusHandler.handleCancelOrchestration(cancelArgs, {
+                            taskHistory: this.taskHistory,
+                            activeTasks: this.activeTasks,
+                        });
+                    }
                     case 'optimize-orchestration':
                         return await this.statusHandler.handleOptimizeOrchestration(args);
                     case 'govern-and-apply':
@@ -235,7 +277,18 @@ export class OrchestratorServer {
             const cycle = InferenceCycle.getInstance(process.cwd(), {
                 skipApply: args.skipApply ?? false,
             });
-            const result = await cycle.governExternalProposals(args.proposals);
+            const aside = await spawnAside({
+                description: `Governance cycle: ${args.proposals.length} proposals`,
+                priorVerdictContext: { proposalCount: args.proposals.length },
+            });
+            let result;
+            try {
+                result = await cycle.governExternalProposals(args.proposals);
+                addObservations(aside.asideId, extractGovernanceObservations(result));
+            }
+            finally {
+                closeAside(aside.asideId);
+            }
             const approved = result.votes.filter((v) => v.decision === 'approve').length;
             const rejected = result.votes.length - approved;
             return {
@@ -243,6 +296,7 @@ export class OrchestratorServer {
                         type: 'text',
                         text: JSON.stringify({
                             cycleId: result.cycleId,
+                            asideId: aside.asideId,
                             approved,
                             rejected,
                             votes: result.votes,
@@ -280,6 +334,7 @@ export class OrchestratorServer {
      * Stop the server
      */
     async stop() {
+        closeAllAsides();
         await frameworkLogger.log('orchestrator.server', 'shutdown', 'info', {
             message: '0xRay Orchestrator MCP Server shutting down',
         });

package/dist/mcps/performance-analysis.server.js

@@ -3,98 +3,74 @@
  *
  * Comprehensive metrics analysis for framework integration and optimization
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
-class XrayPerformanceAnalysisServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
     startTime;
     constructor() {
-        this.server = new Server({
-            name: "performance-analysis", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("performance-analysis", "3.1.0");
         this.startTime = Date.now();
-        this.setupToolHandlers();
-        frameworkLogger.log("mcp-performance-analysis", "server-initialized", "info");
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "performance-analysis",
-                        description: "Comprehensive metrics analysis for framework integration and optimization",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                scope: {
-                                    type: "string",
-                                    enum: [
-                                        "full",
-                                        "runtime",
-                                        "build",
-                                        "resources",
-                                        "bottlenecks",
-                                    ],
-                                    default: "full",
-                                    description: "Scope of performance analysis",
-                                },
-                                duration: {
-                                    type: "number",
-                                    default: 30,
-                                    description: "Analysis duration in seconds",
-                                },
-                                detailed: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Include detailed metrics and recommendations",
-                                },
-                            },
+        this.tools = [
+            {
+                name: "performance-analysis",
+                description: "Comprehensive metrics analysis for framework integration and optimization",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        scope: {
+                            type: "string",
+                            enum: [
+                                "full",
+                                "runtime",
+                                "build",
+                                "resources",
+                                "bottlenecks",
+                            ],
+                            default: "full",
+                            description: "Scope of performance analysis",
+                        },
+                        duration: {
+                            type: "number",
+                            default: 30,
+                            description: "Analysis duration in seconds",
+                        },
+                        detailed: {
+                            type: "boolean",
+                            default: false,
+                            description: "Include detailed metrics and recommendations",
                         },
                     },
-                    {
-                        name: "bottleneck-detection",
-                        description: "Identify performance bottlenecks in framework operations",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                operation: {
-                                    type: "string",
-                                    description: "Specific operation to analyze",
-                                },
-                                threshold: {
-                                    type: "number",
-                                    default: 1000,
-                                    description: "Performance threshold in milliseconds",
-                                },
-                            },
+                },
+            },
+            {
+                name: "bottleneck-detection",
+                description: "Identify performance bottlenecks in framework operations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        operation: {
+                            type: "string",
+                            description: "Specific operation to analyze",
+                        },
+                        threshold: {
+                            type: "number",
+                            default: 1000,
+                            description: "Performance threshold in milliseconds",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "performance-analysis":
-                    return await this.handlePerformanceAnalysis(args);
-                case "bottleneck-detection":
-                    return await this.handleBottleneckDetection(args);
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
+                },
+            },
+        ];
+        this.handlers = {
+            "performance-analysis": async (args) => this.handlePerformanceAnalysis(args),
+            "bottleneck-detection": async (args) => this.handleBottleneckDetection(args),
+        };
+        this.setupToolHandlers();
+        frameworkLogger.log("mcp-performance-analysis", "server-initialized", "info");
     }
     async handlePerformanceAnalysis(args) {
         const scope = args?.scope || "full";
@@ -503,13 +479,6 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
         }
         return report;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        const jobId = generateJobId("mcp-performance-analysis-server");
-        await frameworkLogger.log("mcp-performance-analysis", "server-started", "success", {}, undefined, // sessionId
-        jobId);
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

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

@@ -3,14 +3,11 @@
  *
  * 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 * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
-class XrayProcessorPipelineServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
     codexLoader;
     codexRules = [];
     codexTerms = [
@@ -25,14 +22,74 @@ class XrayProcessorPipelineServer {
         "Test Coverage >85%",
     ];
     constructor() {
+        super("processor-pipeline", "3.1.0");
         this.codexLoader = new CodexLoader();
-        this.server = new Server({
-            name: "processor-pipeline", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
+        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.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
@@ -48,89 +105,6 @@ class XrayProcessorPipelineServer {
             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 || {};
@@ -548,11 +522,6 @@ ${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://${fs.realpathSync(process.argv[1])}`) {