0xray 3.1.0 → 3.2.0

package/dist/mcps/lint.server.js

@@ -3,100 +3,64 @@
  *
  * Comprehensive ESLint validation and automated code quality checking
  */
-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 { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XrayLintServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayLintServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "lint", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
-    }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "lint",
-                        description: "Comprehensive ESLint validation and automated code quality checking",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific files to lint (optional - lints all if empty)",
-                                },
-                                fix: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Automatically fix linting issues where possible",
-                                },
-                                strict: {
-                                    type: "boolean",
-                                    default: false,
-                                    description: "Use strict linting rules",
-                                },
-                            },
+        super("lint", "3.1.0");
+        this.tools = [
+            {
+                name: "lint",
+                description: "Comprehensive ESLint validation and automated code quality checking",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific files to lint (optional - lints all if empty)",
                         },
-                    },
-                    {
-                        name: "lint-check",
-                        description: "Check code quality without making changes",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                files: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Files to check",
-                                },
-                                rules: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific ESLint rules to check",
-                                },
-                            },
+                        fix: {
+                            type: "boolean",
+                            default: false,
+                            description: "Automatically fix linting issues where possible",
+                        },
+                        strict: {
+                            type: "boolean",
+                            default: false,
+                            description: "Use strict linting rules",
                         },
                     },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case "lint":
-                        return await this.handleLint(args);
-                    case "lint-check":
-                        return await this.handleLintCheck(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `❌ Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            },
+            {
+                name: "lint-check",
+                description: "Check code quality without making changes",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files to check",
                         },
-                    ],
-                };
-            }
-        });
+                        rules: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific ESLint rules to check",
+                        },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "lint": async (args) => this.handleLint(args),
+            "lint-check": async (args) => this.handleLintCheck(args),
+        };
+        this.setupToolHandlers();
+        void frameworkLogger.log("lint.server", "-xray-lint-mcp-server-initialized-", "info", { message: "0xRay Lint MCP Server initialized" });
     }
     async handleLint(args) {
         const files = args.files || [];
@@ -367,14 +331,9 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Warnings: ${results.issues.warnings}
 - Fixed: ${results.issues.fixed}`;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        await frameworkLogger.log("lint.server", "-xray-lint-mcp-server-started-", "info", { message: "0xRay Lint MCP Server started" });
-    }
 }
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayLintServer();
     server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
 }

package/dist/mcps/model-health-check.server.js

@@ -3,67 +3,45 @@
  *
  * Advanced model compatibility validation and dynamic health assessment
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { modelRouter } from "../core/model-router.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XrayModelHealthCheckServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "model-health-check", version: "1.22.67",
-        }, {
-            capabilities: {
-                tools: {},
+        super("model-health-check", "3.1.0");
+        this.tools = [
+            {
+                name: "model-health-check",
+                description: "Advanced model compatibility validation and dynamic health assessment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        models: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific models to check (optional - checks all configured if empty)",
+                        },
+                        compatibility: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include compatibility matrix in results",
+                        },
+                        performance: {
+                            type: "boolean",
+                            default: true,
+                            description: "Include performance metrics in results",
+                        },
+                    },
+                },
             },
-        });
+        ];
+        this.handlers = {
+            "model-health-check": async (args) => this.handleModelHealthCheck((args || {})),
+        };
         this.setupToolHandlers();
         frameworkLogger.log("mcps/model-health-check", "initialize", "info");
     }
-    setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "model-health-check",
-                        description: "Advanced model compatibility validation and dynamic health assessment",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                models: {
-                                    type: "array",
-                                    items: { type: "string" },
-                                    description: "Specific models to check (optional - checks all configured if empty)",
-                                },
-                                compatibility: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include compatibility matrix in results",
-                                },
-                                performance: {
-                                    type: "boolean",
-                                    default: true,
-                                    description: "Include performance metrics in results",
-                                },
-                            },
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            switch (name) {
-                case "model-health-check":
-                    return await this.handleModelHealthCheck((args || {}));
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-        });
-    }
     async handleModelHealthCheck(args) {
         const models = args.models || [modelRouter.getValidatedModel()];
         const includeCompatibility = args.compatibility !== false;
@@ -214,15 +192,10 @@ class XrayModelHealthCheckServer {
         }
         return report;
     }
