0xray 3.1.1 → 3.2.0

package/dist/mcps/state-manager.server.js

@@ -3,28 +3,132 @@
  *
  * Advanced state management with persistence, synchronization, and conflict resolution
  */
-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 { CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import fs from "fs";
 import path from "path";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-class XrayStateManagerServer {
-    server;
+class XrayStateManagerServer extends XrayKnowledgeSkillBase {
     state = new Map();
     stateFile;
     backups = new Map();
     constructor() {
-        this.server = new Server({
-            name: "state-manager", version: "3.1.0",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
+        super("state-manager", "3.1.0");
         this.stateFile = path.join(process.cwd(), ".opencode", "state", "mcp-state.json");
         this.ensureStateDirectory();
         this.loadState();
+        this.tools = [
+            {
+                name: "get-state",
+                description: "Get state value by key with type safety and validation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        defaultValue: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "number" },
+                                { type: "boolean" },
+                                { type: "object" },
+                                { type: "array" },
+                            ],
+                        },
+                        validate: { type: "boolean", default: true },
+                    },
+                    required: ["key"],
+                },
+            },
+            {
+                name: "set-state",
+                description: "Set state value by key with conflict resolution and persistence",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        value: {
+                            oneOf: [
+                                { type: "string" },
+                                { type: "number" },
+                                { type: "boolean" },
+                                { type: "object" },
+                                { type: "array" },
+                            ],
+                        },
+                        persist: { type: "boolean", default: true },
+                        backup: { type: "boolean", default: false },
+                    },
+                    required: ["key", "value"],
+                },
+            },
+            {
+                name: "delete-state",
+                description: "Delete state value by key with cleanup and validation",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        key: { type: "string" },
+                        force: { type: "boolean", default: false },
+                    },
+                    required: ["key"],
+                },
+            },
+            {
+                name: "list-state",
+                description: "List all state keys with filtering and metadata",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prefix: { type: "string" },
+                        includeValues: { type: "boolean", default: false },
+                        limit: { type: "number", default: 100 },
+                    },
+                },
+            },
+            {
+                name: "backup-state",
+                description: "Create backup of current state or specific keys",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        keys: { type: "array", items: { type: "string" } },
+                        name: { type: "string" },
+                    },
+                },
+            },
+            {
+                name: "restore-state",
+                description: "Restore state from backup",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string" },
+                        keys: { type: "array", items: { type: "string" } },
+                    },
+                    required: ["name"],
+                },
+            },
+            {
+                name: "validate-state",
+                description: "Validate state integrity and consistency",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        deep: { type: "boolean", default: false },
+                        repair: { type: "boolean", default: false },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "get-state": async (args) => this.handleGetState(args),
+            "set-state": async (args) => this.handleSetState(args),
+            "delete-state": async (args) => this.handleDeleteState(args),
+            "list-state": async (args) => this.handleListState(args),
+            "backup-state": async (args) => this.handleBackupState(args),
+            "restore-state": async (args) => this.handleRestoreState(args),
+            "validate-state": async (args) => this.handleValidateState(args),
+        };
         this.setupToolHandlers();
         const jobId = generateJobId("mcp-state-manager-init");
         frameworkLogger.log("mcps/state-manager", "initialize", "info", {}, undefined, jobId);
@@ -62,144 +166,18 @@ class XrayStateManagerServer {
         }
     }
     setupToolHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: "get-state",
