qa360 1.4.5 → 2.0.1

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

@@ -0,0 +1,538 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

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