0xray 2.0.0 → 2.1.0

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

@@ -0,0 +1,158 @@
+/**
+ * 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
+ *
+ * @version 1.0.0
+ * @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,108 @@
+/**
+ * Performance Regression Testing
+ *
+ * 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 { 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/xray-codex-injection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .xray fallbacks).
+ */
+interface ToolExecuteAfterInput {
+    tool: string;
+    args?: ToolArguments;
+    result?: ToolResult;
+}
+interface ToolExecuteBeforeOutput {
+    model?: string;
+}
+interface ToolArguments {
+    content?: string;
+    filePath?: string;
+    command?: string;
+    prompt?: string;
+    message?: string;
+    directory?: string;
+    replace?: boolean;
+}
+interface ToolResult {
+    success?: boolean;
+    error?: string;
+    content?: string;
+}
+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>;
+}>;
+export {};

package/dist/plugin/xray-codex-injection.js

@@ -1,5 +1,5 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .strray fallbacks).
+ * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .xray fallbacks).
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -59,7 +59,7 @@ async function loadConfigPaths() {
         }
     }
     const logger = await loadFrameworkLogger();
-    logger.log("strray-codex-plugin", "config-paths-load-failed", "warning", { warning: "Failed to load config-paths module from any location" });
+    logger.log("xray-codex-plugin", "config-paths-load-failed", "warning", { warning: "Failed to load config-paths module from any location" });
 }
 async function resolveCodexPath(root) {
     await loadConfigPaths();
@@ -91,7 +91,7 @@ async function importSystemPromptGenerator() {
         }
     }
     const logger = await loadFrameworkLogger();
-    logger.log("strray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
+    logger.log("xray-codex-plugin", "system-prompt-generator-load-failed", "warning", { warning: "Failed to load lean system prompt generator, using fallback" });
 }
 function validateModulePath(resolvedPath, allowedPrefix) {
     const normalized = path.resolve(resolvedPath);
@@ -100,7 +100,7 @@ function validateModulePath(resolvedPath, allowedPrefix) {
         throw new Error(`Module path validation failed: ${normalized} is outside allowed path ${allowed}`);
     }
 }