-                        description: "Get state value by key with type safety and validation",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                key: { type: "string" },
-                                defaultValue: {
-                                    oneOf: [
-                                        { type: "string" },
-                                        { type: "number" },
-                                        { type: "boolean" },
-                                        { type: "object" },
-                                        { type: "array" },
-                                    ],
-                                },
-                                validate: { type: "boolean", default: true },
-                            },
-                            required: ["key"],
-                        },
-                    },
-                    {
-                        name: "set-state",
-                        description: "Set state value by key with conflict resolution and persistence",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                key: { type: "string" },
-                                value: {
-                                    oneOf: [
-                                        { type: "string" },
-                                        { type: "number" },
-                                        { type: "boolean" },
-                                        { type: "object" },
-                                        { type: "array" },
-                                    ],
-                                },
-                                persist: { type: "boolean", default: true },
-                                backup: { type: "boolean", default: false },
-                            },
-                            required: ["key", "value"],
-                        },
-                    },
-                    {
-                        name: "delete-state",
-                        description: "Delete state value by key with cleanup and validation",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                key: { type: "string" },
-                                force: { type: "boolean", default: false },
-                            },
-                            required: ["key"],
-                        },
-                    },
-                    {
-                        name: "list-state",
-                        description: "List all state keys with filtering and metadata",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                prefix: { type: "string" },
-                                includeValues: { type: "boolean", default: false },
-                                limit: { type: "number", default: 100 },
-                            },
-                        },
-                    },
-                    {
-                        name: "backup-state",
-                        description: "Create backup of current state or specific keys",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                keys: { type: "array", items: { type: "string" } },
-                                name: { type: "string" },
-                            },
-                        },
-                    },
-                    {
-                        name: "restore-state",
-                        description: "Restore state from backup",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                name: { type: "string" },
-                                keys: { type: "array", items: { type: "string" } },
-                            },
-                            required: ["name"],
-                        },
-                    },
-                    {
-                        name: "validate-state",
-                        description: "Validate state integrity and consistency",
-                        inputSchema: {
-                            type: "object",
-                            properties: {
-                                deep: { type: "boolean", default: false },
-                                repair: { type: "boolean", default: false },
-                            },
-                        },
-                    },
-                ],
-            };
-        });
-        // Handle tool calls
+        this.setupListToolsHandler();
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const handler = this.handlers[name];
+            if (!handler)
+                throw new Error(`Unknown tool: ${name}`);
             try {
-                const { name, arguments: args } = request.params;
-                switch (name) {
-                    case "get-state":
-                        return await this.handleGetState(args);
-                    case "set-state":
-                        return await this.handleSetState(args);
-                    case "delete-state":
-                        return await this.handleDeleteState(args);
-                    case "list-state":
-                        return await this.handleListState(args);
-                    case "backup-state":
-                        return await this.handleBackupState(args);
-                    case "restore-state":
-                        return await this.handleRestoreState(args);
-                    case "validate-state":
-                        return await this.handleValidateState(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
+                return await handler(args);
             }
             catch (error) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
-                        }],
-                };
+                frameworkLogger.log("mcps/state-manager", "tool", "error", { tool: name, error: String(error) });
+                throw error;
             }
         });
     }
