0xray 3.1.1 → 3.3.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/memory-routing/index.js

@@ -0,0 +1,4 @@
+export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
+export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
+export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/null-provider.js

@@ -0,0 +1,51 @@
+const EMPTY_CONTEXT = {
+    providerId: 'null',
+    matchedSignals: [],
+    matchedTags: [],
+    flags: {},
+    synthesisAvailable: false,
+};
+export class NullMemoryRoutingProvider {
+    id = 'null';
+    name = 'Null (no memory routing)';
+    isAvailable() {
+        return true;
+    }
+    buildRoutingContext() {
+        return { ...EMPTY_CONTEXT };
+    }
+    enhanceAgentCapabilities(base) {
+        return new Map(base);
+    }
+    enrichTasks(tasks) {
+        return tasks;
+    }
+    buildInheritedContext() {
+        return { providerId: 'null', matchedSignals: [], flags: {} };
+    }
+    selectAgent(capabilities, requiredCapabilities, complexity) {
+        let bestAgent = null;
+        let bestScore = -1;
+        for (const [agent, caps] of capabilities) {
+            if (complexity > caps.complexityThreshold)
+                continue;
+            const matchCount = requiredCapabilities.filter((c) => caps.capabilities.includes(c)).length;
+            const score = matchCount * 10 + caps.concurrentTasks;
+            if (score > bestScore) {
+                bestScore = score;
+                bestAgent = agent;
+            }
+        }
+        return bestAgent;
+    }
+    resolveThinDispatch(baseAgent, _operation, complexityScore) {
+        return {
+            agent: baseAgent,
+            adjustedScore: complexityScore,
+            context: { ...EMPTY_CONTEXT },
+        };
+    }
+}
+export function createMemoryRoutingProvider() {
+    return new NullMemoryRoutingProvider();
+}

package/dist/memory-routing/provider-loader.js

