qa360 2.2.1 → 2.2.13

package/cli/dist/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/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * QA360 Web Crawler
+ *
+ * Automatically discovers and analyzes web applications for E2E test generation
+ */
+import type { CrawlOptions, CrawlResult, PageDefinition, CrawlProgress, CrawlEventHandler } from './types.js';
+/**
+ * Web Crawler class
+ */
+export declare class WebCrawler {
+    private options;
+    private eventHandler?;
+    private analyzer;
+    private visited;
+    private queue;
+    private pages;
+    private errors;
+    private warnings;
+    private startTime;
+    private readonly defaultOptions;
+    constructor(options: CrawlOptions);
+    /**
+     * Set event handler for progress updates
+     */
+    on(event: CrawlEventHandler): void;
+    /**
+     * Emit event to handler
+     */
+    private emit;
+    /**
+     * Normalize URL for comparison
+     */
+    private normalizeUrl;
+    /**
+     * Check if URL should be excluded
+     */
+    private isExcluded;
+    /**
+     * Start crawling
+     */
+    crawl(): Promise<CrawlResult>;
+    /**
+     * Build site map from crawled pages
+     */
+    private buildSiteMap;
+}
+/**
+ * Crawl a web application and return results
+ */
+export declare function crawlWebsite(options: CrawlOptions): Promise<CrawlResult>;
+/**
+ * Crawl a website with progress callback
+ */
+export declare function crawlWebsiteWithProgress(options: CrawlOptions, onProgress: (progress: CrawlProgress, page?: PageDefinition) => void): Promise<CrawlResult>;
+export * from './types.js';
+export { generateSelector, generateSelectorFromElement } from './selector-generator.js';
+export { generateJourneys } from './journey-generator.js';