0xray 4.0.12 → 4.0.13

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/analysis/FailureAnalysisEngine.d.ts

@@ -1,39 +0,0 @@
-/**
- * Failure Analysis Engine for Post-Processor
- */
-import { FailureAnalysis, MonitoringResult } from "../types.js";
-export declare class FailureAnalysisEngine {
-    constructor();
-    /**
-     * Analyze CI/CD failure and determine root cause
-     */
-    analyzeFailure(monitoringResult: MonitoringResult): Promise<FailureAnalysis>;
-    /**
-     * Classify the type of failure based on monitoring results
-     */
-    private classifyFailure;
-    /**
-     * Assess the severity of the failure
-     */
-    private assessSeverity;
-    /**
-     * Calculate confidence in the analysis
-     */
-    private calculateConfidence;
-    /**
-     * Determine the root cause of the failure
-     */
-    private determineRootCause;
-    /**
-     * Generate recommended actions for the failure
-     */
-    private generateRecommendedActions;
-    /**
-     * Generate suggested fixes for the failure
-     */
-    private generateSuggestedFixes;
-    /**
-     * Initialize analysis patterns and rules
-     */
-    private initializeAnalysisPatterns;
-}

package/dist/postprocessor/analysis/FailureAnalysisEngine.js

@@ -1,245 +0,0 @@
-/**
- * Failure Analysis Engine for Post-Processor
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-export class FailureAnalysisEngine {
-    constructor() {
-        // Initialize analysis patterns and rules
-        this.initializeAnalysisPatterns();
-    }
-    /**
-     * Analyze CI/CD failure and determine root cause
-     */
-    async analyzeFailure(monitoringResult) {
-        const jobId = `failure-analysis-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        await frameworkLogger.log("-failure-analysis-engine", "-analyzing-ci-cd-failure-", "info", { message: "🔍 Analyzing CI/CD failure..." });
-        // Determine failure category
-        const category = this.classifyFailure(monitoringResult);
-        // Assess confidence and severity
-        const severity = this.assessSeverity(monitoringResult);
-        const confidence = this.calculateConfidence(monitoringResult, category);
-        // Determine root cause
-        const rootCause = await this.determineRootCause(monitoringResult, category);
-        // Generate recommended actions
-        const recommendedActions = this.generateRecommendedActions(category, rootCause);
-        // Suggest potential fixes
-        const suggestedFixes = this.generateSuggestedFixes(category, rootCause);
-        return {
-            category,
-            severity,
-            confidence,
-            rootCause,
-            recommendedActions,
-            suggestedFixes,
-        };
-    }
-    /**
-     * Classify the type of failure based on monitoring results
-     */
-    classifyFailure(monitoringResult) {
-        // Check CI status first
-        if (monitoringResult.ciStatus?.status === "failure") {
-            const failedJobs = monitoringResult.ciStatus.failedJobs || [];
-            // Analyze failed job names for patterns
-            if (failedJobs.some((job) => job.includes("test"))) {
-                return "test-failure";
-            }
-            if (failedJobs.some((job) => job.includes("lint"))) {
-                return "code-quality-failure";
-            }
-            if (failedJobs.some((job) => job.includes("build"))) {
-                return "build-failure";
-            }
-            if (failedJobs.some((job) => job.includes("security"))) {
-                return "security-failure";
-            }
-            return "ci-pipeline-failure";
-        }
-        // Check performance issues
-        if (monitoringResult.performanceStatus?.status === "failed") {
-            return "performance-regression";
-        }
-        // Check security issues
-        if (monitoringResult.securityStatus?.status === "failed") {
-            return "security-vulnerability";
-        }
-        return "unknown-failure";
-    }
-    /**
-     * Assess the severity of the failure
-     */
-    assessSeverity(monitoringResult) {
-        const failedJobs = monitoringResult.failedJobs || [];
-        // Critical failures
-        if (failedJobs.some((job) => job.includes("security") || job.includes("build"))) {
-            return "critical";
-        }
-        // High severity
-        if (failedJobs.some((job) => job.includes("test") && failedJobs.length > 2)) {
-            return "high";
-        }
-        // Medium severity
-        if (failedJobs.some((job) => job.includes("performance") || job.includes("e2e"))) {
-            return "medium";
-        }
-        // Low severity (minor issues)
-        return "low";
-    }
-    /**
-     * Calculate confidence in the analysis
-     */
-    calculateConfidence(monitoringResult, category) {
-        let confidence = 0.5; // Base confidence
-        // Increase confidence based on clear failure patterns
-        if (monitoringResult.ciStatus?.failedJobs?.length === 1) {
-            confidence += 0.2; // Single clear failure
-        }
-        // Increase for specific error patterns
-        if (category === "test-failure" || category === "build-failure") {
-            confidence += 0.2;
-        }
-        // Decrease for complex multi-job failures
-        if ((monitoringResult.failedJobs?.length || 0) > 3) {
-            confidence -= 0.1;
-        }
-        return Math.max(0.1, Math.min(1.0, confidence));
-    }
-    /**
-     * Determine the root cause of the failure
-     */
-    async determineRootCause(monitoringResult, category) {
-        switch (category) {
-            case "test-failure":
-                return "Unit, integration, or end-to-end tests are failing due to code changes";
-            case "build-failure":
-                return "TypeScript compilation, bundling, or build process failed";
-            case "code-quality-failure":
-                return "ESLint, Prettier, or code quality checks failed";
-            case "security-failure":
-                return "Security vulnerability scan detected issues in dependencies or code";
-            case "performance-regression":
-                return "Performance tests detected regression in speed or resource usage";
-            case "ci-pipeline-failure":
-                return "CI/CD pipeline configuration or infrastructure issue";
-            default:
-                return "Unknown failure cause - requires manual investigation";
-        }
-    }
-    /**
-     * Generate recommended actions for the failure
-     */
-    generateRecommendedActions(category, rootCause) {
-        const actions = [];
-        // Category-specific actions
-        switch (category) {
-            case "test-failure":
-                actions.push("Run tests locally: npm test");
-                actions.push("Check test output for specific failing assertions");
-                actions.push("Review recent code changes that might affect tests");
-                actions.push("Check for flaky tests that need to be skipped or fixed");
-                break;
-            case "build-failure":
-                actions.push("Run build locally: npm run build");
-                actions.push("Check TypeScript compilation errors");
-                actions.push("Verify all dependencies are properly installed");
-                actions.push("Check for missing type definitions");
-                break;
-            case "code-quality-failure":
-                actions.push("Run lint locally: npm run lint");
-                actions.push("Fix ESLint errors and warnings");
-                actions.push("Run formatter: npm run lint:fix");
-                break;
-            case "security-failure":
-                actions.push("Run security audit: npm run security-audit");
-                actions.push("Review npm audit output for vulnerable packages");
-                actions.push("Update dependencies: npm audit fix");
-                actions.push("Check for security advisories in package.json");
-                break;
-            case "performance-regression":
-                actions.push("Run performance tests: npm run test:performance");
-                actions.push("Review performance baselines and regressions");
-                actions.push("Optimize code for better performance");
-                actions.push("Update performance expectations if changes are acceptable");
-                break;
-            default:
-                actions.push("Review CI/CD pipeline logs for detailed error information");
-                actions.push("Check recent commits for problematic changes");
-                actions.push("Verify CI/CD configuration and environment");
-                break;
-        }
-        // Common actions
-        actions.push("Check CI/CD pipeline logs on GitHub Actions");
-        actions.push("Reproduce issue locally before pushing fixes");
-        actions.push("Consider reverting recent changes if issue persists");
-        return actions;
-    }
-    /**
-     * Generate suggested fixes for the failure
-     */
-    generateSuggestedFixes(category, rootCause) {
-        const fixes = [];
-        switch (category) {
-            case "test-failure":
-                fixes.push({
-                    type: "dependency-update",
-                    confidence: 0.7,
-                    description: "Update test dependencies that might be causing issues",
-                    files: ["package.json", "package-lock.json"],
-                    changes: ["npm update", "npm install"],
-                });
-                fixes.push({
-                    type: "test-regeneration",
-                    confidence: 0.6,
-                    description: "Skip or fix flaky tests that are failing consistently",
-                    files: ["src/__tests__/**/*.test.ts"],
-                    changes: ["Add describe.skip()", "Fix test assertions"],
-                });
-                break;
-            case "build-failure":
-                fixes.push({
-                    type: "dependency-update",
-                    confidence: 0.8,
-                    description: "Install missing type definitions or update dependencies",
-                    files: ["package.json"],
-                    changes: ["npm install @types/package-name"],
-                });
-                break;
-            case "code-quality-failure":
-                fixes.push({
-                    type: "code-fix",
-                    confidence: 0.9,
-                    description: "Automatically fix code formatting and style issues",
-                    files: ["src/**/*.{ts,js}"],
-                    changes: ["npm run lint:fix"],
-                });
-                break;
-            case "security-failure":
-                fixes.push({
-                    type: "dependency-update",
-                    confidence: 0.8,
-                    description: "Fix security vulnerabilities in dependencies",
-                    files: ["package.json", "package-lock.json"],
-                    changes: ["npm audit fix", "npm audit fix --force"],
-                });
-                break;
-            case "performance-regression":
-                fixes.push({
-                    type: "code-fix",
-                    confidence: 0.5,
-                    description: "Optimize performance-critical code sections",
-                    files: ["src/**/*.ts"],
-                    changes: ["Profile code performance", "Optimize algorithms"],
-                });
-                break;
-        }
-        return fixes;
-    }
-    /**
-     * Initialize analysis patterns and rules
-     */
-    initializeAnalysisPatterns() {
-        // Initialize patterns for failure classification
-        // This could be expanded with more sophisticated pattern matching
-        frameworkLogger.log("failure-analysis", "patterns-initialized", "info");
-    }
-}

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

@@ -1,48 +0,0 @@
-/**
- * Auto-Fix Engine for Post-Processor
- */
-import { FixResult, FailureAnalysis, PostProcessorContext } from "../types.js";
-export interface AppliedFixRecord {
-    type: string;
-    files: string[];
-    description: string;
-    timestamp: Date;
-    appliedChanges: string[];
-}
-export declare class AutoFixEngine {
-    private confidenceThreshold;
-    private appliedFixes;
-    constructor(confidenceThreshold?: number);
-    /**
-     * Attempt to automatically apply fixes for a failure
-     */
-    applyFixes(analysis: FailureAnalysis, context: PostProcessorContext): Promise<FixResult>;
-    /**
-     * Apply a single suggested fix
-     */
-    private applySingleFix;
-    /**
-     * Apply dependency updates
-     */
-    private applyDependencyUpdate;
-    /**
-     * Apply automatic code fixes
-     */
-    private applyCodeFix;
-    /**
-     * Apply test regeneration fixes
-     */
-    private applyTestRegeneration;
-    /**
-     * Validate that applied fixes resolve the issue
-     */
-    validateFixes(fixes: AppliedFixRecord[], originalFailure: FailureAnalysis, context: PostProcessorContext): Promise<boolean>;
-    /**
-     * Rollback applied fixes if validation fails
-     */
-    rollbackFixes(fixes: AppliedFixRecord[]): Promise<void>;
-    /**
-     * Get the list of applied fixes
-     */
-    getAppliedFixes(): AppliedFixRecord[];
-}

package/dist/postprocessor/autofix/AutoFixEngine.js

@@ -1,254 +0,0 @@
-/**
- * Auto-Fix Engine for Post-Processor
- */
-import { execSync } from "child_process";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import * as fs from "fs";
-import * as path from "path";
-export class AutoFixEngine {
-    confidenceThreshold;
-    appliedFixes = [];
-    constructor(confidenceThreshold = 0.8) {
-        this.confidenceThreshold = confidenceThreshold;
-    }
-    /**
-     * Attempt to automatically apply fixes for a failure
-     */
-    async applyFixes(analysis, context) {
-        const jobId = `auto-fix-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        await frameworkLogger.log("-auto-fix-engine", "-attempting-auto-fixes-for-failure-analysis-", "info", { message: "🔧 Attempting auto-fixes for failure analysis..." });
-        if (analysis.confidence < this.confidenceThreshold) {
-            await frameworkLogger.log("-auto-fix-engine", "-confidence-too-low-analysis-confidence-for-auto-f", "info", {
-                message: `⚠️  Confidence too low (${analysis.confidence}) for auto-fixes`,
-            });
-            return {
-                success: false,
-                appliedFixes: [],
-                requiresManualIntervention: true,
-                confidence: analysis.confidence,
-                rollbackAvailable: false,
-            };
-        }
-        const appliedFixes = [];
-        // Apply fixes in order of confidence
-        const sortedFixes = analysis.suggestedFixes.sort((a, b) => b.confidence - a.confidence);
-        for (const fix of sortedFixes) {
-            try {
-                await frameworkLogger.log("-auto-fix-engine", "-applying-fix-fix-description-", "info", { message: `🔧 Applying fix: ${fix.description}` });
-                const result = await this.applySingleFix(fix, context);
-                if (result.success) {
-                    appliedFixes.push({
-                        type: fix.type,
-                        files: fix.files ?? [],
-                        description: fix.description,
-                        timestamp: new Date(),
-                        appliedChanges: result.changes ?? [],
-                    });
-                    await frameworkLogger.log("-auto-fix-engine", "-fix-applied-successfully-fix-description-", "success", { message: `✅ Fix applied successfully: ${fix.description}` });
-                }
-                else {
-                    await frameworkLogger.log("auto-fix-engine", "fix-failed", "error", {
-                        jobId,
-                        description: fix.description,
-                        error: result.error,
-                    });
-                }
-            }
-            catch (error) {
-                await frameworkLogger.log("-auto-fix-engine", "-fix-error-fix-description-error-", "error", { message: `❌ Fix error: ${fix.description} - ${error}` });
-            }
-        }
-        const success = appliedFixes.length > 0;
-        const requiresManualIntervention = !success || appliedFixes.length < sortedFixes.length;
-        return {
-            success,
-            appliedFixes,
-            requiresManualIntervention,
-            confidence: analysis.confidence,
-            rollbackAvailable: appliedFixes.length > 0,
-        };
-    }
-    /**
-     * Apply a single suggested fix
-     */
-    async applySingleFix(fix, context) {
-        switch (fix.type) {
-            case "dependency-update":
-                return this.applyDependencyUpdate(fix);
-            case "code-fix":
-                return this.applyCodeFix(fix);
-            case "test-regeneration":
-                return this.applyTestRegeneration(fix);
-            default:
-                return {
-                    success: false,
-                    error: `Unsupported fix type: ${fix.type}`,
-                };
-        }
-    }
-    /**
-     * Apply dependency updates
-     */
-    async applyDependencyUpdate(fix) {
-        try {
-            await frameworkLogger.log("-auto-fix-engine", "-updating-dependencies-", "info", { message: "📦 Updating dependencies..." });
-            // Run npm audit fix
-            execSync("npm audit fix", {
-                stdio: "inherit",
-                timeout: 300000, // 5 minutes
-            });
-            // Check if package.json was modified
-            const packageJsonPath = path.join(process.cwd(), "package.json");
-            const packageLockPath = path.join(process.cwd(), "package-lock.json");
-            const changes = [];
-            if (fs.existsSync(packageJsonPath))
-                changes.push("package.json");
-            if (fs.existsSync(packageLockPath))
-                changes.push("package-lock.json");
-            return {
-                success: true,
-                changes,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Dependency update failed: ${error}`,
-            };
-        }
-    }
-    /**
-     * Apply automatic code fixes
-     */
-    async applyCodeFix(fix) {
-        try {
-            await frameworkLogger.log("-auto-fix-engine", "-applying-automatic-code-fixes-", "info", { message: "🛠️  Applying automatic code fixes..." });
-            // Run ESLint auto-fix
-            execSync("npm run lint:fix", {
-                stdio: "inherit",
-                timeout: 120000, // 2 minutes
-            });
-            // Check for modified files
-            const gitStatus = execSync("git status --porcelain", {
-                encoding: "utf8",
-                timeout: 30000,
-            });
-            const changes = gitStatus
-                .split("\n")
-                .filter((line) => line.trim())
-                .map((line) => line.split(" ").pop() || "")
-                .filter((file) => file && (file.endsWith(".ts") || file.endsWith(".js")));
-            return {
-                success: true,
-                changes,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Code fix failed: ${error}`,
-            };
-        }
-    }
-    /**
-     * Apply test regeneration fixes
-     */
-    async applyTestRegeneration(fix) {
-        try {
-            await frameworkLogger.log("-auto-fix-engine", "-applying-test-regeneration-fixes-", "info", { message: "🧪 Applying test regeneration fixes..." });
-            // This would be more sophisticated in a real implementation
-            // For now, we'll skip flaky tests that are commonly failing
-            const testFiles = [
-                "src/__tests__/integration/orchestrator/concurrent-execution.test.ts",
-                "src/__tests__/integration/orchestrator/basic-orchestrator.test.ts",
-                "src/__tests__/integration/codex-enforcement-e2e.test.ts",
-            ];
-            const changes = [];
-            for (const testFile of testFiles) {
-                if (fs.existsSync(testFile)) {
-                    // Check if file contains common failure patterns
-                    const content = fs.readFileSync(testFile, "utf8");
-                    // Skip tests that are likely to fail based on patterns
-                    if (content.includes("toBeLessThan(3000)") ||
-                        content.includes('toBe("design")') ||
-                        content.includes("toBe(false)")) {
-                        // Add skip to the test (this is a simplified approach)
-                        // In practice, this would be more sophisticated
-                        await frameworkLogger.log("-auto-fix-engine", "-skipping-problematic-test-in-testfile-", "info", { message: `⏭️  Skipping problematic test in ${testFile}` });
-                        changes.push(testFile);
-                    }
-                }
-            }
-            return {
-                success: true,
-                changes,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Test regeneration failed: ${error}`,
-            };
-        }
-    }
-    /**
-     * Validate that applied fixes resolve the issue
-     */
-    async validateFixes(fixes, originalFailure, context) {
-        const jobId = `fix-validation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        await frameworkLogger.log("-auto-fix-engine", "-validating-applied-fixes-", "success", { message: "✅ Validating applied fixes..." });
-        try {
-            // Run relevant tests based on failure type
-            switch (originalFailure.category) {
-                case "test-failure":
-                    execSync("npm test", { stdio: "pipe", timeout: 120000 });
-                    break;
-                case "build-failure":
-                    execSync("npm run build", { stdio: "pipe", timeout: 120000 });
-                    break;
-                case "code-quality-failure":
-                    execSync("npm run lint", { stdio: "pipe", timeout: 60000 });
-                    break;
-                case "security-failure":
-                    execSync("npm run security-audit", { stdio: "pipe", timeout: 60000 });
-                    break;
-                case "performance-regression":
-                    execSync("npm run test:performance", {
-                        stdio: "pipe",
-                        timeout: 120000,
-                    });
-                    break;
-                default:
-                    // Run a basic validation
-                    execSync("npm run typecheck", { stdio: "pipe", timeout: 60000 });
-            }
-            await frameworkLogger.log("-auto-fix-engine", "-fix-validation-passed-", "success", { message: "✅ Fix validation passed" });
-            return true;
-        }
-        catch (error) {
-            await frameworkLogger.log("auto-fix-engine", "validation-failed", "error", { jobId });
-            return false;
-        }
-    }
-    /**
-     * Rollback applied fixes if validation fails
-     */
-    async rollbackFixes(fixes) {
-        await frameworkLogger.log("-auto-fix-engine", "-rolling-back-applied-fixes-", "info", { message: "🔄 Rolling back applied fixes..." });
-        try {
-            // Simple git reset for now
-            execSync("git reset --hard HEAD~1", { stdio: "inherit" });
-            await frameworkLogger.log("-auto-fix-engine", "-fixes-rolled-back-", "success", { message: "✅ Fixes rolled back" });
-        }
-        catch (error) {
-            await frameworkLogger.log("autofix-engine", "rollback-failed", "error", { error: error instanceof Error ? error.message : String(error) });
-            throw error;
-        }
-    }
-    /**
-     * Get the list of applied fixes
-     */
-    getAppliedFixes() {
-        return this.appliedFixes;
-    }
-}

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

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