qa360 2.2.15 → 2.2.20

package/cli/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/cli/dist/core/crawler/selector-generator.js

@@ -50,12 +50,9 @@ export function generateSelector(element) {
     if (className && !isGenericClass(className)) {
         const classes = className.split(' ').filter(c => !isGenericClass(c));
         if (classes.length > 0) {
-            // Smart class selection: prioritize meaningful classes
-            const meaningfulClasses = selectMeaningfulClasses(classes);
-            const classSelector = meaningfulClasses.map(c => `.${escapeCss(c)}`).join('');
-            // Limit total selector length
-            const qualifiedSelector = tagName ? `${tagName}${classSelector}` : classSelector;
-            return truncateSelector(qualifiedSelector, 200);
+            const classSelector = classes.map(c => `.${escapeCss(c)}`).join('');
+            // Qualify with tag if available
+            return tagName ? `${tagName}${classSelector}` : classSelector;
         }
     }
     // 7. Tag + text content (for buttons, links)
@@ -172,72 +169,6 @@ function isSelectorStable(selector) {
 function escapeCss(str) {
     return str.replace(/(["\\])/g, '\\$1').replace(/"/g, '\\"');
 }
-/**
- * Select the most meaningful classes from a class list
- * Prioritizes: unique identifiers, component names, action-oriented classes
- * Deprioritizes: utility classes (spacing, colors, sizing)
- */
-function selectMeaningfulClasses(classes) {
-    // Tailwind and other utility class patterns to deprioritize
-    const utilityPatterns = [
-        /^(p|m|px|py|pt|pb|pl|pr)-/, // spacing
-        /^(mt|mb|ml|mr)-/, // margin spacing
-        /^(text|bg|border)-/, // colors
-        /^(w|h)-/, // sizing
-        /^(flex|grid|block|inline)/, // display
-        /^(justify|items|self)/, // flexbox/grid
-        /^(rounded|shadow|opacity)/, // styling
-        /^gap-/, // flex gap
-        /^(line-)?height-/, // height
-        /^(font|weight|size)/, // typography
-    ];
-    // Score each class by "meaningfulness"
-    const scored = classes.map(cls => {
-        let score = 50; // base score
-        // Bonus: component-like names (contain meaningful words)
-        if (/[A-Z][a-z]+/.test(cls))
-            score += 30; // CamelCase components
-        if (/button|btn|input|form|card|modal|nav|header|footer|sidebar|menu|dropdown/i.test(cls))
-            score += 25;
-        // Bonus: contains numbers (likely unique)
-        if (/\d+/.test(cls))
-            score += 15;
-        // Penalty: utility classes
-        for (const pattern of utilityPatterns) {
-            if (pattern.test(cls)) {
-                score -= 40;
-                break;
-            }
-        }
-        return { class: cls, score };
-    });
-    // Sort by score (descending) and take top 5
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, 5).map(s => s.class);
-}
-/**
- * Truncate selector to max length while keeping it valid
- * Preserves the most specific parts
- */
-function truncateSelector(selector, maxLength) {
-    if (selector.length <= maxLength)
-        return selector;
-    // For class-based selectors, remove classes from the middle
-    const classMatch = selector.match(/^(\w+)((\.[\w-]+)+)$/);
-    if (classMatch) {
-        const tag = classMatch[1];
-        const classes = classMatch[2].split('.').filter(c => c); // Remove empty strings
-        // Keep first 2 and last 2 classes (most specific)
-        if (classes.length > 4) {
-            const kept = [...classes.slice(0, 2), ...classes.slice(-2)];
-            const truncated = `${tag}.${kept.join('.')}`;
-            if (truncated.length <= maxLength)
-                return truncated;
-        }
-    }
-    // Final fallback: just truncate (may not be valid CSS but prevents overflow)
-    return selector.substring(0, maxLength - 3) + '...';
-}
 /**
  * Optimize selector for resiliency
  */

package/cli/dist/core/generation/crawler-pack-generator.d.ts

@@ -1,7 +1,7 @@
 /**
  * QA360 Crawler Pack Generator
  *
- * Crawls a website and generates a complete pack.yml in v2 format
+ * Crawls a website and generates a complete pack.yml with E2E tests
  */
 import type { CrawlOptions, CrawlResult } from '../crawler/index.js';
 /**