qa360 2.2.1 → 2.2.13

package/cli/dist/core/slo/vault.d.ts

@@ -0,0 +1,102 @@
+/**
+ * SLO/SLI Vault Integration
+ *
+ * Integrates SLO/SLI data storage and retrieval with the Evidence Vault.
+ */
+import type { Database } from 'sqlite3';
+import type { SLO, SLI, SLIMeasurement, SLOViolation, SLOStatus } from './types.js';
+/**
+ * SLO Vault class
+ */
+export declare class SLOVault {
+    private db;
+    private dbRun;
+    private dbAll;
+    private dbGet;
+    constructor(db: Database);
+    /**
+     * Initialize SLO/SLI tables
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store an SLO definition
+     */
+    storeSLO(slo: SLO): Promise<void>;
+    /**
+     * Store an SLI definition
+     */
+    storeSLI(sli: SLI): Promise<void>;
+    /**
+     * Store an SLI measurement
+     */
+    storeMeasurement(measurement: SLIMeasurement, runId?: string): Promise<void>;
+    /**
+     * Store an SLO snapshot
+     */
+    storeSLOSnapshot(sloId: string, data: {
+        currentValue: number;
+        target: number;
+        status: SLOStatus;
+        errorBudgetRemaining: number;
+        burnRate?: number;
+        windowStart: number;
+        windowEnd: number;
+    }, runId?: string): Promise<void>;
+    /**
+     * Store an SLO violation
+     */
+    storeViolation(violation: SLOViolation): Promise<void>;
+    /**
+     * Get all SLO definitions
+     */
+    getSLOs(): Promise<SLO[]>;
+    /**
+     * Get an SLO by ID
+     */
+    getSLO(id: string): Promise<SLO | null>;
+    /**
+     * Get all SLI definitions
+     */
+    getSLIs(): Promise<SLI[]>;
+    /**
+     * Get measurements for an SLI
+     */
+    getMeasurements(sliId: string, windowStart?: number, windowEnd?: number, limit?: number): Promise<SLIMeasurement[]>;
+    /**
+     * Get violations for an SLO
+     */
+    getViolations(sloId?: string, resolved?: boolean): Promise<SLOViolation[]>;
+    /**
+     * Get SLO snapshots for trend analysis
+     */
+    getSLOSnapshots(sloId: string, windowStart?: number, windowEnd?: number, limit?: number): Promise<Array<{
+        timestamp: number;
+        currentValue: number;
+        target: number;
+        status: SLOStatus;
+        errorBudgetRemaining: number;
+        burnRate?: number;
+    }>>;
+    /**
+     * Delete an SLO and its associated data
+     */
+    deleteSLO(id: string): Promise<void>;
+    /**
+     * Delete an SLI and its associated data
+     */
+    deleteSLI(id: string): Promise<void>;
+    /**
+     * Resolve a violation
+     */
+    resolveViolation(violationId: string): Promise<void>;
+    /**
+     * Get SLO statistics
+     */
+    getStatistics(): Promise<{
+        totalSLOs: number;
+        totalSLIs: number;
+        statusCounts: Record<SLOStatus, number>;
+        activeViolations: number;
+        totalMeasurements: number;
+    }>;
+}

package/cli/dist/core/slo/vault.js

