qa360 2.2.7 → 2.2.9

package/cli/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/cli/dist/core/schemas/pack.schema.json

@@ -1,236 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://qa360.dev/schemas/pack.v1.json",
-  "title": "QA360 Pack Configuration v1",
-  "description": "Schema for QA360 test pack configuration files",
-  "type": "object",
-  "required": ["version", "name", "gates"],
-  "properties": {
-    "version": {
-      "type": "integer",
-      "const": 1,
-      "description": "Pack schema version"
-    },
-    "name": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 100,
-      "pattern": "^[a-zA-Z0-9_-]+$",
-      "description": "Pack name (alphanumeric, underscore, hyphen only)"
-    },
-    "description": {
-      "type": "string",
-      "maxLength": 500,
-      "description": "Human-readable pack description"
-    },
-    "gates": {
-      "type": "array",
-      "minItems": 1,
-      "uniqueItems": true,
-      "items": {
-        "type": "string",
-        "enum": ["api_smoke", "ui", "perf", "sast", "dast", "a11y"]
-      },
-      "description": "Quality gates to execute"
-    },
-    "targets": {
-      "type": "object",
-      "properties": {
-        "api": {
-          "type": "object",
-          "properties": {
-            "baseUrl": {
-              "type": "string",
-              "format": "uri",
-              "description": "Base URL for API testing"
-            },
-            "smoke": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "pattern": "^(GET|POST|PUT|DELETE|PATCH) .+ -> \\d{3}$",
-                "description": "Smoke test definition: METHOD path -> expectedStatus"
-              }
-            }
-          },
-          "required": ["baseUrl"]
-        },
-        "web": {
-          "type": "object",
-          "properties": {
-            "baseUrl": {
-              "type": "string",
-              "format": "uri",
-              "description": "Base URL for web testing"
-            },
-            "pages": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "description": "Page paths to test"
-              }
-            }
-          },
-          "required": ["baseUrl"]
-        }
-      },
-      "description": "Test targets configuration"
-    },
-    "budgets": {
-      "type": "object",
-      "properties": {
-        "perf_p95_ms": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 30000,
-          "description": "Performance budget: 95th percentile response time in ms"
-        },
-        "a11y_min": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 100,
-          "description": "Accessibility minimum score (0-100)"
-        }
-      },
-      "description": "Performance and quality budgets"
-    },
-    "security": {
-      "type": "object",
-      "properties": {
-        "sast_max_high": {
-          "type": "integer",
-          "minimum": 0,
-          "description": "Maximum allowed high-severity SAST findings"
-        },
-        "secrets_leak": {
-          "type": "integer",
-          "const": 0,
-          "description": "Secrets leak tolerance (must be 0)"
-        }
-      },
-      "description": "Security constraints"
-    },
-    "data": {
-      "type": "object",
-      "properties": {
-        "profile": {
-          "type": "string",
-          "enum": ["demo", "staging", "production"],
-          "description": "Data profile to use"
-        },
-        "seed": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Random seed for reproducible data generation"
-        }
-      },
-      "description": "Test data configuration"
-    },
-    "hooks": {
-      "type": "object",
-      "properties": {
-        "beforeAll": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "properties": {
-              "run": {
-                "type": "string",
-                "description": "Command to execute"
-              },
-              "timeout": {
-                "type": "integer",
-                "minimum": 1000,
-                "default": 30000,
-                "description": "Timeout in milliseconds"
-              }
-            },
-            "required": ["run"]
-          },
-          "description": "Commands to run before all tests"
-        },
-        "afterAll": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "properties": {
-              "run": {
-                "type": "string",
-                "description": "Command to execute"
-              },
-              "timeout": {
-                "type": "integer",
-                "minimum": 1000,
-                "default": 30000,
-                "description": "Timeout in milliseconds"
-              }
-            },
-            "required": ["run"]
-          },
-          "description": "Commands to run after all tests"
-        }
-      },
-      "description": "Lifecycle hooks"
-    },
-    "execution": {
-      "type": "object",
-      "properties": {
-        "retry_on": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "enum": ["ECONNRESET", "ETIMEDOUT", "502", "503", "504", "element-detached", "navigation-timeout"]
-          },
-          "description": "Error patterns that trigger retries"
-        },
-        "max_retries": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 5,
-          "default": 1,
-          "description": "Maximum number of retries per test"
-        },
-        "fail_on_readiness": {
-          "type": "boolean",
-          "default": true,
-          "description": "Fail if readiness checks fail"
-        },
-        "timeout": {
-          "type": "integer",
-          "minimum": 1000,
-          "default": 30000,
-          "description": "Global timeout per test in milliseconds"
-        }
-      },
-      "description": "Execution configuration"
-    },
-    "observability": {
-      "type": "object",
-      "properties": {
-        "metrics": {
-          "type": "boolean",
-          "default": true,
-          "description": "Enable metrics collection"
-        },
-        "trace": {
-          "type": "string",
-          "enum": ["none", "basic", "detailed"],
-          "default": "basic",
-          "description": "Tracing level"
-        }
-      },
-      "description": "Observability settings"
-    },
-    "environment": {
-      "type": "object",
-      "patternProperties": {
-        "^[A-Z_][A-Z0-9_]*$": {
-          "type": "string",
-          "description": "Environment variable value or secret reference"
-        }
-      },
-      "description": "Environment variables and secrets"
-    }
-  },
-  "additionalProperties": false
-}