qa360 2.1.7 → 2.2.0

package/dist/core/self-healing/assertion-healer.js

@@ -1,371 +0,0 @@
-/**
- * Assertion Healer
- *
- * Intelligently heals broken assertions in tests.
- * Supports Jest, Chai, and Node.js assert styles.
- */
-/**
- * Assertion Healer class
- */
-export class AssertionHealer {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Attempt to heal a broken assertion
-     */
-    async healAssertion(options) {
-        if (!this.config.features.assertionUpdates) {
-            return null;
-        }
-        const parsed = this.parseAssertion(options);
-        if (!parsed) {
-            return null;
-        }
-        // Determine if healing is possible
-        const confidence = this.calculateHealingConfidence(parsed, options);
-        if (confidence < (this.config.confidenceThreshold || 0.7)) {
-            return null;
-        }
-        // Generate healed assertion
-        const updatedAssertion = this.generateHealedAssertion(parsed, options);
-        return {
-            testFile: '', // Caller should fill this
-            lineNumber: options.lineNumber,
-            originalAssertion: parsed.originalAssertion || '',
-            updatedAssertion,
-            expected: options.expected,
-            actual: options.actual,
-            confidence,
-            assertionType: parsed.type
-        };
-    }
-    /**
-     * Parse the assertion from file content
-     */
-    parseAssertion(options) {
-        const lines = options.fileContent.split('\n');
-        const line = lines[options.lineNumber - 1];
-        if (!line) {
-            return null;
-        }
-        const framework = options.framework === 'auto' ? this.detectFramework(options.fileContent) : options.framework;
-        switch (framework) {
-            case 'jest':
-                return this.parseJestAssertion(line, options);
-            case 'chai':
-                return this.parseChaiAssertion(line, options);
-            case 'assert':
-                return this.parseAssertAssertion(line, options);
-            default:
-                // Try all parsers
-                return (this.parseJestAssertion(line, options) ||
-                    this.parseChaiAssertion(line, options) ||
-                    this.parseAssertAssertion(line, options));
-        }
-    }
-    /**
-     * Detect test framework from file content
-     */
-    detectFramework(content) {
-        const hasJest = /\b(expect|describe|it|test)\(/.test(content);
-        const hasChai = /\b(expect|should)\./.test(content) && /\b(chai|assert)\b/.test(content);
-        const hasAssert = /\b(require\(['"]assert['"]\)|import.*assert)\b/.test(content);
-        if (hasJest && !hasChai)
-            return 'jest';
-        if (hasChai)
-            return 'chai';
-        if (hasAssert)
-            return 'assert';
-        return 'jest'; // Default
-    }
-    /**
-     * Parse Jest-style assertion
-     */
-    parseJestAssertion(line, options) {
-        const jestPattern = /expect\(([^)]+)\)\.\s*(not\.)?(to[\w]+)\(([^)]*)\)/;
-        const match = line.match(jestPattern);
-        if (!match) {
-            return null;
-        }
-        const [, actual, negated, matcher, expected] = match;
-        const type = this.mapJestMatcherToType(matcher);
-        return {
-            type,
-            originalAssertion: line.trim(),
-            actual: actual.trim(),
-            expected: expected.trim() || options.expected,
-            negated: !!negated,
-            matcher,
-            line: options.lineNumber,
-            column: line.indexOf(match[0]) + 1
-        };
-    }
-    /**
-     * Parse Chai-style assertion
-     */
-    parseChaiAssertion(line, options) {
-        // expect(actual).to/match/have.property
-        const expectPattern = /expect\(([^)]+)\)\.\s*(to|should)\.\s*(not\.)?([\w.]+)\(([^)]*)\)/;
-        let match = line.match(expectPattern);
-        if (match) {
-            const [, actual, , negated, matcher, expected] = match;
-            const type = this.mapChaiMatcherToType(matcher);
-            return {
-                type,
-                originalAssertion: line.trim(),
-                actual: actual.trim(),
-                expected: expected.trim() || options.expected,
-                negated: !!negated,
-                matcher,
-                line: options.lineNumber,
-                column: line.indexOf(match[0]) + 1
-            };
-        }
-        // should style
-        const shouldPattern = /([\w.]+)\.should\.\s*(not\.)?([\w.]+)\(([^)]*)\)/;
-        match = line.match(shouldPattern);
-        if (match) {
-            const [, actual, negated, matcher, expected] = match;
-            const type = this.mapChaiMatcherToType(matcher);
-            return {
-                type,
-                originalAssertion: line.trim(),
-                actual: actual.trim(),
-                expected: expected.trim() || options.expected,
-                negated: !!negated,
-                matcher,
-                line: options.lineNumber,
-                column: line.indexOf(match[0]) + 1
-            };
-        }
-        return null;
-    }
-    /**
-     * Parse Node.js assert-style assertion
-     */
-    parseAssertAssertion(line, options) {
-        // assert.strictEqual(actual, expected)
-        const strictEqualPattern = /assert\.(strictEqual|deepStrictEqual|equal)\(([^,]+),\s*([^)]+)\)/;
-        let match = line.match(strictEqualPattern);
-        if (match) {
-            const [, method, actual, expected] = match;
-            return {
-                type: 'equality',
-                originalAssertion: line.trim(),
-                actual: actual.trim(),
-                expected: expected.trim(),
-                negated: false,
-                matcher: method,
-                line: options.lineNumber,
-                column: line.indexOf(match[0]) + 1
-            };
-        }
-        // assert actual, expected
-        const simplePattern = new RegExp('^(assert\\.\\w+\\([^,]+),\\s*)');
-        const simpleMatch = line.match(simplePattern);
-        if (simpleMatch) {
-            return {
-                type: 'equality',
-                originalAssertion: line.trim(),
-                actual: simpleMatch[1],
-                expected: options.expected,
-                negated: false,
-                matcher: 'assert',
-                line: options.lineNumber,
-                column: 1
-            };
-        }
-        return null;
-    }
-    /**
-     * Map Jest matcher to assertion type
-     */
-    mapJestMatcherToType(matcher) {
-        const matcherMap = {
-            'toBe': 'equality',
-            'toEqual': 'equality',
-            'toStrictEqual': 'equality',
-            'toBeGreaterThan': 'count',
-            'toBeGreaterThanOrEqual': 'count',
-            'toBeLessThan': 'count',
-            'toBeLessThanOrEqual': 'count',
-            'toContain': 'containment',
-            'toContainEqual': 'containment',
-            'toMatch': 'containment',
-            'toMatchObject': 'containment',
-            'toBeTruthy': 'truthiness',
-            'toBeFalsy': 'truthiness',
-            'toBeNull': 'truthiness',
-            'toBeUndefined': 'truthiness',
-            'toBeDefined': 'truthiness',
-            'toHaveLength': 'count',
-            'toHaveProperty': 'containment'
-        };
-        return matcherMap[matcher] || 'equality';
-    }
-    /**
-     * Map Chai matcher to assertion type
-     */
-    mapChaiMatcherToType(matcher) {
-        const matcherMap = {
-            'equal': 'equality',
-            'deep.equal': 'equality',
-            'eql': 'equality',
-            'above': 'count',
-            'least': 'count',
-            'below': 'count',
-            'most': 'count',
-            'include': 'containment',
-            'contain': 'containment',
-            'contains': 'containment',
-            'match': 'containment',
-            'property': 'containment',
-            'true': 'truthiness',
-            'false': 'truthiness',
-            'null': 'truthiness',
-            'undefined': 'truthiness',
-            'exist': 'truthiness',
-            'empty': 'truthiness',
-            'lengthOf': 'count'
-        };
-        return matcherMap[matcher] || 'equality';
-    }
-    /**
-     * Calculate confidence for healing
-     */
-    calculateHealingConfidence(parsed, options) {
-        let confidence = 0.5;
-        // Type-specific adjustments
-        if (parsed.type === 'equality') {
-            // Simple value changes are high confidence
-            const diffScore = this.calculateStringSimilarity(options.expected, options.actual);
-            confidence = Math.max(confidence, diffScore * 0.9);
-        }
-        if (parsed.type === 'containment') {
-            // Adding missing items is medium-high confidence
-            confidence = 0.75;
-        }
-        if (parsed.type === 'count') {
-            // Adjusting numbers is high confidence
-            const expectedNum = parseInt(options.expected, 10);
-            const actualNum = parseInt(options.actual, 10);
-            if (!isNaN(expectedNum) && !isNaN(actualNum)) {
-                confidence = 0.85;
-            }
-        }
-        // Adjust for negation
-        if (parsed.negated) {
-            confidence *= 0.8; // Lower confidence for negated assertions
-        }
-        // Adjust for error message clarity
-        if (options.errorMessage) {
-            if (options.errorMessage.includes('Expected:') && options.errorMessage.includes('Received:')) {
-                confidence += 0.1;
-            }
-        }
-        return Math.min(confidence, 1.0);
-    }
-    /**
-     * Generate healed assertion
-     */
-    generateHealedAssertion(parsed, options) {
-        const actualValue = this.formatValue(options.actual);
-        const expectedValue = this.formatValue(options.expected);
-        if (parsed.matcher?.includes('toBe') || parsed.matcher === 'equal') {
-            // Jest: expect(actual).toBe(expected)
-            // Chai: expect(actual).to.equal(expected)
-            const isJest = parsed.matcher?.startsWith('to');
-            const separator = isJest ? `.${parsed.matcher}(` : `.to.${parsed.matcher}(`;
-            return `expect(${parsed.actual}).${parsed.negated ? 'not.' : ''}${separator}${expectedValue})`;
-        }
-        if (parsed.matcher?.includes('Equal') || parsed.matcher === 'deep.equal' || parsed.matcher === 'eql') {
-            return `expect(${parsed.actual})${parsed.negated ? '.not.' : '.'}${parsed.matcher || 'toEqual'}(${expectedValue})`;
-        }
-        if (parsed.matcher?.includes('Contain') || parsed.matcher?.includes('include')) {
-            return `expect(${parsed.actual})${parsed.negated ? '.not.' : '.'}${parsed.matcher || 'toContain'}(${expectedValue})`;
-        }
-        // Default: update expected value in original
-        let result = parsed.originalAssertion || '';
-        // Replace the expected value
-        const lastComma = result.lastIndexOf(',');
-        if (lastComma !== -1) {
-            result = result.substring(0, lastComma + 1) + ' ' + expectedValue + result.substring(result.lastIndexOf(')'));
-        }
-        return result;
-    }
-    /**
-     * Format a value for use in code
-     */
-    formatValue(value) {
-        // Try to detect if it's already formatted
-        if (/^['"`{[\[]/.test(value)) {
-            return value;
-        }
-        // Numbers
-        if (/^\d+$/.test(value)) {
-            return value;
-        }
-        // Booleans
-        if (value === 'true' || value === 'false') {
-            return value;
-        }
-        // Null/undefined
-        if (value === 'null' || value === 'undefined') {
-            return value;
-        }
-        // Default: treat as string
-        return JSON.stringify(value);
-    }
-    /**
-     * Calculate similarity between two strings (Levenshtein-based)
-     */
-    calculateStringSimilarity(str1, str2) {
-        const len1 = str1.length;
-        const len2 = str2.length;
-        if (len1 === 0)
-            return len2 === 0 ? 1 : 0;
-        if (len2 === 0)
-            return 0;
-        const matrix = [];
-        for (let i = 0; i <= len1; i++) {
-            matrix[i] = [i];
-        }
-        for (let j = 0; j <= len2; j++) {
-            matrix[0][j] = j;
-        }
-        for (let i = 1; i <= len1; i++) {
-            for (let j = 1; j <= len2; j++) {
-                const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-                matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-            }
-        }
-        const maxLen = Math.max(len1, len2);
-        return 1 - matrix[len1][len2] / maxLen;
-    }
-    /**
-     * Parse multiple assertions from a file
-     */
-    parseAssertionsFromFile(content) {
-        const assertions = [];
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const options = {
-                fileContent: content,
-                lineNumber: i + 1,
-                expected: '',
-                actual: '',
-                framework: 'auto'
-            };
-            const parsed = this.parseJestAssertion(line, options) ||
-                this.parseChaiAssertion(line, options) ||
-                this.parseAssertAssertion(line, options);
-            if (parsed) {
-                assertions.push(parsed);
-            }
-        }
-        return assertions;
-    }
-}

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

