0xray 4.0.11 → 4.0.13

package/dist/postprocessor/services/RegressionAnalysisService.js

@@ -1,130 +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 { getKernel } from '../../core/kernel-patterns.js';
-import { createAgentDelegator } from '../../delegation/agent-delegator.js';
-import { frameworkLogger } from '../../core/framework-logger.js';
-import { XrayStateManager } from '../../state/state-manager.js';
-import { xrayConfigLoader } 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 XrayStateManager();
-        const agentDelegator = createAgentDelegator(stateManager, xrayConfigLoader);
-        // 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.d.ts

@@ -1,57 +0,0 @@
-/**
- * Success Handler for Post-Processor
- *
- * Handles successful post-processor operations including metrics collection,
- * notifications, cleanup, and reporting.
- */
-import { PostProcessorContext, PostProcessorResult, MonitoringResult } from "../types.js";
-export interface SuccessHandlerConfig {
-    successConfirmation?: boolean;
-    cleanupEnabled?: boolean;
-    notificationEnabled?: boolean;
-    metricsCollection?: boolean;
-}
-export interface SuccessMetrics {
-    totalDuration: number;
-    attempts: number;
-    fixesApplied: number;
-    monitoringChecks: number;
-    redeployments: number;
-    timestamp: Date;
-}
-export declare class SuccessHandler {
-    private config;
-    constructor(config?: SuccessHandlerConfig);
-    /**
-     * Handle successful post-processor completion
-     */
-    handleSuccess(context: PostProcessorContext, result: PostProcessorResult, monitoringResults: MonitoringResult[]): Promise<SuccessMetrics>;
-    /**
-     * Confirm deployment success
-     */
-    private confirmSuccess;
-    /**
-     * Send success notifications
-     */
-    private sendNotifications;
-    /**
-     * Perform post-success cleanup
-     */
-    private performCleanup;
-    /**
-     * Collect success metrics
-     */
-    private collectMetrics;
-    /**
-     * Log success metrics
-     */
-    private logMetrics;
-    /**
-     * Generate comprehensive success report
-     */
-    generateSuccessReport(context: PostProcessorContext, result: PostProcessorResult, metrics: SuccessMetrics): string;
-    /**
-     * Get current configuration stats
-     */
-    getStats(): SuccessHandlerConfig;
-}

package/dist/postprocessor/success/SuccessHandler.js

@@ -1,134 +0,0 @@
-/**
- * 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 };
-    }
-}

package/dist/postprocessor/triggers/APITrigger.d.ts

@@ -1,34 +0,0 @@
-/**
- * API Trigger for Post-Processor
- *
- * Provides a REST API endpoint to manually trigger PostProcessor
- * operations. Useful for CI/CD pipelines, manual test triggers,
- * and retry mechanisms.
- *
- * @since 2026-03-08
- */
-import express from 'express';
-import { PostProcessor } from '../PostProcessor.js';
-import { PostProcessorContext } from '../types.js';
-export interface APIConfig {
-    path?: string;
-    apiKey?: string;
-    enabled?: boolean;
-}
-export interface APIRequest {
-    tool?: string;
-    operation?: string;
-    reason?: string;
-}
-export declare class APITrigger {
-    private postProcessor;
-    private initialized;
-    private app;
-    private config;
-    constructor(postProcessor: PostProcessor, config: APIConfig);
-    initialize(): Promise<void>;
-    private setupAPIEndpoints;
-    triggerPostProcessor(context: PostProcessorContext): Promise<void>;
-    getApp(): express.Application;
-    shutdown(): void;
-}

package/dist/postprocessor/triggers/APITrigger.js

