qa360 1.4.5 → 2.0.1

package/dist/core/regression/vault.js

@@ -0,0 +1,289 @@
+/**
+ * Regression Vault Integration
+ *
+ * Integrates regression data storage and retrieval with the Evidence Vault.
+ */
+import { promisify } from 'util';
+/**
+ * Regression Vault class
+ */
+export class RegressionVault {
+    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 regression tables
+     */
+    async initialize() {
+        const schema = `
+      -- Regression detections table
+      CREATE TABLE IF NOT EXISTS regression_detections (
+          id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          baseline_run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE SET NULL,
+          type TEXT NOT NULL,
+          severity TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'detected',
+          metric_name TEXT NOT NULL,
+          baseline_value REAL NOT NULL,
+          current_value REAL NOT NULL,
+          absolute_change REAL NOT NULL,
+          percent_change REAL NOT NULL,
+          significance REAL NOT NULL,
+          confidence REAL NOT NULL,
+          direction TEXT NOT NULL,
+          affected_component TEXT,
+          gate TEXT NOT NULL,
+          context_json TEXT,
+          suggestions_json TEXT NOT NULL,
+          commits_json TEXT,
+          timestamp INTEGER NOT NULL,
+          notes TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_regression_run_id ON regression_detections(run_id);
+      CREATE INDEX IF NOT EXISTS idx_regression_baseline_run_id ON regression_detections(baseline_run_id);
+      CREATE INDEX IF NOT EXISTS idx_regression_type ON regression_detections(type);
+      CREATE INDEX IF NOT EXISTS idx_regression_severity ON regression_detections(severity);
+      CREATE INDEX IF NOT EXISTS idx_regression_status ON regression_detections(status);
+      CREATE INDEX IF NOT EXISTS idx_regression_metric ON regression_detections(metric_name);
+      CREATE INDEX IF NOT EXISTS idx_regression_timestamp ON regression_detections(timestamp);
+
+      -- Regression snapshots (aggregate metrics over time)
+      CREATE TABLE IF NOT EXISTS regression_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          metric_name TEXT NOT NULL,
+          value REAL NOT NULL,
+          baseline_value REAL,
+          change_percent REAL,
+          is_regression INTEGER DEFAULT 0,
+          timestamp INTEGER NOT NULL,
+          UNIQUE(run_id, metric_name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_regression_snapshots_run_id ON regression_snapshots(run_id);
+      CREATE INDEX IF NOT EXISTS idx_regression_snapshots_metric ON regression_snapshots(metric_name);
+
+      -- Regression history for trend analysis
+      CREATE TABLE IF NOT EXISTS regression_history (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          metric_name TEXT NOT NULL,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          value REAL NOT NULL,
+          mean REAL NOT NULL,
+          std_dev REAL NOT NULL,
+          sample_size INTEGER NOT NULL,
+          window_start INTEGER NOT NULL,
+          window_end INTEGER NOT NULL,
+          timestamp INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_regression_history_metric ON regression_history(metric_name);
+      CREATE INDEX IF NOT EXISTS idx_regression_history_timestamp ON regression_history(timestamp);
+    `;
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+        for (const statement of statements) {
+            await this.dbRun(statement, []);
+        }
+    }
+    /**
+     * Store a regression detection
+     */
+    async storeRegression(regression) {
+        await this.dbRun(`INSERT INTO regression_detections (
+        id, run_id, baseline_run_id, type, severity, status,
+        metric_name, baseline_value, current_value, absolute_change,
+        percent_change, significance, confidence, direction,
+        affected_component, gate, context_json, suggestions_json,
+        commits_json, timestamp, notes
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            regression.id,
+            regression.runId,
+            regression.baselineRunId,
+            regression.type,
+            regression.severity,
+            regression.status,
+            regression.metricName,
+            regression.baselineValue,
+            regression.currentValue,
+            regression.absoluteChange,
+            regression.percentChange,
+            regression.significance,
+            regression.confidence,
+            regression.direction,
+            regression.affectedComponent,
+            regression.gate,
+            regression.context ? JSON.stringify(regression.context) : null,
+            JSON.stringify(regression.suggestions),
+            regression.commits ? JSON.stringify(regression.commits) : null,
+            regression.timestamp,
+            regression.notes || null
+        ]);
+    }
+    /**
+     * Store multiple regressions
+     */
+    async storeRegressions(regressions) {
+        for (const regression of regressions) {
+            await this.storeRegression(regression);
+        }
+    }
+    /**
+     * Get regressions by run ID
+     */
+    async getRegressionsByRun(runId) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections WHERE run_id = ? ORDER BY severity DESC, percent_change DESC`, [runId]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Get regressions by type
+     */
+    async getRegressionsByType(type, limit = 100) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections WHERE type = ? ORDER BY timestamp DESC LIMIT ?`, [type, limit]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Get regressions by severity
+     */
+    async getRegressionsBySeverity(severity, limit = 100) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections WHERE severity = ? ORDER BY timestamp DESC LIMIT ?`, [severity, limit]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Get regressions by status
+     */
+    async getRegressionsByStatus(status, limit = 100) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections WHERE status = ? ORDER BY timestamp DESC LIMIT ?`, [status, limit]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Get recent regressions
+     */
+    async getRecentRegressions(limit = 50) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections ORDER BY timestamp DESC LIMIT ?`, [limit]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Get regressions for a metric
+     */
+    async getRegressionsByMetric(metricName, limit = 50) {
+        const rows = await this.dbAll(`SELECT * FROM regression_detections WHERE metric_name = ? ORDER BY timestamp DESC LIMIT ?`, [metricName, limit]);
+        return this.mapRowsToDetections(rows);
+    }
+    /**
+     * Update regression status
+     */
+    async updateRegressionStatus(id, status, notes) {
+        let sql = `UPDATE regression_detections SET status = ?`;
+        const params = [status];
+        if (notes) {
+            sql += `, notes = ?`;
+            params.push(notes);
+        }
+        sql += ` WHERE id = ?`;
+        params.push(id);
+        await this.dbRun(sql, params);
+    }
+    /**
+     * Store regression snapshot
+     */
+    async storeSnapshot(runId, metricName, value, baselineValue) {
+        const changePercent = baselineValue !== undefined
+            ? ((value - baselineValue) / baselineValue) * 100
+            : null;
+        await this.dbRun(`INSERT OR REPLACE INTO regression_snapshots (
+        run_id, metric_name, value, baseline_value, change_percent, timestamp
+      ) VALUES (?, ?, ?, ?, ?, ?)`, [runId, metricName, value, baselineValue, changePercent, Date.now()]);
+    }
+    /**
+     * Get metric history for trend analysis
+     */
+    async getMetricHistory(metricName, limit = 100) {
+        const rows = await this.dbAll(`SELECT run_id, value, timestamp FROM regression_snapshots
+       WHERE metric_name = ?
+       ORDER BY timestamp DESC
+       LIMIT ?`, [metricName, limit]);
+        return rows.map((r) => ({
+            runId: r.run_id,
+            value: r.value,
+            timestamp: r.timestamp
+        }));
+    }
+    /**
+     * Get regression statistics
+     */
+    async getStatistics() {
+        const total = await this.dbGet(`SELECT COUNT(*) as count FROM regression_detections`, []);
+        const bySeverity = await this.dbAll(`SELECT severity, COUNT(*) as count FROM regression_detections GROUP BY severity`, []);
+        const byType = await this.dbAll(`SELECT type, COUNT(*) as count FROM regression_detections GROUP BY type`, []);
+        const byStatus = await this.dbAll(`SELECT status, COUNT(*) as count FROM regression_detections GROUP BY status`, []);
+        const weekAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+        const recent = await this.dbGet(`SELECT COUNT(*) as count FROM regression_detections WHERE timestamp >= ?`, [weekAgo]);
+        const severityMap = {};
+        for (const row of bySeverity) {
+            severityMap[row.severity] = row.count;
+        }
+        const typeMap = {};
+        for (const row of byType) {
+            typeMap[row.type] = row.count;
+        }
+        const statusMap = {};
+        for (const row of byStatus) {
+            statusMap[row.status] = row.count;
+        }
+        return {
+            total: total?.count || 0,
+            bySeverity: severityMap,
+            byType: typeMap,
+            byStatus: statusMap,
+            recent: recent?.count || 0
+        };
+    }
+    /**
+     * Delete old regressions
+     */
+    async deleteOldRegressions(olderThanMs) {
+        const cutoff = Date.now() - olderThanMs;
+        const result = await this.dbRun(`DELETE FROM regression_detections WHERE timestamp < ?`, [cutoff]);
+        return result.changes || 0;
+    }
+    /**
+     * Map database rows to RegressionDetection objects
+     */
+    mapRowsToDetections(rows) {
+        return rows.map((r) => ({
+            id: r.id,
+            runId: r.run_id,
+            baselineRunId: r.baseline_run_id,
+            type: r.type,
+            severity: r.severity,
+            status: r.status,
+            metricName: r.metric_name,
+            baselineValue: r.baseline_value,
+            currentValue: r.current_value,
+            absoluteChange: r.absolute_change,
+            percentChange: r.percent_change,
+            significance: r.significance,
+            confidence: r.confidence,
+            direction: r.direction,
+            affectedComponent: r.affected_component,
+            gate: r.gate,
+            context: r.context_json ? JSON.parse(r.context_json) : undefined,
+            suggestions: JSON.parse(r.suggestions_json),
+            commits: r.commits_json ? JSON.parse(r.commits_json) : undefined,
+            timestamp: r.timestamp,
+            notes: r.notes
+        }));
+    }
+}

package/dist/core/repair/engine/fixer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Code Fixer
+ *
+ * Applies fix suggestions to test files.
+ */
+import type { FixSuggestion, FixResult } from '../types.js';
+export interface FixerOptions {
+    backup?: boolean;
+    backupDir?: string;
+    dryRun?: boolean;
+    createPatch?: boolean;
+}
+/**
+ * Apply fix suggestions to files
+ */
+export declare function applyFixes(suggestions: FixSuggestion[], options?: FixerOptions): Promise<FixResult>;
+/**
+ * Generate unified diff format
+ */
+export declare function generateDiff(original: string, modified: string): string;
+/**
+ * Revert changes from backup
+ */
+export declare function revertBackup(backupPath: string, originalPath: string): Promise<boolean>;

package/dist/core/repair/engine/fixer.js

@@ -0,0 +1,226 @@
+/**
+ * Code Fixer
+ *
+ * Applies fix suggestions to test files.
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { join, basename } from 'path';
+import { mkdirSync, existsSync } from 'fs';
+/**
+ * Apply fix suggestions to files
+ */
+export async function applyFixes(suggestions, options = {}) {
+    const changes = [];
+    let applied = 0;
+    let failed = 0;
+    // Group suggestions by file
+    const byFile = new Map();
+    for (const suggestion of suggestions) {
+        if (!byFile.has(suggestion.filePath)) {
+            byFile.set(suggestion.filePath, []);
+        }
+        byFile.get(suggestion.filePath).push(suggestion);
+    }
+    // Apply fixes per file
+    for (const [filePath, fileSuggestions] of byFile.entries()) {
+        try {
+            const result = await applyFixesToFile(filePath, fileSuggestions, options);
+            changes.push(...result.changes);
+            applied += result.applied;
+            failed += result.failed;
+        }
+        catch (error) {
+            failed++;
+        }
+    }
+    return {
+        success: failed === 0,
+        suggestions,
+        applied,
+        failed,
+        testsPassed: 0, // Will be updated by test runner
+        testsFailed: 0,
+        changes
+    };
+}
+/**
+ * Apply fixes to a single file
+ */
+async function applyFixesToFile(filePath, suggestions, options) {
+    const fullPath = filePath; // Assume relative to cwd or already absolute
+    // Read original content
+    const original = await readFile(fullPath, 'utf-8');
+    let modified = original;
+    const changes = [];
+    // Create backup if requested
+    let backupPath = '';
+    if (options.backup) {
+        backupPath = await createBackup(fullPath, options.backupDir);
+    }
+    // Apply suggestions in reverse line order (to preserve line numbers)
+    const sortedSuggestions = [...suggestions].sort((a, b) => b.line - a.line);
+    for (const suggestion of sortedSuggestions) {
+        try {
+            const result = applySuggestion(modified, suggestion);
+            if (result.changed) {
+                changes.push({
+                    path: fullPath,
+                    original: modified,
+                    modified: result.content,
+                    backup: backupPath
+                });
+                modified = result.content;
+            }
+        }
+        catch (error) {
+            // Failed to apply this suggestion
+        }
+    }
+    // Write modified content
+    if (!options.dryRun && changes.length > 0) {
+        await writeFile(fullPath, modified, 'utf-8');
+    }
+    const applied = changes.length;
+    const failed = suggestions.length - applied;
+    return { changes, applied, failed };
+}
+/**
+ * Apply a single suggestion to content
+ */
+function applySuggestion(content, suggestion) {
+    const lines = content.split('\n');
+    const lineIndex = suggestion.line - 1; // Convert to 0-based
+    if (lineIndex < 0 || lineIndex >= lines.length) {
+        return { changed: false, content };
+    }
+    // Apply different fix strategies
+    switch (suggestion.type) {
+        case 'fix_timeout':
+            return insertTimeout(lines, lineIndex, suggestion.code);
+        case 'fix_import':
+            return insertImport(lines, suggestion.code);
+        case 'add_assertion':
+            return insertAssertion(lines, lineIndex, suggestion.code);
+        case 'update_expectation':
+            return updateLine(lines, lineIndex, suggestion.code);
+        default:
+            return insertCodeAtLine(lines, lineIndex, suggestion.code);
+    }
+}
+/**
+ * Insert timeout at test level
+ */
+function insertTimeout(lines, lineIndex, code) {
+    // Find the test function and insert timeout after it
+    for (let i = lineIndex; i >= 0 && i >= lineIndex - 5; i--) {
+        if (lines[i].includes('it(') || lines[i].includes('test(')) {
+            lines[i] = lines[i].replace(/,?\s*\)\s*=>/, `, { timeout: 10000 } =>`);
+            return { changed: true, content: lines.join('\n') };
+        }
+    }
+    return { changed: false, content: lines.join('\n') };
+}
+/**
+ * Insert import at top of file
+ */
+function insertImport(lines, code) {
+    // Find last import and insert after it
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim().startsWith('import ')) {
+            lastImportIndex = i;
+        }
+    }
+    if (lastImportIndex >= 0) {
+        lines.splice(lastImportIndex + 1, 0, code);
+        return { changed: true, content: lines.join('\n') };
+    }
+    return { changed: false, content: lines.join('\n') };
+}
+/**
+ * Insert assertion in test
+ */
+function insertAssertion(lines, lineIndex, code) {
+    // Insert before the closing brace
+    for (let i = lineIndex; i < Math.min(lines.length, lineIndex + 10); i++) {
+        if (lines[i].trim() === '});') {
+            lines.splice(i, 0, code);
+            return { changed: true, content: lines.join('\n') };
+        }
+    }
+    return { changed: false, content: lines.join('\n') };
+}
+/**
+ * Update a specific line
+ */
+function updateLine(lines, lineIndex, code) {
+    if (lineIndex >= 0 && lineIndex < lines.length) {
+        lines[lineIndex] = code;
+        return { changed: true, content: lines.join('\n') };
+    }
+    return { changed: false, content: lines.join('\n') };
+}
+/**
+ * Insert code at specific line
+ */
+function insertCodeAtLine(lines, lineIndex, code) {
+    lines.splice(lineIndex, 0, code);
+    return { changed: true, content: lines.join('\n') };
+}
+/**
+ * Create backup of a file
+ */
+async function createBackup(filePath, backupDir) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupFileName = `${filePath}.backup-${timestamp}`;
+    if (backupDir) {
+        if (!existsSync(backupDir)) {
+            mkdirSync(backupDir, { recursive: true });
+        }
+        const backupPath = join(backupDir, basename(filePath));
+        await writeFile(backupPath, await readFile(filePath, 'utf-8'));
+        return backupPath;
+    }
+    await writeFile(backupFileName, await readFile(filePath, 'utf-8'));
+    return backupFileName;
+}
+/**
+ * Generate unified diff format
+ */
+export function generateDiff(original, modified) {
+    const origLines = original.split('\n');
+    const modLines = modified.split('\n');
+    const diff = [];
+    let i = 0;
+    let j = 0;
+    while (i < origLines.length || j < modLines.length) {
+        if (i < origLines.length && j < modLines.length && origLines[i] === modLines[j]) {
+            i++;
+            j++;
+        }
+        else {
+            if (i < origLines.length) {
+                diff.push(`- ${origLines[i]}`);
+                i++;
+            }
+            if (j < modLines.length) {
+                diff.push(`+ ${modLines[j]}`);
+                j++;
+            }
+        }
+    }
+    return diff.join('\n');
+}
+/**
+ * Revert changes from backup
+ */
+export async function revertBackup(backupPath, originalPath) {
+    try {
+        const content = await readFile(backupPath, 'utf-8');
+        await writeFile(originalPath, content, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/repair/engine/suggestion-engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fix Suggestion Engine
+ *
+ * Generates fix suggestions using LLM.
+ */
+import type { FixSuggestion, TestError, RepairOptions } from '../types.js';
+export interface SuggestionOptions extends RepairOptions {
+    maxSuggestions?: number;
+    includeCode?: boolean;
+}
+/**
+ * Generate fix suggestions for test errors
+ */
+export declare function generateFixSuggestions(errors: TestError[], testCode: string, sourceCode?: string, options?: SuggestionOptions): Promise<FixSuggestion[]>;
+/**
+ * Get quick fix suggestions without LLM
+ */
+export declare function getQuickFixes(error: TestError): FixSuggestion[];