0xray 4.0.11 → 4.0.13

package/dist/postprocessor/redeploy/RedeployCoordinator.d.ts

@@ -1,91 +0,0 @@
-/**
- * Redeploy Coordinator for Post-Processor
- */
-import { FixResult, PostProcessorContext } from "../types.js";
-export interface RedeployResult {
-    success: boolean;
-    deploymentId: string;
-    commitSha: string;
-    environment: string;
-    duration: number;
-    error?: string;
-    rollbackPerformed?: boolean;
-    canaryResults?: CanaryResult[];
-}
-export interface CanaryResult {
-    phase: number;
-    trafficPercentage: number;
-    success: boolean;
-    metrics: {
-        responseTime: number;
-        errorRate: number;
-        throughput: number;
-    };
-    duration: number;
-}
-export interface RedeployConfig {
-    maxRetries: number;
-    retryDelay: number;
-    backoffStrategy: "linear" | "exponential";
-    canaryEnabled: boolean;
-    canaryPhases: number;
-    canaryTrafficIncrement: number;
-    healthCheckTimeout: number;
-    rollbackOnFailure: boolean;
-}
-export declare class RedeployCoordinator {
-    private config;
-    constructor(config?: Partial<RedeployConfig>);
-    /**
-     * Execute redeployment with fixes
-     */
-    executeRedeploy(context: PostProcessorContext, fixResult: FixResult): Promise<RedeployResult>;
-    /**
-     * Validate pre-deployment requirements
-     */
-    private validatePreDeployment;
-    /**
-     * Execute deployment with retry logic
-     */
-    private deployWithRetry;
-    /**
-     * Execute canary deployment with progressive traffic rollout
-     */
-    private executeCanaryDeployment;
-    /**
-     * Execute direct deployment (no canary)
-     */
-    private executeDirectDeployment;
-    /**
-     * Deploy to canary environment
-     */
-    private deployToCanary;
-    /**
-     * Monitor canary health during deployment
-     */
-    private monitorCanaryHealth;
-    /**
-     * Check if canary metrics indicate healthy deployment
-     */
-    private isCanaryHealthy;
-    /**
-     * Wait between canary phases
-     */
-    private waitBetweenPhases;
-    /**
-     * Promote canary deployment to production
-     */
-    private promoteToProduction;
-    /**
-     * Validate post-deployment health
-     */
-    private validatePostDeployment;
-    /**
-     * Rollback deployment on failure
-     */
-    private rollbackDeployment;
-    /**
-     * Calculate wait time before retry using backoff strategy
-     */
-    private waitBeforeRetry;
-}

package/dist/postprocessor/redeploy/RedeployCoordinator.js

