0xray 3.4.1 → 3.4.3

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

package/dist/postprocessor/PostProcessor.d.ts

@@ -0,0 +1,107 @@
+/**
+ * 0xRay Post-Processor - Core Infrastructure
+ *
+ * Automated CI/CD loop orchestration: commit → push → monitor → fix → redeploy → monitor
+ * Provides systematic error prevention and deployment automation.
+ *
+ * @since 2026-01-13
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { SessionMonitor } from "../session/session-monitor.js";
+import { PostProcessorConfig, PostProcessorResult, PostProcessorContext } from "./types.js";
+export declare class PostProcessor {
+    private stateManager;
+    private sessionMonitor;
+    private config;
+    private monitoringEngine;
+    private failureAnalysisEngine;
+    private autoFixEngine;
+    private fixValidator;
+    private reportValidator;
+    private regressionAnalysisService;
+    private redeployCoordinator;
+    private escalationEngine;
+    private successHandler;
+    private triggers;
+    constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | null, config?: Partial<PostProcessorConfig>);
+    /**
+     * Generate automated framework report if conditions are met
+     */
+    private generateFrameworkReport;
+    /**
+     * Validate generated reports for hidden issues
+     */
+    private validateGeneratedReport;
+    /**
+     * Clean up old reports based on retention policy
+     */
+    private cleanupOldReports;
+    /**
+     * Analyze code changes to provide meaningful context to processors
+     * FIX: Issue #1 - Pass actual code analysis to processors
+     */
+    private analyzeCodeChanges;
+    /**
+     * Load processor configuration from features.json
+     * FIX: Issue #2 - Make processor registration configurable
+     */
+    private loadProcessorConfig;
+    /**
+     * Initialize the post-processor system
+     */
+    initialize(): Promise<void>;
+    /**
+     * Validate architectural compliance against codex rules
+     */
+    private validateArchitecturalCompliance;
+    private checkSystemIntegrity;
+    private checkIntegrationTesting;
+    private checkPathResolution;
+    private checkFeatureCompleteness;
+    /**
+     * Rule 50: Path Analysis Guidelines Enforcement
+     * Ensures AIs follow path resolution guidelines for all write/edit operations
+     * Covers all 3 types of path violations from PATH_RESOLUTION_ANALYSIS.md
+     */
+    private checkPathAnalysisGuidelines;
+    /**
+     * Execute the complete post-processor loop
+     */
+    executePostProcessorLoop(context: PostProcessorContext): Promise<PostProcessorResult>;
+    /**
+     * Execute the monitoring loop until success or max attempts
+     */
+    private executeMonitoringLoop;
+    /**
+     * Redeploy after applying fixes using the RedeployCoordinator
+     */
+    private redeployWithFixes;
+    /**
+     * Attempt to apply automatic fixes
+     */
+    private attemptAutoFix;
+    /**
+     * Escalate to manual intervention
+     */
+    private escalateToManualIntervention;
+    /**
+     * Wait before retry with exponential backoff
+     */
+    private waitBeforeRetry;
+    /**
+     * Get post-processor status
+     */
+    getStatus(): Promise<any>;
+    /**
+     * Call appropriate agent/skill to fix architectural compliance violations
+     */
+    private callAgentForArchitecturalFix;
+    /**
+     * Calculate complexity score for automated report triggering
+     */
+    private calculateComplexityScore;
+    /**
+     * Revalidate after agent fix attempt
+     */
+    private revalidateAfterFix;
+}

package/dist/postprocessor/analysis/CodeChangeAnalyzer.d.ts

@@ -0,0 +1,11 @@
+import { PostProcessorContext } from "../types.js";
+export declare class CodeChangeAnalyzer {
+    analyzeCodeChanges(context: PostProcessorContext): Promise<{
+        operation: "commit";
+        files: string[];
+        newCode: Map<string, string>;
+        existingCode: Map<string, string>;
+        tests: string[];
+        dependencies: string[];
+    }>;
+}

package/dist/postprocessor/analysis/FailureAnalysisEngine.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Failure Analysis Engine for Post-Processor
+ */
+import { FailureAnalysis, MonitoringResult } from "../types.js";
+export declare class FailureAnalysisEngine {
+    constructor();
+    /**
+     * Analyze CI/CD failure and determine root cause
+     */
+    analyzeFailure(monitoringResult: MonitoringResult): Promise<FailureAnalysis>;
+    /**
+     * Classify the type of failure based on monitoring results
+     */
+    private classifyFailure;
+    /**
+     * Assess the severity of the failure
+     */
+    private assessSeverity;
+    /**
+     * Calculate confidence in the analysis
+     */
+    private calculateConfidence;
+    /**
+     * Determine the root cause of the failure
+     */
+    private determineRootCause;
+    /**
+     * Generate recommended actions for the failure
+     */
+    private generateRecommendedActions;
+    /**
+     * Generate suggested fixes for the failure
+     */
+    private generateSuggestedFixes;
+    /**
+     * Initialize analysis patterns and rules
+     */
+    private initializeAnalysisPatterns;
+}

package/dist/postprocessor/autofix/AutoFixEngine.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Auto-Fix Engine for Post-Processor
+ */
+import { FixResult, FailureAnalysis, PostProcessorContext } from "../types.js";
+export interface AppliedFixRecord {
+    type: string;
+    files: string[];
+    description: string;
+    timestamp: Date;
+    appliedChanges: string[];
+}
+export declare class AutoFixEngine {
+    private confidenceThreshold;
+    private appliedFixes;
+    constructor(confidenceThreshold?: number);
+    /**
+     * Attempt to automatically apply fixes for a failure
+     */
+    applyFixes(analysis: FailureAnalysis, context: PostProcessorContext): Promise<FixResult>;
+    /**
+     * Apply a single suggested fix
+     */
+    private applySingleFix;
+    /**
+     * Apply dependency updates
+     */
+    private applyDependencyUpdate;
+    /**
+     * Apply automatic code fixes
+     */
+    private applyCodeFix;
+    /**
+     * Apply test regeneration fixes
+     */
+    private applyTestRegeneration;
+    /**
+     * Validate that applied fixes resolve the issue
+     */
+    validateFixes(fixes: AppliedFixRecord[], originalFailure: FailureAnalysis, context: PostProcessorContext): Promise<boolean>;
+    /**
+     * Rollback applied fixes if validation fails
+     */
+    rollbackFixes(fixes: AppliedFixRecord[]): Promise<void>;
+    /**
+     * Get the list of applied fixes
+     */
+    getAppliedFixes(): AppliedFixRecord[];
+}