@@ -622,12 +600,6 @@ ${results.repairedKeys.length > 0 ? `**Repaired Keys:**\n${results.repairedKeys.
         }
         return dependents;
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        const jobId = generateJobId("mcp-state-manager-start");
-        frameworkLogger.log("mcps/state-manager", "start", "success", {}, undefined, jobId);
-    }
 }
 // Start the server if run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {

package/dist/monitoring/nudge-watchdog.js

@@ -9,7 +9,6 @@
  * - repair-failure: Processor indicates fix but error persists
  *
  * @module monitoring/nudge-watchdog
- * @version 1.0.0
  */
 import { EventEmitter } from "events";
 import { frameworkLogger } from "../core/framework-logger.js";

package/dist/nucleus/default-plugins.js

@@ -8,18 +8,10 @@
  */
 import { frameworkLogger } from '../core/framework-logger.js';
 import { pluginRegistry } from './plugin-registry.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-const origSetRequestHandler = Server.prototype.setRequestHandler;
-Server.prototype.setRequestHandler = function (schema, handler) {
-    if (schema === ListToolsRequestSchema) {
-        this.__xrayListToolsHandler = handler;
-    }
-    if (schema === CallToolRequestSchema) {
-        this.__xrayCallToolHandler = handler;
-    }
-    return origSetRequestHandler.call(this, schema, handler);
-};
+// Note: handlers are extracted directly from the SDK's Server internal
+// _requestHandlers Map (keyed by method literal) instead of patching
+// Server.prototype.setRequestHandler. This avoids global prototype mutation
+// while preserving access to the same tool/handler metadata.
 // ── Named exports (17 servers) ──────────────────────────────────────────────
 import { XrayCodeReviewServer } from '../mcps/knowledge-skills/code-review.server.js';
 import { XraySecurityAuditServer } from '../mcps/knowledge-skills/security-audit.server.js';
@@ -54,13 +46,14 @@ async function toServerDescriptor(instance, serverName) {
     const srv = instance;
     const tools = srv.tools ?? [];
     const handlers = srv.handlers ?? {};
-    // Try captured handlers from the inner MCP Server instance
+    // Read handlers from SDK's internal _requestHandlers Map (keyed by method literal)
     const mcp = srv.server;
-    const listHandler = mcp?.__xrayListToolsHandler ?? srv.__xrayListToolsHandler;
-    const callHandler = mcp?.__xrayCallToolHandler ?? srv.__xrayCallToolHandler;
+    const requestHandlers = mcp?._requestHandlers;
+    const listHandler = requestHandlers?.get('tools/list');
+    const callHandler = requestHandlers?.get('tools/call');
     if (tools.length === 0 && listHandler) {
         try {
-            const listResult = await listHandler();
+            const listResult = await listHandler({ method: 'tools/list', params: {} }, {});
             if (listResult?.tools?.length) {
                 return {
                     name: serverName,
@@ -69,7 +62,8 @@ async function toServerDescriptor(instance, serverName) {
                         if (!callHandler) {
                             throw new Error(`Unknown tool '${toolName}' on server '${serverName}'`);
                         }
-                        return callHandler({ params: { name: toolName, arguments: args } });
+                        const result = await callHandler({ method: 'tools/call', params: { name: toolName, arguments: args } }, {});
+                        return result;
                     },
                 };
             }
@@ -154,7 +148,7 @@ export async function registerDefaultPlugins() {
         { label: 'git-workflow', create: () => new XrayGitWorkflowServer(), serverName: 'git-workflow' },
         { label: 'log-monitor', create: () => new LogMonitorServer(), serverName: 'log-monitor' },
         { label: 'session-management', create: () => new SessionManagementServer(), serverName: 'session-management' },
-        { label: 'strategist', create: () => new StrategistServer(), serverName: 'xray/strategist' },
+        { label: 'strategist', create: () => new StrategistServer(), serverName: 'strategist' },
     ]);
     // ── Batch 5: Content & Growth ──
     const batch5Count = await registerBatch('content-growth', [
@@ -167,7 +161,7 @@ export async function registerDefaultPlugins() {
     // ── Batch 6: Specialized ──
     const batch6Count = await registerBatch('specialized', [
         { label: 'bug-triage-specialist', create: () => new BugTriageSpecialistServer(), serverName: 'bug-triage-specialist' },
-        { label: 'skill-invocation', create: () => new SkillInvocationServer(), serverName: 'xray/skill-invocation' },
+        { label: 'skill-invocation', create: () => new SkillInvocationServer(), serverName: 'skill-invocation' },
         { label: 'testing-best-practices', create: () => new XrayTestingBestPracticesServer(), serverName: 'testing-best-practices' },
     ]);
     const registered = batch1Count + batch2Count + batch3Count + batch4Count + batch5Count + batch6Count;

package/dist/nucleus/index.js

@@ -6,7 +6,6 @@
  */
 export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdapter, NUCLEUS_VERSION, NUCLEUS_DESCRIPTION, } from './kernel.js';
 export { pluginRegistry, } from './plugin-registry.js';
-export { NucleusOrchestrator } from './orchestrator.js';
 export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
 export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
 export { registerDefaultPlugins } from './default-plugins.js';

package/dist/orchestrator/agent-spawn-governor.js

@@ -4,7 +4,6 @@
  * Critical governance component that prevents infinite agent spawning
  * and enforces spawn limits across the multi-agent orchestration system.
  *
- * @version 1.0.0
  * @since 2026-01-23
  */
 import { frameworkLogger } from "../core/framework-logger.js";

package/dist/orchestrator/intelligent-commit-batcher.js

@@ -4,9 +4,8 @@
  *
  * Configuration is read from .xray/features.json -> commit_cycle
  */
-import * as fs from "fs";
-import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { featuresConfigLoader } from "../core/features-config.js";
 import { runCommandSafe } from "../utils/command-runner.js";
 export class IntelligentCommitBatcher {
     pendingChanges = [];
@@ -35,14 +34,7 @@ export class IntelligentCommitBatcher {
     }
     loadFeaturesConfig() {
         try {
-            const configPaths = [
-                path.join(process.cwd(), ".xray", "features.json"),
-            ];
-            for (const configPath of configPaths) {
-                if (fs.existsSync(configPath)) {
-                    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
-                }
-            }
+            return featuresConfigLoader.loadConfig();
         }
         catch (e) {
             frameworkLogger.log("intelligent-commit-batcher", "config-load-failed", "warning", { error: e instanceof Error ? e.message : String(e) });

package/dist/orchestrator/multi-agent-orchestration-coordinator.js

@@ -4,7 +4,6 @@
  * Central coordinator for multi-agent orchestration that integrates all orchestration components
  * for comprehensive E2E workflow management and coordination.
  *
- * @version 1.1.0
  * @since 2026-01-23
  */
 import { KernelOrchestrator } from "../core/orchestrator.js";

package/dist/orchestrator/orchestrator.js

@@ -4,17 +4,16 @@
  * Coordinates multi-step tasks and delegates to specialized subagents.
  * Implements Sisyphus integration for relentless execution.
  *
- * @version 1.0.0
  * @since 2026-01-07
  */
 import { enhancedMultiAgentOrchestrator } from "./enhanced-multi-agent-orchestrator.js";
+import { featuresConfigLoader } from "../core/features-config.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { routingOutcomeTracker } from "../delegation/analytics/outcome-tracker.js";
 import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
 import { VotingCoordinator } from "../delegation/voting-coordinator.js";
 import { getAgentExpertiseLevel } from "../delegation/agent-expertise.js";
 import { XrayStateManager } from "../state/state-manager.js";
-import fs from "fs";
 export class XrayOrchestrator {
     config;
     activeTasks = new Map();
@@ -35,22 +34,13 @@ export class XrayOrchestrator {
      */
     loadOrchestratorConfig() {
         try {
-            const configPaths = [
-                ".xray/features.json",
-                ".xray/features.json",
-            ];
-            for (const configPath of configPaths) {
-                if (fs.existsSync(configPath)) {
-                    const content = fs.readFileSync(configPath, "utf-8");
-                    const features = JSON.parse(content);
-                    if (features.multi_agent_orchestration) {
-                        const ma = features.multi_agent_orchestration;
-                        return {
-                            maxConcurrentTasks: ma.max_concurrent_agents,
-                            conflictResolutionStrategy: this.mapConflictResolution(ma.conflict_resolution),
-                        };
-                    }
-                }
+            const features = featuresConfigLoader.loadConfig();
+            if (features.multi_agent_orchestration) {
+                const ma = features.multi_agent_orchestration;
+                return {
+                    maxConcurrentTasks: ma.max_concurrent_agents,
+                    conflictResolutionStrategy: this.mapConflictResolution(ma.conflict_resolution),
+                };
             }
         }
         catch (e) {

package/dist/orchestrator/self-direction-activation.js

@@ -5,7 +5,6 @@
  * Activates the framework's dormant self-evolution systems for continuous improvement.
  * This version works without advanced-features dependencies for initial deployment.
  *
- * @version 2.0.0
  * @since 2026-01-24
  */
 // Framework core imports

package/dist/orchestrator/universal-registry-bridge.js

@@ -4,7 +4,6 @@
  * Connects 0xRay to external agent registries.
  * Enables dynamic agent configuration loading from external sources.
  *
- * @version 1.0.0
  * @since 2026-02-14
  */
 import { readFile } from "fs/promises";

package/dist/performance/performance-budget-enforcer.js

@@ -9,7 +9,6 @@
  * - First Contentful Paint <2s
  * - Time to Interactive <5s
  *
- * @version 1.0.0
  * @since 2026-01-08
  */
 import { EventEmitter } from "events";

package/dist/performance/performance-regression-tester.js

@@ -4,7 +4,6 @@
  * Automated testing system that detects performance regressions and
  * enforces performance budget compliance in CI/CD pipelines.
  *
- * @version 1.0.0
  * @since 2026-01-08
  */
 import { performance } from "perf_hooks";

package/dist/plugin/plugin-codex-context.js

@@ -0,0 +1,87 @@
+import * as fs from "fs";
+import * as path from "path";
+import { resolveCodexPath } from "./plugin-modules.js";
+import { PluginLogger } from "./plugin-logger.js";
+let cachedCodexContexts = null;
+async function getCodexFileLocations(directory) {
+    const root = directory || process.cwd();
+    const resolved = await resolveCodexPath(root);
+    resolved.push(path.join(root, ".opencode", "codex.codex"), path.join(root, ".xray", "agents_template.md"), path.join(root, "AGENTS.md"));
+    return resolved;
+}
+function readFileContent(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch (error) {
+        const logger = new PluginLogger(process.cwd());
+        logger.error(`Failed to read file ${filePath}`, error);
+        return null;
+    }
+}
+export function extractCodexMetadata(content) {
+    if (content.trim().startsWith("{")) {
+        try {
+            const parsed = JSON.parse(content);
+            const version = parsed.version || "1.6.0";
+            const terms = parsed.terms || {};
+            const termCount = Object.keys(terms).length;
+            return { version, termCount };
+        }
+        catch {
+            // Not valid JSON, try markdown format
+        }
+    }
+    const versionMatch = content.match(/\*\*Version\*\*:\s*(\d+\.\d+\.\d+)/);
+    const version = versionMatch?.[1] ?? "1.6.0";
+    const termMatches = content.match(/####\s*\d+\.\s/g);
+    const termCount = termMatches ? termMatches.length : 0;
+    return { version, termCount };
+}
+export function createCodexContextEntry(filePath, content) {
+    const metadata = extractCodexMetadata(content);
+    return {
+        id: `xray-codex-${path.basename(filePath)}`,
+        source: filePath,
+        content,
+        priority: "critical",
+        metadata: {
+            version: metadata.version,
+            termCount: metadata.termCount,
+            loadedAt: new Date().toISOString(),
+        },
+    };
+}
+export async function loadCodexContext(directory) {
+    if (cachedCodexContexts) {
+        return cachedCodexContexts;
+    }
+    const codexContexts = [];
+    const locations = await getCodexFileLocations(directory);
+    for (const fileLocation of locations) {
+        const fullPath = path.isAbsolute(fileLocation) ? fileLocation : path.join(directory, fileLocation);
+        const content = readFileContent(fullPath);
+        if (content && content.trim().length > 0) {
+            const entry = createCodexContextEntry(fullPath, content);
+            if (entry.metadata.termCount > 0) {
+                codexContexts.push(entry);
+            }
+        }
+    }
+    cachedCodexContexts = codexContexts;
+    if (codexContexts.length === 0) {
+        const { getOrCreateLogger } = await import("./plugin-logger.js");
+        void getOrCreateLogger(directory).then((l) => l.error(`No valid codex files found. Checked: ${locations.join(", ")}`));
+    }
+    return codexContexts;
+}
+export function formatCodexContext(contexts) {
+    if (contexts.length === 0) {
+        return "";
+    }
+    const parts = [];
+    for (const context of contexts) {
+        parts.push(`# 0xRay Codex Context v${context.metadata.version}`, `Source: ${context.source}`, `Terms Loaded: ${context.metadata.termCount}`, `Loaded At: ${context.metadata.loadedAt}`, "", context.content, "", "---", "");
+    }
+    return parts.join("\n");
+}