@@ -1,342 +0,0 @@
-/**
- * Redeploy Coordinator for Post-Processor
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { execSync } from "child_process";
-export class RedeployCoordinator {
-    config;
-    constructor(config = {}) {
-        this.config = {
-            maxRetries: 3,
-            retryDelay: 30000,
-            backoffStrategy: "exponential",
-            canaryEnabled: true,
-            canaryPhases: 3,
-            canaryTrafficIncrement: 25,
-            healthCheckTimeout: 60000,
-            rollbackOnFailure: true,
-            ...config,
-        };
-    }
-    /**
-     * Execute redeployment with fixes
-     */
-    async executeRedeploy(context, fixResult) {
-        const jobId = `redeploy-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const deploymentId = `deploy-${context.commitSha}-${Date.now()}`;
-        const startTime = Date.now();
-        await frameworkLogger.log("-redeploy-coordinator", "-starting-redeployment-deploymentid-for-commit-con", "info", {
-            message: `🚀 Starting redeployment ${deploymentId} for commit ${context.commitSha}`,
-        });
-        try {
-            // Pre-deployment validation
-            await this.validatePreDeployment(context, fixResult);
-            // Execute deployment with retry logic
-            const deployResult = await this.deployWithRetry(context, deploymentId, jobId);
-            // Post-deployment validation
-            const validationResult = await this.validatePostDeployment(deployResult, jobId);
-            if (validationResult.success) {
-                await frameworkLogger.log("redeploy-coordinator", "deployment-completed", "success", { jobId, deploymentId });
-                const result = {
-                    success: true,
-                    deploymentId,
-                    commitSha: context.commitSha,
-                    environment: "production", // Could be configurable
-                    duration: Date.now() - startTime,
-                };
-                if (deployResult.canaryResults) {
-                    result.canaryResults = deployResult.canaryResults;
-                }
-                return result;
-            }
-            else {
-                // Deployment validation failed - rollback if enabled
-                if (this.config.rollbackOnFailure) {
-                    await frameworkLogger.log("redeploy-coordinator", "deployment-validation-failed", "error", { jobId, action: "rollback-initiated" });
-                    await this.rollbackDeployment(deploymentId, context);
-                    const result = {
-                        success: false,
-                        deploymentId,
-                        commitSha: context.commitSha,
-                        environment: "production",
-                        duration: Date.now() - startTime,
-                        error: validationResult.error || "Deployment validation failed",
-                        rollbackPerformed: true,
-                    };
-                    return result;
-                }
-                else {
-                    return {
-                        success: false,
-                        deploymentId,
-                        commitSha: context.commitSha,
-                        environment: "production",
-                        duration: Date.now() - startTime,
-                        error: validationResult.error,
-                    };
-                }
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("RedeployCoordinator", "redeploy", "error", { error, message: `❌ Redeployment ${deploymentId} failed:` });
-            return {
-                success: false,
-                deploymentId,
-                commitSha: context.commitSha,
-                environment: "production",
-                duration: Date.now() - startTime,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Validate pre-deployment requirements
-     */
-    async validatePreDeployment(context, fixResult) {
-        await frameworkLogger.log("-redeploy-coordinator", "-validating-pre-deployment-requirements-", "info", { message: "🔍 Validating pre-deployment requirements..." });
-        // Ensure all fixes were successfully applied
-        if (!fixResult.success) {
-            throw new Error("Cannot redeploy: fixes were not successfully applied");
-        }
-        // Validate that the commit exists and is properly formatted
-        try {
-            execSync(`git rev-parse --verify ${context.commitSha}`, {
-                stdio: "pipe",
-                timeout: 10000,
-            });
-        }
-        catch (error) {
-            throw new Error(`Invalid commit SHA: ${context.commitSha}`);
-        }
-        // Check if deployment environment is available
-        // This would integrate with actual deployment infrastructure
-        await frameworkLogger.log("-redeploy-coordinator", "-pre-deployment-validation-passed-", "success", { message: "✅ Pre-deployment validation passed" });
-    }
-    /**
-     * Execute deployment with retry logic
-     */
-    async deployWithRetry(context, deploymentId, jobId) {
-        let attempt = 0;
-        const maxRetries = this.config.maxRetries;
-        while (attempt < maxRetries) {
-            try {
-                await frameworkLogger.log("-redeploy-coordinator", "-deployment-attempt-attempt-1-maxretries-for-deplo", "info", {
-                    message: `🔄 Deployment attempt ${attempt + 1}/${maxRetries} for ${deploymentId}`,
-                });
-                if (this.config.canaryEnabled) {
-                    // Execute canary deployment
-                    const canaryResults = await this.executeCanaryDeployment(context, deploymentId, jobId);
-                    return { canaryResults };
-                }
-                else {
-                    // Execute direct deployment
-                    await this.executeDirectDeployment(context, deploymentId);
-                    return {};
-                }
-            }
-            catch (error) {
-                await frameworkLogger.log("redeploy-coordinator", "deployment-attempt-failed", "error", {
-                    jobId,
-                    attempt: attempt + 1,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                if (attempt === maxRetries - 1) {
-                    throw error; // Final attempt failed
-                }
-                // Wait before retry
-                await this.waitBeforeRetry(attempt);
-                attempt++;
-            }
-        }
-        throw new Error(`Deployment failed after ${maxRetries} attempts`);
-    }
-    /**
-     * Execute canary deployment with progressive traffic rollout
-     */
-    async executeCanaryDeployment(context, deploymentId, jobId) {
-        const results = [];
-        const phases = this.config.canaryPhases;
-        await frameworkLogger.log("-redeploy-coordinator", "-executing-canary-deployment-with-phases-phases-", "info", { message: `🎯 Executing canary deployment with ${phases} phases` });
-        for (let phase = 1; phase <= phases; phase++) {
-            const trafficPercentage = Math.min(phase * this.config.canaryTrafficIncrement, 100);
-            await frameworkLogger.log("-redeploy-coordinator", "-canary-phase-phase-phases-trafficpercentage-traff", "info", {
-                message: `📊 Canary Phase ${phase}/${phases}: ${trafficPercentage}% traffic`,
-            });
-            const phaseStartTime = Date.now();
-            try {
-                // Deploy to canary subset
-                await this.deployToCanary(context, deploymentId, phase, trafficPercentage);
-                // Monitor canary health
-                const metrics = await this.monitorCanaryHealth(phase, this.config.healthCheckTimeout);
-                const phaseResult = {
-                    phase,
-                    trafficPercentage,
-                    success: this.isCanaryHealthy(metrics),
-                    metrics,
-                    duration: Date.now() - phaseStartTime,
-                };
-                results.push(phaseResult);
-                if (!phaseResult.success) {
-                    throw new Error(`Canary phase ${phase} failed health checks`);
-                }
-                await frameworkLogger.log("-redeploy-coordinator", "-canary-phase-phase-successful-phaseresult-duratio", "success", {
-                    message: `✅ Canary Phase ${phase} successful (${phaseResult.duration}ms)`,
-                });
-                // Wait between phases for observation
-                if (phase < phases) {
-                    await this.waitBetweenPhases();
-                }
-            }
-            catch (error) {
-                await frameworkLogger.log("redeploy-coordinator", "canary-phase-failed", "error", {
-                    jobId,
-                    phase,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-        }
-        // All phases successful - complete deployment
-        await this.promoteToProduction(context, deploymentId);
-        await frameworkLogger.log("redeploy-coordinator", "canary-promoted", "success", { jobId, phase: "complete" });
-        return results;
-    }
-    /**
-     * Execute direct deployment (no canary)
-     */
-    async executeDirectDeployment(context, deploymentId) {
-        await frameworkLogger.log("-redeploy-coordinator", "-executing-direct-deployment-for-deploymentid-", "info", { message: `🚀 Executing direct deployment for ${deploymentId}` });
-        // For this implementation, we'll simulate deployment by pushing to trigger CI/CD
-        // In a real system, this would integrate with deployment APIs
-        // Trigger a new CI/CD run to validate the fixes
-        try {
-            execSync("git push origin master", {
-                stdio: "pipe",
-                timeout: 30000,
-            });
-            await frameworkLogger.log("-redeploy-coordinator", "-deployment-triggered-via-git-push-", "success", { message: "✅ Deployment triggered via git push" });
-        }
-        catch (error) {
-            throw new Error(`Deployment trigger failed: ${error}`);
-        }
-    }
-    /**
-     * Deploy to canary environment
-     */
-    async deployToCanary(context, deploymentId, phase, trafficPercentage) {
-        // Placeholder for canary deployment logic
-        // In a real system, this would integrate with load balancers, service meshes, etc.
-        await frameworkLogger.log("-redeploy-coordinator", "-deploying-trafficpercentage-traffic-to-canary-for", "info", {
-            message: `🚢 Deploying ${trafficPercentage}% traffic to canary for phase ${phase}`,
-        });
-        // Simulate deployment time
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-    }
-    /**
-     * Monitor canary health during deployment
-     */
-    async monitorCanaryHealth(phase, timeout) {
-        await frameworkLogger.log("-redeploy-coordinator", "-monitoring-canary-health-for-phase-phase-timeout-", "info", {
-            message: `📊 Monitoring canary health for phase ${phase} (${timeout}ms timeout)`,
-        });
-        // Placeholder for health monitoring
-        // In a real system, this would check metrics from monitoring systems
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-        // Simulate health metrics
-        return {
-            responseTime: 150 + Math.random() * 50, // 150-200ms
-            errorRate: Math.random() * 0.01, // 0-1%
-            throughput: 1000 + Math.random() * 500, // 1000-1500 req/s
-        };
-    }
-    /**
-     * Check if canary metrics indicate healthy deployment
-     */
-    isCanaryHealthy(metrics) {
-        const { responseTime, errorRate, throughput } = metrics;
-        // Define health thresholds
-        const maxResponseTime = 300; // ms
-        const maxErrorRate = 0.05; // 5%
-        const minThroughput = 800; // req/s
-        return (responseTime <= maxResponseTime &&
-            errorRate <= maxErrorRate &&
-            throughput >= minThroughput);
-    }
-    /**
-     * Wait between canary phases
-     */
-    async waitBetweenPhases() {
-        const waitTime = 10000; // 10 seconds
-        await frameworkLogger.log("-redeploy-coordinator", "-waiting-waittime-ms-between-canary-phases-", "info", { message: `⏳ Waiting ${waitTime}ms between canary phases...` });
-        await new Promise((resolve) => setTimeout(resolve, waitTime));
-    }
-    /**
-     * Promote canary deployment to production
-     */
-    async promoteToProduction(context, deploymentId) {
-        await frameworkLogger.log("-redeploy-coordinator", "-promoting-canary-deployment-to-production-", "info", { message: "🎯 Promoting canary deployment to production" });
-        // Placeholder for production promotion
-        // In a real system, this would route 100% traffic to the new version
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-    /**
-     * Validate post-deployment health
-     */
-    async validatePostDeployment(deployResult, jobId) {
-        await frameworkLogger.log("-redeploy-coordinator", "-validating-post-deployment-health-", "info", { message: "🔍 Validating post-deployment health..." });
-        try {
-            // Run post-deployment health checks
-            // This could include API endpoint checks, database connectivity, etc.
-            // For now, simulate a basic health check
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-            await frameworkLogger.log("-redeploy-coordinator", "-post-deployment-validation-passed-", "success", { message: "✅ Post-deployment validation passed" });
-            return { success: true, error: "" };
-        }
-        catch (error) {
-            await frameworkLogger.log("redeploy-coordinator", "post-deployment-validation-failed", "error", { jobId });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Rollback deployment on failure
-     */
-    async rollbackDeployment(deploymentId, context) {
-        await frameworkLogger.log("-redeploy-coordinator", "-rolling-back-deployment-deploymentid-", "info", { message: `🔄 Rolling back deployment ${deploymentId}` });
-        try {
-            // Placeholder for rollback logic
-            // In a real system, this would revert to the previous version
-            // For this implementation, we could revert the git commit
-            execSync("git reset --hard HEAD~1", {
-                stdio: "pipe",
-                timeout: 10000,
-            });
-            await frameworkLogger.log("-redeploy-coordinator", "-deployment-rolled-back-successfully-", "success", { message: "✅ Deployment rolled back successfully" });
-        }
-        catch (error) {
-            frameworkLogger.log("RedeployCoordinator", "rollback", "error", { error, message: "❌ Rollback failed:" });
-            throw new Error(`Rollback failed: ${error}`);
-        }
-    }
-    /**
-     * Calculate wait time before retry using backoff strategy
-     */
-    async waitBeforeRetry(attempt) {
-        const baseDelay = this.config.retryDelay;
-        let delay;
-        if (this.config.backoffStrategy === "exponential") {
-            delay = baseDelay * Math.pow(2, attempt);
-        }
-        else {
-            delay = baseDelay * (attempt + 1);
-        }
-        // Cap maximum delay at 5 minutes
-        delay = Math.min(delay, 300000);
-        await frameworkLogger.log("-redeploy-coordinator", "-waiting-delay-ms-before-retry-attempt-attempt-1-", "info", {
-            message: `⏳ Waiting ${delay}ms before retry (attempt ${attempt + 1})`,
-        });
-        await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-}

package/dist/postprocessor/redeploy/RetryHandler.d.ts

@@ -1,49 +0,0 @@
-/**
- * Retry Handler for Redeploy Operations
- */
-export interface RetryConfig {
-    maxRetries: number;
-    baseDelay: number;
-    backoffStrategy: "linear" | "exponential";
-}
-export interface RetryableError {
-    type?: string;
-    code?: string;
-    statusCode?: number;
-}
-export declare class RetryHandler {
-    private config;
-    constructor(config?: RetryConfig);
-    /**
-     * Execute an operation with retry logic
-     */
-    executeWithRetry<T>(operation: () => Promise<T>, shouldRetry?: (error: RetryableError, attempt: number) => boolean): Promise<T>;
-    /**
-     * Calculate delay based on backoff strategy
-     */
-    private calculateDelay;
-    /**
-     * Wait for the specified duration
-     */
-    private wait;
-    /**
-     * Default retry conditions for deployment operations
-     */
-    static shouldRetryDeployment(error: RetryableError, attempt: number): boolean;
-    /**
-     * Specialized retry handler for deployment operations
-     */
-    executeDeploymentWithRetry<T>(deploymentOperation: () => Promise<T>): Promise<T>;
-    /**
-     * Specialized retry handler for API calls
-     */
-    executeApiCallWithRetry<T>(apiCall: () => Promise<T>): Promise<T>;
-    /**
-     * Get retry statistics
-     */
-    getStats(): {
-        maxRetries: number;
-        baseDelay: number;
-        backoffStrategy: string;
-    };
-}

package/dist/postprocessor/redeploy/RetryHandler.js

@@ -1,118 +0,0 @@
-/**
- * Retry Handler for Redeploy Operations
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class RetryHandler {
-    config;
-    constructor(config = {
-        maxRetries: 3,
-        baseDelay: 30000,
-        backoffStrategy: "exponential",
-    }) {
-        this.config = config;
-    }
-    /**
-     * Execute an operation with retry logic
-     */
-    async executeWithRetry(operation, shouldRetry) {
-        let lastError = {};
-        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                const retryable = error;
-                lastError = retryable;
-                // Don't retry on the last attempt
-                if (attempt === this.config.maxRetries) {
-                    break;
-                }
-                // Check if we should retry this error
-                if (shouldRetry && !shouldRetry(retryable, attempt)) {
-                    break;
-                }
-                // Calculate delay and wait
-                const delay = this.calculateDelay(attempt);
-                await frameworkLogger.log("-retry-handler", "-operation-failed-attempt-attempt-1-retrying-in-de", "error", {
-                    message: `⏳ Operation failed (attempt ${attempt + 1}), retrying in ${delay}ms...`,
-                });
-                await this.wait(delay);
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Calculate delay based on backoff strategy
-     */
-    calculateDelay(attempt) {
-        const { baseDelay, backoffStrategy } = this.config;
-        switch (backoffStrategy) {
-            case "exponential":
-                return baseDelay * Math.pow(2, attempt);
-            case "linear":
-                return baseDelay * (attempt + 1);
-            default:
-                return baseDelay;
-        }
-    }
-    /**
-     * Wait for the specified duration
-     */
-    async wait(duration) {
-        return new Promise((resolve) => setTimeout(resolve, duration));
-    }
-    /**
-     * Default retry conditions for deployment operations
-     */
-    static shouldRetryDeployment(error, attempt) {
-        // Don't retry certain types of errors
-        const nonRetryableErrors = [
-            "authentication_failed",
-            "authorization_failed",
-            "invalid_configuration",
-            "quota_exceeded",
-        ];
-        if (nonRetryableErrors.some((type) => error.type?.includes(type))) {
-            return false;
-        }
-        // Don't retry after too many attempts for transient errors
-        if (attempt >= 2 && error.type === "transient") {
-            return false;
-        }
-        // Retry network and timeout errors
-        if (error.code === "ECONNRESET" ||
-            error.code === "ETIMEDOUT" ||
-            error.code === "ENOTFOUND") {
-            return true;
-        }
-        // Retry 5xx HTTP errors
-        if (error.statusCode >= 500 && error.statusCode < 600) {
-            return true;
-        }
-        // Default: retry for most errors
-        return true;
-    }
-    /**
-     * Specialized retry handler for deployment operations
-     */
-    async executeDeploymentWithRetry(deploymentOperation) {
-        return this.executeWithRetry(deploymentOperation, RetryHandler.shouldRetryDeployment);
-    }
-    /**
-     * Specialized retry handler for API calls
-     */
-    async executeApiCallWithRetry(apiCall) {
-        return this.executeWithRetry(apiCall, (error, attempt) => {
-            // Retry on network errors and 5xx status codes
-            return (error.code === "ECONNRESET" ||
-                error.code === "ETIMEDOUT" ||
-                (error.statusCode >= 500 && error.statusCode < 600));
-        });
-    }
-    /**
-     * Get retry statistics
-     */
-    getStats() {
-        return { ...this.config };
-    }
-}

package/dist/postprocessor/services/RegressionAnalysisService.d.ts

@@ -1,39 +0,0 @@
-/**
- * Regression Analysis Service
- *
- * Systematically analyzes PostProcessor operations to detect regressions,
- * AI code removal attempts, and other critical issues.
- * Triggers multi-agent conferences when analysis is required.
- *
- * @since 2026-03-08
- */
-import { PostProcessorContext } from '../types.js';
-export interface AnalysisDecision {
-    required: boolean;
-    reason?: string;
-    agents?: string[];
-    depth?: 'shallow' | 'deep' | 'comprehensive';
-    confidence?: number;
-}
-/**
- * Main service for systematic regression analysis
- */
-export declare class RegressionAnalysisService {
-    private kernel;
-    /**
-     * Determine if regression analysis is required for this context
-     */
-    shouldAnalyze(context: PostProcessorContext): Promise<AnalysisDecision>;
-    /**
-     * Invoke regression analysis with appropriate agents
-     */
-    invokeAnalysis(context: PostProcessorContext, decision: AnalysisDecision): Promise<void>;
-    /**
-     * Validate that no regression was introduced after operation
-     */
-    validateNoRegression(context: PostProcessorContext): Promise<void>;
-    /**
-     * Detect if operation is attempting to remove code
-     */
-    private isCodeRemovalAttempt;
-}