qa360 2.1.7 → 2.2.0

package/dist/core/visual/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * QA360 Visual Regression Module
- *
- * Visual comparison testing for UI changes
- */
-export { VisualRegressionTester, createVisualRegressionTester, runVisualRegressionTests, type VisualRegressionConfig, type VisualRegressionResult, type ScreenshotData, } from './visual-regression.js';

package/dist/core/visual/index.js

@@ -1,6 +0,0 @@
-/**
- * QA360 Visual Regression Module
- *
- * Visual comparison testing for UI changes
- */
-export { VisualRegressionTester, createVisualRegressionTester, runVisualRegressionTests, } from './visual-regression.js';

package/dist/core/visual/visual-regression.d.ts

@@ -1,113 +0,0 @@
-/**
- * QA360 Visual Regression Testing
- *
- * Compares screenshots against baselines to detect visual changes.
- * Uses pixel diffing with configurable thresholds.
- */
-export interface VisualRegressionConfig {
-    /** Directory to store baseline images */
-    baselineDir?: string;
-    /** Directory to store actual images */
-    actualDir?: string;
-    /** Directory to store diff images */
-    diffDir?: string;
-    /** Maximum allowed pixel difference (0-1) */
-    maxDiffThreshold?: number;
-    /** Maximum allowed different pixels (0-1) */
-    maxDifferentPixels?: number;
-    /** Whether to update baselines */
-    updateBaselines?: boolean;
-    /** Whether to ignore anti-aliasing differences */
-    ignoreAntiAliasing?: boolean;
-    /** Color to highlight differences */
-    diffColor?: {
-        r: number;
-        g: number;
-        b: number;
-    };
-}
-export interface VisualRegressionResult {
-    name: string;
-    status: 'pass' | 'fail' | 'updated';
-    diffPixels: number;
-    diffPercentage: number;
-    diffImagePath?: string;
-    baselinePath: string;
-    actualPath: string;
-    error?: string;
-}
-export interface ScreenshotData {
-    width: number;
-    height: number;
-    data: Buffer;
-}
-/**
- * Visual Regression Tester
- *
- * Captures screenshots and compares them against baseline images.
- */
-export declare class VisualRegressionTester {
-    private baselineDir;
-    private actualDir;
-    private diffDir;
-    private maxDiffThreshold;
-    private maxDifferentPixels;
-    private updateBaselines;
-    private ignoreAntiAliasing;
-    private diffColor;
-    constructor(config?: VisualRegressionConfig);
-    private ensureDirectories;
-    /**
-     * Compare a screenshot against baseline
-     */
-    compare(name: string, screenshot: Buffer, width: number, height: number): Promise<VisualRegressionResult>;
-    /**
-     * Compare two image buffers
-     */
-    private compareBuffers;
-    /**
-     * Generate a diff image highlighting differences
-     */
-    private generateDiffImage;
-    /**
-     * Get baseline file path for a test
-     */
-    private getBaselinePath;
-    /**
-     * Get actual file path for a test
-     */
-    private getActualPath;
-    /**
-     * Get diff file path for a test
-     */
-    private getDiffPath;
-    /**
-     * Get hash of a screenshot for deduplication
-     */
-    getScreenshotHash(screenshot: Buffer): string;
-    /**
-     * Clean up old actual screenshots
-     */
-    cleanup(maxAge?: number): void;
-}
-/**
- * Create a visual regression tester
- */
-export declare function createVisualRegressionTester(config?: VisualRegressionConfig): VisualRegressionTester;
-/**
- * Run visual regression tests
- */
-export declare function runVisualRegressionTests(tests: Array<{
-    name: string;
-    screenshot: Buffer;
-    width: number;
-    height: number;
-}>, config?: VisualRegressionConfig): Promise<{
-    results: VisualRegressionResult[];
-    summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        updated: number;
-    };
-}>;

package/dist/core/visual/visual-regression.js