-    async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        frameworkLogger.log("mcps/model-health-check", "start", "info");
-    }
 }
 // Start the server if this file is run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
     const server = new XrayModelHealthCheckServer();
-    server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+    server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 export default XrayModelHealthCheckServer;

package/dist/mcps/orchestrator/aside-context.js

@@ -0,0 +1,207 @@
+/**
+ * AsideContext — bounded subcontext for depth, continuity, and layered exploration
+ *
+ * Enables the orchestrator to spawn sub-investigations that inherit session context,
+ * accumulate structured observations from v3 subsystems (governance, orchestration,
+ * complexity analysis), and feed results back into the governance loop.
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+let asideCounter = 0;
+const activeAsides = new Map();
+export function getActiveAsideCount() {
+    return activeAsides.size;
+}
+export function getActiveAsideIds() {
+    return Array.from(activeAsides.keys());
+}
+export function getAsideState(asideId) {
+    return activeAsides.get(asideId);
+}
+export function addObservations(asideId, observations) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    aside.observations.push(...observations);
+    return true;
+}
+export function extractGovernanceObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "governanceCycleId",
+        value: result.cycleId,
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceVoteCount",
+        value: String(result.votes.length),
+        source: "inference/inference-cycle.ts",
+    });
+    const approved = result.votes.filter((v) => v.decision === "approve").length;
+    const rejected = result.votes.filter((v) => v.decision === "reject").length;
+    obs.push({
+        key: "governanceApprovedCount",
+        value: String(approved),
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceRejectedCount",
+        value: String(rejected),
+        source: "inference/inference-cycle.ts",
+    });
+    if (result.corpusSummary) {
+        obs.push({
+            key: "corpusSessionCount",
+            value: String(result.corpusSummary.sessions),
+            source: "inference/inference-cycle.ts",
+        });
+        obs.push({
+            key: "corpusPatternCount",
+            value: String(result.corpusSummary.recurringPatterns),
+            source: "inference/inference-cycle.ts",
+        });
+    }
+    return obs;
+}
+export function extractOrchestrationObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "orchestrationSuccess",
+        value: String(result.success),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksCompleted",
+        value: String(result.completedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksFailed",
+        value: String(result.failedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "orchestrationDuration",
+        value: `${result.duration}ms`,
+        source: "mcps/orchestrator/types.ts",
+    });
+    for (const b of result.bottlenecks) {
+        obs.push({
+            key: "bottleneck",
+            value: b.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    for (const r of result.recommendations) {
+        obs.push({
+            key: "recommendation",
+            value: r.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    return obs;
+}
+export function extractComplexityObservations(analysis) {
+    const obs = [];
+    obs.push({
+        key: "complexityScore",
+        value: String(analysis.overallComplexity),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "recommendedStrategy",
+        value: analysis.recommendedStrategy,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "parallelPotential",
+        value: String(analysis.parallelPotential),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "estimatedDuration",
+        value: `${analysis.estimatedDuration}ms`,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    for (const tc of analysis.taskComplexity) {
+        obs.push({
+            key: `taskComplexity`,
+            value: `${tc.complexity} (${tc.category})`,
+            source: "mcps/orchestrator/execution/execution-planner.ts",
+        });
+    }
+    return obs;
+}
+export async function spawnAside(options) {
+    const asideId = options.parentAsideId
+        ? `${options.parentAsideId}.aside-${++asideCounter}`
+        : `aside-${++asideCounter}-${Date.now()}`;
+    const startTime = Date.now();
+    const aside = {
+        asideId,
+        description: options.description,
+        startedAt: startTime,
+        observations: [],
+        ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
+        ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
+        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    activeAsides.set(asideId, aside);
+    frameworkLogger.log("aside-context", "aside-spawn", "info", {
+        asideId,
+        description: options.description,
+        sessionId: options.sessionId,
+        parentAsideId: options.parentAsideId,
+        activeAsideCount: activeAsides.size,
+    });
+    if (options.priorVerdictContext) {
+        const decision = options.priorVerdictContext["decision"];
+        if (decision) {
+            aside.observations.push({
+                key: "governanceDecision",
+                value: String(decision),
+                source: "priorVerdictContext",
+            });
+        }
+    }
+    const duration = Date.now() - startTime;
+    const result = {
+        asideId,
+        description: options.description,
+        success: true,
+        duration,
+        observations: aside.observations,
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    frameworkLogger.log("aside-context", "aside-complete", "info", {
+        asideId,
+        duration,
+        observationCount: aside.observations.length,
+        activeAsideCount: activeAsides.size,
+    });
+    return result;
+}
+export function closeAside(asideId) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    activeAsides.delete(asideId);
+    frameworkLogger.log("aside-context", "aside-closed", "info", {
+        asideId,
+        duration: Date.now() - aside.startedAt,
+        remainingActive: activeAsides.size,
+    });
+    return true;
+}
+export function closeAllAsides() {
+    const count = activeAsides.size;
+    activeAsides.clear();
+    frameworkLogger.log("aside-context", "aside-close-all", "info", {
+        closedCount: count,
+    });
+    return count;
+}
+export function resetAsideContext() {
+    activeAsides.clear();
+    asideCounter = 0;
+}

package/dist/mcps/orchestrator/handlers/complexity-handler.js

@@ -5,6 +5,7 @@
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { addObservations, extractComplexityObservations } from '../aside-context.js';
 /**
  * Complexity Handler
  * Processes analyze-complexity requests
@@ -14,12 +15,15 @@ export class ComplexityHandler {
     /**
      * Handle analyze-complexity request
      */