@@ -0,0 +1,427 @@
+/**
+ * SLO/SLI Vault Integration
+ *
+ * Integrates SLO/SLI data storage and retrieval with the Evidence Vault.
+ */
+import { promisify } from 'util';
+/**
+ * SLO Vault class
+ */
+export class SLOVault {
+    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 SLO/SLI tables
+     */
+    async initialize() {
+        const schema = `
+      -- SLO definitions table
+      CREATE TABLE IF NOT EXISTS slo_definitions (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT,
+          sli_ids TEXT NOT NULL,
+          target REAL NOT NULL,
+          window_ms INTEGER NOT NULL,
+          error_budget_json TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'unknown',
+          current_value REAL,
+          tags TEXT,
+          owner TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_status ON slo_definitions(status);
+      CREATE INDEX IF NOT EXISTS idx_slo_owner ON slo_definitions(owner);
+      CREATE INDEX IF NOT EXISTS idx_slo_tags ON slo_definitions(tags);
+
+      -- SLI definitions table
+      CREATE TABLE IF NOT EXISTS sli_definitions (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT,
+          type TEXT NOT NULL,
+          source TEXT NOT NULL,
+          query_json TEXT NOT NULL,
+          aggregation TEXT NOT NULL,
+          unit TEXT NOT NULL,
+          threshold_json TEXT NOT NULL,
+          category TEXT NOT NULL,
+          tags TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sli_type ON sli_definitions(type);
+      CREATE INDEX IF NOT EXISTS idx_sli_category ON sli_definitions(category);
+
+      -- SLI measurements table
+      CREATE TABLE IF NOT EXISTS sli_measurements (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          sli_id TEXT NOT NULL REFERENCES sli_definitions(id) ON DELETE CASCADE,
+          run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+          timestamp INTEGER NOT NULL,
+          value REAL NOT NULL,
+          total INTEGER,
+          good INTEGER,
+          bad INTEGER,
+          unit TEXT NOT NULL,
+          window_start INTEGER NOT NULL,
+          window_end INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_sli_id ON sli_measurements(sli_id);
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_run_id ON sli_measurements(run_id);
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_timestamp ON sli_measurements(timestamp);
+
+      -- SLO violations table
+      CREATE TABLE IF NOT EXISTS slo_violations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          slo_id TEXT NOT NULL REFERENCES slo_definitions(id) ON DELETE CASCADE,
+          timestamp INTEGER NOT NULL,
+          value REAL NOT NULL,
+          expected REAL NOT NULL,
+          severity TEXT NOT NULL,
+          context_json TEXT,
+          resolved INTEGER DEFAULT 0,
+          resolved_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_slo_id ON slo_violations(slo_id);
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_timestamp ON slo_violations(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_resolved ON slo_violations(resolved);
+
+      -- SLO snapshots (aggregated SLO status over time)
+      CREATE TABLE IF NOT EXISTS slo_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          slo_id TEXT NOT NULL REFERENCES slo_definitions(id) ON DELETE CASCADE,
+          run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+          timestamp INTEGER NOT NULL,
+          current_value REAL NOT NULL,
+          target REAL NOT NULL,
+          status TEXT NOT NULL,
+          error_budget_remaining REAL NOT NULL,
+          burn_rate REAL,
+          window_start INTEGER NOT NULL,
+          window_end INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_snapshots_slo_id ON slo_snapshots(slo_id);
+      CREATE INDEX IF NOT EXISTS idx_slo_snapshots_timestamp ON slo_snapshots(timestamp);
+    `;
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+        for (const statement of statements) {
+            await this.dbRun(statement, []);
+        }
+    }
+    /**
+     * Store an SLO definition
+     */
+    async storeSLO(slo) {
+        await this.dbRun(`INSERT OR REPLACE INTO slo_definitions (
+        id, name, description, sli_ids, target, window_ms,
+        error_budget_json, status, current_value, tags, owner,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            slo.id,
+            slo.name,
+            slo.description || null,
+            JSON.stringify(slo.sliIds),
+            slo.target,
+            slo.windowMs,
+            JSON.stringify(slo.errorBudget),
+            slo.status,
+            slo.currentValue || null,
+            slo.tags ? JSON.stringify(slo.tags) : null,
+            slo.owner || null,
+            slo.createdAt,
+            Date.now()
+        ]);
+    }
+    /**
+     * Store an SLI definition
+     */
+    async storeSLI(sli) {
+        await this.dbRun(`INSERT OR REPLACE INTO sli_definitions (
+        id, name, description, type, source, query_json,
+        aggregation, unit, threshold_json, category, tags,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            sli.id,
+            sli.name,
+            sli.description || null,
+            sli.type,
+            sli.source,
+            JSON.stringify(sli.query),
+            sli.aggregation,
+            sli.unit,
+            JSON.stringify(sli.threshold),
+            sli.category,
+            sli.tags ? JSON.stringify(sli.tags) : null,
+            sli.createdAt,
+            Date.now()
+        ]);
+    }
+    /**
+     * Store an SLI measurement
+     */
+    async storeMeasurement(measurement, runId) {
+        await this.dbRun(`INSERT INTO sli_measurements (
+        sli_id, run_id, timestamp, value, total, good, bad,
+        unit, window_start, window_end
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            measurement.sliId,
+            runId || null,
+            measurement.timestamp,
+            measurement.value,
+            measurement.total || null,
+            measurement.good || null,
+            measurement.bad || null,
+            measurement.unit,
+            measurement.windowStart,
+            measurement.windowEnd
+        ]);
+    }
+    /**
+     * Store an SLO snapshot
+     */
+    async storeSLOSnapshot(sloId, data, runId) {
+        await this.dbRun(`INSERT INTO slo_snapshots (
+        slo_id, run_id, timestamp, current_value, target, status,
+        error_budget_remaining, burn_rate, window_start, window_end
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            sloId,
+            runId || null,
+            Date.now(),
+            data.currentValue,
+            data.target,
+            data.status,
+            data.errorBudgetRemaining,
+            data.burnRate || null,
+            data.windowStart,
+            data.windowEnd
+        ]);
+    }
+    /**
+     * Store an SLO violation
+     */
+    async storeViolation(violation) {
+        await this.dbRun(`INSERT INTO slo_violations (
+        slo_id, timestamp, value, expected, severity,
+        context_json, resolved, resolved_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+            violation.sloId,
+            violation.timestamp,
+            violation.value,
+            violation.expected,
+            violation.severity,
+            violation.context ? JSON.stringify(violation.context) : null,
+            violation.resolved ? 1 : 0,
+            violation.resolvedAt || null
+        ]);
+    }
+    /**
+     * Get all SLO definitions
+     */
+    async getSLOs() {
+        const rows = await this.dbAll(`SELECT * FROM slo_definitions`, []);
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            description: r.description,
+            sliIds: JSON.parse(r.sli_ids),
+            target: r.target,
+            windowMs: r.window_ms,
+            errorBudget: JSON.parse(r.error_budget_json),
+            status: r.status,
+            currentValue: r.current_value,
+            tags: r.tags ? JSON.parse(r.tags) : undefined,
+            owner: r.owner,
+            createdAt: r.created_at,
+            updatedAt: r.updated_at
+        }));
+    }
+    /**
+     * Get an SLO by ID
+     */
+    async getSLO(id) {
+        const row = await this.dbGet(`SELECT * FROM slo_definitions WHERE id = ?`, [id]);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            description: row.description,
+            sliIds: JSON.parse(row.sli_ids),
+            target: row.target,
+            windowMs: row.window_ms,
+            errorBudget: JSON.parse(row.error_budget_json),
+            status: row.status,
+            currentValue: row.current_value,
+            tags: row.tags ? JSON.parse(row.tags) : undefined,
+            owner: row.owner,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    /**
+     * Get all SLI definitions
+     */
+    async getSLIs() {
+        const rows = await this.dbAll(`SELECT * FROM sli_definitions`, []);
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            description: r.description,
+            type: r.type,
+            source: r.source,
+            query: JSON.parse(r.query_json),
+            aggregation: r.aggregation,
+            unit: r.unit,
+            threshold: JSON.parse(r.threshold_json),
+            category: r.category,
+            tags: r.tags ? JSON.parse(r.tags) : undefined,
+            createdAt: r.created_at,
+            updatedAt: r.updated_at
+        }));
+    }
+    /**
+     * Get measurements for an SLI
+     */
+    async getMeasurements(sliId, windowStart, windowEnd, limit = 1000) {
+        let sql = `SELECT * FROM sli_measurements WHERE sli_id = ?`;
+        const params = [sliId];
+        if (windowStart) {
+            sql += ` AND timestamp >= ?`;
+            params.push(windowStart);
+        }
+        if (windowEnd) {
+            sql += ` AND timestamp <= ?`;
+            params.push(windowEnd);
+        }
+        sql += ` ORDER BY timestamp DESC LIMIT ?`;
+        params.push(limit);
+        const rows = await this.dbAll(sql, params);
+        return rows.map((r) => ({
+            sliId: r.sli_id,
+            timestamp: r.timestamp,
+            value: r.value,
+            total: r.total,
+            good: r.good,
+            bad: r.bad,
+            unit: r.unit,
+            windowStart: r.window_start,
+            windowEnd: r.window_end
+        }));
+    }
+    /**
+     * Get violations for an SLO
+     */
+    async getViolations(sloId, resolved) {
+        let sql = `SELECT * FROM slo_violations WHERE 1=1`;
+        const params = [];
+        if (sloId) {
+            sql += ` AND slo_id = ?`;
+            params.push(sloId);
+        }
+        if (resolved !== undefined) {
+            sql += ` AND resolved = ?`;
+            params.push(resolved ? 1 : 0);
+        }
+        sql += ` ORDER BY timestamp DESC`;
+        const rows = await this.dbAll(sql, params);
+        return rows.map((r) => ({
+            id: r.id?.toString() || '',
+            sloId: r.slo_id,
+            timestamp: r.timestamp,
+            value: r.value,
+            expected: r.expected,
+            severity: r.severity,
+            context: r.context_json ? JSON.parse(r.context_json) : undefined,
+            resolved: r.resolved === 1,
+            resolvedAt: r.resolved_at
+        }));
+    }
+    /**
+     * Get SLO snapshots for trend analysis
+     */
+    async getSLOSnapshots(sloId, windowStart, windowEnd, limit = 100) {
+        let sql = `SELECT * FROM slo_snapshots WHERE slo_id = ?`;
+        const params = [sloId];
+        if (windowStart) {
+            sql += ` AND timestamp >= ?`;
+            params.push(windowStart);
+        }
+        if (windowEnd) {
+            sql += ` AND timestamp <= ?`;
+            params.push(windowEnd);
+        }
+        sql += ` ORDER BY timestamp DESC LIMIT ?`;
+        params.push(limit);
+        const rows = await this.dbAll(sql, params);
+        return rows.map((r) => ({
+            timestamp: r.timestamp,
+            currentValue: r.current_value,
+            target: r.target,
+            status: r.status,
+            errorBudgetRemaining: r.error_budget_remaining,
+            burnRate: r.burn_rate
+        }));
+    }
+    /**
+     * Delete an SLO and its associated data
+     */
+    async deleteSLO(id) {
+        await this.dbRun(`DELETE FROM slo_definitions WHERE id = ?`, [id]);
+    }
+    /**
+     * Delete an SLI and its associated data
+     */
+    async deleteSLI(id) {
+        await this.dbRun(`DELETE FROM sli_definitions WHERE id = ?`, [id]);
+    }
+    /**
+     * Resolve a violation
+     */
+    async resolveViolation(violationId) {
+        await this.dbRun(`UPDATE slo_violations SET resolved = 1, resolved_at = ? WHERE id = ?`, [Date.now(), parseInt(violationId, 10)]);
+    }
+    /**
+     * Get SLO statistics
+     */
+    async getStatistics() {
+        const totalSLOs = await this.dbGet(`SELECT COUNT(*) as count FROM slo_definitions`, []);
+        const totalSLIs = await this.dbGet(`SELECT COUNT(*) as count FROM sli_definitions`, []);
+        const statusCounts = await this.dbAll(`SELECT status, COUNT(*) as count FROM slo_definitions GROUP BY status`, []);
+        const activeViolations = await this.dbGet(`SELECT COUNT(*) as count FROM slo_violations WHERE resolved = 0`, []);
+        const totalMeasurements = await this.dbGet(`SELECT COUNT(*) as count FROM sli_measurements`, []);
+        const statusMap = {
+            healthy: 0,
+            warning: 0,
+            breached: 0,
+            unknown: 0
+        };
+        for (const row of statusCounts) {
+            statusMap[row.status] = row.count;
+        }
+        return {
+            totalSLOs: totalSLOs?.count || 0,
+            totalSLIs: totalSLIs?.count || 0,
+            statusCounts: statusMap,
+            activeViolations: activeViolations?.count || 0,
+            totalMeasurements: totalMeasurements?.count || 0
+        };
+    }
+}

package/cli/dist/core/tui/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * QA360 TUI (Terminal UI) Module
+ * Phase 8: Real-time test execution monitoring
+ */
+export type { TUIOptions, TUIState, TUIGateState, TUIEvent, TUIRenderer, TUIProgressBarOptions, TUITableOptions, TUILayout, TUISection } from './types.js';
+export { TerminalRenderer } from './renderer.js';
+export { TUIMonitor, createMonitor, monitorExecution } from './monitor.js';

package/cli/dist/core/tui/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 TUI (Terminal UI) Module
+ * Phase 8: Real-time test execution monitoring
+ */
+export { TerminalRenderer } from './renderer.js';
+export { TUIMonitor, createMonitor, monitorExecution } from './monitor.js';

package/cli/dist/core/tui/monitor.d.ts

@@ -0,0 +1,92 @@
+/**
+ * TUI Monitor - Real-time test execution monitor
+ * Listens to Phase3Runner events and updates the terminal UI
+ */
+import type { TUIOptions, TUIState, TUIEvent, TUIGateState } from './types.js';
+export declare class TUIMonitor {
+    private options;
+    private renderer;
+    private state;
+    private refreshInterval?;
+    private eventBuffer;
+    private gateStartTime;
+    constructor(options?: TUIOptions);
+    /**
+     * Start monitoring a test run
+     */
+    start(totalGates: number): void;
+    /**
+     * Emit an event during test execution
+     */
+    emit(event: TUIEvent): void;
+    /**
+     * Update gate status
+     */
+    updateGate(name: string, updates: Partial<TUIGateState>): void;
+    /**
+     * Mark gate as started
+     */
+    startGate(name: string): void;
+    /**
+     * Mark gate as completed
+     */
+    completeGate(name: string, success: boolean, results?: {
+        total: number;
+        passed: number;
+        failed: number;
+    }): void;
+    /**
+     * Set current phase
+     */
+    setPhase(phase: string): void;
+    /**
+     * Set current progress (0-100)
+     */
+    setProgress(progress: number): void;
+    /**
+     * Update test progress for current gate
+     */
+    updateTestProgress(gateName: string, completed: number, total: number): void;
+    /**
+     * Mark run as failed
+     */
+    fail(error: string): void;
+    /**
+     * Mark run as completed
+     */
+    complete(): void;
+    /**
+     * Stop monitoring and cleanup
+     */
+    stop(): void;
+    /**
+     * Cleanup and restore terminal
+     */
+    cleanup(): void;
+    /**
+     * Get current state
+     */
+    getState(): Readonly<TUIState>;
+    /**
+     * Get event buffer
+     */
+    getEvents(): ReadonlyArray<TUIEvent>;
+    private processEvent;
+    private updateElapsed;
+    private calculateETA;
+    private updateProgress;
+    private printSummary;
+    private formatCount;
+    private formatDuration;
+    private setupExitHandlers;
+    private removeExitHandlers;
+    private handleExit;
+}
+/**
+ * Create a monitor instance for programmatic use
+ */
+export declare function createMonitor(options?: TUIOptions): TUIMonitor;
+/**
+ * Convenience function to monitor a Phase3Runner execution
+ */
+export declare function monitorExecution(execute: (emit: (event: TUIEvent) => void) => Promise<void>, options?: TUIOptions): Promise<void>;