0xray 4.0.11 → 4.0.13

package/dist/plugin/plugin-modules.d.ts

@@ -1,11 +0,0 @@
-import type { SystemPromptGeneratorFn, StateManagerLike, FeaturesConfigLoaderLike, DetectTaskTypeFn } from "./plugin-types.js";
-export declare function getProcessorManager(): any;
-export declare function getXrayStateManager(): (new (persistencePath?: string) => StateManagerLike) | null;
-export declare function getFeaturesConfigLoader(): FeaturesConfigLoaderLike | null;
-export declare function getDetectTaskType(): DetectTaskTypeFn | null;
-export declare function getSystemPromptGenerator(): SystemPromptGeneratorFn | null;
-export declare function resolveCodexPath(root: string): Promise<string[]>;
-export declare function resolveStateDir(root?: string): Promise<string>;
-export declare function importSystemPromptGenerator(): Promise<void>;
-export declare function validateModulePath(resolvedPath: string, allowedPrefix: string): void;
-export declare function loadXrayComponents(): Promise<void>;

package/dist/plugin/plugin-modules.js

@@ -1,144 +0,0 @@
-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}`);
-        }
-    }
-}

package/dist/plugin/plugin-quality-gate.d.ts

@@ -1,11 +0,0 @@
-import type { PluginLogger } from "./plugin-logger.js";
-export declare function runEnforcerQualityGate(input: {
-    tool: string;
-    args?: {
-        content?: string;
-        filePath?: string;
-    };
-}, logger: PluginLogger): Promise<{
-    passed: boolean;
-    violations: string[];
-}>;

package/dist/plugin/plugin-quality-gate.js

@@ -1,88 +0,0 @@
-import * as fs from "fs";
-export async function runEnforcerQualityGate(input, logger) {
-    const violations = [];
-    const { tool, args } = input;
-    try {
-        const { RuleEnforcer } = await import("../enforcement/rule-enforcer.js");
-        const ruleEnforcer = new RuleEnforcer();
-        const context = {
-            operation: tool === "write" ? "write" : tool === "edit" ? "edit" : "read",
-        };
-        if (args?.filePath) {
-            context.files = [args.filePath];
-        }
-        if (args?.content) {
-            context.newCode = args.content;
-        }
-        const report = await ruleEnforcer.validateOperation(tool, context);
-        const blockingViolations = [];
-        const allViolations = [];
-        if (report.errors && report.errors.length > 0) {
-            for (const error of report.errors) {
-                allViolations.push(error);
-                blockingViolations.push(error);
-            }
-        }
-        if (report.results) {
-            for (const result of report.results) {
-                if (!result.passed) {
-                    const isBlocking = result.severity === "error" || result.severity === "blocking" || result.severity === "high";
-                    allViolations.push(result.message);
-                    if (isBlocking) {
-                        blockingViolations.push(result.message);
-                    }
-                }
-            }
-        }
-        if (allViolations.length > 0) {
-            logger.log(`⚠️ ENFORCER: ${allViolations.length} rule violation(s) detected`);
-            for (const v of allViolations.slice(0, 5)) {
-                logger.log(`   - ${v}`);
-            }
-            if (allViolations.length > 5) {
-                logger.log(`   ... and ${allViolations.length - 5} more`);
-            }
-        }
-        const passed = blockingViolations.length === 0;
-        violations.push(...blockingViolations);
-        if (!passed) {
-            logger.error(`🚫 Quality Gate FAILED with ${blockingViolations.length} blocking violation(s)`);
-        }
-        else {
-            logger.log(`✅ Quality Gate PASSED (${allViolations.length} warning(s))`);
-        }
-        return { passed, violations };
-    }
-    catch (error) {
-        logger.log(`Warning: RuleEnforcer unavailable, using fallback checks: ${error instanceof Error ? error.message : String(error)}`);
-        if (tool === "write" && args?.filePath) {
-            const filePath = args.filePath;
-            if (filePath.endsWith(".ts") &&
-                !filePath.includes(".test.") &&
-                !filePath.includes(".spec.")) {
-                const testPath = filePath.replace(".ts", ".test.ts");
-                const specPath = filePath.replace(".ts", ".spec.ts");
-                if (!fs.existsSync(testPath) && !fs.existsSync(specPath)) {
-                    violations.push(`tests-required: No test file found for ${filePath}`);
-                }
-            }
-        }
-        if (args?.content) {
-            const errorPatterns = [/console\.log\s*\(/g, /TODO\s*:/gi, /FIXME\s*:/gi];
-            for (const pattern of errorPatterns) {
-                if (pattern.test(args.content)) {
-                    violations.push(`resolve-all-errors: Found error pattern in code`);
-                    break;
-                }
-            }
-        }
-        const passed = violations.length === 0;
-        if (!passed) {
-            logger.error(`🚫 Fallback Quality Gate FAILED with ${violations.length} violation(s)`);
-        }
-        else {
-            logger.log(`✅ Fallback Quality Gate PASSED`);
-        }
-        return { passed, violations };
-    }
-}

package/dist/plugin/plugin-types.d.ts

@@ -1,93 +0,0 @@
-import type { ProcessorConfig, ProcessorResult } from "../processors/processor-manager.js";
-import type { ProcessorContext } from "../processors/processor-types.js";
-import type { StateManager } from "../state/state-manager.js";
-import type { FeaturesConfig, TaskType } from "../core/features-config.js";
-import type { RuleValidationContext } from "../enforcement/types.js";
-export type { ProcessorConfig, ProcessorResult, ProcessorContext, StateManager, FeaturesConfig, TaskType, RuleValidationContext, };
-export interface FrameworkLoggerLike {
-    log(module: string, event: string, status: string, data?: Record<string, string | number | boolean>): void;
-}
-export interface ProcessorRegistrationConfig {
-    name: string;
-    type: "pre" | "post";
-    priority: number;
-    enabled: boolean;
-}
-export interface PreProcessorInput {
-    tool?: string;
-    args?: unknown;
-    context?: unknown;
-}
-export interface PreProcessorContext {
-    filePath?: string;
-    operation?: string;
-    content?: string;
-    directory?: string;
-    tool?: string;
-}
-export interface PreProcessorResult {
-    success: boolean;
-    results: ProcessorResult[];
-}
-export interface StateManagerLike {
-    get<T>(key: string): T | undefined;
-    set<T>(key: string, value: T): void;
-}
-export interface FeaturesConfigLoaderLike {
-    loadConfig(): FeaturesConfig;
-}
-export type ResolveCodexPathFn = (root: string) => string[];
-export type ResolveStateDirFn = (projectRoot?: string) => string;
-export type SystemPromptGeneratorFn = (config: SystemPromptConfigLike) => Promise<string>;
-export interface SystemPromptConfigLike {
-    showWelcomeBanner?: boolean;
-    showCodexContext?: boolean;
-    enableTokenOptimization?: boolean;
-    maxTokenBudget?: number;
-    showCriticalTermsOnly?: boolean;
-    showEssentialLinks?: boolean;
-}
-export interface ToolExecuteAfterInput {
-    tool: string;
-    args?: ToolArguments;
-    result?: ToolResult;
-}
-export interface ToolExecuteBeforeOutput {
-    model?: string;
-}
-export interface ToolArguments {
-    content?: string;
-    filePath?: string;
-    command?: string;
-    prompt?: string;
-    message?: string;
-    directory?: string;
-    replace?: boolean;
-}
-export interface ToolResult {
-    success?: boolean;
-    error?: string;
-    content?: string;
-}
-export interface ProcessorManagerLike {
-    registerProcessor(config: ProcessorConfig): void;
-    executePreProcessors(input: PreProcessorInput): Promise<PreProcessorResult>;
-    executePostProcessors(operation: string, data: ProcessorContext, preResults: ProcessorResult[]): Promise<ProcessorResult[]>;
-}
-export type DetectTaskTypeFn = (toolName: string, context?: {
-    fileCount?: number;
-    isComplex?: boolean;
-}) => TaskType;
-export type ModuleWithProcessorManager = {
-    ProcessorManager: new (sm: StateManagerLike) => ProcessorManagerLike;
-};
-export type ModuleWithStateManager = {
-    XrayStateManager: new (persistencePath?: string) => StateManagerLike;
-};
-export type ModuleWithFeaturesConfig = {
-    featuresConfigLoader: FeaturesConfigLoaderLike;
-    detectTaskType: DetectTaskTypeFn;
-};
-export type ModuleWithSystemPrompt = {
-    generateLeanSystemPrompt: SystemPromptGeneratorFn;
-};

package/dist/plugin/plugin-types.js

@@ -1 +0,0 @@
-export {};

package/dist/plugin/xray-codex-injection.d.ts

@@ -1,39 +0,0 @@
-/**
- * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; xray codex injection + .xray fallbacks).
- */
-import type { ToolExecuteAfterInput, ToolExecuteBeforeOutput } from "./plugin-types.js";
-export { classifyTaskType } from "./plugin-helpers.js";
-export { validateModulePath } from "./plugin-modules.js";
-export { extractCodexMetadata, createCodexContextEntry, formatCodexContext } from "./plugin-codex-context.js";
-export { isWriteEditOperation, isPublishOperation, TOOL_AGENT_MAP, registerAllProcessors, registerAfterPostProcessors, resolveAgentName, getFrameworkVersion, getFrameworkIdentity } from "./plugin-helpers.js";
-export { runEnforcerQualityGate } from "./plugin-quality-gate.js";
-export { PluginLogger } from "./plugin-logger.js";
-export default function xrayCodexPlugin(input: {
-    client?: string;
-    directory?: string;
-    worktree?: string;
-}): Promise<{
-    "experimental.chat.system.transform": (_input: Record<string, unknown>, output: {
-        system?: string[];
-    }) => Promise<void>;
-    "tool.execute.before": (input: {
-        tool: string;
-        args?: {
-            content?: string;
-            filePath?: string;
-        };
-    }, output: ToolExecuteBeforeOutput) => Promise<void>;
-    "tool.execute.after": (input: ToolExecuteAfterInput, _output: Record<string, unknown>) => Promise<void>;
-    "chat.message": (input: {
-        parts?: Array<{
-            type?: string;
-            text?: string;
-        }>;
-    }, output: {
-        parts?: Array<{
-            type?: string;
-            text?: string;
-        }>;
-    }) => Promise<void>;
-    config: (_config: Record<string, unknown>) => Promise<void>;
-}>;