0xray 3.1.1 → 3.3.0

package/dist/nucleus/thin-dispatch.js

@@ -9,6 +9,8 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getLevelFromScore, getAgentForTier, levelToTier, } from "../delegation/complexity-core.js";
 import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
+import { getMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
+initializeMemoryRouting();
 export const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
 /**
  * Score the complexity of an operation given its description and context.
@@ -52,6 +54,32 @@ export function routeToAgent(scoreOrLevel, level) {
  */
 export function scoreAndRoute(operation, context, thresholds) {
     const score = scoreComplexity(operation, context, thresholds);
-    const agent = routeToAgent(score);
+    let agent = routeToAgent(score);
+    const provider = getMemoryRoutingProviderSync();
+    let memoryRouting;
+    if (provider.id !== "null") {
+        const resolved = provider.resolveThinDispatch(agent, operation, score.score);
+        agent = resolved.agent;
+        memoryRouting = {
+            providerId: resolved.context.providerId,
+            adjustedScore: resolved.adjustedScore,
+            signals: resolved.context.matchedSignals,
+        };
+        const adjustedLevel = getLevelFromScore(resolved.adjustedScore, thresholds);
+        frameworkLogger.log("nucleus-thin-dispatch", "memory-routing", "info", {
+            providerId: resolved.context.providerId,
+            baseAgent: routeToAgent(score),
+            resolvedAgent: agent,
+            baseScore: score.score,
+            adjustedScore: resolved.adjustedScore,
+            level: adjustedLevel,
+            signals: resolved.context.matchedSignals,
+        });
+        return {
+            score: { ...score, score: resolved.adjustedScore, level: adjustedLevel },
+            agent,
+            memoryRouting,
+        };
+    }
     return { score, agent };
 }

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");
+}

package/dist/plugin/plugin-helpers.js

