0xray 3.4.2 → 3.4.4

package/dist/orchestrator/universal-librarian-consultation.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Universal Librarian Consultation System
+ * Ensures researcher is involved in all major system actions for documentation and versioning
+ */
+import { RuleEnforcer } from "../enforcement/rule-enforcer.js";
+export interface SystemAction {
+    type: "code-change" | "rule-modification" | "architectural-change" | "configuration_update" | "documentation_update";
+    description: string;
+    scope: "framework" | "agent" | "tool" | "configuration" | "documentation";
+    complexity: "low" | "medium" | "high" | "critical";
+    files?: string[];
+    components?: string[];
+    metadata?: {
+        triggeredBy?: string;
+        [key: string]: unknown;
+    };
+}
+export interface LibrarianConsultationResult {
+    approved: boolean;
+    documentationImpact: "none" | "minor" | "major" | "critical";
+    versionUpdates: VersionUpdate[];
+    recommendations: string[];
+    pairProgrammingRequired: boolean;
+}
+export interface VersionUpdate {
+    file: string;
+    field: string;
+    oldVersion: string;
+    newVersion: string;
+    reason: string;
+}
+export interface ActionResult {
+    success: boolean;
+    [key: string]: unknown;
+}
+export interface LibrarianConsultationResult {
+    approved: boolean;
+    documentationImpact: "none" | "minor" | "major" | "critical";
+    versionUpdates: VersionUpdate[];
+    recommendations: string[];
+    pairProgrammingRequired: boolean;
+}
+export interface VersionUpdate {
+    file: string;
+    field: string;
+    oldVersion: string;
+    newVersion: string;
+    reason: string;
+}
+export declare class UniversalLibrarianConsultation {
+    private ruleEnforcer;
+    constructor(ruleEnforcer: RuleEnforcer);
+    /**
+     * Pre-action consultation - must be called before any major system action
+     */
+    consultBeforeAction(action: SystemAction): Promise<LibrarianConsultationResult>;
+    /**
+     * Post-action consultation - must be called after any major system action
+     */
+    consultAfterAction(action: SystemAction, result: ActionResult): Promise<void>;
+    /**
+     * Check if this action is related to researcher operations (to prevent recursion)
+     */
+    private isLibrarianOperation;
+    /**
+     * Assess documentation impact of the action
+     */
+    private assessDocumentationImpact;
+    /**
+     * Determine what version updates are needed
+     */
+    private determineVersionUpdates;
+    /**
+     * Check if pair programming with researcher is required
+     */
+    private requiresPairProgramming;
+    /**
+     * Generate recommendations for the action
+     */
+    private generateRecommendations;
+    /**
+     * Update documentation after action completion
+     */
+    private updateDocumentation;
+    /**
+     * Update versions after action completion
+     */
+    private updateVersions;
+    /**
+     * Validate documentation integrity
+     */
+    private validateDocumentationIntegrity;
+    /**
+     * Determine which documentation files need updating
+     */
+    private determineDocumentationFiles;
+}
+export declare const universalLibrarianConsultation: UniversalLibrarianConsultation;