-async function loadStringRayComponents() {
+async function loadXrayComponents() {
     if (_ProcessorManager && _StrRayStateManager && _featuresConfigLoader)
         return;
     const logger = await getOrCreateLogger(process.cwd());
@@ -126,7 +126,7 @@ async function loadStringRayComponents() {
         const message = e instanceof Error ? e.message : String(e);
         logger.log(`❌ Failed to load from cwd/dist/: ${message}`);
     }
-    const pluginPaths = ["0xray", "strray-framework"];
+    const pluginPaths = ["0xray"];
     for (const pluginPath of pluginPaths) {
         try {
             // FIXED: Avoided hardcoded /dist/ in node_modules paths to prevent build corruption
@@ -186,7 +186,7 @@ class PluginLogger {
             fs.mkdirSync(logsDir, { recursive: true });
         }
         const today = new Date().toISOString().split("T")[0];
-        this.logPath = path.join(logsDir, `strray-plugin-${today}.log`);
+        this.logPath = path.join(logsDir, `xray-plugin-${today}.log`);
     }
     async logAsync(message) {
         try {
@@ -337,7 +337,7 @@ 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, ".strray", "agents_template.md"), path.join(root, ".opencode", "strray", "agents_template.md"), path.join(root, "AGENTS.md"));
+    resolved.push(path.join(root, ".opencode", "codex.codex"), path.join(root, ".xray", "agents_template.md"), path.join(root, ".opencode", "xray", "agents_template.md"), path.join(root, "AGENTS.md"));
     return resolved;
 }
 function readFileContent(filePath) {
@@ -372,7 +372,7 @@ function extractCodexMetadata(content) {
 function createCodexContextEntry(filePath, content) {
     const metadata = extractCodexMetadata(content);
     return {
-        id: `strray-codex-${path.basename(filePath)}`,
+        id: `xray-codex-${path.basename(filePath)}`,
         source: filePath,
         content,
         priority: "critical",
@@ -467,7 +467,7 @@ function isWriteEditOperation(tool) {
     return tool === "write" || tool === "edit" || tool === "multiedit";
 }
 function isPublishOperation(tool) {
-    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "strray-release";
+    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "xray-release";
 }
 function resolveAgentName(input) {
     const globalAgent = globalThis.currentAgent;
@@ -533,7 +533,7 @@ function logTestAutoCreationResult(results, logger) {
 // ---------------------------------------------------------------------------
 // Main plugin function
 // ---------------------------------------------------------------------------
-export default async function strrayCodexPlugin(input) {
+export default async function xrayCodexPlugin(input) {
     const { directory: inputDirectory } = input;
     const directory = inputDirectory || process.cwd();
     return {
@@ -568,7 +568,7 @@ export default async function strrayCodexPlugin(input) {
             const logger = await getOrCreateLogger(directory);
             logger.log(`🚀 TOOL EXECUTE BEFORE HOOK FIRED: ${input.tool}`);
             logger.log(`📥 Full input: ${JSON.stringify(input)}`);
-            await loadStringRayComponents();
+            await loadXrayComponents();
             if (_featuresConfigLoader && _detectTaskType) {
                 try {
                     const config = _featuresConfigLoader.loadConfig();
@@ -601,7 +601,7 @@ export default async function strrayCodexPlugin(input) {
                 }
                 let stateManager;
                 let processorManager;
-                const globalState = globalThis.strRayStateManager;
+                const globalState = globalThis.xrayStateManager || globalThis.strRayStateManager;
                 if (globalState) {
                     logger.log("🔗 Connecting to booted 0xRay framework");
                     stateManager = globalState;
@@ -609,6 +609,7 @@ export default async function strrayCodexPlugin(input) {
                 else {
                     logger.log("🚀 0xRay framework not booted, initializing...");
                     stateManager = new _StrRayStateManager(await resolveStateDir(directory));
+                    globalThis.xrayStateManager = stateManager;
                     globalThis.strRayStateManager = stateManager;
                 }
                 processorManager = stateManager.get("processor:manager") ?? null;
@@ -667,7 +668,7 @@ export default async function strrayCodexPlugin(input) {
         },
         "tool.execute.after": async (input, _output) => {
             const logger = await getOrCreateLogger(directory);
-            await loadStringRayComponents();
+            await loadXrayComponents();
             const { tool, args, result } = input;
             try {
                 const { routingOutcomeTracker } = await import("../delegation/analytics/outcome-tracker.js");
@@ -816,7 +817,7 @@ export default async function strrayCodexPlugin(input) {
             }
         },
         config: async (_config) => {
-            const lockFile = path.join(directory, ".opencode", "logs", ".strray-init.lock");
+            const lockFile = path.join(directory, ".opencode", "logs", ".xray-init.lock");
             const now = Date.now();
             try {
                 if (fs.existsSync(lockFile)) {

package/dist/postprocessor/PostProcessor.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 0xRay Post-Processor - Core Infrastructure
+ *
+ * Automated CI/CD loop orchestration: commit → push → monitor → fix → redeploy → monitor
+ * Provides systematic error prevention and deployment automation.
+ *
+ * @version 1.0.0
+ * @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/PostProcessor.js

@@ -208,7 +208,7 @@ export class PostProcessor {
         const fs = await import("fs");
         const path = await import("path");
         try {
-            const configPath = resolveConfigPath("features.json") ?? path.join(process.cwd(), ".opencode", "strray", "features.json");
+            const configPath = resolveConfigPath("features.json") ?? path.join(process.cwd(), ".opencode", "xray", "features.json");
             if (fs.existsSync(configPath)) {
                 const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
                 return config.processors || {};

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

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

@@ -0,0 +1,23 @@
+/**
+ * Fix Validator for Post-Processor Auto-Fix System
+ *
+ * Validates applied fixes and provides rollback functionality.
+ */
+import { FailureAnalysis, PostProcessorContext } from "../types.js";
+export interface AppliedFix {
+    type: string;
+    files: string[];
+    description: string;
+    timestamp: Date;
+    rollbackData?: any;
+}
+export declare class FixValidator {
+    /**
+     * Validate that applied fixes resolve the original issue
+     */
+    validateFixes(appliedFixes: AppliedFix[], analysis: FailureAnalysis, context: PostProcessorContext): Promise<boolean>;
+    /**
+     * Rollback applied fixes
+     */
+    rollbackFixes(appliedFixes: AppliedFix[]): Promise<void>;
+}

package/dist/postprocessor/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Post-Processor Configuration
+ */
+import { PostProcessorConfig } from "./types.js";
+export declare const defaultConfig: PostProcessorConfig;
+export declare function validateConfig(config: Partial<PostProcessorConfig>): PostProcessorConfig;