qa360 2.1.0 → 2.1.1

package/dist/commands/scan.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+export declare const scanCommand: Command;

package/dist/commands/scan.js

@@ -0,0 +1,155 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+import { chromium } from '@playwright/test';
+import { DOMScanner } from '../scanners/dom-scanner.js';
+import { JSONReporter } from '../generators/json-reporter.js';
+import { TestGenerator } from '../generators/test-generator.js';
+import { resolve } from 'path';
+import { mkdirSync } from 'fs';
+export const scanCommand = new Command('scan');
+scanCommand
+    .description('Scan a web page for UI elements and generate test configurations')
+    .argument('<url>', 'URL of the page to scan')
+    .option('-o, --output <file>', 'Output file path (default: ".qa360/discovery/elements.json")')
+    .option('-i, --include <types>', 'Element types to include: buttons,links,forms,inputs,images,headings,all (default: "all")')
+    .option('-e, --exclude <selectors>', 'CSS selectors to exclude (comma-separated)')
+    .option('-s, --screenshot', 'Capture screenshots of elements (not yet implemented)')
+    .option('-a, --auto-generate-test', 'Auto-generate QA360 test file')
+    .option('-t, --timeout <ms>', 'Navigation timeout in milliseconds', '30000')
+    .option('--headed', 'Run in headed mode (show browser)')
+    .action(async (url, options) => {
+    const startTime = Date.now();
+    // Validate URL
+    try {
+        new URL(url);
+    }
+    catch {
+        console.error(`❌ Invalid URL: ${url}`);
+        process.exit(1);
+    }
+    // Parse include types
+    const includeTypes = options.include || 'all';
+    const include = includeTypes
+        .split(',')
+        .map((t) => t.trim().toLowerCase());
+    // Validate element types
+    const validTypes = ['buttons', 'links', 'forms', 'inputs', 'images', 'headings', 'all'];
+    for (const type of include) {
+        if (!validTypes.includes(type)) {
+            console.error(`❌ Invalid element type: ${type}`);
+            console.error(`   Valid types: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Parse exclude selectors
+    const exclude = options.exclude
+        ? options.exclude.split(',').map((s) => s.trim())
+        : [];
+    const scanOptions = {
+        url,
+        output: options.output || '.qa360/discovery/elements.json',
+        include,
+        exclude,
+        screenshot: options.screenshot || false,
+        autoGenerateTest: options.autoGenerateTest || false,
+        timeout: parseInt(options.timeout, 10) || 30000,
+        headless: !options.headed
+    };
+    console.log(`🔍 Scanning page: ${url}`);
+    console.log('━'.repeat(50));
+    let browser = null;
+    let context = null;
+    let page = null;
+    try {
+        // Launch browser
+        browser = await chromium.launch({
+            headless: scanOptions.headless
+        });
+        context = await browser.newContext({
+            viewport: { width: 1280, height: 720 }
+        });
+        page = await context.newPage();
+        // Navigate to URL
+        await page.goto(url, {
+            timeout: scanOptions.timeout,
+            waitUntil: 'networkidle'
+        });
+        // Run scan
+        const scanner = new DOMScanner(page, url);
+        const elements = await scanner.scan(scanOptions);
+        // Generate summary
+        const summary = {
+            totalElements: elements.length,
+            buttons: elements.filter(e => e.type === 'button').length,
+            links: elements.filter(e => e.type === 'link').length,
+            forms: elements.filter(e => e.type === 'form').length,
+            inputs: elements.filter(e => e.type === 'input').length,
+            images: elements.filter(e => e.type === 'image').length,
+            headings: elements.filter(e => e.type === 'heading').length
+        };
+        // Print summary
+        console.log(`✅ Buttons found:      ${summary.buttons}`);
+        console.log(`✅ Links found:        ${summary.links}`);
+        console.log(`✅ Forms found:        ${summary.forms}`);
+        console.log(`✅ Inputs found:       ${summary.inputs}`);
+        console.log(`✅ Images found:       ${summary.images}`);
+        console.log(`✅ Headings found:     ${summary.headings}`);
+        console.log('━'.repeat(50));
+        console.log(`📦 Total elements:     ${summary.totalElements}`);
+        console.log();
+        // Create output directory
+        const outputPath = resolve(scanOptions.output);
+        const outputDir = outputPath.substring(0, outputPath.lastIndexOf('/'));
+        mkdirSync(outputDir, { recursive: true });
+        // Generate scan result
+        const result = {
+            scanDate: new Date().toISOString(),
+            url,
+            duration: Date.now() - startTime,
+            summary,
+            elements
+        };
+        // Generate JSON report
+        const reporter = new JSONReporter();
+        await reporter.generate(result, outputPath);
+        console.log(`💾 Saved to: ${outputPath}`);
+        // Auto-generate test if requested
+        if (options.autoGenerateTest) {
+            const testGenerator = new TestGenerator();
+            const testPath = outputPath.replace('.json', '.yml');
+            await testGenerator.generate(result, testPath);
+            console.log(`📄 Test generated: ${testPath}`);
+        }
+        // Screenshots (placeholder for future implementation)
+        if (options.screenshot) {
+            console.log(`📸 Screenshots: ${outputDir}/screenshots/ (not yet implemented)`);
+        }
+        // Cleanup
+        await page.close();
+        await context.close();
+        await browser.close();
+        console.log();
+        console.log(`✨ Scan completed in ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+        console.log();
+        console.log('💡 Next steps:');
+        console.log(`   • Review the discovered elements`);
+        if (options.autoGenerateTest) {
+            console.log(`   • Run the auto-generated test: qa360 run ${outputPath.replace('.json', '.yml')}`);
+        }
+        console.log(`   • Edit the test to remove unwanted elements`);
+    }
+    catch (error) {
+        // Cleanup on error
+        if (page)
+            await page.close().catch(() => { });
+        if (context)
+            await context.close().catch(() => { });
+        if (browser)
+            await browser.close().catch(() => { });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`❌ Scan failed: ${errorMessage}`);
+        process.exit(1);
+    }
+});

package/dist/core/core/coverage/analyzer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Coverage Analyzer
+ *
+ * Analyzes coverage data to provide insights, trends, and recommendations.
+ */
+import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageThreshold, CoverageType, CoverageReport } from './types.js';
+/**
+ * Historical coverage data point
+ */
+interface HistoricalCoverage {
+    runId: string;
+    timestamp: number;
+    metrics: CoverageMetrics;
+}
+/**
+ * Coverage Analyzer class
+ */
+export declare class CoverageAnalyzer {
+    private history;
+    /**
+     * Analyze coverage and generate insights
+     */
+    analyze(result: CoverageResult, threshold?: CoverageThreshold): CoverageReport;
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(metrics: CoverageMetrics, threshold?: CoverageThreshold): boolean;
+    /**
+     * Check if a single file meets thresholds
+     */
+    checkFileThresholds(file: FileCoverage, threshold?: CoverageThreshold): boolean;
+    /**
+     * Find coverage gaps
+     */
+    findGaps(files: Record<string, FileCoverage>, threshold?: CoverageThreshold): CoverageGap[];
+    /**
+     * Calculate priority for covering a file
+     */
+    private calculatePriority;
+    /**
+     * Estimate effort to cover a file
+     */
+    private estimateEffort;
+    /**
+     * Generate test suggestions for a file
+     */
+    private generateSuggestions;
+    /**
+     * Group consecutive numbers into ranges
+     */
+    private groupConsecutiveNumbers;
+    /**
+     * Get top and bottom files by coverage
+     */
+    getTopFiles(files: Record<string, FileCoverage>, limit?: number): Array<{
+        path: string;
+        coverage: number;
+        type: 'best' | 'worst';
+    }>;
+    /**
+     * Compare two coverage results
+     */
+    compare(baseResult: CoverageResult, compareResult: CoverageResult): CoverageComparison;
+    /**
+     * Add historical coverage data
+     */
+    addHistory(key: string, data: HistoricalCoverage): void;
+    /**
+     * Get coverage trends
+     */
+    getTrends(key: string, type?: CoverageType, limit?: number): CoverageTrend[];
+    /**
+     * Calculate trend direction
+     */
+    getTrendDirection(trends: CoverageTrend[]): 'improving' | 'stable' | 'declining';
+    /**
+     * Predict future coverage based on trends
+     */
+    predictCoverage(key: string, type: CoverageType | undefined, targetCoverage: number): {
+        predictedReach: number | null;
+        projectedCoverage: number;
+        confidence: 'high' | 'medium' | 'low';
+    };
+    /**
+     * Generate coverage summary text
+     */
+    generateSummary(metrics: CoverageMetrics): string;
+    /**
+     * Format coverage percentage with color indicator
+     */
+    formatCoverage(percentage: number, threshold?: number): string;
+    /**
+     * Clear history
+     */
+    clearHistory(key?: string): void;
+}
+/**
+ * Create a coverage analyzer
+ */
+export declare function createCoverageAnalyzer(): CoverageAnalyzer;
+export {};

