qa360 2.1.7 → 2.2.0

package/dist/core/self-healing/engine.js

@@ -1,538 +0,0 @@
-/**
- * Self-Healing Engine
- *
- * Main orchestration for self-healing functionality.
- * Coordinates selector healing, assertion healing, and AI assistance.
- */
-import { SelectorHealer } from './selector-healer.js';
-import { AssertionHealer } from './assertion-healer.js';
-import { createLLMProvider } from '../ai/index.js';
-/**
- * Self-Healing Engine class
- */
-export class SelfHealingEngine {
-    config;
-    selectorHealer;
-    assertionHealer;
-    currentSession;
-    constructor(config) {
-        this.config = config;
-        this.selectorHealer = new SelectorHealer(config);
-        this.assertionHealer = new AssertionHealer(config);
-    }
-    /**
-     * Start a new self-healing session
-     */
-    startSession() {
-        const sessionId = this.generateSessionId();
-        const startTime = Date.now();
-        this.currentSession = {
-            sessionId,
-            startTime,
-            endTime: 0,
-            duration: 0,
-            config: this.config,
-            selectorHeals: [],
-            assertionUpdates: [],
-            apiHeals: [],
-            success: false,
-            unhealed: 0,
-            summary: {
-                totalIssues: 0,
-                healed: 0,
-                failed: 0,
-                highConfidence: 0,
-                mediumConfidence: 0,
-                lowConfidence: 0,
-                byType: {
-                    selector: 0,
-                    assertion: 0,
-                    api: 0,
-                    timeout: 0
-                },
-                successRate: 0
-            }
-        };
-        return sessionId;
-    }
-    /**
-     * End current session and return results
-     */
-    endSession() {
-        if (!this.currentSession) {
-            return null;
-        }
-        this.currentSession.endTime = Date.now();
-        this.currentSession.duration = this.currentSession.endTime - this.currentSession.startTime;
-        this.currentSession.summary = this.calculateSummary();
-        const session = { ...this.currentSession };
-        this.currentSession = undefined;
-        return session;
-    }
-    /**
-     * Attempt to heal a test failure
-     */
-    async healFailure(context) {
-        if (!this.config.enabled || !this.currentSession) {
-            return {
-                success: false,
-                healed: false,
-                suggestion: null,
-                reason: 'Self-healing is disabled or no active session'
-            };
-        }
-        this.currentSession.summary.totalIssues++;
-        // Determine failure type and attempt healing
-        switch (context.testType) {
-            case 'ui':
-                return await this.healUiFailure(context);
-            case 'api':
-                return await this.healApiFailure(context);
-            default:
-                return await this.healGenericFailure(context);
-        }
-    }
-    /**
-     * Heal a UI test failure (selector issues)
-     */
-    async healUiFailure(context) {
-        // Extract selector from error message
-        const selector = this.extractSelector(context.errorMessage);
-        if (!selector) {
-            return {
-                success: false,
-                healed: false,
-                suggestion: null,
-                reason: 'Could not extract selector from error message'
-            };
-        }
-        const errorType = this.inferSelectorErrorType(context.errorMessage);
-        const result = await this.selectorHealer.healSelector({
-            originalSelector: selector,
-            pageUrl: context.pageUrl,
-            domSnapshot: context.domSnapshot,
-            errorType,
-            expectedText: this.extractExpectedText(context.errorMessage),
-            confidenceThreshold: this.config.confidenceThreshold
-        });
-        this.currentSession.selectorHeals.push(result);
-        this.currentSession.summary.byType.selector++;
-        if (result.confidence >= this.config.confidenceThreshold && result.healedSelector !== result.originalSelector) {
-            this.currentSession.summary.healed++;
-            this.currentSession.summary.highConfidence++;
-            return {
-                success: true,
-                healed: true,
-                suggestion: {
-                    code: this.formatSelectorHeal(result),
-                    explanation: `Replace selector "${result.originalSelector}" with "${result.healedSelector}" using ${result.strategy} strategy (confidence: ${(result.confidence * 100).toFixed(0)}%)`,
-                    filePath: context.testSource,
-                    lineNumber: this.extractLineNumber(context.stackTrace),
-                    confidence: result.confidence,
-                    effort: 'low',
-                    healingType: 'selector'
-                },
-                reason: 'Selector healed successfully'
-            };
-        }
-        this.currentSession.summary.failed++;
-        this.currentSession.unhealed++;
-        // Try AI-assisted healing if enabled
-        if (this.config.features.aiAssisted) {
-            const aiSuggestion = await this.tryAiHealing(context);
-            if (aiSuggestion) {
-                return {
-                    success: true,
-                    healed: false,
-                    suggestion: aiSuggestion,
-                    reason: 'AI suggestion available'
-                };
-            }
-        }
-        return {
-            success: false,
-            healed: false,
-            suggestion: null,
-            reason: result.failureReason
-        };
-    }
-    /**
-     * Heal an API test failure
-     */
-    async healApiFailure(context) {
-        if (!context.requestDetails) {
-            return {
-                success: false,
-                healed: false,
-                suggestion: null,
-                reason: 'No request details available'
-            };
-        }
-        const apiHeal = this.analyzeApiFailure(context);
-        this.currentSession.apiHeals.push(apiHeal);
-        this.currentSession.summary.byType.api++;
-        if (apiHeal.confidence >= this.config.confidenceThreshold) {
-            this.currentSession.summary.healed++;
-            return {
-                success: true,
-                healed: true,
-                suggestion: {
-                    code: apiHeal.suggestion,
-                    explanation: `API change detected: ${apiHeal.changeType}. Suggested fix: ${apiHeal.suggestion}`,
-                    filePath: context.testSource,
-                    lineNumber: this.extractLineNumber(context.stackTrace),
-                    confidence: apiHeal.confidence,
-                    effort: 'medium',
-                    healingType: 'api'
-                },
-                reason: 'API failure analyzed'
-            };
-        }
-        this.currentSession.summary.failed++;
-        this.currentSession.unhealed++;
-        return {
-            success: false,
-            healed: false,
-            suggestion: null,
-            reason: 'API heal confidence below threshold'
-        };
-    }
-    /**
-     * Heal a generic test failure
-     */
-    async healGenericFailure(context) {
-        // Try AI-assisted healing for generic failures
-        if (this.config.features.aiAssisted) {
-            const aiSuggestion = await this.tryAiHealing(context);
-            if (aiSuggestion) {
-                this.currentSession.summary.healed++;
-                return {
-                    success: true,
-                    healed: false,
-                    suggestion: aiSuggestion,
-                    reason: 'AI suggestion available'
-                };
-            }
-        }
-        this.currentSession.summary.failed++;
-        this.currentSession.unhealed++;
-        return {
-            success: false,
-            healed: false,
-            suggestion: null,
-            reason: 'No healing strategy available for this failure type'
-        };
-    }
-    /**
-     * Try AI-assisted healing
-     */
-    async tryAiHealing(context) {
-        try {
-            const aiClient = await createLLMProvider({ preferred: 'deepseek' });
-            const prompt = this.buildAiPrompt(context);
-            const response = await aiClient.generate({
-                prompt,
-                systemPrompt: 'You are an expert test debugging assistant. Analyze test failures and provide specific code fixes.',
-                maxTokens: 1000,
-                temperature: 0.3
-            });
-            if (!response.content) {
-                return null;
-            }
-            return {
-                code: this.extractCodeFromAiResponse(response.content),
-                explanation: this.extractExplanationFromAiResponse(response.content),
-                filePath: context.testSource,
-                lineNumber: this.extractLineNumber(context.stackTrace),
-                confidence: 0.7, // AI suggestions have medium confidence by default
-                effort: 'medium',
-                healingType: 'other',
-                applied: false,
-                verified: false
-            };
-        }
-        catch (error) {
-            // Silently fail on AI errors
-            return null;
-        }
-    }
-    /**
-     * Build AI prompt from failure context
-     */
-    buildAiPrompt(context) {
-        let prompt = `Test Failure Analysis Request\n\n`;
-        prompt += `Test Type: ${context.testType}\n`;
-        prompt += `Gate: ${context.gate}\n`;
-        prompt += `Test Source: ${context.testSource}\n\n`;
-        prompt += `Error Message:\n${context.errorMessage}\n\n`;
-        if (context.stackTrace) {
-            prompt += `Stack Trace:\n${context.stackTrace}\n\n`;
-        }
-        if (context.pageUrl) {
-            prompt += `Page URL: ${context.pageUrl}\n\n`;
-        }
-        if (context.requestDetails) {
-            prompt += `Request Details:\n`;
-            prompt += `- URL: ${context.requestDetails.url}\n`;
-            prompt += `- Method: ${context.requestDetails.method}\n`;
-            if (context.requestDetails.status) {
-                prompt += `- Status: ${context.requestDetails.status}\n`;
-            }
-            prompt += `\n`;
-        }
-        prompt += `Please provide:\n`;
-        prompt += `1. A specific code fix for this failure\n`;
-        prompt += `2. A brief explanation of why this fix works\n`;
-        prompt += `3. Estimated effort level (low/medium/high)\n\n`;
-        prompt += `Format your response with:\n`;
-        prompt += `- CODE: [your fix]\n`;
-        prompt += `- EXPLANATION: [your explanation]\n`;
-        prompt += `- EFFORT: [low/medium/high]\n`;
-        return prompt;
-    }
-    /**
-     * Extract code from AI response
-     */
-    extractCodeFromAiResponse(response) {
-        const codeMatch = response.match(/CODE:\s*([\s\S]*?)(?=EXPLANATION:|$)/i);
-        return codeMatch ? codeMatch[1].trim() : response;
-    }
-    /**
-     * Extract explanation from AI response
-     */
-    extractExplanationFromAiResponse(response) {
-        const expMatch = response.match(/EXPLANATION:\s*([\s\S]*?)(?=EFFORT:|$)/i);
-        return expMatch ? expMatch[1].trim() : 'AI-generated fix';
-    }
-    /**
-     * Analyze API failure
-     */
-    analyzeApiFailure(context) {
-        const details = context.requestDetails;
-        const changeType = this.detectApiChangeType(context);
-        const confidences = {
-            'path_changed': 0.7,
-            'method_changed': 0.6,
-            'status_changed': 0.8,
-            'response_structure': 0.65,
-            'auth_required': 0.75,
-            'deprecated': 0.9,
-            'moved_permanently': 0.85
-        };
-        let suggestion = '';
-        switch (changeType) {
-            case 'status_changed':
-                suggestion = `Update expected status from ${context.metadata?.expectedStatus} to ${details.status}`;
-                break;
-            case 'auth_required':
-                suggestion = 'Add authentication headers to the request';
-                break;
-            case 'path_changed':
-                suggestion = 'Update the API endpoint path';
-                break;
-            case 'method_changed':
-                suggestion = `Change request method to ${details.method}`;
-                break;
-            default:
-                suggestion = 'Review API specification for changes';
-        }
-        return {
-            originalSpec: `${details.method} ${details.url}`,
-            healedSpec: `${details.method} ${details.url}`,
-            changeType,
-            suggestion,
-            confidence: confidences[changeType] || 0.5
-        };
-    }
-    /**
-     * Detect API change type from context
-     */
-    detectApiChangeType(context) {
-        const msg = context.errorMessage.toLowerCase();
-        const details = context.requestDetails;
-        if (msg.includes('401') || msg.includes('403') || msg.includes('unauthorized') || msg.includes('forbidden')) {
-            return 'auth_required';
-        }
-        if (msg.includes('404') || msg.includes('not found')) {
-            return 'path_changed';
-        }
-        if (msg.includes('405') || msg.includes('method not allowed')) {
-            return 'method_changed';
-        }
-        if (msg.includes('410') || msg.includes('gone')) {
-            return 'deprecated';
-        }
-        if (msg.includes('status') || msg.includes('expected 200')) {
-            return 'status_changed';
-        }
-        if (msg.includes('response') || msg.includes('cannot read') || msg.includes('undefined')) {
-            return 'response_structure';
-        }
-        if (msg.includes('301') || msg.includes('302') || msg.includes('moved')) {
-            return 'moved_permanently';
-        }
-        return 'response_structure';
-    }
-    /**
-     * Extract selector from error message
-     */
-    extractSelector(errorMessage) {
-        // Common patterns for selector errors
-        const patterns = [
-            /selector['"]\s*:\s*['"]([^'"]+)['"]/i,
-            /['"]([^'"]+\s*selector[^'"]*)['"]/i,
-            /found\s+['"]([^'"]+)['"]/i,
-            /waiting\s+for\s+['"]([^'"]+)['"]/i
-        ];
-        for (const pattern of patterns) {
-            const match = errorMessage.match(pattern);
-            if (match && match[1]) {
-                return match[1];
-            }
-        }
-        return null;
-    }
-    /**
-     * Extract expected text from error message
-     */
-    extractExpectedText(errorMessage) {
-        const textMatch = errorMessage.match(/text\s+['"]([^'"]+)['"]/i);
-        return textMatch ? textMatch[1] : undefined;
-    }
-    /**
-     * Infer selector error type from message
-     */
-    inferSelectorErrorType(errorMessage) {
-        const msg = errorMessage.toLowerCase();
-        if (msg.includes('timeout') || msg.includes('timed out')) {
-            return 'timeout';
-        }
-        if (msg.includes('not found') || msg.includes('found 0')) {
-            return 'not_found';
-        }
-        if (msg.includes('found multiple') || msg.includes('ambiguous')) {
-            return 'ambiguous';
-        }
-        if (msg.includes('detached') || msg.includes('removed from dom')) {
-            return 'detached';
-        }
-        if (msg.includes('not visible') || msg.includes('hidden')) {
-            return 'invisible';
-        }
-        if (msg.includes('stale') || msg.includes('element reference')) {
-            return 'stale';
-        }
-        return 'not_found';
-    }
-    /**
-     * Extract line number from stack trace
-     */
-    extractLineNumber(stackTrace) {
-        if (!stackTrace)
-            return 0;
-        const lineMatch = stackTrace.match(/:(\d+)(?::\d+)?/);
-        return lineMatch ? parseInt(lineMatch[1], 10) : 0;
-    }
-    /**
-     * Format selector heal result
-     */
-    formatSelectorHeal(result) {
-        return `// Replace: ${result.originalSelector}\n// With: ${result.healedSelector}\n// Strategy: ${result.strategy} (confidence: ${(result.confidence * 100).toFixed(0)}%)`;
-    }
-    /**
-     * Calculate session summary
-     */
-    calculateSummary() {
-        if (!this.currentSession) {
-            return {
-                totalIssues: 0,
-                healed: 0,
-                failed: 0,
-                highConfidence: 0,
-                mediumConfidence: 0,
-                lowConfidence: 0,
-                byType: { selector: 0, assertion: 0, api: 0, timeout: 0 },
-                successRate: 0
-            };
-        }
-        const summary = this.currentSession.summary;
-        const allHeals = [
-            ...this.currentSession.selectorHeals,
-            ...this.currentSession.assertionUpdates,
-            ...this.currentSession.apiHeals
-        ];
-        for (const heal of allHeals) {
-            if (heal.confidence >= 0.8) {
-                summary.highConfidence++;
-            }
-            else if (heal.confidence >= 0.5) {
-                summary.mediumConfidence++;
-            }
-            else {
-                summary.lowConfidence++;
-            }
-        }
-        summary.successRate = summary.totalIssues > 0
-            ? summary.healed / summary.totalIssues
-            : 0;
-        return summary;
-    }
-    /**
-     * Generate unique session ID
-     */
-    generateSessionId() {
-        return `sh_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    }
-    /**
-     * Get current session
-     */
-    getSession() {
-        return this.currentSession;
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-        this.selectorHealer = new SelectorHealer(this.config);
-        this.assertionHealer = new AssertionHealer(this.config);
-    }
-    /**
-     * Check if self-healing is enabled
-     */
-    isEnabled() {
-        return this.config.enabled;
-    }
-    /**
-     * Get confidence threshold
-     */
-    getConfidenceThreshold() {
-        return this.config.confidenceThreshold;
-    }
-}
-/**
- * Create a self-healing engine with default config
- */
-export function createSelfHealingEngine(config) {
-    const defaultConfig = {
-        enabled: true,
-        maxAttempts: 3,
-        confidenceThreshold: 0.7,
-        autoApply: false,
-        backup: true,
-        features: {
-            selectorHealing: true,
-            assertionUpdates: true,
-            apiHealing: true,
-            timeoutAdjustment: true,
-            aiAssisted: true
-        },
-        selectorStrategies: {
-            useDataTestIds: true,
-            useAriaLabels: true,
-            useTextSelectors: true,
-            fuzzyMatching: true
-        }
-    };
-    return new SelfHealingEngine({ ...defaultConfig, ...config });
-}

package/dist/core/self-healing/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * QA360 Self-Healing Module
- *
- * Exports all self-healing functionality.
- */
-export type { SelfHealingConfig, SelectorErrorType, SelectorHealingStrategy, SelectorHealingResult, AssertionType, AssertionUpdateResult, ApiChangeType, ApiHealingResult, SelfHealingSession, SelfHealingSummary, TestFailureContext, AiHealingSuggestion } from './types.js';
-export { SelectorHealer, createDefaultSelfHealingConfig } from './selector-healer.js';
-export { AssertionHealer } from './assertion-healer.js';
-export { SelfHealingEngine, createSelfHealingEngine, type SelfHealingResult } from './engine.js';
-export { createDefaultSelfHealingConfig as createSelfHealingConfig } from './selector-healer.js';

package/dist/core/self-healing/index.js

@@ -1,11 +0,0 @@
-/**
- * QA360 Self-Healing Module
- *
- * Exports all self-healing functionality.
- */
-// Classes
-export { SelectorHealer, createDefaultSelfHealingConfig } from './selector-healer.js';
-export { AssertionHealer } from './assertion-healer.js';
-export { SelfHealingEngine, createSelfHealingEngine } from './engine.js';
-// Convenience re-exports
-export { createDefaultSelfHealingConfig as createSelfHealingConfig } from './selector-healer.js';

package/dist/core/self-healing/selector-healer.d.ts

@@ -1,103 +0,0 @@
-/**
- * Selector Healer
- *
- * Intelligently heals broken CSS selectors in UI/E2E tests.
- * Uses multiple strategies to find replacement selectors.
- */
-import type { SelectorHealingResult, SelectorHealingStrategy, SelectorErrorType, SelfHealingConfig } from './types.js';
-/**
- * Configuration for selector healing
- */
-interface SelectorHealOptions {
-    /** Page URL where selector failed */
-    pageUrl?: string;
-    /** DOM snapshot at time of failure */
-    domSnapshot?: {
-        title: string;
-        url: string;
-        html?: string;
-        elements: Record<string, number>;
-    };
-    /** Error type that occurred */
-    errorType?: SelectorErrorType;
-    /** Original selector that failed */
-    originalSelector: string;
-    /** Expected element type (button, input, etc.) */
-    expectedType?: string;
-    /** Text content the element should have */
-    expectedText?: string;
-    /** Confidence threshold for healing */
-    confidenceThreshold?: number;
-}
-/**
- * Candidate replacement selector
- */
-interface SelectorCandidate {
-    selector: string;
-    strategy: SelectorHealingStrategy;
-    confidence: number;
-    reason: string;
-}
-/**
- * Selector Healer class
- */
-export declare class SelectorHealer {
-    private config;
-    constructor(config: SelfHealingConfig);
-    /**
-     * Attempt to heal a broken selector
-     */
-    healSelector(options: SelectorHealOptions): Promise<SelectorHealingResult>;
-    /**
-     * Try data-testid attribute strategies
-     */
-    private tryDataTestIdStrategies;
-    /**
-     * Try ARIA label strategies
-     */
-    private tryAriaLabelStrategies;
-    /**
-     * Try text content strategies
-     */
-    private tryTextContentStrategies;
-    /**
-     * Try fuzzy matching strategies
-     */
-    private tryFuzzyMatchStrategies;
-    /**
-     * Infer failure reason from error type
-     */
-    private inferFailureReason;
-    /**
-     * Escape string for CSS selectors
-     */
-    private escapeCssString;
-    /**
-     * Escape string for XPath
-     */
-    private escapeXPathString;
-    /**
-     * Parse selector to understand its structure
-     */
-    parseSelector(selector: string): {
-        tag?: string;
-        id?: string;
-        classes: string[];
-        attributes: Record<string, string>;
-        pseudoClasses: string[];
-        combinators: string[];
-    };
-    /**
-     * Generate multiple healing candidates for a selector
-     */
-    generateHealingCandidates(selector: string, context?: Pick<SelectorHealOptions, 'expectedText' | 'errorType'>): Promise<SelectorCandidate[]>;
-    /**
-     * Remove duplicate candidates
-     */
-    private deduplicateCandidates;
-}
-/**
- * Create a default self-healing config
- */
-export declare function createDefaultSelfHealingConfig(): SelfHealingConfig;
-export {};