@@ -0,0 +1,155 @@
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+export function spawnPromise(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "inherit", "pipe"],
+        });
+        let stderr = "";
+        if (child.stderr) {
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve({ stdout: "", stderr });
+            }
+            else {
+                reject(new Error(`Process exited with code ${code}: ${stderr}`));
+            }
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+    });
+}
+export function getFrameworkVersion() {
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.version || "1.4.6";
+    }
+    catch {
+        return "1.4.6";
+    }
+}
+export function getFrameworkIdentity() {
+    const version = getFrameworkVersion();
+    return `0xRay Framework v${version} - AI Orchestration
+
+🔧 Core: architect, code-reviewer, refactorer, testing-lead, strategist
+📚 Codex: 5 Essential Terms (99.6% Error Prevention Target)
+🎯 Goal: Progressive, production-ready development workflow
+
+📖 Documentation: config dir (codex, config, agents docs) — resolved via config-paths
+`;
+}
+export const TOOL_AGENT_MAP = {
+    write: { agent: "code-reviewer", skill: "write" },
+    edit: { agent: "code-reviewer", skill: "edit" },
+    multiedit: { agent: "code-reviewer", skill: "multiedit" },
+    bash: { agent: "testing-lead", skill: "execution" },
+    search: { agent: "researcher", skill: "search" },
+    read: { agent: "researcher", skill: "read" },
+    glob: { agent: "researcher", skill: "glob" },
+    grep: { agent: "researcher", skill: "search" },
+    ls: { agent: "researcher", skill: "list" },
+};
+export function classifyTaskType(tool, args) {
+    const cmd = String(args?.command ?? "").toLowerCase().trim();
+    if (tool === "bash" && cmd) {
+        if (/(npm|yarn|pnpm)\s+test|jest|vitest|mocha|pytest/.test(cmd))
+            return "testing";
+        if (/(npm|yarn|pnpm)\s+run|npx|cargo|go run|make\s/.test(cmd))
+            return "build";
+        if (/audit|security|snyk|owasp|bandit/.test(cmd))
+            return "security";
+        if (/eslint|prettier|black|ruff|lint|format/.test(cmd))
+            return "lint";
+        if (/git\s/.test(cmd))
+            return "git";
+        if (/(npm|yarn|pnpm)\s+install|pip install|cargo add/.test(cmd))
+            return "install";
+        if (/grep|rg |find |ls |cat |head |tail /.test(cmd))
+            return "search";
+    }
+    if (tool === "write")
+        return "write";
+    if (tool === "edit" || tool === "multiedit")
+        return "edit";
+    if (tool === "read")
+        return "read";
+    if (tool === "search" || tool === "grep" || tool === "glob")
+        return "search";
+    return "unknown";
+}
+export function isWriteEditOperation(tool) {
+    return tool === "write" || tool === "edit" || tool === "multiedit";
+}
+export function isPublishOperation(tool) {
+    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "xray-release";
+}
+export function resolveAgentName(input) {
+    const globalAgent = globalThis.currentAgent;
+    if (globalAgent?.agentType)
+        return globalAgent.agentType;
+    if (globalAgent?.type)
+        return globalAgent.type;
+    if (input?.agentType)
+        return input.agentType;
+    return "architect";
+}
+export function registerAllProcessors(pm) {
+    pm.registerProcessor({ name: "preValidate", type: "pre", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "codexCompliance", type: "pre", priority: 20, enabled: true });
+    pm.registerProcessor({ name: "versionCompliance", type: "pre", priority: 25, enabled: true });
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 5, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+export function registerAfterPostProcessors(pm) {
+    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 50, enabled: true });
+    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
+    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
+}
+export function logPreProcessorResults(results, logger) {
+    logger.log(`📊 Pre-processor result: ${results.success ? "SUCCESS" : "FAILED"} (${results.results.length} processors)`);
+    if (!results.success) {
+        const failures = results.results.filter((r) => !r.success);
+        for (const f of failures) {
+            logger.error(`❌ Pre-processor ${f.processorName} failed: ${f.error}`);
+        }
+    }
+    else {
+        for (const r of results.results) {
+            logger.log(`✅ Pre-processor ${r.processorName}: ${r.success ? "OK" : "FAILED"}`);
+        }
+    }
+}
+export function logPostProcessorResults(results, logger) {
+    const allSuccess = results.every((r) => r.success);
+    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${results.length} processors)`);
+    for (const r of results) {
+        if (r.success) {
+            logger.log(`✅ Post-processor ${r.processorName}: OK`);
+        }
+        else {
+            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
+        }
+    }
+}
+export function logTestAutoCreationResult(results, logger) {
+    const testAutoResult = results.find((r) => r.processorName === "testAutoCreation");
+    if (testAutoResult) {
+        const data = testAutoResult.data;
+        if (testAutoResult.success && data?.testCreated && data?.testFile) {
+            logger.log(`✅ TEST AUTO-CREATION: Created ${data.testFile}`);
+        }
+        else if (!testAutoResult.success) {
+            logger.log(`ℹ️ TEST AUTO-CREATION: ${testAutoResult.error ?? "skipped - no new files"}`);
+        }
+    }
+}

package/dist/plugin/plugin-logger.js

@@ -0,0 +1,46 @@
+import * as fs from "fs";
+import * as path from "path";
+export class PluginLogger {
+    logPath;
+    constructor(directory) {
+        const logsDir = path.join(directory, ".opencode", "logs");
+        if (!fs.existsSync(logsDir)) {
+            fs.mkdirSync(logsDir, { recursive: true });
+        }
+        const today = new Date().toISOString().split("T")[0];
+        this.logPath = path.join(logsDir, `xray-plugin-${today}.log`);
+    }
+    async logAsync(message) {
+        try {
+            const timestamp = new Date().toISOString();
+            const logEntry = `[${timestamp}] ${message}\n`;
+            await fs.promises.appendFile(this.logPath, logEntry, "utf-8");
+        }
+        catch {
+            // Silent fail - logging failure should not break plugin
+        }
+    }
+    log(message) {
+        void this.logAsync(message);
+    }
+    error(message, error) {
+        const errorDetail = error instanceof Error ? `: ${error.message}` : "";
+        this.log(`ERROR: ${message}${errorDetail}`);
+    }
+}
+let loggerInstance = null;
+let loggerInitPromise = null;
+export async function getOrCreateLogger(directory) {
+    if (loggerInstance) {
+        return loggerInstance;
+    }
+    if (loggerInitPromise) {
+        return loggerInitPromise;
+    }
+    loggerInitPromise = (async () => {
+        const logger = new PluginLogger(directory);
+        loggerInstance = logger;
+        return logger;
+    })();
+    return loggerInitPromise;
+}

package/dist/plugin/plugin-modules.js

@@ -0,0 +1,144 @@
+import * as path from "path";
+import { getOrCreateLogger } from "./plugin-logger.js";
+let _resolveCodexPath = null;
+let _resolveStateDir = null;
+let _frameworkLogger = null;
+let _systemPromptGenerator = null;
+let _ProcessorManager = null;
+let _XrayStateManager = null;
+let _featuresConfigLoader = null;
+let _detectTaskType = null;
+export function getProcessorManager() { return _ProcessorManager; }
+export function getXrayStateManager() { return _XrayStateManager; }
+export function getFeaturesConfigLoader() { return _featuresConfigLoader; }
+export function getDetectTaskType() { return _detectTaskType; }
+export function getSystemPromptGenerator() { return _systemPromptGenerator; }
+async function loadFrameworkLogger() {
+    if (_frameworkLogger)
+        return _frameworkLogger;
+    const candidates = [
+        "../core/framework-logger.js",
+        "../../node_modules/0xray/dist/core/framework-logger.js",
+    ];
+    for (const p of candidates) {
+        try {
+            const mod = await import(p);
+            _frameworkLogger = mod.frameworkLogger;
+            return _frameworkLogger;
+        }
+        catch (_) {
+            // try next candidate
+        }
+    }
+    _frameworkLogger = {
+        log: (_module, _event, _status, _data) => { },
+    };
+    return _frameworkLogger;
+}
+async function loadConfigPaths() {
+    if (_resolveCodexPath && _resolveStateDir)
+        return;
+    const candidates = [
+        "../core/config-paths.js",
+        "../../node_modules/0xray/dist/core/config-paths.js",
+    ];
+    for (const p of candidates) {
+        try {
+            const mod = await import(p);
+            _resolveCodexPath = mod.resolveCodexPath;
+            _resolveStateDir = mod.resolveStateDir;
+            return;
+        }
+        catch (_) {
+            // try next candidate
+        }
+    }
+    const logger = await loadFrameworkLogger();
+    logger.log("xray-codex-plugin", "config-paths-load-failed", "warning", { warning: "Failed to load config-paths module from any location" });
+}
+export async function resolveCodexPath(root) {
+    await loadConfigPaths();
+    if (!_resolveCodexPath)
+        throw new Error("resolveCodexPath not available after loading");
+    return _resolveCodexPath(root);
+}
+export async function resolveStateDir(root) {
+    await loadConfigPaths();
+    if (!_resolveStateDir)
+        throw new Error("resolveStateDir not available after loading");
+    return _resolveStateDir(root);
+}
+export async function importSystemPromptGenerator() {
+    if (_systemPromptGenerator)
+        return;
+    const candidates = [
+        "../core/system-prompt-generator.js",
+        "../../node_modules/0xray/dist/core/system-prompt-generator.js",
+    ];
+    for (const p of candidates) {
+        try {
+            const module = await import(p);
+            _systemPromptGenerator = module.generateLeanSystemPrompt;
+            return;
+        }
+        catch (_) {
+            // try next candidate
+        }
+    }
+    const logger = await loadFrameworkLogger();
+    logger.log("xray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
+}
+export function validateModulePath(resolvedPath, allowedPrefix) {
+    const normalized = path.resolve(resolvedPath);
+    const allowed = path.resolve(allowedPrefix);
+    if (!normalized.startsWith(allowed)) {
+        throw new Error(`Module path validation failed: ${normalized} is outside allowed path ${allowed}`);
+    }
+}
+export async function loadXrayComponents() {
+    if (_ProcessorManager && _XrayStateManager && _featuresConfigLoader)
+        return;
+    const logger = await getOrCreateLogger(process.cwd());
+    try {
+        const root = process.cwd();
+        const distPrefix = path.join(root, 'dist');
+        validateModulePath(`${root}/dist/processors/processor-manager.js`, distPrefix);
+        validateModulePath(`${root}/dist/state/state-manager.js`, distPrefix);
+        validateModulePath(`${root}/dist/core/features-config.js`, distPrefix);
+        const procModule = await import(`${root}/dist/processors/processor-manager.js`);
+        const stateModule = await import(`${root}/dist/state/state-manager.js`);
+        const featuresModule = await import(`${root}/dist/core/features-config.js`);
+        _ProcessorManager = procModule.ProcessorManager;
+        _XrayStateManager = stateModule.XrayStateManager;
+        _featuresConfigLoader = featuresModule.featuresConfigLoader;
+        _detectTaskType = featuresModule.detectTaskType;
+        logger.log(`✅ Loaded from cwd/dist/`);
+        return;
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logger.log(`❌ Failed to load from cwd/dist/: ${message}`);
+    }
+    const pluginPaths = ["0xray"];
+    for (const pluginPath of pluginPaths) {
+        try {
+            const nodeModulesPrefix = path.join(process.cwd(), 'node_modules');
+            validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/processors/processor-manager.js`, nodeModulesPrefix);
+            validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/state/state-manager.js`, nodeModulesPrefix);
+            validateModulePath(`${process.cwd()}/node_modules/${pluginPath}/dist/core/features-config.js`, nodeModulesPrefix);
+            const pm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/processors/processor-manager.js`);
+            const sm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/state/state-manager.js`);
+            const fm = await import(`${process.cwd()}/node_modules/${pluginPath}/dist/core/features-config.js`);
+            _ProcessorManager = pm.ProcessorManager;
+            _XrayStateManager = sm.XrayStateManager;
+            _featuresConfigLoader = fm.featuresConfigLoader;
+            _detectTaskType = fm.detectTaskType;
+            logger.log(`✅ Loaded from node_modules/${pluginPath}/dist/`);
+            return;
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.log(`❌ Failed to load from node_modules/${pluginPath}/dist/: ${message}`);
+        }
+    }
+}