qa360 1.4.5 → 2.0.1

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

@@ -0,0 +1,97 @@
+/**
+ * Assertion Healer
+ *
+ * Intelligently heals broken assertions in tests.
+ * Supports Jest, Chai, and Node.js assert styles.
+ */
+import type { AssertionUpdateResult, AssertionType, SelfHealingConfig } from './types.js';
+/**
+ * Parsed assertion information
+ */
+interface ParsedAssertion {
+    type: AssertionType;
+    originalAssertion?: string;
+    actual: string;
+    expected: string;
+    negated: boolean;
+    matcher?: string;
+    line: number;
+    column: number;
+}
+/**
+ * Assertion healing options
+ */
+interface AssertionHealOptions {
+    /** Test file content */
+    fileContent: string;
+    /** Line number of failed assertion */
+    lineNumber: number;
+    /** Expected value */
+    expected: string;
+    /** Actual value received */
+    actual: string;
+    /** Error message from failure */
+    errorMessage?: string;
+    /** Test framework (jest, chai, assert) */
+    framework?: 'jest' | 'chai' | 'assert' | 'auto';
+}
+/**
+ * Assertion Healer class
+ */
+export declare class AssertionHealer {
+    private config;
+    constructor(config: SelfHealingConfig);
+    /**
+     * Attempt to heal a broken assertion
+     */
+    healAssertion(options: AssertionHealOptions): Promise<AssertionUpdateResult | null>;
+    /**
+     * Parse the assertion from file content
+     */
+    private parseAssertion;
+    /**
+     * Detect test framework from file content
+     */
+    private detectFramework;
+    /**
+     * Parse Jest-style assertion
+     */
+    private parseJestAssertion;
+    /**
+     * Parse Chai-style assertion
+     */
+    private parseChaiAssertion;
+    /**
+     * Parse Node.js assert-style assertion
+     */
+    private parseAssertAssertion;
+    /**
+     * Map Jest matcher to assertion type
+     */
+    private mapJestMatcherToType;
+    /**
+     * Map Chai matcher to assertion type
+     */
+    private mapChaiMatcherToType;
+    /**
+     * Calculate confidence for healing
+     */
+    private calculateHealingConfidence;
+    /**
+     * Generate healed assertion
+     */
+    private generateHealedAssertion;
+    /**
+     * Format a value for use in code
+     */
+    private formatValue;
+    /**
+     * Calculate similarity between two strings (Levenshtein-based)
+     */
+    private calculateStringSimilarity;
+    /**
+     * Parse multiple assertions from a file
+     */
+    parseAssertionsFromFile(content: string): ParsedAssertion[];
+}
+export {};

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

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

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