qa360 2.1.0 → 2.1.1

package/dist/core/core/coverage/vault.js

@@ -0,0 +1,405 @@
+/**
+ * Coverage Vault Integration
+ *
+ * Integrates coverage data storage and retrieval with the Evidence Vault.
+ */
+import { promisify } from 'util';
+/**
+ * Coverage Vault class
+ */
+export class CoverageVault {
+    db;
+    dbRun;
+    dbAll;
+    dbGet;
+    constructor(db) {
+        this.db = db;
+        this.dbRun = promisify(db.run.bind(db));
+        this.dbAll = promisify(db.all.bind(db));
+        this.dbGet = promisify(db.get.bind(db));
+    }
+    /**
+     * Initialize coverage tables
+     */
+    async initialize() {
+        const schema = `
+      -- Coverage metrics table
+      CREATE TABLE IF NOT EXISTS coverage_metrics (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          gate TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          total_lines INTEGER DEFAULT 0,
+          covered_lines INTEGER DEFAULT 0,
+          branch_coverage REAL DEFAULT 0,
+          function_coverage REAL DEFAULT 0,
+          line_coverage REAL DEFAULT 0,
+          statement_coverage REAL DEFAULT 0,
+          total_branches INTEGER DEFAULT 0,
+          covered_branches INTEGER DEFAULT 0,
+          total_functions INTEGER DEFAULT 0,
+          covered_functions INTEGER DEFAULT 0,
+          total_statements INTEGER DEFAULT 0,
+          covered_statements INTEGER DEFAULT 0,
+          uncovered_lines TEXT,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_run_id ON coverage_metrics(run_id);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_gate ON coverage_metrics(gate);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_file_path ON coverage_metrics(file_path);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_run_gate ON coverage_metrics(run_id, gate);
+
+      -- Coverage trends table
+      CREATE TABLE IF NOT EXISTS coverage_trends (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          test_id TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          coverage_type TEXT NOT NULL,
+          coverage_value REAL NOT NULL,
+          date INTEGER NOT NULL,
+          commit TEXT,
+          branch TEXT,
+          UNIQUE(test_id, file_path, coverage_type, date)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_test_id ON coverage_trends(test_id);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_file_path ON coverage_trends(file_path);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_date ON coverage_trends(date);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_type ON coverage_trends(coverage_type);
+
+      -- Coverage summary table (aggregate metrics per run)
+      CREATE TABLE IF NOT EXISTS coverage_summary (
+          run_id TEXT PRIMARY KEY REFERENCES runs(id) ON DELETE CASCADE,
+          line_coverage REAL NOT NULL DEFAULT 0,
+          branch_coverage REAL NOT NULL DEFAULT 0,
+          function_coverage REAL NOT NULL DEFAULT 0,
+          statement_coverage REAL NOT NULL DEFAULT 0,
+          total_files INTEGER DEFAULT 0,
+          files_meeting_threshold INTEGER DEFAULT 0,
+          total_lines INTEGER DEFAULT 0,
+          covered_lines INTEGER DEFAULT 0,
+          thresholds_met INTEGER DEFAULT 1,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_summary_created_at ON coverage_summary(created_at);
+    `;
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+        for (const statement of statements) {
+            await this.dbRun(statement, []);
+        }
+    }
+    /**
+     * Store coverage result for a run
+     */
+    async storeCoverage(runId, result) {
+        // Store per-file metrics
+        for (const [filePath, fileCoverage] of Object.entries(result.files)) {
+            const record = {
+                run_id: runId,
+                gate: result.gate,
+                file_path: filePath,
+                total_lines: fileCoverage.totalLines,
+                covered_lines: fileCoverage.coveredLines,
+                branch_coverage: fileCoverage.branchCoverage,
+                function_coverage: fileCoverage.functionCoverage,
+                line_coverage: fileCoverage.lineCoverage,
+                statement_coverage: fileCoverage.statementCoverage,
+                total_branches: fileCoverage.totalBranches,
+                covered_branches: fileCoverage.coveredBranches,
+                total_functions: fileCoverage.totalFunctions,
+                covered_functions: fileCoverage.coveredFunctions,
+                total_statements: fileCoverage.totalStatements,
+                covered_statements: fileCoverage.coveredStatements,
+                uncovered_lines: JSON.stringify(fileCoverage.uncoveredLines),
+                created_at: Date.now()
+            };
+            await this.dbRun(`INSERT INTO coverage_metrics (
+          run_id, gate, file_path, total_lines, covered_lines,
+          branch_coverage, function_coverage, line_coverage, statement_coverage,
+          total_branches, covered_branches, total_functions, covered_functions,
+          total_statements, covered_statements, uncovered_lines, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                record.run_id, record.gate, record.file_path, record.total_lines, record.covered_lines,
+                record.branch_coverage, record.function_coverage, record.line_coverage, record.statement_coverage,
+                record.total_branches, record.covered_branches, record.total_functions, record.covered_functions,
+                record.total_statements, record.covered_statements, record.uncovered_lines, record.created_at
+            ]);
+        }
+        // Store aggregate summary
+        await this.storeSummary(runId, result.metrics);
+    }
+    /**
+     * Store coverage summary for a run
+     */
+    async storeSummary(runId, metrics) {
+        await this.dbRun(`INSERT OR REPLACE INTO coverage_summary (
+        run_id, line_coverage, branch_coverage, function_coverage, statement_coverage,
+        total_files, files_meeting_threshold, total_lines, covered_lines, thresholds_met, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            runId,
+            metrics.lineCoverage,
+            metrics.branchCoverage,
+            metrics.functionCoverage,
+            metrics.statementCoverage,
+            metrics.totalFiles,
+            metrics.filesMeetingThreshold,
+            metrics.totalLines,
+            metrics.coveredLines,
+            1, // thresholds_met placeholder
+            Date.now()
+        ]);
+    }
+    /**
+     * Retrieve coverage for a run
+     */
+    async getCoverage(runId) {
+        const rows = await this.dbAll(`SELECT * FROM coverage_metrics WHERE run_id = ?`, [runId]);
+        if (rows.length === 0) {
+            return null;
+        }
+        const files = {};
+        let gate = 'unknown';
+        for (const row of rows) {
+            gate = row.gate;
+            files[row.file_path] = {
+                path: row.file_path,
+                totalLines: row.total_lines,
+                coveredLines: row.covered_lines,
+                lineCoverage: row.line_coverage,
+                totalBranches: row.total_branches,
+                coveredBranches: row.covered_branches,
+                branchCoverage: row.branch_coverage,
+                totalFunctions: row.total_functions,
+                coveredFunctions: row.covered_functions,
+                functionCoverage: row.function_coverage,
+                totalStatements: row.total_statements,
+                coveredStatements: row.covered_statements,
+                statementCoverage: row.statement_coverage,
+                uncoveredLines: JSON.parse(row.uncovered_lines || '[]'),
+                partiallyCoveredLines: [],
+                branchesByLine: {}
+            };
+        }
+        // Get summary
+        const summary = await this.getSummary(runId);
+        const metrics = summary || {
+            lineCoverage: 0,
+            branchCoverage: 0,
+            functionCoverage: 0,
+            statementCoverage: 0,
+            totalFiles: Object.keys(files).length,
+            filesWithCoverage: Object.keys(files).length,
+            filesMeetingThreshold: 0,
+            totalLines: 0,
+            coveredLines: 0,
+            timestamp: Date.now()
+        };
+        return {
+            source: 'custom',
+            gate,
+            files,
+            metrics,
+            format: 'json',
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Get coverage summary for a run
+     */
+    async getSummary(runId) {
+        const row = await this.dbGet(`SELECT * FROM coverage_summary WHERE run_id = ?`, [runId]);
+        if (!row) {
+            return null;
+        }
+        return {
+            lineCoverage: row.line_coverage,
+            branchCoverage: row.branch_coverage,
+            functionCoverage: row.function_coverage,
+            statementCoverage: row.statement_coverage,
+            totalFiles: row.total_files,
+            filesWithCoverage: row.total_files,
+            filesMeetingThreshold: row.files_meeting_threshold,
+            totalLines: row.total_lines,
+            coveredLines: row.covered_lines,
+            timestamp: row.created_at
+        };
+    }
+    /**
+     * Get coverage trends for a file
+     */
+    async getTrends(filePath, coverageType = 'line', limit = 30) {
+        const rows = await this.dbAll(`SELECT * FROM coverage_trends
+       WHERE file_path = ? AND coverage_type = ?
+       ORDER BY date DESC
+       LIMIT ?`, [filePath, coverageType, limit]);
+        const trends = [];
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const row = rows[i];
+            const prev = i > 0 ? rows[i - 1] : null;
+            trends.push({
+                runId: row.run_id,
+                timestamp: row.date,
+                coverage: row.coverage_value,
+                type: coverageType,
+                change: prev ? row.coverage_value - prev.coverage_value : 0,
+                commit: row.commit,
+                branch: row.branch
+            });
+        }
+        return trends;
+    }
+    /**
+     * Get overall coverage trends
+     */
+    async getOverallTrends(coverageType = 'line', limit = 30) {
+        const rows = await this.dbAll(`SELECT
+        run_id,
+        ${coverageType}_coverage as coverage_value,
+        created_at as date
+       FROM coverage_summary
+       ORDER BY date DESC
+       LIMIT ?`, [limit]);
+        const trends = [];
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const row = rows[i];
+            const prev = i > 0 ? rows[i - 1] : null;
+            trends.push({
+                runId: row.run_id,
+                timestamp: row.date,
+                coverage: row.coverage_value,
+                type: coverageType,
+                change: prev ? row.coverage_value - prev.coverage_value : 0
+            });
+        }
+        return trends;
+    }
+    /**
+     * Get coverage by gate
+     */
+    async getCoverageByGate(gate, limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        cs.line_coverage,
+        cs.branch_coverage,
+        cs.function_coverage,
+        cs.statement_coverage,
+        cs.total_files,
+        cs.files_meeting_threshold,
+        cs.total_lines,
+        cs.covered_lines,
+        cs.created_at as timestamp
+       FROM coverage_summary cs
+       JOIN runs r ON cs.run_id = r.id
+       JOIN gates g ON g.run_id = r.id
+       WHERE g.name = ?
+       ORDER BY cs.created_at DESC
+       LIMIT ?`, [gate, limit]);
+        return rows.map(row => ({
+            lineCoverage: row.line_coverage,
+            branchCoverage: row.branch_coverage,
+            functionCoverage: row.function_coverage,
+            statementCoverage: row.statement_coverage,
+            totalFiles: row.total_files,
+            filesWithCoverage: row.total_files,
+            filesMeetingThreshold: row.files_meeting_threshold,
+            totalLines: row.total_lines,
+            coveredLines: row.covered_lines,
+            timestamp: row.timestamp
+        }));
+    }
+    /**
+     * Get files with lowest coverage
+     */
+    async getLowestCoverageFiles(limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        file_path,
+        AVG(line_coverage) as avg_coverage,
+        gate
+       FROM coverage_metrics
+       GROUP BY file_path
+       ORDER BY avg_coverage ASC
+       LIMIT ?`, [limit]);
+        return rows.map(row => ({
+            filePath: row.file_path,
+            coverage: row.avg_coverage,
+            gate: row.gate
+        }));
+    }
+    /**
+     * Get files with highest coverage
+     */
+    async getHighestCoverageFiles(limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        file_path,
+        AVG(line_coverage) as avg_coverage,
+        gate
+       FROM coverage_metrics
+       GROUP BY file_path
+       ORDER BY avg_coverage DESC
+       LIMIT ?`, [limit]);
+        return rows.map(row => ({
+            filePath: row.file_path,
+            coverage: row.avg_coverage,
+            gate: row.gate
+        }));
+    }
+    /**
+     * Get coverage statistics across all runs
+     */
+    async getStatistics() {
+        const totalRuns = await this.dbGet(`SELECT COUNT(DISTINCT run_id) as count FROM coverage_summary`, []);
+        const averages = await this.dbGet(`SELECT
+        AVG(line_coverage) as line,
+        AVG(branch_coverage) as branch,
+        AVG(function_coverage) as function
+       FROM coverage_summary`, []);
+        const best = await this.dbGet(`SELECT run_id, line_coverage FROM coverage_summary ORDER BY line_coverage DESC LIMIT 1`, []);
+        const worst = await this.dbGet(`SELECT run_id, line_coverage FROM coverage_summary ORDER BY line_coverage ASC LIMIT 1`, []);
+        return {
+            totalRuns: totalRuns?.count || 0,
+            averageLineCoverage: averages?.line || 0,
+            averageBranchCoverage: averages?.branch || 0,
+            averageFunctionCoverage: averages?.function || 0,
+            bestCoverage: { runId: best?.run_id || '', coverage: best?.line_coverage || 0 },
+            worstCoverage: { runId: worst?.run_id || '', coverage: worst?.line_coverage || 0 }
+        };
+    }
+    /**
+     * Delete coverage data for a run
+     */
+    async deleteCoverage(runId) {
+        await this.dbRun(`DELETE FROM coverage_metrics WHERE run_id = ?`, [runId]);
+        await this.dbRun(`DELETE FROM coverage_summary WHERE run_id = ?`, [runId]);
+        await this.dbRun(`DELETE FROM coverage_trends WHERE run_id = ?`, [runId]);
+    }
+    /**
+     * Get recent coverage changes (comparison with previous run)
+     */
+    async getRecentChanges(limit = 5) {
+        const rows = await this.dbAll(`SELECT
+        run_id,
+        created_at as timestamp,
+        line_coverage
+       FROM coverage_summary
+       ORDER BY created_at DESC
+       LIMIT ?`, [limit * 2] // Get extra to calculate changes
+        );
+        const result = [];
+        for (let i = 0; i < Math.min(rows.length - 1, limit); i++) {
+            const current = rows[i];
+            const previous = rows[i + 1];
+            result.push({
+                runId: current.run_id,
+                timestamp: current.timestamp,
+                lineCoverage: current.line_coverage,
+                change: previous ? current.line_coverage - previous.line_coverage : 0
+            });
+        }
+        return result;
+    }
+}

package/dist/core/runner/phase3-runner.js

@@ -497,10 +497,31 @@ export class Phase3Runner {
         const { PlaywrightUiAdapter } = await import('../adapters/playwright-ui.js');
         const adapter = new PlaywrightUiAdapter();
         // Transform v2 config to adapter format
-        // v2: { baseUrl, pages } -> adapter expects: { target: { baseUrl, pages } }
+        // v2: { baseUrl, pages: [{ url: '/', expectedElements: [...] }] }
+        // adapter expects: { target: { baseUrl, pages: ['https://.../'] } }
         const gateConfigData = gateConfig.config || {};
-        const pages = gateConfigData.pages ||
-            (gateConfigData.baseUrl ? [gateConfigData.baseUrl] : undefined);
+        // Transform page objects to full URLs
+        // v2 pages format: [{ url: '/', expectedElements: [...] }] or ['/', '/about']
+        const rawPages = gateConfigData.pages;
+        let pages;
+        if (rawPages && Array.isArray(rawPages) && rawPages.length > 0) {
+            const baseUrl = gateConfigData.baseUrl || '';
+            pages = rawPages.map((p) => {
+                if (typeof p === 'string') {
+                    // Already a URL string - make it absolute if relative
+                    return p.startsWith('http') ? p : `${baseUrl.replace(/\/$/, '')}${p}`;
+                }
+                else if (p && typeof p === 'object' && p.url) {
+                    // Page object { url: '/', ... } - convert to full URL
+                    const url = p.url;
+                    return url.startsWith('http') ? url : `${baseUrl.replace(/\/$/, '')}${url}`;
+                }
+                return p;
+            });
+        }
+        else if (gateConfigData.baseUrl) {
+            pages = [gateConfigData.baseUrl];
+        }
         const config = {
             target: {
                 baseUrl: gateConfigData.baseUrl,

package/dist/generators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generator exports
+ */
+export { JSONReporter } from './json-reporter.js';
+export { TestGenerator } from './test-generator.js';

package/dist/generators/index.js

@@ -0,0 +1,5 @@
+/**
+ * Generator exports
+ */
+export { JSONReporter } from './json-reporter.js';
+export { TestGenerator } from './test-generator.js';

package/dist/generators/json-reporter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * JSON Reporter for scan results
+ */
+import type { ScanResult } from '../types/scan.js';
+export declare class JSONReporter {
+    /**
+     * Generate a JSON report from scan results
+     */
+    generate(result: ScanResult, outputPath: string): Promise<void>;
+}

package/dist/generators/json-reporter.js

@@ -0,0 +1,12 @@
+/**
+ * JSON Reporter for scan results
+ */
+import { writeFileSync } from 'fs';
+export class JSONReporter {
+    /**
+     * Generate a JSON report from scan results
+     */
+    async generate(result, outputPath) {
+        writeFileSync(outputPath, JSON.stringify(result, null, 2));
+    }
+}

package/dist/generators/test-generator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Test Generator - creates QA360 test files from scan results
+ */
+import type { ScanResult } from '../types/scan.js';
+export declare class TestGenerator {
+    /**
+     * Generate a QA360 test file from scan results
+     */
+    generate(result: ScanResult, outputPath: string): Promise<void>;
+    /**
+     * Get unique selectors from discovered elements
+     */
+    private getUniqueSelectors;
+    /**
+     * Generate a test name from hostname
+     */
+    private generateTestName;
+}

package/dist/generators/test-generator.js

@@ -0,0 +1,78 @@
+/**
+ * Test Generator - creates QA360 test files from scan results
+ */
+import { writeFileSync } from 'fs';
+import { dump as yamlDump } from 'js-yaml';
+export class TestGenerator {
+    /**
+     * Generate a QA360 test file from scan results
+     */
+    async generate(result, outputPath) {
+        const url = new URL(result.url);
+        const baseUrl = `${url.protocol}//${url.host}`;
+        // Get unique selectors only
+        const uniqueSelectors = this.getUniqueSelectors(result.elements);
+        // Generate the test configuration
+        const testConfig = {
+            version: 2,
+            name: this.generateTestName(url.hostname),
+            description: `Auto-generated test from scan of ${result.url}`,
+            gates: {
+                'ui-smoke': {
+                    adapter: 'playwright-ui',
+                    enabled: true,
+                    config: {
+                        baseUrl,
+                        pages: [
+                            {
+                                url: url.pathname || '/',
+                                expectedElements: uniqueSelectors
+                            }
+                        ]
+                    }
+                }
+            },
+            execution: {
+                default_timeout: 30000,
+                default_retries: 1,
+                on_failure: 'continue'
+            }
+        };
+        // Convert to YAML using js-yaml
+        const yaml = yamlDump(testConfig, {
+            indent: 2,
+            lineWidth: -1,
+            noRefs: true,
+            quotingType: '"',
+            forceQuotes: false
+        });
+        writeFileSync(outputPath, yaml);
+    }
+    /**
+     * Get unique selectors from discovered elements
+     */
+    getUniqueSelectors(elements) {
+        const seen = new Set();
+        const unique = [];
+        // Always include body as a fallback
+        unique.push('body');
+        for (const el of elements) {
+            if (!seen.has(el.selector)) {
+                seen.add(el.selector);
+                unique.push(el.selector);
+            }
+        }
+        return unique;
+    }
+    /**
+     * Generate a test name from hostname
+     */
+    generateTestName(hostname) {
+        return hostname
+            .replace(/^www\./, '')
+            .replace(/[^a-z0-9]/gi, '-')
+            .toLowerCase()
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+}

package/dist/index.js

@@ -37,6 +37,7 @@ import { createCrawlCommand } from './commands/crawl.js';
 // import { createOllamaCommands } from './commands/ollama.js'; // TODO: Re-enable when Ollama exports from core are fixed
 import { createGenerateCommands } from './commands/generate.js';
 // import { createRepairCommand } from './commands/repair.js'; // TODO: fix repair imports
+import { scanCommand } from './commands/scan.js';
 const program = new Command();
 program
     .name('qa360')
@@ -230,6 +231,8 @@ program.addCommand(regressionCommand);
 program.addCommand(createRetryCommands());
 // Crawl Command (UI Testing 100% - Auto-generate packs from websites)
 program.addCommand(createCrawlCommand());
+// Scan Command (DOM Element Discovery)
+program.addCommand(scanCommand);
 // Show banner
 console.log(chalk.bold.blue('QA360 Core v' + version));
 console.log(chalk.gray('Transform software testing into verifiable, signed, and traceable proofs\n'));

package/dist/scanners/dom-scanner.d.ts

@@ -0,0 +1,52 @@
+/**
+ * DOM Element Scanner
+ * Automatically discovers UI elements on a web page using Playwright
+ */
+import type { Page } from '@playwright/test';
+import type { DiscoveredElement, ScanOptions } from '../types/scan.js';
+export declare class DOMScanner {
+    private page;
+    private url;
+    constructor(page: Page, url: string);
+    /**
+     * Scan the page for elements based on options
+     */
+    scan(options: ScanOptions): Promise<DiscoveredElement[]>;
+    /**
+     * Scan for buttons (button elements and elements with role="button")
+     */
+    private scanButtons;
+    /**
+     * Scan for links
+     */
+    private scanLinks;
+    /**
+     * Scan for forms
+     */
+    private scanForms;
+    /**
+     * Scan for inputs
+     */
+    private scanInputs;
+    /**
+     * Scan for images
+     */
+    private scanImages;
+    /**
+     * Scan for headings
+     */
+    private scanHeadings;
+    /**
+     * Generate a CSS selector for an element
+     * Priority: ID > first class > tag + attribute > tag
+     */
+    private generateSelector;
+    /**
+     * Check if a type should be included in the scan
+     */
+    private shouldInclude;
+    /**
+     * Filter out elements that match exclusion patterns
+     */
+    private filterExcluded;
+}