package/dist/orchestrator/universal-registry-bridge.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Universal Registry Bridge
+ *
+ * Connects 0xRay to external agent registries.
+ * Enables dynamic agent configuration loading from external sources.
+ *
+ * @since 2026-02-14
+ */
+import type { AgentConfig } from "../agents/types.js";
+export interface ExternalRegistryConfig {
+    type: "file" | "http" | "npm";
+    location: string;
+    refreshInterval?: number;
+}
+export interface RegistryAgentDefinition {
+    name: string;
+    description: string;
+    version: string;
+    capabilities?: string[];
+    config?: Record<string, unknown>;
+}
+export interface BridgeOptions {
+    registries: ExternalRegistryConfig[];
+    cacheDir?: string;
+    autoRefresh?: boolean;
+}
+export declare class UniversalRegistryBridge {
+    private registries;
+    private cacheDir;
+    private autoRefresh;
+    private cache;
+    private logger;
+    constructor(options: BridgeOptions);
+    /**
+     * Load agents from all configured registries
+     */
+    loadAgents(): Promise<RegistryAgentDefinition[]>;
+    /**
+     * Fetch agents from a specific registry
+     */
+    private fetchFromRegistry;
+    /**
+     * Load agents from a local file
+     */
+    private loadFromFile;
+    /**
+     * Simple YAML parser for agent definitions
+     * Handles basic agent registry format
+     */
+    private parseYamlAgents;
+    /**
+     * Load agents from HTTP endpoint
+     */
+    private loadFromHttp;
+    /**
+     * Load agents from npm package
+     */
+    private loadFromNpm;
+    /**
+     * Convert registry definition to AgentConfig
+     */
+    toAgentConfig(registryDef: RegistryAgentDefinition): Partial<AgentConfig>;
+    /**
+     * Get cached agents from a specific registry
+     */
+    getCached(registryType: string, location: string): RegistryAgentDefinition[] | undefined;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Add a new registry dynamically
+     */
+    addRegistry(registry: ExternalRegistryConfig): void;
+    /**
+     * Get all configured registries
+     */
+    getRegistries(): ExternalRegistryConfig[];
+}
+/**
+ * Create a bridge from integration config
+ */
+export declare function createRegistryBridge(configPath?: string): Promise<UniversalRegistryBridge>;
+export declare function getDefaultBridge(): UniversalRegistryBridge;

package/dist/performance/performance-budget-enforcer.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Performance Budget Enforcement System
+ *
+ * Comprehensive performance testing and monitoring system that enforces
+ * Universal Development Codex performance budget requirements.
+ *
+ * Performance Budget Requirements:
+ * - Bundle size <2MB (gzipped <700KB)
+ * - First Contentful Paint <2s
+ * - Time to Interactive <5s
+ *
+ * @since 2026-01-08
+ */
+import { EventEmitter } from "events";
+export declare const PERFORMANCE_BUDGET: {
+    readonly bundleSize: {
+        readonly uncompressed: number;
+        readonly gzipped: number;
+    };
+    readonly webVitals: {
+        readonly firstContentfulPaint: 2000;
+        readonly timeToInteractive: 5000;
+        readonly largestContentfulPaint: 2500;
+        readonly cumulativeLayoutShift: 0.1;
+        readonly firstInputDelay: 100;
+    };
+    readonly runtime: {
+        readonly memoryUsage: number;
+        readonly startupTime: 100;
+        readonly testExecutionTime: 5000;
+    };
+};
+export interface BundleSizeMetrics {
+    totalSize: number;
+    gzippedSize: number;
+    fileCount: number;
+    largestFile: {
+        name: string;
+        size: number;
+        gzippedSize: number;
+    };
+    breakdown: Array<{
+        name: string;
+        size: number;
+        gzippedSize: number;
+        percentage: number;
+    }>;
+}
+export interface WebVitalsMetrics {
+    firstContentfulPaint: number;
+    timeToInteractive: number;
+    largestContentfulPaint: number;
+    cumulativeLayoutShift: number;
+    firstInputDelay: number;
+    timestamp: number;
+}
+export interface RuntimePerformanceMetrics {
+    memoryUsage: {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    };
+    startupTime: number;
+    cpuUsage: number;
+    timestamp: number;
+}
+export interface PerformanceBudgetViolation {
+    metric: string;
+    actual: number;
+    budget: number;
+    percentage: number;
+    severity: "warning" | "error" | "critical";
+    recommendation: string;
+}
+export interface PerformanceReport {
+    timestamp: number;
+    bundleSize: BundleSizeMetrics;
+    webVitals: WebVitalsMetrics | null;
+    runtime: RuntimePerformanceMetrics;
+    violations: PerformanceBudgetViolation[];
+    recommendations: string[];
+    overallStatus: "pass" | "warning" | "fail";
+}
+/**
+ * Comprehensive performance budget enforcement system
+ */
+export declare class PerformanceBudgetEnforcer extends EventEmitter {
+    private reports;
+    private monitoringActive;
+    private alertThresholds;
+    private started;
+    private boundViolation;
+    private boundBudgetExceeded;
+    constructor();
+    start(): void;
+    private setupEventHandlers;
+    destroy(): void;
+    /**
+     * Analyze bundle size against performance budget
+     */
+    analyzeBundleSize(distPath?: string): Promise<BundleSizeMetrics>;
+    /**
+     * Measure web vitals (simulated for server-side framework)
+     * In a real web application, this would use the Web Vitals library
+     */
+    measureWebVitals(): Promise<WebVitalsMetrics>;
+    /**
+     * Measure runtime performance metrics
+     */
+    measureRuntimePerformance(): RuntimePerformanceMetrics;
+    /**
+     * Check performance budget compliance
+     */
+    checkBudgetCompliance(bundleSize: BundleSizeMetrics, webVitals: WebVitalsMetrics | null, runtime: RuntimePerformanceMetrics): PerformanceBudgetViolation[];
+    /**
+     * Generate comprehensive performance report
+     */
+    generatePerformanceReport(): Promise<PerformanceReport>;
+    /**
+     * Generate performance optimization recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Handle performance violations
+     */
+    private handleViolation;
+    /**
+     * Handle budget exceeded events
+     */
+    private handleBudgetExceeded;
+    /**
+     * Start continuous performance monitoring
+     */
+    startMonitoring(intervalMs?: number): void;
+    /**
+     * Stop performance monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Get historical performance reports
+     */
+    getReports(limit?: number): PerformanceReport[];
+    /**
+     * Export performance data for analysis
+     */
+    exportPerformanceData(): {
+        reports: PerformanceReport[];
+        summary: {
+            totalReports: number;
+            averageViolations: number;
+            mostCommonViolation: string;
+            trend: "improving" | "stable" | "degrading";
+        };
+    };
+}
+export declare const performanceBudgetEnforcer: PerformanceBudgetEnforcer;