@@ -1,236 +0,0 @@
-/**
- * QA360 Visual Regression Testing
- *
- * Compares screenshots against baselines to detect visual changes.
- * Uses pixel diffing with configurable thresholds.
- */
-import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { createHash } from 'crypto';
-/**
- * Visual Regression Tester
- *
- * Captures screenshots and compares them against baseline images.
- */
-export class VisualRegressionTester {
-    baselineDir;
-    actualDir;
-    diffDir;
-    maxDiffThreshold;
-    maxDifferentPixels;
-    updateBaselines;
-    ignoreAntiAliasing;
-    diffColor;
-    constructor(config = {}) {
-        this.baselineDir = config.baselineDir || '.qa360/visual/baselines';
-        this.actualDir = config.actualDir || '.qa360/visual/actual';
-        this.diffDir = config.diffDir || '.qa360/visual/diffs';
-        this.maxDiffThreshold = config.maxDiffThreshold ?? 0.01; // 1% max diff per pixel
-        this.maxDifferentPixels = config.maxDifferentPixels ?? 0.001; // 0.1% of pixels can differ
-        this.updateBaselines = config.updateBaselines ?? false;
-        this.ignoreAntiAliasing = config.ignoreAntiAliasing ?? true;
-        this.diffColor = config.diffColor || { r: 255, g: 0, b: 0 }; // Red
-        this.ensureDirectories();
-    }
-    ensureDirectories() {
-        for (const dir of [this.baselineDir, this.actualDir, this.diffDir]) {
-            if (!existsSync(dir)) {
-                mkdirSync(dir, { recursive: true });
-            }
-        }
-    }
-    /**
-     * Compare a screenshot against baseline
-     */
-    async compare(name, screenshot, width, height) {
-        const baselinePath = this.getBaselinePath(name);
-        const actualPath = this.getActualPath(name);
-        // Save actual screenshot
-        writeFileSync(actualPath, screenshot);
-        // Check if baseline exists
-        if (!existsSync(baselinePath)) {
-            if (this.updateBaselines) {
-                writeFileSync(baselinePath, screenshot);
-                return {
-                    name,
-                    status: 'updated',
-                    diffPixels: 0,
-                    diffPercentage: 0,
-                    baselinePath,
-                    actualPath,
-                };
-            }
-            return {
-                name,
-                status: 'fail',
-                diffPixels: -1,
-                diffPercentage: 100,
-                baselinePath,
-                actualPath,
-                error: 'No baseline found. Run with --update-baselines to create one.',
-            };
-        }
-        // Load baseline
-        const baseline = readFileSync(baselinePath);
-        // Compare images
-        const diff = this.compareBuffers(baseline, screenshot, width, height);
-        // Determine if test passes
-        const pixelDiffRatio = diff.diffPixels / (width * height);
-        const passes = pixelDiffRatio <= this.maxDifferentPixels &&
-            diff.maxDiffValue <= this.maxDiffThreshold;
-        // Generate diff image if failed
-        let diffImagePath;
-        if (!passes || this.updateBaselines) {
-            diffImagePath = this.getDiffPath(name);
-            this.generateDiffImage(baseline, screenshot, width, height, diff.diffBuffer, diffImagePath);
-        }
-        // Update baseline if requested
-        if (this.updateBaselines && !passes) {
-            writeFileSync(baselinePath, screenshot);
-            return {
-                name,
-                status: 'updated',
-                diffPixels: diff.diffPixels,
-                diffPercentage: (diff.diffPixels / (width * height)) * 100,
-                diffImagePath,
-                baselinePath,
-                actualPath,
-            };
-        }
-        return {
-            name,
-            status: passes ? 'pass' : 'fail',
-            diffPixels: diff.diffPixels,
-            diffPercentage: (diff.diffPixels / (width * height)) * 100,
-            diffImagePath,
-            baselinePath,
-            actualPath,
-        };
-    }
-    /**
-     * Compare two image buffers
-     */
-    compareBuffers(baseline, actual, width, height) {
-        // Assume PNG format (simplified - would use PNG decoder in production)
-        // For now, just compare raw buffer sizes as a simple check
-        if (baseline.length !== actual.length) {
-            return {
-                diffPixels: width * height,
-                maxDiffValue: 1,
-                diffBuffer: Buffer.alloc(width * height * 4),
-            };
-        }
-        const baselineData = new Uint8ClampedArray(baseline);
-        const actualData = new Uint8ClampedArray(actual);
-        const diffBuffer = new Uint8ClampedArray(baseline.length);
-        let diffPixels = 0;
-        let maxDiffValue = 0;
-        // Compare pixel by pixel (assuming RGBA)
-        for (let i = 0; i < baselineData.length; i += 4) {
-            const r1 = baselineData[i];
-            const g1 = baselineData[i + 1];
-            const b1 = baselineData[i + 2];
-            const a1 = baselineData[i + 3];
-            const r2 = actualData[i];
-            const g2 = actualData[i + 1];
-            const b2 = actualData[i + 2];
-            const a2 = actualData[i + 3];
-            // Calculate color difference
-            const diffR = Math.abs(r1 - r2);
-            const diffG = Math.abs(g1 - g2);
-            const diffB = Math.abs(b1 - b2);
-            const diffA = Math.abs(a1 - a2);
-            // Overall difference (normalized 0-1)
-            const diffValue = Math.max(diffR, diffG, diffB, diffA) / 255;
-            maxDiffValue = Math.max(maxDiffValue, diffValue);
-            // Check if pixel differs significantly
-            const isDifferent = diffValue > (this.ignoreAntiAliasing ? 0.05 : 0);
-            if (isDifferent) {
-                diffPixels++;
-                // Store diff color in diff buffer
-                diffBuffer[i] = this.diffColor.r;
-                diffBuffer[i + 1] = this.diffColor.g;
-                diffBuffer[i + 2] = this.diffColor.b;
-                diffBuffer[i + 3] = 255;
-            }
-            else {
-                // Store original pixel
-                diffBuffer[i] = r2;
-                diffBuffer[i + 1] = g2;
-                diffBuffer[i + 2] = b2;
-                diffBuffer[i + 3] = a2;
-            }
-        }
-        return {
-            diffPixels,
-            maxDiffValue,
-            diffBuffer: Buffer.from(diffBuffer),
-        };
-    }
-    /**
-     * Generate a diff image highlighting differences
-     */
-    generateDiffImage(baseline, actual, width, height, diffBuffer, outputPath) {
-        // In production, this would create a proper PNG
-        // For now, just save the diff buffer
-        writeFileSync(outputPath, diffBuffer);
-    }
-    /**
-     * Get baseline file path for a test
-     */
-    getBaselinePath(name) {
-        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
-        return join(this.baselineDir, `${hash}.png`);
-    }
-    /**
-     * Get actual file path for a test
-     */
-    getActualPath(name) {
-        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
-        return join(this.actualDir, `${hash}.png`);
-    }
-    /**
-     * Get diff file path for a test
-     */
-    getDiffPath(name) {
-        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
-        return join(this.diffDir, `${hash}.png`);
-    }
-    /**
-     * Get hash of a screenshot for deduplication
-     */
-    getScreenshotHash(screenshot) {
-        return createHash('sha256').update(screenshot).digest('hex');
-    }
-    /**
-     * Clean up old actual screenshots
-     */
-    cleanup(maxAge = 24 * 60 * 60 * 1000) {
-        const now = Date.now();
-        // Implementation would clean up old files
-    }
-}
-/**
- * Create a visual regression tester
- */
-export function createVisualRegressionTester(config) {
-    return new VisualRegressionTester(config);
-}
-/**
- * Run visual regression tests
- */
-export async function runVisualRegressionTests(tests, config) {
-    const tester = new VisualRegressionTester(config);
-    const results = [];
-    for (const test of tests) {
-        const result = await tester.compare(test.name, test.screenshot, test.width, test.height);
-        results.push(result);
-    }
-    const summary = {
-        total: results.length,
-        passed: results.filter((r) => r.status === 'pass').length,
-        failed: results.filter((r) => r.status === 'fail').length,
-        updated: results.filter((r) => r.status === 'updated').length,
-    };
-    return { results, summary };
-}

