qa360 2.1.2 → 2.1.4

package/dist/core/dashboard/server.d.ts

@@ -1,72 +0,0 @@
-/**
- * Dashboard Server - HTTP-based real-time dashboard
- * Serves HTML dashboard with Server-Sent Events for updates
- */
-import type { DashboardConfig, DashboardState, DashboardEvent } from './types.js';
-import type { EvidenceVault } from '../vault/index.js';
-export declare class DashboardServer {
-    private config;
-    private server?;
-    private clients;
-    private state;
-    private eventHistory;
-    private vault?;
-    private currentRunId?;
-    constructor(config: DashboardConfig);
-    /**
-     * Set the vault for flakiness data access
-     */
-    setVault(vault: EvidenceVault): void;
-    /**
-     * Set the current run ID for flakiness tracking
-     */
-    setRunId(runId: string): void;
-    /**
-     * Update flakiness data from vault
-     */
-    updateFlakinessData(): Promise<void>;
-    /**
-     * Start the dashboard server
-     */
-    start(): Promise<string>;
-    /**
-     * Stop the dashboard server
-     */
-    stop(): Promise<void>;
-    /**
-     * Emit an event (called during test execution)
-     */
-    emit(event: DashboardEvent): Promise<void>;
-    /**
-     * Set gates for the run
-     */
-    setGates(gateNames: string[]): void;
-    /**
-     * Update a specific gate's state
-     */
-    private updateGate;
-    /**
-     * Update overall progress
-     */
-    private updateProgress;
-    /**
-     * Broadcast state to all connected clients
-     */
-    private broadcast;
-    /**
-     * Handle HTTP requests
-     */
-    private handleRequest;
-    /**
-     * Open browser automatically
-     */
-    private openBrowser;
-    /**
-     * Get current state
-     */
-    getState(): Readonly<DashboardState>;
-    /**
-     * Get event history
-     */
-    getEvents(): ReadonlyArray<DashboardEvent>;
-}

package/dist/core/dashboard/server.js