package/dist/performance/performance-regression-tester.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Performance Regression Testing
+ *
+ * Automated testing system that detects performance regressions and
+ * enforces performance budget compliance in CI/CD pipelines.
+ *
+ * @since 2026-01-08
+ */
+import { PerformanceBudgetEnforcer, PerformanceReport } from "./performance-budget-enforcer.js";
+export interface PerformanceRegressionTest {
+    name: string;
+    description: string;
+    testFunction: () => Promise<void> | void;
+    timeout: number;
+    expectedDuration?: number;
+    tolerance: number;
+}
+export interface RegressionTestResult {
+    testName: string;
+    duration: number;
+    expectedDuration?: number;
+    deviation: number;
+    status: "pass" | "warning" | "fail";
+    error?: string;
+    timestamp: number;
+}
+export interface PerformanceBaseline {
+    testName: string;
+    averageDuration: number;
+    standardDeviation: number;
+    sampleCount: number;
+    lastUpdated: number;
+    tolerance: number;
+}
+export interface RegressionTestSuite {
+    name: string;
+    description: string;
+    tests: PerformanceRegressionTest[];
+    baselineFile: string;
+    failOnRegression: boolean;
+    warningThreshold: number;
+    failureThreshold: number;
+}
+/**
+ * Performance regression testing system
+ */
+export declare class PerformanceRegressionTester {
+    private baselines;
+    private results;
+    private budgetEnforcer;
+    constructor(budgetEnforcer?: PerformanceBudgetEnforcer);
+    /**
+     * Load performance baselines from file
+     */
+    loadBaselines(baselineFile: string): void;
+    /**
+     * Save performance baselines to file
+     */
+    saveBaselines(baselineFile: string): void;
+    /**
+     * Run a single performance regression test
+     */
+    runRegressionTest(test: PerformanceRegressionTest): Promise<RegressionTestResult>;
+    /**
+     * Run a complete regression test suite
+     */
+    runTestSuite(suite: RegressionTestSuite): Promise<{
+        results: RegressionTestResult[];
+        summary: {
+            totalTests: number;
+            passed: number;
+            warnings: number;
+            failed: number;
+            averageDeviation: number;
+            maxDeviation: number;
+            duration: number;
+        };
+        budgetReport?: PerformanceReport;
+        success: boolean;
+    }>;
+    /**
+     * Update baselines with new test results
+     */
+    private updateBaselines;
+    /**
+     * Generate test suite summary
+     */
+    private generateSummary;
+    /**
+     * Create default performance regression test suite
+     */
+    createDefaultTestSuite(): RegressionTestSuite;
+    /**
+     * Export test results for analysis
+     */
+    exportResults(): {
+        results: RegressionTestResult[];
+        baselines: Record<string, PerformanceBaseline>;
+        summary: {
+            totalTests: number;
+            passRate: number;
+            averageDeviation: number;
+            regressionDetected: boolean;
+        };
+    };
+}
+export declare const performanceRegressionTester: PerformanceRegressionTester;