package/dist/core/watch/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * QA360 Watch Module
- *
- * Continuous testing and benchmarking capabilities.
- */
-export { WatchMode, createWatchMode } from './watch-mode.js';
-export type { WatchModeOptions, WatchRunResult, WatchStats, BenchmarkConfig, BenchmarkResult } from './watch-mode.js';

package/dist/core/watch/index.js

@@ -1,6 +0,0 @@
-/**
- * QA360 Watch Module
- *
- * Continuous testing and benchmarking capabilities.
- */
-export { WatchMode, createWatchMode } from './watch-mode.js';

package/dist/core/watch/watch-mode.d.ts

@@ -1,213 +0,0 @@
-/**
- * QA360 Watch Mode
- *
- * Continuous testing mode that monitors file changes and re-runs tests.
- * Features:
- * - File watching with debounce
- * - Smart test selection based on changed files
- * - Benchmark mode for performance comparison
- * - Statistics aggregation across runs
- *
- * @example
- * ```typescript
- * const watcher = new WatchMode({
- *   workingDir: process.cwd(),
- *   debounceMs: 300,
- *   onRunStart: () => console.log('Running tests...'),
- *   onRunComplete: (result) => console.log('Done:', result)
- * });
- *
- * await watcher.start();
- * ```
- */
-import { type Phase3RunResult } from '../runner/phase3-runner.js';
-/**
- * Watch mode configuration options
- */
-export interface WatchModeOptions {
-    /** Working directory for tests */
-    workingDir: string;
-    /** Path to pack.yml file */
-    packPath?: string;
-    /** Debounce delay in milliseconds (default: 300) */
-    debounceMs?: number;
-    /** Patterns to ignore (default: node_modules, .git, dist) */
-    ignore?: string[];
-    /** Whether to run initial test on start (default: true) */
-    runOnStart?: boolean;
-    /** Whether to clear screen between runs (default: true) */
-    clearScreen?: boolean;
-    /** Callback when a run starts */
-    onRunStart?: (runNumber: number) => void;
-    /** Callback when a run completes */
-    onRunComplete?: (result: WatchRunResult) => void;
-    /** Callback when a file changes */
-    onFileChange?: (path: string) => void;
-    /** Callback on error */
-    onError?: (error: Error) => void;
-}
-/**
- * Result of a single watch run
- */
-export interface WatchRunResult {
-    /** Run number (incrementing) */
-    runNumber: number;
-    /** Timestamp when run started */
-    startedAt: Date;
-    /** Timestamp when run completed */
-    completedAt: Date;
-    /** Duration in milliseconds */
-    duration: number;
-    /** Phase3Runner result */
-    result: Phase3RunResult;
-    /** Files that triggered this run */
-    changedFiles: string[];
-    /** Whether this run was successful */
-    success: boolean;
-}
-/**
- * Aggregated statistics across watch runs
- */
-export interface WatchStats {
-    /** Total number of runs */
-    totalRuns: number;
-    /** Number of successful runs */
-    successfulRuns: number;
-    /** Number of failed runs */
-    failedRuns: number;
-    /** Average duration in milliseconds */
-    avgDuration: number;
-    /** Fastest run duration */
-    fastestRun: number;
-    /** Slowest run duration */
-    slowestRun: number;
-    /** Total duration of all runs */
-    totalDuration: number;
-    /** Trust score average */
-    avgTrustScore: number;
-    /** Total tests executed */
-    totalTests: number;
-    /** Total passed tests */
-    totalPassed: number;
-    /** Total failed tests */
-    totalFailed: number;
-}
-/**
- * Benchmark configuration
- */
-export interface BenchmarkConfig {
-    /** Number of iterations to run */
-    iterations: number;
-    /** Warm-up iterations (not counted in stats) */
-    warmupIterations: number;
-    /** Whether to run with cache enabled */
-    withCache: boolean;
-    /** Whether to run in parallel */
-    parallel?: boolean;
-}
-/**
- * Benchmark result
- */
-export interface BenchmarkResult {
-    /** Average duration across iterations */
-    avgDuration: number;
-    /** Minimum duration */
-    minDuration: number;
-    /** Maximum duration */
-    maxDuration: number;
-    /** Standard deviation */
-    stdDev: number;
-    /** Median duration */
-    median: number;
-    /** P95 duration */
-    p95: number;
-    /** P99 duration */
-    p99: number;
-    /** Number of successful runs */
-    successfulRuns: number;
-    /** Total iterations */
-    totalIterations: number;
-    /** Throughput (runs per second) */
-    throughput: number;
-}
-/**
- * Watch Mode Manager
- *
- * Monitors file changes and runs tests automatically.
- */
-export declare class WatchMode {
-    private options;
-    private watchers;
-    private runNumber;
-    private isRunning;
-    private debounceTimer?;
-    private pendingChanges;
-    private runResults;
-    private stats;
-    private packConfig?;
-    constructor(options: WatchModeOptions);
-    /**
-     * Start watching files and running tests
-     */
-    start(): Promise<void>;
-    /**
-     * Stop watching files
-     */
-    stop(): Promise<void>;
-    /**
-     * Get current statistics
-     */
-    getStats(): WatchStats;
-    /**
-     * Get run history
-     */
-    getRunHistory(): WatchRunResult[];
-    /**
-     * Run benchmark tests
-     */
-    benchmark(config: BenchmarkConfig): Promise<BenchmarkResult>;
-    /**
-     * Load pack configuration
-     */
-    private loadPackConfig;
-    /**
-     * Setup file watcher using native Node.js fs.watch
-     */
-    private setupWatcher;
-    /**
-     * Check if a path should be ignored
-     */
-    private shouldIgnore;
-    /**
-     * Handle file change with debouncing
-     */
-    private handleFileChange;
-    /**
-     * Run tests and update statistics
-     */
-    private runTests;
-    /**
-     * Update aggregated statistics
-     */
-    private updateStats;
-    /**
-     * Calculate benchmark statistics
-     */
-    private calculateBenchmarkStats;
-    /**
-     * Log formatted run result
-     */
-    private logRunResult;
-    /**
-     * Format statistics for display
-     */
-    private formatStats;
-    /**
-     * Log message
-     */
-    private log;
-}
-/**
- * Factory function to create a watch mode instance
- */
-export declare function createWatchMode(options: WatchModeOptions): WatchMode;