-    async handleAnalyzeComplexity(args) {
+    async handleAnalyzeComplexity(args, asideId) {
         const { tasks = [] } = args;
         await frameworkLogger.log('orchestrator.server', 'analyze-complexity-start', 'info', { taskCount: tasks.length });
         try {
             const analysis = await this.planner.analyzeTaskComplexity(tasks);
             const recommendations = this.generateRecommendations(analysis);
+            if (asideId) {
+                addObservations(asideId, extractComplexityObservations(analysis));
+            }
             return {
                 content: [
                     {

package/dist/mcps/orchestrator/handlers/status-handler.js

@@ -41,7 +41,14 @@ export class StatusHandler {
                 // Overall status
                 status = this.getOverallStatus(deps);
             }
-            const response = this.formatStatusResponse(status, detailed);
+            let response = this.formatStatusResponse(status, detailed);
+            if (detailed && deps.asideCount !== undefined) {
+                response += `\n\n**Active Aside Contexts:**`;
+                response += `\n• Count: ${deps.asideCount}`;
+                if (deps.asideIds && deps.asideIds.length > 0) {
+                    response += `\n• IDs: ${deps.asideIds.join(', ')}`;
+                }
+            }
             return { content: [{ type: 'text', text: response }] };
         }
         catch (error) {

package/dist/mcps/orchestrator/handlers/task-handler.js

@@ -6,6 +6,7 @@
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { mcpClientManager } from '../../../mcps/mcp-client.js';
+import { addObservations, extractOrchestrationObservations } from '../aside-context.js';
 /**
  * Task Handler
  * Processes orchestrate-task requests
@@ -49,6 +50,10 @@ export class TaskHandler {
             if (results.agentOutputs) {
                 orchestrationResult.agentOutputs = results.agentOutputs;
             }
+            // Push observations into aside context if active
+            if (deps.asideId) {
+                addObservations(deps.asideId, extractOrchestrationObservations(orchestrationResult));
+            }
             // Store in history
             deps.taskHistory.push({
                 sessionId,

package/dist/mcps/orchestrator/index.js

@@ -0,0 +1,5 @@
+export { OrchestratorServer, createOrchestratorServer } from './server.js';
+export { TaskHandler } from './handlers/task-handler.js';
+export { ComplexityHandler } from './handlers/complexity-handler.js';
+export { StatusHandler } from './handlers/status-handler.js';
+export { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, resetAsideContext, extractGovernanceObservations, extractOrchestrationObservations, extractComplexityObservations, } from './aside-context.js';