@@ -1,354 +0,0 @@
-/**
- * Dashboard Server - HTTP-based real-time dashboard
- * Serves HTML dashboard with Server-Sent Events for updates
- */
-import { createServer } from 'http';
-import { URL } from 'url';
-import { DASHBOARD_HTML } from './assets.js';
-export class DashboardServer {
-    config;
-    server;
-    clients = new Map();
-    state;
-    eventHistory = [];
-    vault;
-    currentRunId;
-    constructor(config) {
-        this.config = config;
-        this.state = {
-            status: 'idle',
-            currentPhase: 'Ready',
-            progress: 0,
-            gates: [],
-            startTime: Date.now(),
-            elapsed: 0
-        };
-    }
-    /**
-     * Set the vault for flakiness data access
-     */
-    setVault(vault) {
-        this.vault = vault;
-    }
-    /**
-     * Set the current run ID for flakiness tracking
-     */
-    setRunId(runId) {
-        this.currentRunId = runId;
-    }
-    /**
-     * Update flakiness data from vault
-     */
-    async updateFlakinessData() {
-        if (!this.vault || !this.currentRunId) {
-            return;
-        }
-        try {
-            const flakinessRecords = await this.vault.getRunFlakiness(this.currentRunId);
-            if (flakinessRecords.length === 0) {
-                this.state.flakiness = {
-                    enabled: false,
-                    averageScore: 0,
-                    totalTests: 0,
-                    distribution: {
-                        legendary: 0,
-                        solid: 0,
-                        good: 0,
-                        shaky: 0,
-                        unstable: 0
-                    },
-                    quarantined: [],
-                    recentPatterns: []
-                };
-                return;
-            }
-            // Calculate distribution
-            const distribution = {
-                legendary: 0,
-                solid: 0,
-                good: 0,
-                shaky: 0,
-                unstable: 0
-            };
-            let totalScore = 0;
-            for (const record of flakinessRecords) {
-                totalScore += record.score;
-                distribution[record.category]++;
-            }
-            // Get quarantined tests
-            const quarantinedRecords = await this.vault.getQuarantinedTests(false);
-            const quarantined = quarantinedRecords.map(q => ({
-                testId: q.test_id,
-                testName: q.test_name,
-                gate: q.gate,
-                score: q.score,
-                category: q.category,
-                reason: q.reason,
-                quarantinedAt: q.quarantined_at,
-                resolved: !!q.resolved_at
-            }));
-            // Get recent patterns (from all tests in this run)
-            const patterns = [];
-            const patternTypes = ['timing', 'race_condition', 'external_dependency', 'environment_specific', 'selector_issue', 'unknown'];
-            for (const record of flakinessRecords) {
-                for (const patternType of patternTypes) {
-                    const pattern = await this.vault.getFlakinessPattern(record.test_id, patternType);
-                    if (pattern && pattern.detection_count > 0) {
-                        patterns.push({
-                            testId: record.test_id,
-                            testName: record.test_name,
-                            patternType: pattern.pattern_type,
-                            description: pattern.description,
-                            suggestedFix: pattern.suggested_fix,
-                            confidence: pattern.confidence,
-                            detectionCount: pattern.detection_count
-                        });
-                    }
-                }
-            }
-            // Sort by detection count and limit to 10
-            patterns.sort((a, b) => b.detectionCount - a.detectionCount);
-            const recentPatterns = patterns.slice(0, 10);
-            this.state.flakiness = {
-                enabled: true,
-                averageScore: totalScore / flakinessRecords.length,
-                totalTests: flakinessRecords.length,
-                distribution,
-                quarantined,
-                recentPatterns
-            };
-        }
-        catch (error) {
-            console.error('Failed to load flakiness data:', error);
-        }
-    }
-    /**
-     * Start the dashboard server
-     */
-    async start() {
-        const port = this.config.port;
-        const host = this.config.host || '127.0.0.1';
-        await new Promise((resolve, reject) => {
-            // Create HTTP server
-            const srv = createServer(this.handleRequest.bind(this));
-            srv.on('error', (err) => {
-                if (err?.code === 'EADDRINUSE') {
-                    reject(new Error(`Port ${port} already in use`));
-                }
-                else {
-                    reject(err);
-                }
-            });
-            srv.listen(port, host, () => {
-                this.server = srv;
-                const url = `http://${host}:${port}`;
-                console.log(`\n  Dashboard running at ${url}`);
-                resolve();
-            });
-        });
-        // Auto-open browser if requested
-        if (this.config.autoOpen) {
-            await this.openBrowser();
-        }
-        return `http://${host}:${port}`;
-    }
-    /**
-     * Stop the dashboard server
-     */
-    async stop() {
-        return new Promise((resolve) => {
-            // Close all SSE connections
-            this.clients.forEach((close, res) => {
-                try {
-                    res.end();
-                }
-                catch {
-                    // Ignore
-                }
-            });
-            this.clients.clear();
-            // Close HTTP server
-            if (this.server) {
-                this.server.close(() => resolve());
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-    /**
-     * Emit an event (called during test execution)
-     */
-    async emit(event) {
-        this.eventHistory.push(event);
-        switch (event.type) {
-            case 'start':
-                this.state.status = 'running';
-                this.state.startTime = event.timestamp;
-                this.state.currentPhase = String(event.data.phase || 'Running');
-                break;
-            case 'gate_start':
-                this.state.currentGate = String(event.data.gate);
-                this.updateGate(String(event.data.gate), { status: 'running' });
-                break;
-            case 'gate_end':
-                const results = event.data.results;
-                this.updateGate(String(event.data.gate), {
-                    status: Boolean(event.data.success) ? 'passed' : 'failed',
-                    duration: Number(event.data.duration),
-                    testsTotal: results?.total,
-                    testsPassed: results?.passed,
-                    testsFailed: results?.failed
-                });
-                this.state.currentGate = undefined;
-                this.updateProgress();
-                break;
-            case 'test_progress':
-                this.updateGate(String(event.data.gate), {
-                    testsTotal: Number(event.data.total),
-                    testsPassed: Number(event.data.completed)
-                });
-                break;
-            case 'complete':
-                this.state.status = 'completed';
-                this.state.progress = 100;
-                // Load flakiness data when run completes
-                await this.updateFlakinessData();
-                break;
-            case 'error':
-                this.state.status = 'failed';
-                break;
-            case 'flakiness_update':
-                await this.updateFlakinessData();
-                break;
-        }
-        this.state.elapsed = Date.now() - this.state.startTime;
-        this.broadcast();
-    }
-    /**
-     * Set gates for the run
-     */
-    setGates(gateNames) {
-        this.state.gates = gateNames.map(name => ({
-            name,
-            status: 'pending'
-        }));
-        this.broadcast();
-    }
-    /**
-     * Update a specific gate's state
-     */
-    updateGate(name, updates) {
-        const gate = this.state.gates.find(g => g.name === name);
-        if (gate) {
-            Object.assign(gate, updates);
-        }
-    }
-    /**
-     * Update overall progress
-     */
-    updateProgress() {
-        const total = this.state.gates.length;
-        const completed = this.state.gates.filter(g => g.status === 'passed' || g.status === 'failed' || g.status === 'skipped').length;
-        this.state.progress = total > 0 ? (completed / total) * 100 : 0;
-    }
-    /**
-     * Broadcast state to all connected clients
-     */
-    broadcast() {
-        const data = `data: ${JSON.stringify(this.state)}\n\n`;
-        this.clients.forEach((close, res) => {
-            try {
-                res.write(data);
-            }
-            catch {
-                // Client disconnected, will be cleaned up
-            }
-        });
-    }
-    /**
-     * Handle HTTP requests
-     */
-    async handleRequest(req, res) {
-        const url = new URL(req.url || '/', `http://${req.headers.host}`);
-        const path = url.pathname;
-        try {
-            if (path === '/' || path === '/dashboard') {
-                // Serve HTML dashboard
-                res.setHeader('Content-Type', 'text/html');
-                res.end(DASHBOARD_HTML);
-            }
-            else if (path === '/events') {
-                // SSE endpoint for real-time updates
-                res.setHeader('Content-Type', 'text/event-stream');
-                res.setHeader('Cache-Control', 'no-cache');
-                res.setHeader('Connection', 'keep-alive');
-                res.flushHeaders();
-                // Send initial state
-                res.write(`data: ${JSON.stringify(this.state)}\n\n`);
-                // Keep connection open
-                this.clients.set(res, () => {
-                    try {
-                        res.end();
-                    }
-                    catch {
-                        // Ignore
-                    }
-                });
-                req.on('close', () => {
-                    this.clients.delete(res);
-                });
-            }
-            else if (path === '/api/state') {
-                // API endpoint for current state
-                res.setHeader('Content-Type', 'application/json');
-                res.end(JSON.stringify(this.state, null, 2));
-            }
-            else if (path === '/api/events') {
-                // API endpoint for event history
-                res.setHeader('Content-Type', 'application/json');
-                res.end(JSON.stringify(this.eventHistory, null, 2));
-            }
-            else if (path === '/health') {
-                // Health check
-                res.setHeader('Content-Type', 'application/json');
-                res.end(JSON.stringify({ status: 'ok', service: 'qa360-dashboard' }));
-            }
-            else {
-                res.writeHead(404);
-                res.end('Not Found');
-            }
-        }
-        catch (error) {
-            console.error('Dashboard request error:', error);
-            res.writeHead(500);
-            res.end('Internal Server Error');
-        }
-    }
-    /**
-     * Open browser automatically
-     */
-    async openBrowser() {
-        const { exec } = await import('child_process');
-        const url = `http://${this.config.host || '127.0.0.1'}:${this.config.port}`;
-        const command = process.platform === 'darwin' ? 'open' :
-            process.platform === 'win32' ? 'start' : 'xdg-open';
-        exec(`${command} ${url}`, (err) => {
-            if (err) {
-                console.warn(`Could not open browser: ${err.message}`);
-            }
-        });
-    }
-    /**
-     * Get current state
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * Get event history
-     */
-    getEvents() {
-        return this.eventHistory;
-    }
-}

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

@@ -1,70 +0,0 @@
-/**
- * QA360 Dashboard Module
- * Phase 8: Web Dashboard for test execution visualization
- */
-export interface DashboardConfig {
-    port: number;
-    host?: string;
-    autoOpen?: boolean;
-    refreshRate?: number;
-}
-export interface DashboardState {
-    status: 'idle' | 'running' | 'completed' | 'failed';
-    currentPhase: string;
-    progress: number;
-    currentGate?: string;
-    gates: DashboardGateState[];
-    startTime: number;
-    elapsed: number;
-    eta?: number;
-    flakiness?: DashboardFlakinessState;
-}
-export interface DashboardFlakinessState {
-    enabled: boolean;
-    averageScore: number;
-    totalTests: number;
-    distribution: FlakinessDistribution;
-    quarantined: DashboardQuarantineItem[];
-    recentPatterns: DashboardPatternItem[];
-}
-export interface FlakinessDistribution {
-    legendary: number;
-    solid: number;
-    good: number;
-    shaky: number;
-    unstable: number;
-}
-export interface DashboardQuarantineItem {
-    testId: string;
-    testName: string;
-    gate: string;
-    score: number;
-    category: string;
-    reason: string;
-    quarantinedAt: number;
-    resolved: boolean;
-}
-export interface DashboardPatternItem {
-    testId: string;
-    testName: string;
-    patternType: string;
-    description: string;
-    suggestedFix: string;
-    confidence: number;
-    detectionCount: number;
-}
-export interface DashboardGateState {
-    name: string;
-    status: 'pending' | 'running' | 'passed' | 'failed' | 'skipped';
-    duration?: number;
-    testsTotal?: number;
-    testsPassed?: number;
-    testsFailed?: number;
-    output?: string[];
-    error?: string;
-}
-export interface DashboardEvent {
-    type: 'start' | 'gate_start' | 'gate_end' | 'test_progress' | 'complete' | 'error' | 'flakiness_update';
-    timestamp: number;
-    data: Record<string, unknown>;
-}

package/dist/core/dashboard/types.js

@@ -1,5 +0,0 @@
-/**
- * QA360 Dashboard Module
- * Phase 8: Web Dashboard for test execution visualization
- */
-export {};

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

@@ -1,115 +0,0 @@
-/**
- * QA360 Test Discoverer
- *
- * Automatically discovers and categorizes test files in a project.
- * Supports Playwright, K6, Cypress, and other test frameworks.
- */
-/**
- * Detected test information
- */
-export interface TestFile {
-    path: string;
-    type: TestType;
-    framework: TestFramework;
-    relativePath: string;
-}
-/**
- * Discovered tests in a project
- */
-export interface DiscoveredTests {
-    playwright: TestFile[];
-    k6: TestFile[];
-    cypress: TestFile[];
-    jest: TestFile[];
-    vitest: TestFile[];
-    other: TestFile[];
-}
-/**
- * Test type categories
- */
-export type TestType = 'api' | 'ui' | 'e2e' | 'perf' | 'load' | 'security' | 'sast' | 'dast' | 'a11y' | 'unit' | 'integration';
-/**
- * Supported test frameworks
- */
-export type TestFramework = 'playwright' | 'k6' | 'cypress' | 'jest' | 'vitest' | 'mocha' | 'jasmine' | 'unknown';
-/**
- * Test discovery options
- */
-export interface DiscoverOptions {
-    rootDir?: string;
-    patterns?: string[];
-    excludePatterns?: string[];
-}
-/**
- * Result of routing a test to an adapter
- */
-export interface AdapterRouting {
-    adapter: string;
-    config?: Record<string, unknown>;
-}
-/**
- * Test Discoverer
- *
- * Scans a project directory for test files and categorizes them
- * by framework and type.
- */
-export declare class TestDiscoverer {
-    private readonly rootDir;
-    private readonly defaultPatterns;
-    private readonly DEFAULT_PATTERNS;
-    private readonly DEFAULT_EXCLUDES;
-    constructor(options?: DiscoverOptions);
-    /**
-     * Discover all test files in the project
-     */
-    discover(): Promise<DiscoveredTests>;
-    /**
-     * Find all test files using glob patterns
-     */
-    private findTestFiles;
-    /**
-     * Categorize a file into a test category
-     */
-    private categorizeFile;
-    /**
-     * Detect the test framework from file path and content
-     */
-    detectFramework(filePath: string): TestFramework;
-    /**
-     * Detect the type of test (api, ui, perf, etc.)
-     */
-    detectType(filePath: string): TestType;
-    /**
-     * Route a test file to the appropriate QA360 adapter
-     */
-    routeToAdapter(test: TestFile): AdapterRouting;
-    /**
-     * Discover tests for a specific gate
-     */
-    discoverForGate(gate: string): Promise<TestFile[]>;
-    /**
-     * Get summary statistics of discovered tests
-     */
-    getSummary(): Promise<TestSummary>;
-    private countAll;
-    private countByType;
-}
-/**
- * Test summary statistics
- */
-export interface TestSummary {
-    total: number;
-    byFramework: {
-        playwright: number;
-        k6: number;
-        cypress: number;
-        jest: number;
-        vitest: number;
-        other: number;
-    };
-    byType: Record<string, number>;
-}
-/**
- * Create a test discoverer
- */
-export declare function createTestDiscoverer(options?: DiscoverOptions): TestDiscoverer;