qa360 1.4.5 → 2.0.1

package/dist/core/generation/test-optimizer.d.ts

@@ -0,0 +1,117 @@
+/**
+ * QA360 Test Optimizer
+ *
+ * Optimizes generated tests for better quality and maintainability.
+ * Removes redundancy, improves assertions, and enhances performance.
+ */
+import type { GeneratedTest } from './types.js';
+/**
+ * Optimization options
+ */
+export interface OptimizationOptions {
+    /**
+     * Remove duplicate tests
+     */
+    removeDuplicates?: boolean;
+    /**
+     * Merge similar tests
+     */
+    mergeSimilarTests?: boolean;
+    /**
+     * Improve assertions
+     */
+    improveAssertions?: boolean;
+    /**
+     * Add performance optimizations
+     */
+    addPerformanceOptimizations?: boolean;
+    /**
+     * Reduce test flakiness
+     */
+    reduceFlakiness?: boolean;
+    /**
+     * Target maximum test count
+     */
+    maxTestCount?: number;
+}
+/**
+ * Optimization result
+ */
+export interface OptimizationResult {
+    optimized: GeneratedTest[];
+    removed: number;
+    merged: number;
+    improvements: string[];
+}
+/**
+ * Test Optimizer class
+ */
+export declare class TestOptimizer {
+    private readonly options;
+    private readonly defaultOptions;
+    constructor(options?: OptimizationOptions);
+    /**
+     * Optimize generated tests
+     */
+    optimize(tests: GeneratedTest[]): OptimizationResult;
+    /**
+     * Remove duplicate tests
+     */
+    private removeDuplicateTests;
+    /**
+     * Merge similar test cases
+     */
+    private mergeSimilarTestCases;
+    /**
+     * Improve test assertions
+     */
+    private improveTestAssertions;
+    /**
+     * Add performance improvements
+     */
+    private addPerformanceImprovements;
+    /**
+     * Reduce test flakiness
+     */
+    private reduceTestFlakiness;
+    /**
+     * Prioritize tests by importance
+     */
+    private prioritizeTests;
+    /**
+     * Create test signature for deduplication
+     */
+    private createTestSignature;
+    /**
+     * Calculate similarity between two tests
+     */
+    private calculateSimilarity;
+    /**
+     * Merge multiple tests into one
+     */
+    private mergeTests;
+    /**
+     * Extract test cases from code
+     */
+    private extractTestCases;
+    /**
+     * Enhance assertions in code
+     */
+    private enhanceAssertions;
+    /**
+     * Optimize performance
+     */
+    private optimizePerformance;
+    /**
+     * Add stability improvements
+     */
+    private addStabilityImprovements;
+    /**
+     * Get optimization suggestions for a test
+     */
+    getSuggestions(test: GeneratedTest): string[];
+}
+/**
+ * Create optimizer with default config
+ */
+export declare function createOptimizer(options?: OptimizationOptions): TestOptimizer;

package/dist/core/generation/test-optimizer.js

