qa360 2.1.7 → 2.2.0

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

@@ -1,405 +0,0 @@
-/**
- * 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/coverage/analyzer.d.ts

@@ -1,101 +0,0 @@
-/**
- * Coverage Analyzer
- *
- * Analyzes coverage data to provide insights, trends, and recommendations.
- */
-import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageThreshold, CoverageType, CoverageReport } from './types.js';
-/**
- * Historical coverage data point
- */
-interface HistoricalCoverage {
-    runId: string;
-    timestamp: number;
-    metrics: CoverageMetrics;
-}
-/**
- * Coverage Analyzer class
- */
-export declare class CoverageAnalyzer {
-    private history;
-    /**
-     * Analyze coverage and generate insights
-     */
-    analyze(result: CoverageResult, threshold?: CoverageThreshold): CoverageReport;
-    /**
-     * Check if coverage meets thresholds
-     */
-    checkThresholds(metrics: CoverageMetrics, threshold?: CoverageThreshold): boolean;
-    /**
-     * Check if a single file meets thresholds
-     */
-    checkFileThresholds(file: FileCoverage, threshold?: CoverageThreshold): boolean;
-    /**
-     * Find coverage gaps
-     */
-    findGaps(files: Record<string, FileCoverage>, threshold?: CoverageThreshold): CoverageGap[];
-    /**
-     * Calculate priority for covering a file
-     */
-    private calculatePriority;
-    /**
-     * Estimate effort to cover a file
-     */
-    private estimateEffort;
-    /**
-     * Generate test suggestions for a file
-     */
-    private generateSuggestions;
-    /**
-     * Group consecutive numbers into ranges
-     */
-    private groupConsecutiveNumbers;
-    /**
-     * Get top and bottom files by coverage
-     */
-    getTopFiles(files: Record<string, FileCoverage>, limit?: number): Array<{
-        path: string;
-        coverage: number;
-        type: 'best' | 'worst';
-    }>;
-    /**
-     * Compare two coverage results
-     */
-    compare(baseResult: CoverageResult, compareResult: CoverageResult): CoverageComparison;
-    /**
-     * Add historical coverage data
-     */
-    addHistory(key: string, data: HistoricalCoverage): void;
-    /**
-     * Get coverage trends
-     */
-    getTrends(key: string, type?: CoverageType, limit?: number): CoverageTrend[];
-    /**
-     * Calculate trend direction
-     */
-    getTrendDirection(trends: CoverageTrend[]): 'improving' | 'stable' | 'declining';
-    /**
-     * Predict future coverage based on trends
-     */
-    predictCoverage(key: string, type: CoverageType | undefined, targetCoverage: number): {
-        predictedReach: number | null;
-        projectedCoverage: number;
-        confidence: 'high' | 'medium' | 'low';
-    };
-    /**
-     * Generate coverage summary text
-     */
-    generateSummary(metrics: CoverageMetrics): string;
-    /**
-     * Format coverage percentage with color indicator
-     */
-    formatCoverage(percentage: number, threshold?: number): string;
-    /**
-     * Clear history
-     */
-    clearHistory(key?: string): void;
-}
-/**
- * Create a coverage analyzer
- */
-export declare function createCoverageAnalyzer(): CoverageAnalyzer;
-export {};