@@ -0,0 +1,91 @@
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { frameworkLogger } from '../core/framework-logger.js';
+import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
+import { validateMemoryRoutingConfig } from './validate-config.js';
+const REPERTOIRE_CANDIDATE_PATHS = [
+    '../repertoire/dist/provider/memory-routing-provider.js',
+    '../../repertoire/dist/provider/memory-routing-provider.js',
+    '../../../repertoire/dist/provider/memory-routing-provider.js',
+];
+/**
+ * SECURITY: features.json is a trusted configuration boundary.
+ * module_path is resolved from disk and dynamically imported without signature
+ * verification. Only grant write access to features.json to trusted operators.
+ */
+function resolveModulePath(configuredPath, cwd) {
+    if (!configuredPath)
+        return null;
+    const candidates = [
+        resolve(cwd, configuredPath),
+        configuredPath,
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function defaultPathForProvider(provider, cwd) {
+    if (provider !== 'repertoire')
+        return null;
+    for (const rel of REPERTOIRE_CANDIDATE_PATHS) {
+        const abs = resolve(cwd, rel);
+        if (existsSync(abs))
+            return abs;
+    }
+    return null;
+}
+export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
+    const validation = validateMemoryRoutingConfig(config);
+    if (!validation.valid) {
+        await frameworkLogger.log('memory-routing', 'config-invalid', 'error', { errors: validation.errors, provider: config.provider });
+        return createNullProvider();
+    }
+    const effective = validation.normalized;
+    if (!effective.enabled || effective.provider === 'null') {
+        return createNullProvider();
+    }
+    const modulePath = resolveModulePath(effective.module_path, cwd) ??
+        defaultPathForProvider(effective.provider, cwd);
+    if (!modulePath) {
+        await frameworkLogger.log('memory-routing', 'provider-not-found', 'error', {
+            provider: effective.provider,
+            module_path: effective.module_path,
+            message: `Provider "${effective.provider}" is configured but module_path could not be resolved. Falling back to null provider.`,
+        });
+        return createNullProvider();
+    }
+    try {
+        const mod = await import(pathToFileURL(modulePath).href);
+        const factory = mod.createMemoryRoutingProvider ??
+            mod.default?.createMemoryRoutingProvider;
+        if (typeof factory !== 'function') {
+            throw new Error(`Module ${modulePath} must export createMemoryRoutingProvider()`);
+        }
+        const provider = factory((effective.config ?? {}));
+        if (!provider?.id || typeof provider.isAvailable !== 'function') {
+            throw new Error(`Invalid memory routing provider from ${modulePath}`);
+        }
+        if (!provider.isAvailable()) {
+            await frameworkLogger.log('memory-routing', 'provider-unavailable', 'error', {
+                providerId: provider.id,
+                modulePath,
+                message: `Provider "${provider.id}" loaded but isAvailable() returned false. Falling back to null provider.`,
+            });
+            return createNullProvider();
+        }
+        await frameworkLogger.log('memory-routing', 'provider-loaded', 'info', { providerId: provider.id, name: provider.name, modulePath });
+        return provider;
+    }
+    catch (err) {
+        await frameworkLogger.log('memory-routing', 'provider-load-failed', 'error', {
+            modulePath,
+            error: err instanceof Error ? err.message : String(err),
+            cwd,
+            configDir: dirname(modulePath),
+        });
+        return createNullProvider();
+    }
+}

package/dist/memory-routing/provider-registry.js

@@ -0,0 +1,40 @@
+import { featuresConfigLoader } from '../core/features-config.js';
+import { NullMemoryRoutingProvider } from './null-provider.js';
+import { loadMemoryRoutingProvider } from './provider-loader.js';
+import { validateMemoryRoutingConfig } from './validate-config.js';
+let cachedProvider = null;
+let loadPromise = null;
+const nullProviderSingleton = new NullMemoryRoutingProvider();
+export function getMemoryRoutingConfig() {
+    const raw = featuresConfigLoader.loadConfig().memory_routing;
+    const validation = validateMemoryRoutingConfig(raw ?? { enabled: false, provider: 'null' });
+    return validation.normalized;
+}
+export async function getMemoryRoutingProvider(forceReload = false) {
+    if (!forceReload && cachedProvider)
+        return cachedProvider;
+    if (!forceReload && loadPromise)
+        return loadPromise;
+    const config = getMemoryRoutingConfig();
+    loadPromise = loadMemoryRoutingProvider(config).then((provider) => {
+        cachedProvider = provider;
+        loadPromise = null;
+        return provider;
+    });
+    return loadPromise;
+}
+/** Synchronous accessor — returns shared null singleton until async load completes. */
+export function getMemoryRoutingProviderSync() {
+    return cachedProvider ?? nullProviderSingleton;
+}
+export function resetMemoryRoutingProvider() {
+    cachedProvider = null;
+    loadPromise = null;
+}
+/** Kick off background load at module init. */
+export function initializeMemoryRouting() {
+    const config = getMemoryRoutingConfig();
+    if (config.enabled) {
+        void getMemoryRoutingProvider();
+    }
+}

package/dist/memory-routing/types.js

@@ -0,0 +1,7 @@
+/**
+ * Memory Routing Provider — pluggable contract for long-term memory enrichment.
+ *
+ * Repertoire is one implementation. Any provider exposing createMemoryRoutingProvider()
+ * can be loaded via features.json memory_routing.module_path.
+ */
+export {};

package/dist/memory-routing/validate-config.js

@@ -0,0 +1,32 @@
+const VALID_PROVIDERS = new Set(['null', 'repertoire', 'custom']);
+export function validateMemoryRoutingConfig(raw) {
+    const errors = [];
+    const input = (raw ?? {});
+    const enabled = input.enabled === true;
+    const provider = typeof input.provider === 'string' ? input.provider : 'null';
+    if (!VALID_PROVIDERS.has(provider)) {
+        errors.push(`Invalid memory_routing.provider "${provider}". Must be one of: null, repertoire, custom.`);
+    }
+    if (enabled && provider !== 'null' && !input.module_path) {
+        errors.push(`memory_routing.provider "${provider}" requires module_path when enabled.`);
+    }
+    if (input.module_path !== undefined && typeof input.module_path !== 'string') {
+        errors.push('memory_routing.module_path must be a string.');
+    }
+    if (input.config !== undefined && (typeof input.config !== 'object' || input.config === null)) {
+        errors.push('memory_routing.config must be an object.');
+    }
+    const normalized = {
+        enabled,
+        provider: VALID_PROVIDERS.has(provider)
+            ? provider
+            : 'null',
+    };
+    if (typeof input.module_path === 'string') {
+        normalized.module_path = input.module_path;
+    }
+    if (input.config && typeof input.config === 'object') {
+        normalized.config = input.config;
+    }
+    return { valid: errors.length === 0, errors, normalized };
+}

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';