package/dist/plugin/plugin-codex-context.d.ts

@@ -0,0 +1,18 @@
+export interface CodexContextEntry {
+    id: string;
+    source: string;
+    content: string;
+    priority: "critical" | "high" | "normal" | "low";
+    metadata: {
+        version: string;
+        termCount: number;
+        loadedAt: string;
+    };
+}
+export declare function extractCodexMetadata(content: string): {
+    version: string;
+    termCount: number;
+};
+export declare function createCodexContextEntry(filePath: string, content: string): CodexContextEntry;
+export declare function loadCodexContext(directory: string): Promise<CodexContextEntry[]>;
+export declare function formatCodexContext(contexts: CodexContextEntry[]): string;

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

@@ -0,0 +1,23 @@
+import type { ToolArguments, PreProcessorResult, ProcessorManagerLike, ProcessorResult } from "./plugin-types.js";
+import type { PluginLogger } from "./plugin-logger.js";
+export declare function spawnPromise(command: string, args: string[], cwd: string): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare function getFrameworkVersion(): string;
+export declare function getFrameworkIdentity(): string;
+export declare const TOOL_AGENT_MAP: Record<string, {
+    agent: string;
+    skill: string;
+}>;
+export declare function classifyTaskType(tool: string, args?: ToolArguments): string;
+export declare function isWriteEditOperation(tool: string): boolean;
+export declare function isPublishOperation(tool: string): boolean;
+export declare function resolveAgentName(input: {
+    agentType?: string;
+} | undefined): string;
+export declare function registerAllProcessors(pm: ProcessorManagerLike): void;
+export declare function registerAfterPostProcessors(pm: ProcessorManagerLike): void;
+export declare function logPreProcessorResults(results: PreProcessorResult, logger: PluginLogger): void;
+export declare function logPostProcessorResults(results: ProcessorResult[], logger: PluginLogger): void;
+export declare function logTestAutoCreationResult(results: ProcessorResult[], logger: PluginLogger): void;

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

@@ -0,0 +1,8 @@
+export declare class PluginLogger {
+    private logPath;
+    constructor(directory: string);
+    logAsync(message: string): Promise<void>;
+    log(message: string): void;
+    error(message: string, error?: unknown): void;
+}
+export declare function getOrCreateLogger(directory: string): Promise<PluginLogger>;

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

@@ -0,0 +1,11 @@
+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-quality-gate.d.ts

@@ -0,0 +1,11 @@
+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-types.d.ts

@@ -0,0 +1,93 @@
+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/xray-codex-injection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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>;
+}>;