0xray 2.0.0

package/dist/postprocessor/redeploy/RedeployCoordinator.js

@@ -0,0 +1,342 @@
+/**
+ * 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/services/RegressionAnalysisService.js

@@ -0,0 +1,131 @@
+/**
+ * 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.
+ *
+ * @version 1.0.0
+ * @since 2026-03-08
+ */
+import { getKernel } from '../../core/kernel-patterns.js';
+import { createAgentDelegator } from '../../delegation/agent-delegator.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { StringRayStateManager } from '../../state/state-manager.js';
+import { strRayConfigLoader } from '../../core/config-loader.js';
+/**
+ * Main service for systematic regression analysis
+ */
+export class RegressionAnalysisService {
+    kernel = getKernel();
+    /**
+     * Determine if regression analysis is required for this context
+     */
+    async shouldAnalyze(context) {
+        // Check kernel patterns first
+        const kernelAnalysis = this.kernel.analyze(JSON.stringify(context));
+        // Check for fatal assumptions that require analysis
+        const fatalAssumptions = kernelAnalysis.fatalAssumptions;
+        if (fatalAssumptions && fatalAssumptions.length > 0 && fatalAssumptions[0]) {
+            return {
+                required: true,
+                reason: `Fatal assumption detected: ${fatalAssumptions[0].reason}`,
+                agents: ['bug-triage-specialist', 'code-analyzer', 'code-reviewer'],
+                depth: 'comprehensive',
+                confidence: 0.95
+            };
+        }
+        // Check for cascade patterns that require analysis
+        const cascadePatterns = kernelAnalysis.cascadePatterns;
+        if (cascadePatterns && cascadePatterns.length > 0 && cascadePatterns[0]) {
+            return {
+                required: true,
+                reason: `Cascade pattern detected: ${cascadePatterns[0].pattern}`,
+                agents: ['bug-triage-specialist', 'code-analyzer', 'code-reviewer'],
+                depth: 'comprehensive',
+                confidence: 0.9
+            };
+        }
+        // Check for code removal attempts
+        if (this.isCodeRemovalAttempt(context)) {
+            return {
+                required: true,
+                reason: 'Code removal attempt detected - systematic analysis required',
+                agents: ['bug-triage-specialist', 'code-analyzer', 'code-reviewer'],
+                depth: 'comprehensive',
+                confidence: 0.95
+            };
+        }
+        // Check for AI degradation patterns
+        const pattern = kernelAnalysis.pattern;
+        if (pattern && (pattern.id === 'A10' || pattern.id === 'A15')) {
+            return {
+                required: true,
+                reason: 'AI degradation pattern detected - quality check required',
+                agents: ['bug-triage-specialist', 'code-analyzer', 'code-reviewer'],
+                depth: 'comprehensive',
+                confidence: 0.9
+            };
+        }
+        // No analysis required
+        return {
+            required: false,
+            confidence: 0.8
+        };
+    }
+    /**
+     * Invoke regression analysis with appropriate agents
+     */
+    async invokeAnalysis(context, decision) {
+        await frameworkLogger.log('regression-analysis-service', 'invoking-analysis', 'info', {
+            reason: decision.reason,
+            agents: decision.agents,
+            depth: decision.depth,
+            confidence: decision.confidence
+        });
+        // Create delegation request for multi-agent conference
+        const delegationRequest = {
+            operation: 'regression-analysis',
+            description: `Systematic regression analysis: ${decision.reason}`,
+            context: {
+                ...context,
+                analysisDepth: decision.depth
+            },
+            conferenceType: 'regression-investigation'
+        };
+        // Create agent delegator for this operation
+        const stateManager = new StringRayStateManager();
+        const agentDelegator = createAgentDelegator(stateManager, strRayConfigLoader);
+        // Analyze delegation strategy
+        const analysis = await agentDelegator.analyzeDelegation(delegationRequest);
+        // Execute delegation
+        const result = await agentDelegator.executeDelegation(analysis, delegationRequest);
+        if (!result.success) {
+            await frameworkLogger.log('regression-analysis-service', 'analysis-failed', 'error', {
+                error: result.errors?.join(', '),
+                agents: analysis.agents
+            });
+            // If analysis fails, block the operation
+            throw new Error(`Regression analysis failed: ${result.errors?.join(', ')}`);
+        }
+        await frameworkLogger.log('regression-analysis-service', 'analysis-completed', 'success', {
+            agents: analysis.agents,
+            executionTime: result.totalTime
+        });
+    }
+    /**
+     * Validate that no regression was introduced after operation
+     */
+    async validateNoRegression(context) {
+        // Run regression validation tests
+        await frameworkLogger.log('regression-analysis-service', 'post-operation-validation', 'info', { context: context.operation });
+    }
+    /**
+     * Detect if operation is attempting to remove code
+     */
+    isCodeRemovalAttempt(context) {
+        const operation = context.operation?.toLowerCase() || '';
+        const removalKeywords = ['delete', 'remove', 'eliminate', 'strip', 'prune'];
+        return removalKeywords.some(keyword => operation.includes(keyword));
+    }
+}