@@ -1,122 +0,0 @@
-/**
- * Self-Healing Engine
- *
- * Main orchestration for self-healing functionality.
- * Coordinates selector healing, assertion healing, and AI assistance.
- */
-import type { SelfHealingConfig, SelfHealingSession, TestFailureContext, AiHealingSuggestion } from './types.js';
-/**
- * Self-Healing Engine class
- */
-export declare class SelfHealingEngine {
-    private config;
-    private selectorHealer;
-    private assertionHealer;
-    private currentSession?;
-    constructor(config: SelfHealingConfig);
-    /**
-     * Start a new self-healing session
-     */
-    startSession(): string;
-    /**
-     * End current session and return results
-     */
-    endSession(): SelfHealingSession | null;
-    /**
-     * Attempt to heal a test failure
-     */
-    healFailure(context: TestFailureContext): Promise<SelfHealingResult>;
-    /**
-     * Heal a UI test failure (selector issues)
-     */
-    private healUiFailure;
-    /**
-     * Heal an API test failure
-     */
-    private healApiFailure;
-    /**
-     * Heal a generic test failure
-     */
-    private healGenericFailure;
-    /**
-     * Try AI-assisted healing
-     */
-    private tryAiHealing;
-    /**
-     * Build AI prompt from failure context
-     */
-    private buildAiPrompt;
-    /**
-     * Extract code from AI response
-     */
-    private extractCodeFromAiResponse;
-    /**
-     * Extract explanation from AI response
-     */
-    private extractExplanationFromAiResponse;
-    /**
-     * Analyze API failure
-     */
-    private analyzeApiFailure;
-    /**
-     * Detect API change type from context
-     */
-    private detectApiChangeType;
-    /**
-     * Extract selector from error message
-     */
-    private extractSelector;
-    /**
-     * Extract expected text from error message
-     */
-    private extractExpectedText;
-    /**
-     * Infer selector error type from message
-     */
-    private inferSelectorErrorType;
-    /**
-     * Extract line number from stack trace
-     */
-    private extractLineNumber;
-    /**
-     * Format selector heal result
-     */
-    private formatSelectorHeal;
-    /**
-     * Calculate session summary
-     */
-    private calculateSummary;
-    /**
-     * Generate unique session ID
-     */
-    private generateSessionId;
-    /**
-     * Get current session
-     */
-    getSession(): SelfHealingSession | undefined;
-    /**
-     * Update configuration
-     */
-    updateConfig(updates: Partial<SelfHealingConfig>): void;
-    /**
-     * Check if self-healing is enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Get confidence threshold
-     */
-    getConfidenceThreshold(): number;
-}
-/**
- * Self-healing result
- */
-export interface SelfHealingResult {
-    success: boolean;
-    healed: boolean;
-    suggestion: AiHealingSuggestion | null;
-    reason: string;
-}
-/**
- * Create a self-healing engine with default config
- */
-export declare function createSelfHealingEngine(config?: Partial<SelfHealingConfig>): SelfHealingEngine;