0xray 2.1.4 → 2.2.0

package/dist/enforcement/test-auto-healing.js

@@ -1,325 +0,0 @@
-/**
- * Test Auto-Healing System for 0xRay Framework
- *
- * Automatically detects slow/failing tests and orchestrates fixes using specialized agents
- * Implements intelligent test optimization and refactoring for enterprise reliability
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-export class TestAutoHealingSystem {
-    healingHistory = new Map();
-    /**
-     * Main auto-healing entry point for test failures
-     */
-    async healTestFailures(testResults, context) {
-        const jobId = `test-healing-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const startTime = Date.now();
-        frameworkLogger.log("test-auto-healing", "healing-start", "info", {
-            jobId,
-            testFiles: context.tests?.length || 0,
-            operation: context.operation,
-        });
-        try {
-            // Step 1: Analyze test failures
-            const failureAnalysis = await this.analyzeTestFailures(testResults, context);
-            // Step 2: Prioritize and filter auto-fixable issues
-            const autoFixableIssues = failureAnalysis.filter((analysis) => analysis.autoFixable);
-            const prioritizedIssues = this.prioritizeIssues(autoFixableIssues);
-            // Step 3: Apply automatic fixes
-            const healingResult = await this.applyAutomaticFixes(prioritizedIssues, context, jobId);
-            // Step 4: Coordinate with agents for complex fixes
-            const agentCoordination = await this.coordinateAgentFixes(failureAnalysis.filter((analysis) => !analysis.autoFixable), context, jobId);
-            // Step 5: Generate final report
-            const result = {
-                success: healingResult.success && agentCoordination.success,
-                fixesApplied: healingResult.fixesApplied + agentCoordination.fixesApplied,
-                testsOptimized: healingResult.testsOptimized + agentCoordination.testsOptimized,
-                performanceImprovement: healingResult.performanceImprovement +
-                    agentCoordination.performanceImprovement,
-                agentCoordinationUsed: agentCoordination.agentsUsed.length > 0,
-                recommendations: [
-                    ...healingResult.recommendations,
-                    ...agentCoordination.recommendations,
-                ],
-                nextSteps: [...healingResult.nextSteps, ...agentCoordination.nextSteps],
-            };
-            const duration = Date.now() - startTime;
-            frameworkLogger.log("test-auto-healing", "healing-complete", "success", {
-                jobId,
-                duration,
-                fixesApplied: result.fixesApplied,
-                performanceImprovement: result.performanceImprovement,
-                success: result.success,
-            });
-            return result;
-        }
-        catch (error) {
-            frameworkLogger.log("test-auto-healing", "healing-error", "error", {
-                jobId,
-                error: error instanceof Error
-                    ? error.message
-                    : `Unknown error: ${String(error)}`,
-                operation: context.operation,
-            });
-            return {
-                success: false,
-                fixesApplied: 0,
-                testsOptimized: 0,
-                performanceImprovement: 0,
-                agentCoordinationUsed: false,
-                recommendations: ["Manual review required - auto-healing failed"],
-                nextSteps: ["Review error logs and fix underlying issues"],
-            };
-        }
-    }
-    /**
-     * Analyze test failures and determine root causes
-     */
-    async analyzeTestFailures(testResults, context) {
-        const analyses = [];
-        // Analyze timeout failures (Codex Term #45)
-        if (testResults.timedOut) {
-            analyses.push({
-                testFile: testResults.file || "unknown",
-                failureType: "timeout",
-                rootCause: "Test execution exceeded timeout limits",
-                severity: "high",
-                estimatedFixTime: 15,
-                autoFixable: true,
-                recommendedAgent: "testing-lead",
-                fixStrategy: {
-                    type: "optimize",
-                    description: "Optimize test execution time through parallelization and mocking",
-                    estimatedImprovement: 60,
-                    riskLevel: "low",
-                    requiresAgentCoordination: false,
-                },
-            });
-        }
-        // Analyze performance issues
-        if ((testResults.executionTime ?? 0) > 300000) {
-            // 5 minutes
-            analyses.push({
-                testFile: testResults.file || "unknown",
-                failureType: "performance",
-                rootCause: "Test suite execution too slow",
-                severity: "medium",
-                estimatedFixTime: 30,
-                autoFixable: true,
-                recommendedAgent: "refactorer",
-                fixStrategy: {
-                    type: "parallelize",
-                    description: "Implement parallel test execution and optimize slow tests",
-                    estimatedImprovement: 70,
-                    riskLevel: "medium",
-                    requiresAgentCoordination: true,
-                },
-            });
-        }
-        // Analyze flaky tests
-        const flakyTests = this.detectFlakyTests(testResults);
-        for (const flakyTest of flakyTests) {
-            analyses.push({
-                testFile: flakyTest.file,
-                failureType: "flaky",
-                rootCause: `Test ${flakyTest.name} is flaky - inconsistent results`,
-                severity: "medium",
-                estimatedFixTime: 20,
-                autoFixable: false,
-                recommendedAgent: "bug-triage-specialist",
-                fixStrategy: {
-                    type: "isolate",
-                    description: "Isolate and fix race conditions or timing dependencies",
-                    estimatedImprovement: 90,
-                    riskLevel: "medium",
-                    requiresAgentCoordination: true,
-                },
-            });
-        }
-        return analyses;
-    }
-    /**
-     * Apply automatic fixes for simple issues
-     */
-    async applyAutomaticFixes(issues, context, jobId) {
-        let fixesApplied = 0;
-        let testsOptimized = 0;
-        let performanceImprovement = 0;
-        const recommendations = [];
-        const nextSteps = [];
-        for (const issue of issues) {
-            try {
-                switch (issue.fixStrategy.type) {
-                    case "optimize":
-                        const optimizationResult = await this.optimizeTestTimeouts(issue, context, jobId);
-                        if (optimizationResult.success) {
-                            fixesApplied++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Optimized ${issue.testFile} for better performance`);
-                        }
-                        break;
-                    case "parallelize":
-                        const parallelResult = await this.implementParallelExecution(issue, context, jobId);
-                        if (parallelResult.success) {
-                            fixesApplied++;
-                            testsOptimized++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Implemented parallel execution for ${issue.testFile}`);
-                        }
-                        break;
-                    case "mock":
-                        const mockResult = await this.addTestMocks(issue, context, jobId);
-                        if (mockResult.success) {
-                            fixesApplied++;
-                            performanceImprovement += issue.fixStrategy.estimatedImprovement;
-                            recommendations.push(`Added mocks to speed up ${issue.testFile}`);
-                        }
-                        break;
-                }
-            }
-            catch (error) {
-                nextSteps.push(`Manual intervention needed for ${issue.testFile}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return {
-            success: fixesApplied > 0,
-            fixesApplied,
-            testsOptimized,
-            performanceImprovement,
-            recommendations,
-            nextSteps,
-        };
-    }
-    /**
-     * Coordinate with specialized agents for complex fixes
-     */
-    async coordinateAgentFixes(complexIssues, context, jobId) {
-        let fixesApplied = 0;
-        let testsOptimized = 0;
-        let performanceImprovement = 0;
-        const agentsUsed = [];
-        const recommendations = [];
-        const nextSteps = [];
-        // Group issues by recommended agent
-        const agentGroups = new Map();
-        for (const issue of complexIssues) {
-            if (!agentGroups.has(issue.recommendedAgent)) {
-                agentGroups.set(issue.recommendedAgent, []);
-            }
-            agentGroups.get(issue.recommendedAgent).push(issue);
-        }
-        // Coordinate with each agent
-        for (const [agentName, issues] of agentGroups) {
-            try {
-                const agentResult = await this.invokeSpecializedAgent(agentName, issues, context, jobId);
-                if (agentResult.success) {
-                    fixesApplied += agentResult.fixesApplied;
-                    testsOptimized += agentResult.testsOptimized;
-                    performanceImprovement += agentResult.performanceImprovement;
-                    agentsUsed.push(agentName);
-                    recommendations.push(...agentResult.recommendations);
-                }
-                else {
-                    nextSteps.push(`Agent ${agentName} coordination needed for ${issues.length} issues`);
-                }
-            }
-            catch (error) {
-                nextSteps.push(`Failed to coordinate with ${agentName}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return {
-            success: fixesApplied > 0,
-            fixesApplied,
-            testsOptimized,
-            performanceImprovement,
-            agentsUsed,
-            recommendations,
-            nextSteps,
-        };
-    }
-    /**
-     * Optimize test timeouts automatically
-     */
-    async optimizeTestTimeouts(issue, context, jobId) {
-        // Implementation would modify test files to add timeouts and optimize slow operations
-        // For now, return success to indicate capability
-        frameworkLogger.log("test-auto-healing", "timeout-optimization", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Implement parallel test execution
-     */
-    async implementParallelExecution(issue, context, jobId) {
-        // Implementation would modify test configuration for parallel execution
-        frameworkLogger.log("test-auto-healing", "parallel-execution", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Add mocks to speed up tests
-     */
-    async addTestMocks(issue, context, jobId) {
-        // Implementation would analyze test dependencies and add appropriate mocks
-        frameworkLogger.log("test-auto-healing", "mock-addition", "success", {
-            jobId,
-            testFile: issue.testFile,
-            improvement: issue.fixStrategy.estimatedImprovement,
-        });
-        return { success: true };
-    }
-    /**
-     * Invoke specialized agents for complex fixes
-     */
-    async invokeSpecializedAgent(agentName, issues, context, jobId) {
-        // This would integrate with the actual agent system
-        // For now, simulate agent coordination
-        frameworkLogger.log("test-auto-healing", "agent-coordination", "info", {
-            jobId,
-            agent: agentName,
-            issuesCount: issues.length,
-        });
-        // Simulate agent response
-        return {
-            success: true,
-            fixesApplied: issues.length,
-            testsOptimized: Math.floor(issues.length * 0.8),
-            performanceImprovement: issues.reduce((sum, issue) => sum + issue.fixStrategy.estimatedImprovement, 0),
-            recommendations: [
-                `${agentName} successfully addressed ${issues.length} complex issues`,
-            ],
-        };
-    }
-    /**
-     * Detect flaky tests based on inconsistent results
-     */
-    detectFlakyTests(testResults) {
-        // Implementation would analyze test history for flaky patterns
-        return []; // Placeholder
-    }
-    /**
-     * Prioritize issues for fixing
-     */
-    prioritizeIssues(issues) {
-        return issues.sort((a, b) => {
-            const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
-            const typeOrder = {
-                timeout: 3,
-                performance: 2,
-                "logic-error": 3,
-                flaky: 2,
-                infrastructure: 1,
-            };
-            const aScore = severityOrder[a.severity] * 10 + typeOrder[a.failureType];
-            const bScore = severityOrder[b.severity] * 10 + typeOrder[b.failureType];
-            return bScore - aScore;
-        });
-    }
-}
-// Export singleton instance
-export const testAutoHealingSystem = new TestAutoHealingSystem();

package/dist/integrations/base/ExampleIntegration.d.ts

@@ -1,47 +0,0 @@
-/**
- * Example Integration - Demonstrates using the BaseIntegration class
- *
- * This is a simple example showing how to create a custom integration
- * that extends the BaseIntegration class.
- *
- * @version 1.0.0
- * @since 2026-03-15
- */
-import { BaseIntegration, type HealthResult, type IntegrationConfig } from "./index.js";
-/**
- * Example custom integration
- *
- * Demonstrates how to extend BaseIntegration with custom logic.
- */
-declare class ExampleIntegration extends BaseIntegration {
-    /** Custom property for this integration */
-    private connectionString;
-    private connected;
-    /**
-     * Create a new ExampleIntegration
-     *
-     * @param config - Optional configuration
-     */
-    constructor(config?: Partial<IntegrationConfig>);
-    /**
-     * Set connection string
-     */
-    setConnectionString(connStr: string): void;
-    /**
-     * Check if connected
-     */
-    isConnected(): boolean;
-    /**
-     * Perform integration-specific initialization
-     */
-    protected performInitialization(): Promise<void>;
-    /**
-     * Perform integration-specific shutdown
-     */
-    protected performShutdown(): Promise<void>;
-    /**
-     * Perform integration-specific health check
-     */
-    protected performHealthCheck(): Promise<HealthResult>;
-}
-export { ExampleIntegration };

package/dist/integrations/base/ExampleIntegration.js

@@ -1,181 +0,0 @@
-/**
- * Example Integration - Demonstrates using the BaseIntegration class
- *
- * This is a simple example showing how to create a custom integration
- * that extends the BaseIntegration class.
- *
- * @version 1.0.0
- * @since 2026-03-15
- */
-import { BaseIntegration, createSimpleIntegration, } from "./index.js";
-/**
- * Example custom integration
- *
- * Demonstrates how to extend BaseIntegration with custom logic.
- */
-class ExampleIntegration extends BaseIntegration {
-    /** Custom property for this integration */
-    connectionString = "";
-    connected = false;
-    /**
-     * Create a new ExampleIntegration
-     *
-     * @param config - Optional configuration
-     */
-    constructor(config) {
-        super("example-integration", "1.0.0", {
-            enabled: true,
-            debug: false,
-            logLevel: "info",
-            ...config,
-        });
-    }
-    /**
-     * Set connection string
-     */
-    setConnectionString(connStr) {
-        this.connectionString = connStr;
-    }
-    /**
-     * Check if connected
-     */
-    isConnected() {
-        return this.connected;
-    }
-    // ==========================================================================
-    // Protected abstract method implementations
-    // ==========================================================================
-    /**
-     * Perform integration-specific initialization
-     */
-    async performInitialization() {
-        await this.log("info", "Starting initialization...");
-        // Simulate async initialization (e.g., connecting to a service)
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        if (this.connectionString) {
-            // Would connect to external service here
-            this.connected = true;
-            await this.log("success", "Connected to service");
-        }
-        // Emit custom event
-        this.emit("custom-initialized", { connected: this.connected });
-    }
-    /**
-     * Perform integration-specific shutdown
-     */
-    async performShutdown() {
-        await this.log("info", "Starting shutdown...");
-        // Simulate async cleanup
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        this.connected = false;
-        await this.log("success", "Shutdown complete");
-    }
-    /**
-     * Perform integration-specific health check
-     */
-    async performHealthCheck() {
-        if (!this.connected) {
-            return {
-                healthy: false,
-                message: "Not connected to service",
-                details: { connectionString: !!this.connectionString },
-            };
-        }
-        // In a real integration, you might ping the service here
-        return {
-            healthy: true,
-            message: "Service connection healthy",
-            details: { connected: true },
-        };
-    }
-}
-// ==========================================================================
-// Usage Examples
-// ==========================================================================
-/**
- * Example 1: Using a custom integration class
- */
-async function exampleCustomIntegration() {
-    console.log("\n--- Example 1: Custom Integration ---");
-    // Create integration
-    const integration = new ExampleIntegration({
-        debug: true,
-        logLevel: "debug",
-    });
-    // Set connection string
-    integration.setConnectionString("http://localhost:3000");
-    // Setup event listener
-    integration.on("initialized", (event) => {
-        console.log("Integration initialized event:", event.type);
-    });
-    // Initialize
-    await integration.initialize();
-    // Check health
-    const health = await integration.healthCheck();
-    console.log("Health check:", health);
-    // Get stats
-    const stats = integration.getStats();
-    console.log("Stats:", stats);
-    // Shutdown
-    await integration.shutdown();
-}
-/**
- * Example 2: Using createSimpleIntegration factory
- */
-async function exampleSimpleIntegration() {
-    console.log("\n--- Example 2: Simple Integration ---");
-    // Create a simple integration without subclassing
-    const simple = createSimpleIntegration("simple-integration", "1.0.0", 
-    // Custom health check
-    async () => ({
-        healthy: true,
-        message: "Always healthy",
-    }), 
-    // Custom shutdown
-    async () => {
-        console.log("Custom cleanup performed");
-    });
-    // Initialize
-    await simple.initialize();
-    // Check health
-    const health = await simple.healthCheck();
-    console.log("Health check:", health);
-    // Shutdown
-    await simple.shutdown();
-}
-/**
- * Example 3: Error handling
- */
-async function exampleErrorHandling() {
-    console.log("\n--- Example 3: Error Handling ---");
-    // Create integration that will fail to initialize
-    class FailingIntegration extends BaseIntegration {
-        constructor() {
-            super("failing-integration", "1.0.0");
-        }
-        async performInitialization() {
-            throw new Error("Connection refused");
-        }
-        async performShutdown() {
-            // Cleanup even on failure
-        }
-        async performHealthCheck() {
-            return { healthy: false, message: "Not initialized" };
-        }
-    }
-    const failing = new FailingIntegration();
-    try {
-        await failing.initialize();
-    }
-    catch (error) {
-        console.log("Caught expected error:", error instanceof Error ? error.message : error);
-    }
-}
-// Run examples if this file is executed directly
-// (In a real project, you would import and use the classes)
-// Export for use in other modules
-export { ExampleIntegration };
-// Example usage (uncomment to run):
-// exampleCustomIntegration().catch(console.error);
-// exampleSimpleIntegration().catch(console.error);
-// exampleErrorHandling().catch(console.error);

package/dist/mcps/knowledge-skills/testing-best-practices.server.d.ts

@@ -1,34 +0,0 @@
-/**
- * xray Testing Best Practices MCP Server
- *
- * Knowledge skill for comprehensive testing strategies, TDD/BDD implementation,
- * test coverage optimization, and automated testing workflows
- */
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-declare class XrayTestingBestPracticesServer extends XrayKnowledgeSkillBase {
-    constructor();
-    private analyzeTestCoverage;
-    private designTestStrategy;
-    private implementTDDWorkflow;
-    private optimizeTestPerformance;
-    private setupCICDTesting;
-    private performCoverageAnalysis;
-    private createTestStrategy;
-    private createTDDWorkflow;
-    private analyzeTestPerformance;
-    private createCIPipeline;
-    private prioritizeGaps;
-    private createCoverageImprovementPlan;
-    private createImplementationRoadmap;
-    private recommendTestingTools;
-    private provideTDDExamples;
-    private recommendTDDResources;
-    private createPerformanceOptimizationPlan;
-    private setupPerformanceMonitoring;
-    private generateCIConfigTemplates;
-    private createCITroubleshootingGuide;
-    private getPriorityIcon;
-    private getImpactIcon;
-    private getTestTypeIcon;
-}
-export { XrayTestingBestPracticesServer };