package/dist/postprocessor/success/SuccessHandler.js

@@ -0,0 +1,134 @@
+/**
+ * Success Handler for Post-Processor
+ *
+ * Handles successful post-processor operations including metrics collection,
+ * notifications, cleanup, and reporting.
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+export class SuccessHandler {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            successConfirmation: true,
+            cleanupEnabled: true,
+            notificationEnabled: true,
+            metricsCollection: true,
+            ...config,
+        };
+    }
+    /**
+     * Handle successful post-processor completion
+     */
+    async handleSuccess(context, result, monitoringResults) {
+        const jobId = `success-handler-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        await frameworkLogger.log("success-handler", "handling successful post-processor completion", "info", { jobId, commitSha: context.commitSha, sessionId: result.sessionId });
+        // Perform success confirmation if enabled
+        if (this.config.successConfirmation) {
+            await this.confirmSuccess(context, result);
+        }
+        // Send notifications if enabled
+        if (this.config.notificationEnabled) {
+            await this.sendNotifications(context, result);
+        }
+        // Perform cleanup if enabled
+        if (this.config.cleanupEnabled) {
+            await this.performCleanup(context);
+        }
+        // Collect and log metrics if enabled
+        const metrics = this.collectMetrics(context, result, monitoringResults);
+        if (this.config.metricsCollection) {
+            await this.logMetrics(metrics);
+        }
+        await frameworkLogger.log("success-handler", "success handling completed", "success", { jobId, metrics });
+        return metrics;
+    }
+    /**
+     * Confirm deployment success
+     */
+    async confirmSuccess(context, result) {
+        frameworkLogger.log("SuccessHandler", "confirm-success", "info", { message: "🔍 Confirming deployment success..." });
+        // Simulate confirmation checks
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        frameworkLogger.log("SuccessHandler", "confirm-success", "info", { message: "✅ Deployment success confirmed" });
+    }
+    /**
+     * Send success notifications
+     */
+    async sendNotifications(context, result) {
+        const notification = `Deployment successful: ${context.commitSha} by ${context.author} in ${context.repository}`;
+        frameworkLogger.log("SuccessHandler", "send-notifications", "info", { message: "📢 Success Notification:", notification });
+    }
+    /**
+     * Perform post-success cleanup
+     */
+    async performCleanup(context) {
+        frameworkLogger.log("SuccessHandler", "perform-cleanup", "info", { message: "🧹 Performing post-success cleanup..." });
+        // Simulate cleanup operations
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        frameworkLogger.log("SuccessHandler", "perform-cleanup", "info", { message: "✅ Cleanup completed" });
+    }
+    /**
+     * Collect success metrics
+     */
+    collectMetrics(context, result, monitoringResults) {
+        const totalDuration = result.duration || 0;
+        const attempts = result.attempts;
+        const fixesApplied = result.fixesApplied?.length || 0;
+        const monitoringChecks = monitoringResults.length;
+        const redeployments = Math.max(0, attempts - 1);
+        return {
+            totalDuration,
+            attempts,
+            fixesApplied,
+            monitoringChecks,
+            redeployments,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Log success metrics
+     */
+    async logMetrics(metrics) {
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: "📊 Success Metrics:" });
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: `   Total Duration: ${metrics.totalDuration}ms` });
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: `   Attempts: ${metrics.attempts}` });
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: `   Fixes Applied: ${metrics.fixesApplied}` });
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: `   Monitoring Checks: ${metrics.monitoringChecks}` });
+        frameworkLogger.log("SuccessHandler", "log-metrics", "info", { message: `   Redeployments: ${metrics.redeployments}` });
+    }
+    /**
+     * Generate comprehensive success report
+     */
+    generateSuccessReport(context, result, metrics) {
+        return `
+Post-Processor Success Report
+=============================
+
+Commit: ${context.commitSha}
+Repository: ${context.repository}
+Branch: ${context.branch}
+Author: ${context.author}
+Trigger: ${context.trigger}
+
+Results:
+- Success: ${result.success}
+- Session ID: ${result.sessionId}
+- Attempts: ${metrics.attempts}
+- Fixes Applied: ${metrics.fixesApplied}
+- Monitoring Checks: ${metrics.monitoringChecks}
+- Redeployments: ${metrics.redeployments}
+- Total Duration: ${metrics.totalDuration}ms
+
+Files Processed: ${context.files.length}
+${context.files.map((f) => `  - ${f}`).join("\n")}
+
+Timestamp: ${metrics.timestamp.toISOString()}
+`.trim();
+    }
+    /**
+     * Get current configuration stats
+     */
+    getStats() {
+        return { ...this.config };
+    }
+}