0xray 4.0.33 → 4.0.35

package/dist/performance/performance-regression-tester.js

@@ -1,341 +0,0 @@
-/**
- * Performance Regression Testing
- *
- * Automated testing system that detects performance regressions and
- * enforces performance budget compliance in CI/CD pipelines.
- *
- * @since 2026-01-08
- */
-import { performance } from "perf_hooks";
-import * as fs from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { PerformanceBudgetEnforcer, PERFORMANCE_BUDGET, } from "./performance-budget-enforcer.js";
-/**
- * Performance regression testing system
- */
-export class PerformanceRegressionTester {
-    baselines = new Map();
-    results = [];
-    budgetEnforcer;
-    constructor(budgetEnforcer) {
-        this.budgetEnforcer = budgetEnforcer || new PerformanceBudgetEnforcer();
-    }
-    /**
-     * Load performance baselines from file
-     */
-    loadBaselines(baselineFile) {
-        try {
-            if (fs.existsSync(baselineFile)) {
-                const data = fs.readFileSync(baselineFile, "utf8");
-                const baselines = JSON.parse(data);
-                this.baselines = new Map(Object.entries(baselines));
-            }
-            else {
-                // No existing baselines found, will use defaults
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "baseline-load-failed", "error", { file: baselineFile, error });
-        }
-    }
-    /**
-     * Save performance baselines to file
-     */
-    saveBaselines(baselineFile) {
-        try {
-            const baselines = Object.fromEntries(this.baselines);
-            fs.writeFileSync(baselineFile, JSON.stringify(baselines, null, 2));
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "baseline-save-failed", "error", { file: baselineFile, error });
-        }
-    }
-    /**
-     * Run a single performance regression test
-     */
-    async runRegressionTest(test) {
-        const startTime = performance.now();
-        try {
-            // Set timeout for the test
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`Test timeout after ${test.timeout}ms`)), test.timeout);
-            });
-            const testPromise = Promise.resolve(test.testFunction());
-            await Promise.race([testPromise, timeoutPromise]);
-            const duration = performance.now() - startTime;
-            const baseline = this.baselines.get(test.name);
-            let deviation = 0;
-            let status = "pass";
-            if (baseline) {
-                deviation =
-                    ((duration - baseline.averageDuration) / baseline.averageDuration) *
-                        100;
-                if (Math.abs(deviation) > test.tolerance) {
-                    if (Math.abs(deviation) > test.tolerance * 2) {
-                        status = "fail";
-                    }
-                    else {
-                        status = "warning";
-                    }
-                }
-            }
-            else {
-                // No baseline, create one
-                deviation = 0;
-                status = "pass";
-            }
-            const expectedDuration = baseline
-                ? baseline.averageDuration
-                : test.expectedDuration || duration;
-            const result = {
-                testName: test.name,
-                duration,
-                expectedDuration,
-                deviation,
-                status,
-                timestamp: Date.now(),
-            };
-            this.results.push(result);
-            return result;
-        }
-        catch (error) {
-            const duration = performance.now() - startTime;
-            const result = {
-                testName: test.name,
-                duration,
-                deviation: 0,
-                status: "fail",
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: Date.now(),
-            };
-            this.results.push(result);
-            return result;
-        }
-    }
-    /**
-     * Run a complete regression test suite
-     */
-    async runTestSuite(suite) {
-        // Load baselines
-        this.loadBaselines(suite.baselineFile);
-        const suiteStartTime = performance.now();
-        const results = [];
-        // Run all tests
-        for (const test of suite.tests) {
-            const result = await this.runRegressionTest(test);
-            results.push(result);
-            const statusIcon = result.status === "pass"
-                ? "✅"
-                : result.status === "warning"
-                    ? "⚠️"
-                    : "❌";
-            const durationStr = result.duration.toFixed(2);
-            const deviationStr = result.deviation.toFixed(2);
-            const expectedStr = result.expectedDuration
-                ? result.expectedDuration.toFixed(2)
-                : "N/A";
-            if (result.error) {
-                frameworkLogger.log("performance-regression-tester", "test-failed", "error", { testName: result.testName, error: result.error });
-            }
-        }
-        // Update baselines with new results
-        this.updateBaselines(results);
-        // Generate performance budget report
-        let budgetReport;
-        try {
-            budgetReport = await this.budgetEnforcer.generatePerformanceReport();
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "budget-report-failed", "error", { error });
-        }
-        const suiteDuration = performance.now() - suiteStartTime;
-        const summary = this.generateSummary(results, suiteDuration);
-        // Display summary
-        // Test failure count - kept as console.log for CI visibility
-        if (budgetReport) {
-            if (budgetReport.violations.length > 0) {
-                budgetReport.violations.forEach((v) => { });
-            }
-        }
-        // Save updated baselines
-        this.saveBaselines(suite.baselineFile);
-        // Check if suite should fail
-        const shouldFail = suite.failOnRegression &&
-            (summary.failed > 0 ||
-                (budgetReport && budgetReport.overallStatus === "fail"));
-        if (shouldFail) {
-            throw new Error("Performance regression test suite failed");
-        }
-        else {
-            frameworkLogger.log("performance-regression-tester", "suite-passed", "info", { message: "Performance regression test suite passed" });
-        }
-        const result = {
-            results,
-            summary,
-            success: !shouldFail,
-        };
-        if (budgetReport) {
-            result.budgetReport = budgetReport;
-        }
-        return result;
-    }
-    /**
-     * Update baselines with new test results
-     */
-    updateBaselines(results) {
-        for (const result of results) {
-            if (result.status === "pass" || result.status === "warning") {
-                const existing = this.baselines.get(result.testName);
-                if (existing) {
-                    // Update rolling average
-                    const newCount = existing.sampleCount + 1;
-                    const newAverage = (existing.averageDuration * existing.sampleCount +
-                        result.duration) /
-                        newCount;
-                    // Update standard deviation (simplified)
-                    const variance = Math.pow(result.duration - existing.averageDuration, 2);
-                    const newStdDev = Math.sqrt((existing.standardDeviation *
-                        existing.standardDeviation *
-                        existing.sampleCount +
-                        variance) /
-                        newCount);
-                    this.baselines.set(result.testName, {
-                        ...existing,
-                        averageDuration: newAverage,
-                        standardDeviation: newStdDev,
-                        sampleCount: newCount,
-                        lastUpdated: Date.now(),
-                    });
-                }
-                else {
-                    // Create new baseline
-                    this.baselines.set(result.testName, {
-                        testName: result.testName,
-                        averageDuration: result.duration,
-                        standardDeviation: 0,
-                        sampleCount: 1,
-                        lastUpdated: Date.now(),
-                        tolerance: 10, // Default 10% tolerance
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Generate test suite summary
-     */
-    generateSummary(results, suiteDuration) {
-        const passed = results.filter((r) => r.status === "pass").length;
-        const warnings = results.filter((r) => r.status === "warning").length;
-        const failed = results.filter((r) => r.status === "fail").length;
-        const deviations = results.map((r) => Math.abs(r.deviation));
-        const averageDeviation = deviations.length > 0
-            ? deviations.reduce((a, b) => a + b, 0) / deviations.length
-            : 0;
-        const maxDeviation = deviations.length > 0 ? Math.max(...deviations) : 0;
-        return {
-            totalTests: results.length,
-            passed,
-            warnings,
-            failed,
-            averageDeviation,
-            maxDeviation,
-            duration: suiteDuration,
-        };
-    }
-    /**
-     * Create default performance regression test suite
-     */
-    createDefaultTestSuite() {
-        const tests = [
-            {
-                name: "bundle-size-analysis",
-                description: "Analyze bundle size against performance budget",
-                testFunction: async () => {
-                    await this.budgetEnforcer.analyzeBundleSize();
-                },
-                timeout: 10000,
-                tolerance: 5,
-            },
-            {
-                name: "module-import-performance",
-                description: "Measure core module import performance",
-                testFunction: async () => {
-                    const start = performance.now();
-                    await import("../core/index");
-                    const duration = performance.now() - start;
-                    if (duration > PERFORMANCE_BUDGET.runtime.startupTime) {
-                        throw new Error(`Import time ${duration.toFixed(2)}ms exceeds budget of ${PERFORMANCE_BUDGET.runtime.startupTime}ms`);
-                    }
-                },
-                timeout: 5000,
-                tolerance: 10,
-            },
-            {
-                name: "memory-usage-check",
-                description: "Verify memory usage stays within budget",
-                testFunction: () => {
-                    const memUsage = process.memoryUsage();
-                    if (memUsage.heapUsed > PERFORMANCE_BUDGET.runtime.memoryUsage) {
-                        throw new Error(`Heap usage ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)}MB exceeds budget of ${(PERFORMANCE_BUDGET.runtime.memoryUsage / 1024 / 1024).toFixed(2)}MB`);
-                    }
-                },
-                timeout: 1000,
-                tolerance: 5,
-            },
-            {
-                name: "test-execution-performance",
-                description: "Measure simple test execution time",
-                testFunction: async () => {
-                    const start = performance.now();
-                    // Simple test operation instead of running npm test
-                    const testArray = Array.from({ length: 1000 }, (_, i) => i * i);
-                    const result = testArray.reduce((sum, val) => sum + val, 0);
-                    if (result < 0)
-                        throw new Error("Unexpected result"); // Never happens
-                    const duration = performance.now() - start;
-                    // Just ensure the operation completes in reasonable time
-                    if (duration > 100) {
-                        throw new Error(`Test operation ${duration.toFixed(2)}ms too slow`);
-                    }
-                },
-                timeout: 5000,
-                tolerance: 20,
-            },
-        ];
-        return {
-            name: "0xRay Performance Regression Suite",
-            description: "Comprehensive performance regression tests for 0xRay Framework",
-            tests,
-            baselineFile: "./performance-baselines.json",
-            failOnRegression: true,
-            warningThreshold: 10,
-            failureThreshold: 20,
-        };
-    }
-    /**
-     * Export test results for analysis
-     */
-    exportResults() {
-        const summary = {
-            totalTests: this.results.length,
-            passRate: this.results.length > 0
-                ? (this.results.filter((r) => r.status === "pass").length /
-                    this.results.length) *
-                    100
-                : 0,
-            averageDeviation: this.results.length > 0
-                ? this.results.reduce((sum, r) => sum + Math.abs(r.deviation), 0) /
-                    this.results.length
-                : 0,
-            regressionDetected: this.results.some((r) => r.status === "fail"),
-        };
-        return {
-            results: this.results,
-            baselines: Object.fromEntries(this.baselines),
-            summary,
-        };
-    }
-}
-// Export singleton instance
-export const performanceRegressionTester = new PerformanceRegressionTester();

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

@@ -1,11 +0,0 @@
-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/CodeChangeAnalyzer.js

@@ -1,50 +0,0 @@
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class CodeChangeAnalyzer {
-    async analyzeCodeChanges(context) {
-        const fs = await import("fs");
-        const path = await import("path");
-        const newCode = new Map();
-        const existingCode = new Map();
-        const tests = [];
-        const dependencies = [];
-        try {
-            // Read new/changed files
-            for (const file of context.files || []) {
-                try {
-                    const fullPath = path.join(process.cwd(), file);
-                    if (fs.existsSync(fullPath)) {
-                        // Read new code
-                        const content = fs.readFileSync(fullPath, "utf-8");
-                        newCode.set(file, content);
-                        // Check for test files
-                        if (file.includes(".test.") || file.includes(".spec.")) {
-                            tests.push(file);
-                        }
-                        // Check for package.json or dependency files
-                        if (file.includes("package.json") || file.includes("requirements.txt") || file.includes("Cargo.toml")) {
-                            dependencies.push(file);
-                        }
-                    }
-                }
-                catch (error) {
-                    // Skip files that can't be read
-                    await frameworkLogger.log("-post-processor", "-code-analysis-file-error", "info", { message: `Could not analyze ${file}: ${error}` });
-                }
-            }
-            await frameworkLogger.log("-post-processor", "-code-analysis-complete", "info", {
-                message: `Analyzed ${newCode.size} files, ${tests.length} tests, ${dependencies.length} dependencies`,
-            });
-        }
-        catch (error) {
-            await frameworkLogger.log("-post-processor", "-code-analysis-failed", "error", { message: `Code analysis failed: ${error}` });
-        }
-        return {
-            operation: "commit",
-            files: context.files || [],
-            newCode,
-            existingCode,
-            tests,
-            dependencies,
-        };
-    }
-}

package/dist/postprocessor/config/ProcessorConfigLoader.d.ts

@@ -1,44 +0,0 @@
-export declare class ProcessorConfigLoader {
-    loadProcessorConfig(): Promise<{
-        preValidate?: {
-            enabled?: boolean;
-        };
-        codexCompliance?: {
-            enabled?: boolean;
-        };
-        testAutoCreation?: {
-            enabled?: boolean;
-        };
-        versionCompliance?: {
-            enabled?: boolean;
-        };
-        errorBoundary?: {
-            enabled?: boolean;
-        };
-        agentsMdValidation?: {
-            enabled?: boolean;
-        };
-        stateValidation?: {
-            enabled?: boolean;
-        };
-        post_processors?: {
-            enabled?: boolean;
-            priority_order?: string[];
-        };
-        storytellingTrigger?: {
-            enabled?: boolean;
-        };
-        sessionSummary?: {
-            enabled?: boolean;
-        };
-        testExecution?: {
-            enabled?: boolean;
-        };
-        regressionTesting?: {
-            enabled?: boolean;
-        };
-        inferenceImprovement?: {
-            enabled?: boolean;
-        };
-    }>;
-}

package/dist/postprocessor/config/ProcessorConfigLoader.js

@@ -1,16 +0,0 @@
-import { featuresConfigLoader } from "../../core/features-config.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class ProcessorConfigLoader {
-    async loadProcessorConfig() {
-        try {
-            const config = featuresConfigLoader.loadConfig();
-            return config.processors ?? {};
-        }
-        catch (error) {
-            frameworkLogger.log("postprocessor", "processor-config-load-failed", "info", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        return {};
-    }
-}

package/dist/postprocessor/integration.d.ts

@@ -1,156 +0,0 @@
-/**
- * 0xRay Integration Layer
- *
- * Provides generic connectors for integrating 0xRay's PostProcessor
- * with external applications and frameworks.
- *
- * This is framework-agnostic - works with Express, Fastify, Koa, etc.
- *
- * @since 2026-03-08
- */
-import express from "express";
-import { PostProcessor } from './PostProcessor.js';
-import type { WebhookConfig } from './triggers/WebhookTrigger.js';
-import type { APIConfig } from './triggers/APITrigger.js';
-export { WebhookTrigger } from './triggers/WebhookTrigger.js';
-export { APITrigger } from './triggers/APITrigger.js';
-export type { WebhookConfig, WebhookEvent } from './triggers/WebhookTrigger.js';
-export type { APIConfig, APIRequest } from './triggers/APITrigger.js';
-/**
- * Generic 0xRay integration for any external application
- *
- * Provides:
- * - Webhook receivers (GitHub, GitLab, Bitbucket, Stripe)
- * - REST API triggers (manual trigger, retry, status)
- * - Framework-agnostic (works with Express, Fastify, Koa, etc.)
- *
- * @example
- * ```typescript
- * import { createXrayIntegration } from '0xray/integration';
- *
- * const postProcessor = new PostProcessor(stateManager);
- * const integration = createXrayIntegration(postProcessor);
- *
- * // Get Express app for mounting
- * app.use('/webhooks', integration.getWebhookApp());
- * app.use('/api/post-process', integration.getAPIApp());
- *
- * // Or get raw routers for Fastify/Koa
- * const webhookRouter = integration.getWebhookRouter();
- * const apiRouter = integration.getAPIRouter();
- * ```
- */
-export declare class XrayIntegration {
-    private postProcessor;
-    private webhookTrigger;
-    private apiTrigger;
-    constructor(postProcessor: PostProcessor);
-    /**
-     * Initialize all triggers with default configuration
-     *
-     * @param config - Optional configuration for triggers
-     */
-    initialize(config?: {
-        webhook?: Partial<WebhookConfig>;
-        api?: Partial<APIConfig>;
-    }): Promise<void>;
-    /**
-     * Get webhook app for framework-specific mounting
-     *
-     * Returns an Express Application. For other frameworks,
-     * use getWebhookRouter() to get the router instance.
-     *
-     * @example
-     * ```typescript
-     * // Express
-     * app.use('/webhooks', integration.getWebhookApp());
-     *
-     * // Fastify
-     * await fastify.register(integration.getWebhookRouter(), { prefix: '/webhooks' });
-     *
-     * // Koa
-     * app.use(integration.getWebhookRouter().routes());
-     * ```
-     */
-    getWebhookApp(): express.Application | null;
-    /**
-     * Get webhook router (raw Express router)
-     *
-     * Useful for frameworks that need the router instance directly
-     * rather than the full Express app.
-     */
-    getWebhookRouter(): express.Router | null;
-    /**
-     * Get API trigger app for framework-specific mounting
-     *
-     * @example
-     * ```typescript
-     * // Express
-     * app.use('/api/post-process', integration.getAPIApp());
-     *
-     * // Fastify
-     * await fastify.register(integration.getAPIRouter(), { prefix: '/api/post-process' });
-     * ```
-     */
-    getAPIApp(): express.Application | null;
-    /**
-     * Get API trigger router (raw Express router)
-     *
-     * Useful for frameworks that need the router instance directly.
-     */
-    getAPIRouter(): express.Router | null;
-    /**
-     * Manually trigger PostProcessor via API
-     *
-     * Convenience method for programmatic triggering without
-     * going through the HTTP endpoint.
-     *
-     * @example
-     * ```typescript
-     * await integration.trigger({
-     *   tool: 'test',
-     *   operation: 'run',
-     *   reason: 'Manual test trigger'
-     * });
-     * ```
-     */
-    trigger(options: {
-        tool: string;
-        operation: string;
-        filePath?: string;
-        directory?: string;
-        reason?: string;
-    }): Promise<void>;
-    /**
-     * Shutdown all triggers
-     */
-    shutdown(): Promise<void>;
-}
-/**
- * Factory function for easy integration setup
- *
- * @example
- * ```typescript
- * import { createXrayIntegration } from '0xray/integration';
- *
- * // With default configuration
- * const integration = createXrayIntegration(postProcessor);
- * await integration.initialize();
- *
- * // With custom configuration
- * const integration = createXrayIntegration(postProcessor);
- * await integration.initialize({
- *   webhook: {
- *     provider: 'gitlab',
- *     secret: process.env.GITLAB_WEBHOOK_SECRET,
- *     events: ['push', 'merge_request'],
- *     path: '/webhooks/gitlab'
- *   },
- *   api: {
- *     path: '/api/stray-trigger',
- *     apiKey: process.env.API_KEY
- *   }
- * });
- * ```
- */
-export declare function createXrayIntegration(postProcessor: PostProcessor): XrayIntegration;