package/dist/core/core/coverage/analyzer.js

@@ -0,0 +1,415 @@
+/**
+ * Coverage Analyzer
+ *
+ * Analyzes coverage data to provide insights, trends, and recommendations.
+ */
+/**
+ * Coverage Analyzer class
+ */
+export class CoverageAnalyzer {
+    history = new Map();
+    /**
+     * Analyze coverage and generate insights
+     */
+    analyze(result, threshold) {
+        const thresholdsMet = this.checkThresholds(result.metrics, threshold);
+        const gaps = this.findGaps(result.files, threshold);
+        const topFiles = this.getTopFiles(result.files);
+        return {
+            runId: `run_${Date.now()}`,
+            timestamp: Date.now(),
+            metrics: result.metrics,
+            byGate: { [result.gate]: result.metrics },
+            topFiles,
+            gaps: gaps.slice(0, 10), // Top 10 gaps
+            thresholdsMet,
+            thresholdViolations: gaps.map(g => g.path)
+        };
+    }
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(metrics, threshold) {
+        if (!threshold) {
+            return true;
+        }
+        if (threshold.scope === 'per-file') {
+            // Per-file thresholds checked separately
+            return true;
+        }
+        if (threshold.line !== undefined && metrics.lineCoverage < threshold.line) {
+            return false;
+        }
+        if (threshold.branch !== undefined && metrics.branchCoverage < threshold.branch) {
+            return false;
+        }
+        if (threshold.function !== undefined && metrics.functionCoverage < threshold.function) {
+            return false;
+        }
+        if (threshold.statement !== undefined && metrics.statementCoverage < threshold.statement) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a single file meets thresholds
+     */
+    checkFileThresholds(file, threshold) {
+        if (!threshold) {
+            return true;
+        }
+        if (threshold.line !== undefined && file.lineCoverage < threshold.line) {
+            return false;
+        }
+        if (threshold.branch !== undefined && file.branchCoverage < threshold.branch) {
+            return false;
+        }
+        if (threshold.function !== undefined && file.functionCoverage < threshold.function) {
+            return false;
+        }
+        if (threshold.statement !== undefined && file.statementCoverage < threshold.statement) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Find coverage gaps
+     */
+    findGaps(files, threshold) {
+        const gaps = [];
+        const targetLine = threshold?.line ?? 80;
+        const targetBranch = threshold?.branch ?? 70;
+        const targetFunction = threshold?.function ?? 75;
+        for (const [path, file] of Object.entries(files)) {
+            const minTarget = Math.min(targetLine, targetBranch, targetFunction);
+            const avgCoverage = (file.lineCoverage + file.branchCoverage + file.functionCoverage) / 3;
+            if (avgCoverage < minTarget) {
+                gaps.push({
+                    path,
+                    currentCoverage: avgCoverage,
+                    targetCoverage: minTarget,
+                    gap: minTarget - avgCoverage,
+                    priority: this.calculatePriority(file, minTarget),
+                    effort: this.estimateEffort(file),
+                    uncoveredCount: file.uncoveredLines.length,
+                    suggestions: this.generateSuggestions(file)
+                });
+            }
+        }
+        // Sort by gap size, then priority
+        gaps.sort((a, b) => {
+            if (a.priority !== b.priority) {
+                const priorityOrder = { high: 0, medium: 1, low: 2 };
+                return priorityOrder[a.priority] - priorityOrder[b.priority];
+            }
+            return b.gap - a.gap;
+        });
+        return gaps;
+    }
+    /**
+     * Calculate priority for covering a file
+     */
+    calculatePriority(file, target) {
+        const gap = target - file.lineCoverage;
+        // High priority: large gap in important files
+        if (gap > 30) {
+            return 'high';
+        }
+        // Medium priority: moderate gap
+        if (gap > 10) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Estimate effort to cover a file
+     */
+    estimateEffort(file) {
+        const complexity = file.totalBranches + file.totalFunctions;
+        const uncoveredRatio = file.uncoveredLines.length / Math.max(file.totalLines, 1);
+        if (complexity > 100 || uncoveredRatio > 0.5) {
+            return 'high';
+        }
+        if (complexity > 30 || uncoveredRatio > 0.2) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Generate test suggestions for a file
+     */
+    generateSuggestions(file) {
+        const suggestions = [];
+        if (file.uncoveredLines.length > 0) {
+            const lineRanges = this.groupConsecutiveNumbers(file.uncoveredLines);
+            suggestions.push(`Add tests covering lines: ${lineRanges.slice(0, 3).join(', ')}`);
+        }
+        if (file.branchCoverage < file.lineCoverage) {
+            suggestions.push('Add tests for all branch conditions (true/false paths)');
+        }
+        if (file.functionCoverage < 100) {
+            suggestions.push('Add tests for uncovered functions');
+        }
+        if (file.totalFunctions === 0) {
+            suggestions.push('Consider splitting large functions into smaller, testable units');
+        }
+        return suggestions;
+    }
+    /**
+     * Group consecutive numbers into ranges
+     */
+    groupConsecutiveNumbers(numbers) {
+        if (numbers.length === 0)
+            return [];
+        const sorted = [...numbers].sort((a, b) => a - b);
+        const ranges = [];
+        let start = sorted[0];
+        let prev = sorted[0];
+        for (let i = 1; i < sorted.length; i++) {
+            if (sorted[i] === prev + 1) {
+                prev = sorted[i];
+            }
+            else {
+                ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
+                start = sorted[i];
+                prev = sorted[i];
+            }
+        }
+        ranges.push(start === prev ? `${start}` : `${start}-${prev}`);
+        return ranges;
+    }
+    /**
+     * Get top and bottom files by coverage
+     */
+    getTopFiles(files, limit = 5) {
+        const fileArray = Object.entries(files).map(([path, file]) => ({
+            path,
+            coverage: file.lineCoverage,
+            type: 'best'
+        }));
+        // Sort by coverage
+        fileArray.sort((a, b) => b.coverage - a.coverage);
+        const result = [];
+        // Best files
+        for (let i = 0; i < Math.min(limit, fileArray.length); i++) {
+            result.push({ ...fileArray[i], type: 'best' });
+        }
+        // Worst files
+        for (let i = fileArray.length - 1; i >= Math.max(fileArray.length - limit, 0); i--) {
+            result.push({ path: fileArray[i].path, coverage: fileArray[i].coverage, type: 'worst' });
+        }
+        return result;
+    }
+    /**
+     * Compare two coverage results
+     */
+    compare(baseResult, compareResult) {
+        const baseFiles = baseResult.files;
+        const compareFiles = compareResult.files;
+        const improved = [];
+        const regressed = [];
+        const newFiles = [];
+        const removedFiles = [];
+        // Check all files in base
+        for (const [path, baseFile] of Object.entries(baseFiles)) {
+            const compareFile = compareFiles[path];
+            if (!compareFile) {
+                removedFiles.push(path);
+                continue;
+            }
+            const delta = compareFile.lineCoverage - baseFile.lineCoverage;
+            if (delta > 0.5) {
+                improved.push({
+                    path,
+                    before: baseFile.lineCoverage,
+                    after: compareFile.lineCoverage,
+                    delta
+                });
+            }
+            else if (delta < -0.5) {
+                regressed.push({
+                    path,
+                    before: baseFile.lineCoverage,
+                    after: compareFile.lineCoverage,
+                    delta
+                });
+            }
+        }
+        // Find new files
+        for (const path of Object.keys(compareFiles)) {
+            if (!baseFiles[path]) {
+                newFiles.push(path);
+            }
+        }
+        // Calculate overall change
+        const overallChange = compareResult.metrics.lineCoverage - baseResult.metrics.lineCoverage;
+        return {
+            baseRunId: `base_${baseResult.timestamp}`,
+            compareRunId: `compare_${compareResult.timestamp}`,
+            improved,
+            regressed,
+            newFiles,
+            removedFiles,
+            overallChange
+        };
+    }
+    /**
+     * Add historical coverage data
+     */
+    addHistory(key, data) {
+        if (!this.history.has(key)) {
+            this.history.set(key, []);
+        }
+        const history = this.history.get(key);
+        history.push(data);
+        // Keep only last 100 entries
+        if (history.length > 100) {
+            history.shift();
+        }
+    }
+    /**
+     * Get coverage trends
+     */
+    getTrends(key, type = 'line', limit = 30) {
+        const history = this.history.get(key) || [];
+        const sorted = history
+            .sort((a, b) => a.timestamp - b.timestamp)
+            .slice(-limit);
+        const trends = [];
+        let previousValue = 0;
+        for (const entry of sorted) {
+            let value;
+            switch (type) {
+                case 'line':
+                    value = entry.metrics.lineCoverage;
+                    break;
+                case 'branch':
+                    value = entry.metrics.branchCoverage;
+                    break;
+                case 'function':
+                    value = entry.metrics.functionCoverage;
+                    break;
+                case 'statement':
+                    value = entry.metrics.statementCoverage;
+                    break;
+            }
+            trends.push({
+                runId: entry.runId,
+                timestamp: entry.timestamp,
+                coverage: value,
+                type,
+                change: value - previousValue
+            });
+            previousValue = value;
+        }
+        return trends;
+    }
+    /**
+     * Calculate trend direction
+     */
+    getTrendDirection(trends) {
+        if (trends.length < 3) {
+            return 'stable';
+        }
+        const recent = trends.slice(-5);
+        const avgChange = recent.reduce((sum, t) => sum + t.change, 0) / recent.length;
+        if (avgChange > 1)
+            return 'improving';
+        if (avgChange < -1)
+            return 'declining';
+        return 'stable';
+    }
+    /**
+     * Predict future coverage based on trends
+     */
+    predictCoverage(key, type = 'line', targetCoverage) {
+        const trends = this.getTrends(key, type, 20);
+        if (trends.length < 5) {
+            return {
+                predictedReach: null,
+                projectedCoverage: trends[trends.length - 1]?.coverage || 0,
+                confidence: 'low'
+            };
+        }
+        // Simple linear regression
+        const n = trends.length;
+        let sumX = 0;
+        let sumY = 0;
+        let sumXY = 0;
+        let sumXX = 0;
+        for (let i = 0; i < n; i++) {
+            const x = i;
+            const y = trends[i].coverage;
+            sumX += x;
+            sumY += y;
+            sumXY += x * y;
+            sumXX += x * x;
+        }
+        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+        const intercept = (sumY - slope * sumX) / n;
+        const currentCoverage = trends[n - 1].coverage;
+        const avgCoverage = sumY / n;
+        const variance = trends.reduce((sum, t) => sum + Math.pow(t.coverage - avgCoverage, 2), 0) / n;
+        // Determine confidence based on variance
+        let confidence;
+        if (variance < 25)
+            confidence = 'high';
+        else if (variance < 100)
+            confidence = 'medium';
+        else
+            confidence = 'low';
+        // Project coverage for next run
+        const projectedCoverage = currentCoverage + slope;
+        // Predict when target will be reached
+        let predictedReach = null;
+        if (slope > 0.1) {
+            const runsNeeded = (targetCoverage - currentCoverage) / slope;
+            if (runsNeeded > 0 && runsNeeded < 100) {
+                predictedReach = Date.now() + runsNeeded * 24 * 60 * 60 * 1000; // Assume daily runs
+            }
+        }
+        return { predictedReach, projectedCoverage, confidence };
+    }
+    /**
+     * Generate coverage summary text
+     */
+    generateSummary(metrics) {
+        const parts = [];
+        parts.push(`Line Coverage: ${metrics.lineCoverage.toFixed(1)}%`);
+        parts.push(`Branch Coverage: ${metrics.branchCoverage.toFixed(1)}%`);
+        parts.push(`Function Coverage: ${metrics.functionCoverage.toFixed(1)}%`);
+        if (metrics.totalFiles > 0) {
+            parts.push(`Files: ${metrics.filesWithCoverage}/${metrics.totalFiles}`);
+        }
+        return parts.join(' | ');
+    }
+    /**
+     * Format coverage percentage with color indicator
+     */
+    formatCoverage(percentage, threshold = 80) {
+        if (percentage >= threshold) {
+            return `✓ ${percentage.toFixed(1)}%`;
+        }
+        else if (percentage >= threshold - 10) {
+            return `⚠ ${percentage.toFixed(1)}%`;
+        }
+        return `✗ ${percentage.toFixed(1)}%`;
+    }
+    /**
+     * Clear history
+     */
+    clearHistory(key) {
+        if (key) {
+            this.history.delete(key);
+        }
+        else {
+            this.history.clear();
+        }
+    }
+}
+/**
+ * Create a coverage analyzer
+ */
+export function createCoverageAnalyzer() {
+    return new CoverageAnalyzer();
+}