@@ -1,114 +0,0 @@
-/**
- * API Trigger for Post-Processor
- *
- * Provides a REST API endpoint to manually trigger PostProcessor
- * operations. Useful for CI/CD pipelines, manual test triggers,
- * and retry mechanisms.
- *
- * @since 2026-03-08
- */
-import express from 'express';
-import { frameworkLogger } from '../../core/framework-logger.js';
-export class APITrigger {
-    postProcessor;
-    initialized = false;
-    app;
-    config;
-    constructor(postProcessor, config) {
-        this.postProcessor = postProcessor;
-        this.config = {
-            enabled: true,
-            path: '/api/post-process',
-            ...config
-        };
-        this.app = express();
-    }
-    async initialize() {
-        if (this.initialized)
-            return;
-        // Setup API endpoints
-        this.setupAPIEndpoints();
-        this.initialized = true;
-        frameworkLogger.log('api-trigger', 'initialized', 'info', {
-            path: this.config.path,
-            apiKeyRequired: this.config.apiKey
-        });
-    }
-    setupAPIEndpoints() {
-        const { path: apiPath, apiKey } = this.config;
-        const endpointPath = apiPath || '/api/post-process';
-        // Rate limiting
-        this.app.use(express.json({ limit: '10mb' }));
-        // Middleware: API key authentication (if configured)
-        if (apiKey) {
-            this.app.use((req, res, next) => {
-                const providedKey = req.headers['x-api-key'];
-                if (!providedKey) {
-                    res.status(401).json({ error: 'API key required' });
-                    return;
-                }
-                if (providedKey !== apiKey) {
-                    res.status(403).json({ error: 'Invalid API key' });
-                    return;
-                }
-                next();
-            });
-        }
-        // POST endpoint to trigger PostProcessor
-        this.app.post(endpointPath, async (req, res) => {
-            try {
-                const body = req.body;
-                frameworkLogger.log('api-trigger', 'trigger-request', 'info', {
-                    tool: body.tool,
-                    operation: body.operation,
-                    reason: body.reason
-                });
-                // Create PostProcessor context
-                const context = {
-                    trigger: 'api',
-                    tool: body.tool || 'api',
-                    operation: body.operation || 'manual',
-                    commitSha: '',
-                    repository: '',
-                    branch: '',
-                    author: '',
-                    files: []
-                };
-                // Trigger PostProcessor
-                await this.triggerPostProcessor(context);
-                res.json({
-                    success: true,
-                    message: 'PostProcessor triggered successfully',
-                    triggeredAt: new Date().toISOString()
-                });
-            }
-            catch (error) {
-                frameworkLogger.log('api-trigger', 'trigger-error', 'error', {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-                res.status(500).json({
-                    error: 'PostProcessor trigger failed',
-                    message: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
-        });
-        // GET endpoint for status
-        this.app.get(endpointPath + '/status', (req, res) => {
-            res.json({
-                status: 'operational',
-                triggerType: 'api',
-                configured: this.config.enabled,
-                timestamp: new Date().toISOString()
-            });
-        });
-    }
-    async triggerPostProcessor(context) {
-        await this.postProcessor.executePostProcessorLoop(context);
-    }
-    getApp() {
-        return this.app;
-    }
-    shutdown() {
-        this.initialized = false;
-    }
-}

package/dist/postprocessor/triggers/GitHookTrigger.d.ts

@@ -1,38 +0,0 @@
-/**
- * Git Hook Trigger for Post-Processor
- */
-import { PostProcessor } from "../PostProcessor.js";
-import { PostProcessorContext } from "../types.js";
-interface LogArchiveConfig {
-    archiveDirectory: string;
-    maxFileSizeMB: number;
-    rotationIntervalHours: number;
-    compressionEnabled: boolean;
-    maxAgeHours: number;
-    directories: string[];
-    excludePatterns: string[];
-}
-export { cleanupLogFiles };
-export { archiveLogFiles };
-/**
- * Archive and rotate log files to prevent unbounded growth
- */
-declare function archiveLogFiles(config: LogArchiveConfig): Promise<{
-    archived: number;
-    errors: string[];
-}>;
-declare function cleanupLogFiles(config: any): Promise<{
-    cleaned: number;
-    errors: string[];
-}>;
-export declare class GitHookTrigger {
-    private postProcessor;
-    private initialized;
-    constructor(postProcessor: PostProcessor);
-    initialize(): Promise<void>;
-    private installHook;
-    private generateHookScript;
-    private activateGitHooks;
-    private backupExistingHook;
-    triggerPostProcessor(context: PostProcessorContext): Promise<void>;
-}