@@ -0,0 +1,328 @@
+/**
+ * QA360 Test Optimizer
+ *
+ * Optimizes generated tests for better quality and maintainability.
+ * Removes redundancy, improves assertions, and enhances performance.
+ */
+/**
+ * Test Optimizer class
+ */
+export class TestOptimizer {
+    options;
+    defaultOptions = {
+        removeDuplicates: true,
+        mergeSimilarTests: true,
+        improveAssertions: true,
+        addPerformanceOptimizations: true,
+        reduceFlakiness: true,
+        maxTestCount: 100,
+    };
+    constructor(options = {}) {
+        this.options = { ...this.defaultOptions, ...options };
+    }
+    /**
+     * Optimize generated tests
+     */
+    optimize(tests) {
+        let optimized = [...tests];
+        const improvements = [];
+        let removed = 0;
+        let merged = 0;
+        // Remove duplicates
+        if (this.options.removeDuplicates) {
+            const before = optimized.length;
+            optimized = this.removeDuplicateTests(optimized);
+            removed = before - optimized.length;
+            if (removed > 0) {
+                improvements.push(`Removed ${removed} duplicate test(s)`);
+            }
+        }
+        // Merge similar tests
+        if (this.options.mergeSimilarTests) {
+            const before = optimized.length;
+            optimized = this.mergeSimilarTestCases(optimized);
+            merged = before - optimized.length;
+            if (merged > 0) {
+                improvements.push(`Merged ${merged} similar test(s)`);
+            }
+        }
+        // Improve assertions
+        if (this.options.improveAssertions) {
+            optimized = this.improveTestAssertions(optimized);
+            improvements.push('Improved assertions quality');
+        }
+        // Add performance optimizations
+        if (this.options.addPerformanceOptimizations) {
+            optimized = this.addPerformanceImprovements(optimized);
+            improvements.push('Added performance optimizations');
+        }
+        // Reduce flakiness
+        if (this.options.reduceFlakiness) {
+            optimized = this.reduceTestFlakiness(optimized);
+            improvements.push('Reduced test flakiness');
+        }
+        // Limit test count
+        if (this.options.maxTestCount && optimized.length > this.options.maxTestCount) {
+            const before = optimized.length;
+            optimized = this.prioritizeTests(optimized).slice(0, this.options.maxTestCount);
+            improvements.push(`Prioritized and kept ${this.options.maxTestCount} most important tests (${before - this.options.maxTestCount} removed)`);
+        }
+        return {
+            optimized,
+            removed,
+            merged,
+            improvements,
+        };
+    }
+    /**
+     * Remove duplicate tests
+     */
+    removeDuplicateTests(tests) {
+        const seen = new Set();
+        const unique = [];
+        for (const test of tests) {
+            // Create a signature based on test content
+            const signature = this.createTestSignature(test);
+            if (!seen.has(signature)) {
+                seen.add(signature);
+                unique.push(test);
+            }
+        }
+        return unique;
+    }
+    /**
+     * Merge similar test cases
+     */
+    mergeSimilarTestCases(tests) {
+        const merged = [];
+        const used = new Set();
+        for (let i = 0; i < tests.length; i++) {
+            if (used.has(i))
+                continue;
+            const current = tests[i];
+            const similar = [current];
+            // Find similar tests
+            for (let j = i + 1; j < tests.length; j++) {
+                if (used.has(j))
+                    continue;
+                const similarity = this.calculateSimilarity(current, tests[j]);
+                if (similarity.score > 0.7) {
+                    similar.push(tests[j]);
+                    used.add(j);
+                }
+            }
+            // Merge similar tests or keep as-is
+            if (similar.length > 1) {
+                merged.push(this.mergeTests(similar));
+            }
+            else {
+                merged.push(current);
+            }
+            used.add(i);
+        }
+        return merged;
+    }
+    /**
+     * Improve test assertions
+     */
+    improveTestAssertions(tests) {
+        return tests.map(test => ({
+            ...test,
+            code: this.enhanceAssertions(test.code),
+        }));
+    }
+    /**
+     * Add performance improvements
+     */
+    addPerformanceImprovements(tests) {
+        return tests.map(test => ({
+            ...test,
+            code: this.optimizePerformance(test.code, test.framework),
+        }));
+    }
+    /**
+     * Reduce test flakiness
+     */
+    reduceTestFlakiness(tests) {
+        return tests.map(test => ({
+            ...test,
+            code: this.addStabilityImprovements(test.code, test.framework),
+        }));
+    }
+    /**
+     * Prioritize tests by importance
+     */
+    prioritizeTests(tests) {
+        return tests.sort((a, b) => {
+            // Prefer tests with more assertions
+            const aAssertions = a.summary.assertionCount || 0;
+            const bAssertions = b.summary.assertionCount || 0;
+            if (aAssertions !== bAssertions) {
+                return bAssertions - aAssertions;
+            }
+            // Then prefer shorter tests (faster)
+            const aLines = a.summary.lines;
+            const bLines = b.summary.lines;
+            return aLines - bLines;
+        });
+    }
+    /**
+     * Create test signature for deduplication
+     */
+    createTestSignature(test) {
+        // Normalize code for comparison
+        const normalized = test.code
+            .replace(/\s+/g, ' ')
+            .replace(/\/\/.*$/gm, '') // Remove comments
+            .toLowerCase()
+            .trim();
+        // Simple hash of content
+        let hash = 0;
+        for (let i = 0; i < normalized.length; i++) {
+            const char = normalized.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return `${test.name}-${Math.abs(hash)}`;
+    }
+    /**
+     * Calculate similarity between two tests
+     */
+    calculateSimilarity(test1, test2) {
+        // Check framework match
+        if (test1.framework !== test2.framework) {
+            return { test1, test2, score: 0 };
+        }
+        // Compare structure
+        const words1 = new Set(test1.code.toLowerCase().split(/\W+/));
+        const words2 = new Set(test2.code.toLowerCase().split(/\W+/));
+        let intersection = 0;
+        for (const word of words1) {
+            if (words2.has(word) && word.length > 4) { // Only significant words
+                intersection++;
+            }
+        }
+        const union = new Set([...words1, ...words2]).size;
+        const score = union > 0 ? intersection / union : 0;
+        return { test1, test2, score };
+    }
+    /**
+     * Merge multiple tests into one
+     */
+    mergeTests(tests) {
+        const base = tests[0];
+        const mergedName = `${base.name} (merged ${tests.length})`;
+        // Combine test code (simplified)
+        let mergedCode = base.code;
+        // Extract test cases from each and combine them
+        for (const test of tests.slice(1)) {
+            const testCases = this.extractTestCases(test.code);
+            for (const testCase of testCases) {
+                mergedCode += '\n\n' + testCase;
+            }
+        }
+        return {
+            ...base,
+            name: mergedName,
+            code: mergedCode,
+            summary: {
+                lines: mergedCode.split('\n').length,
+                testCount: tests.reduce((sum, t) => sum + (t.summary.testCount || 0), 0),
+                assertionCount: tests.reduce((sum, t) => sum + (t.summary.assertionCount || 0), 0),
+            },
+        };
+    }
+    /**
+     * Extract test cases from code
+     */
+    extractTestCases(code) {
+        const cases = [];
+        // Match test() or it() blocks
+        const testRegex = /\b(test|it)\s*\(\s*['"]([^'"]+)['"][\s\S]*?\n\s*\}\s*\)/g;
+        let match;
+        while ((match = testRegex.exec(code)) !== null) {
+            cases.push(match[0]);
+        }
+        return cases;
+    }
+    /**
+     * Enhance assertions in code
+     */
+    enhanceAssertions(code) {
+        let enhanced = code;
+        // Add status code checks for API tests
+        enhanced = enhanced.replace(/const response = await fetch\([^)]+\);\s*$/gm, '$&\n    expect(response.status).toBeGreaterThanOrEqual(200);\n    expect(response.status).toBeLessThan(300);');
+        // Add non-empty assertions for array responses
+        enhanced = enhanced.replace(/const data = await response\.json\(\);\s*$/gm, '$&\n    expect(data).toBeDefined();');
+        // Add timeout for slow operations
+        enhanced = enhanced.replace(/\bwaitForURL\(/g, 'waitForURL(');
+        return enhanced;
+    }
+    /**
+     * Optimize performance
+     */
+    optimizePerformance(code, framework) {
+        let optimized = code;
+        if (framework === 'playwright') {
+            // Add reuse of browser contexts where possible
+            optimized = optimized.replace(/test\.describe\(/g, 'test.describe.serial(');
+            // Suggest parallel test execution
+            if (!optimized.includes('test.describe.configure')) {
+                optimized = 'test.describe.configure({ mode: \'parallel\' });\n\n' + optimized;
+            }
+        }
+        // Remove unnecessary waits
+        optimized = optimized.replace(/\bpage\.waitForTimeout\(\d+\)/g, '// waitForTimeout removed - use explicit waits instead');
+        return optimized;
+    }
+    /**
+     * Add stability improvements
+     */
+    addStabilityImprovements(code, framework) {
+        let stable = code;
+        if (framework === 'playwright') {
+            // Replace waitFor with waitForSelector for more reliable waits
+            stable = stable.replace(/\bwaitFor\(/g, 'waitForSelector(');
+            // Add explicit waits for navigation
+            stable = stable.replace(/(\.click\([^)]+\))(?!.*waitFor)/g, '$1\n    await page.waitForLoadState(\'networkidle\');');
+        }
+        // Add retry logic for API tests
+        if (framework === 'playwright' && (code.includes('fetch') || code.includes('axios'))) {
+            stable = stable.replace(/test\s*\(\s*['"]([^'"]+)['"]\s*,\s*async\s+/g, 'test(\'$1 (with retry)\', async ');
+        }
+        return stable;
+    }
+    /**
+     * Get optimization suggestions for a test
+     */
+    getSuggestions(test) {
+        const suggestions = [];
+        // Check for missing assertions
+        if ((test.summary.assertionCount || 0) < (test.summary.testCount || 1)) {
+            suggestions.push('Consider adding more assertions for better coverage');
+        }
+        // Check for long tests
+        if (test.summary.lines > 200) {
+            suggestions.push('Test is very long - consider splitting into smaller tests');
+        }
+        // Check for console.log
+        if (test.code.includes('console.log')) {
+            suggestions.push('Remove console.log statements - use assertions instead');
+        }
+        // Check for hardcoded values
+        if (test.code.includes('123456') || test.code.includes('test@test')) {
+            suggestions.push('Use test fixtures instead of hardcoded values');
+        }
+        // Check for missing error handling
+        if (!test.code.includes('try') && !test.code.includes('catch')) {
+            suggestions.push('Consider adding error handling for robustness');
+        }
+        return suggestions;
+    }
+}
+/**
+ * Create optimizer with default config
+ */
+export function createOptimizer(options) {
+    return new TestOptimizer(options);
+}

package/dist/core/generation/types.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Types for AI Test Generation
+ */
+/**
+ * Base test specification
+ */
+export interface TestSpec {
+    type: 'api' | 'ui' | 'perf' | 'unit';
+    name: string;
+    description?: string;
+    tags?: string[];
+}
+/**
+ * API test specification
+ */
+export interface ApiTestSpec extends TestSpec {
+    type: 'api';
+    baseUrl: string;
+    endpoints: ApiEndpoint[];
+    auth?: AuthSpec;
+    headers?: Record<string, string>;
+}
+/**
+ * API endpoint definition
+ */
+export interface ApiEndpoint {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    description?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    queryParams?: Record<string, string>;
+    expectations?: ApiExpectation[];
+}
+/**
+ * API expectations
+ */
+export interface ApiExpectation {
+    status?: number | number[];
+    responseTime?: string;
+    hasBody?: boolean;
+    schema?: Record<string, unknown>;
+    contains?: string[];
+}
+/**
+ * UI test specification
+ */
+export interface UiTestSpec extends TestSpec {
+    type: 'ui';
+    baseUrl: string;
+    pages: PageSpec[];
+    auth?: AuthSpec;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Page specification for UI tests
+ */
+export interface PageSpec {
+    name: string;
+    url: string;
+    actions: PageAction[];
+    assertions?: Assertion[];
+}
+/**
+ * Page action
+ */
+export interface PageAction {
+    type: 'goto' | 'click' | 'fill' | 'select' | 'wait' | 'hover' | 'screenshot' | 'type' | 'check' | 'uncheck';
+    selector?: string;
+    value?: string;
+    timeout?: number;
+    options?: Record<string, unknown>;
+}
+/**
+ * Assertion for UI tests
+ */
+export interface Assertion {
+    type: 'url' | 'title' | 'visible' | 'text' | 'attribute' | 'count';
+    selector?: string;
+    expected: string | number | boolean;
+    operator?: 'equals' | 'contains' | 'matches' | 'greaterThan' | 'lessThan';
+}
+/**
+ * Performance test specification
+ */
+export interface PerfTestSpec extends TestSpec {
+    type: 'perf';
+    baseUrl: string;
+    scenarios: PerfScenario[];
+    options?: PerfOptions;
+}
+/**
+ * Performance scenario
+ */
+export interface PerfScenario {
+    name: string;
+    weight?: number;
+    requests: PerfRequest[];
+    thinkTime?: number;
+}
+/**
+ * Performance request
+ */
+export interface PerfRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+}
+/**
+ * Performance test options
+ */
+export interface PerfOptions {
+    duration?: string;
+    rate?: number;
+    vus?: number;
+    maxVus?: number;
+    thresholds?: PerfThreshold[];
+}
+/**
+ * Performance thresholds
+ */
+export interface PerfThreshold {
+    metric: 'http_req_duration' | 'http_req_failed' | 'checks';
+    condition: string;
+}
+/**
+ * Unit test specification
+ */
+export interface UnitTestSpec extends TestSpec {
+    type: 'unit';
+    source: {
+        language: 'typescript' | 'javascript' | 'python' | 'go' | 'rust';
+        filePath: string;
+        code?: string;
+        exports?: string[];
+    };
+    framework?: 'vitest' | 'jest' | 'pytest' | 'go test';
+}
+/**
+ * Authentication specification
+ */
+export interface AuthSpec {
+    type: 'none' | 'bearer' | 'basic' | 'api_key' | 'oauth2' | 'jwt';
+    config?: Record<string, unknown>;
+}
+/**
+ * Generation context
+ */
+export interface GenerationContext {
+    projectName: string;
+    framework: 'playwright' | 'k6' | 'vitest' | 'jest';
+    language: 'typescript' | 'javascript' | 'go';
+    outputDir?: string;
+    options?: GenerationOptions;
+}
+/**
+ * Generation options
+ */
+export interface GenerationOptions {
+    includeComments?: boolean;
+    includeAssertions?: boolean;
+    includeRetryLogic?: boolean;
+    optimize?: boolean;
+    targetCoverage?: number;
+    maxTests?: number;
+}
+/**
+ * Generated test result
+ */
+export interface GeneratedTest {
+    name: string;
+    code: string;
+    language: string;
+    framework: string;
+    filePath: string;
+    summary: {
+        lines: number;
+        testCount: number;
+        assertionCount?: number;
+    };
+    metadata?: {
+        generatedAt: string;
+        model: string;
+        tokensUsed: number;
+    };
+}
+/**
+ * Source for test generation
+ */
+export type GenerationSource = {
+    type: 'openapi';
+    urlOrPath: string;
+} | {
+    type: 'har';
+    filePath: string;
+} | {
+    type: 'url';
+    url: string;
+} | {
+    type: 'spec';
+    spec: TestSpec;
+} | {
+    type: 'description';
+    description: string;
+} | {
+    type: 'code';
+    code: string;
+    language: string;
+};

package/dist/core/generation/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for AI Test Generation
+ */
+export {};

package/dist/core/index.d.ts

@@ -60,14 +60,36 @@ export declare class QA360Core {
 export declare const VERSION = "0.9.0-core";
 export * from './proof/index.js';
 export { EvidenceVault } from './vault/index.js';
-export type { RunRecord, GateRecord, FindingRecord } from './vault/index.js';
+export type { RunRecord, GateRecord, FindingRecord, FlakinessRecord, FlakinessPatternRecord, QuarantineRecord } from './vault/index.js';
 export { SecurityRedactor } from './security/redactor.js';
 export { SecretsManager } from './secrets/manager.js';
 export { SecretsCrypto } from './secrets/crypto.js';
 export { PackValidator } from './pack/validator.js';
 export { PackMigrator } from './pack/migrator.js';
 export type { PackConfigV1 } from './types/pack-v1.js';
+export * from './ai/index.js';
+export * from './discoverer/index.js';
+export * from './types/pack-v2.js';
+export type { PackConfigV2, AuthConfigV2, AuthProfile, AuthTypeV2, AuthCacheConfig, GateConfigV2, GateBudgets, GateOptions, HooksConfig, Hook, ExecutionConfigV2, ResourceLimits, SecurityBudgets, PerformanceTargets } from './types/pack-v2.js';
+export * from './pack-v2/index.js';
+export { PackLoaderV2, PackValidatorV2, PackLoadResult } from './pack-v2/index.js';
+export type { PackMigrationResultV2, ValidationError } from './pack-v2/index.js';
+export * from './auth/index.js';
+export * from './generation/index.js';
 export { QA360Server } from './serve/server.js';
 export type { ServeConfig } from './serve/server.js';
 export { Phase3Runner } from './runner/phase3-runner.js';
 export type { Phase3RunnerOptions, Phase3RunResult, GateResult } from './runner/phase3-runner.js';
+export { PlaywrightNativeApiAdapter, createPlaywrightNativeApiAdapter } from './adapters/playwright-native-api.js';
+export type { NativeApiTestConfig, NativeApiSmokeResult } from './adapters/playwright-native-api.js';
+export * from './repair/index.js';
+export * from './tui/index.js';
+export * from './dashboard/index.js';
+export * from './flakiness/index.js';
+export * from './retry/index.js';
+export * from './cache/index.js';
+export * from './watch/index.js';
+export * from './self-healing/index.js';
+export * from './coverage/index.js';
+export * from './slo/index.js';
+export * from './regression/index.js';