ci-triage 0.1.0 → 0.3.0

package/dist/flake-store.js

@@ -0,0 +1,211 @@
+import Database from 'better-sqlite3';
+import { mkdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+let _db = null;
+function dbPath() {
+    const dir = join(homedir(), '.ci-triage');
+    mkdirSync(dir, { recursive: true });
+    return join(dir, 'flake.db');
+}
+function getDb() {
+    if (_db)
+        return _db;
+    _db = new Database(dbPath());
+    bootstrap(_db);
+    return _db;
+}
+function bootstrap(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      repo TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS test_results (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id INTEGER NOT NULL,
+      test_name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      FOREIGN KEY (run_id) REFERENCES runs(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS remediations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      repo TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      fix_action TEXT NOT NULL,
+      description TEXT NOT NULL,
+      resolved_at TEXT NOT NULL,
+      resolved_commit TEXT,
+      verified_clean_run_id TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_runs_repo ON runs(repo);
+    CREATE INDEX IF NOT EXISTS idx_test_results_run_id ON test_results(run_id);
+    CREATE INDEX IF NOT EXISTS idx_test_results_test_name ON test_results(test_name);
+    CREATE INDEX IF NOT EXISTS idx_remediations_repo ON remediations(repo);
+  `);
+}
+/** Persist a run and its test outcomes. */
+export function persistRun(repo, runId, createdAt, tests) {
+    const db = getDb();
+    // Deduplicate: skip if run already stored
+    const existing = db.prepare('SELECT id FROM runs WHERE repo = ? AND run_id = ?').get(repo, String(runId));
+    if (existing)
+        return;
+    const insertRun = db.prepare('INSERT INTO runs (repo, run_id, created_at) VALUES (?, ?, ?)');
+    const insertTest = db.prepare('INSERT INTO test_results (run_id, test_name, status) VALUES (?, ?, ?)');
+    const tx = db.transaction(() => {
+        const result = insertRun.run(repo, String(runId), createdAt);
+        const rowId = result.lastInsertRowid;
+        for (const [testName, status] of Object.entries(tests)) {
+            insertTest.run(rowId, testName, status);
+        }
+    });
+    tx();
+}
+/** Get flake stats for all known tests in a repo. */
+export function getFlakes(repo) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT
+      tr.test_name,
+      SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) AS fail_count,
+      SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) AS pass_count,
+      COUNT(*) AS total_count,
+      MAX(r.created_at) AS last_seen
+    FROM test_results tr
+    JOIN runs r ON tr.run_id = r.id
+    WHERE r.repo = ?
+    GROUP BY tr.test_name
+    HAVING fail_count > 0 AND pass_count > 0
+    ORDER BY fail_count DESC
+  `).all(repo);
+    return rows.map((r) => ({
+        ...r,
+        repo,
+        flake_ratio: r.total_count > 0 ? r.fail_count / r.total_count : 0,
+    }));
+}
+/** Check if a specific test is flaky in a repo based on stored history. */
+export function isFlakySqlite(repo, testName) {
+    const db = getDb();
+    const row = db.prepare(`
+    SELECT
+      SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) AS fail_count,
+      SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) AS pass_count,
+      COUNT(*) AS total_count
+    FROM test_results tr
+    JOIN runs r ON tr.run_id = r.id
+    WHERE r.repo = ? AND tr.test_name = ?
+  `).get(repo, testName);
+    if (!row || row.total_count === 0) {
+        return { is_flaky: false, fail_count: 0, pass_count: 0, flake_ratio: 0 };
+    }
+    const flake_ratio = row.fail_count / row.total_count;
+    const is_flaky = row.fail_count > 0 && row.pass_count > 0;
+    return { is_flaky, fail_count: row.fail_count, pass_count: row.pass_count, flake_ratio };
+}
+/** Remove runs older than `daysOld` days. Returns number of runs deleted. */
+export function pruneRuns(daysOld = 90) {
+    const db = getDb();
+    const cutoff = new Date(Date.now() - daysOld * 24 * 60 * 60 * 1000).toISOString();
+    // Delete test_results for old runs first (FK constraint)
+    db.prepare(`
+    DELETE FROM test_results
+    WHERE run_id IN (SELECT id FROM runs WHERE created_at < ?)
+  `).run(cutoff);
+    const result = db.prepare('DELETE FROM runs WHERE created_at < ?').run(cutoff);
+    return result.changes;
+}
+export function getDbStats(repo) {
+    const db = getDb();
+    const path = dbPath();
+    const runCountRow = repo
+        ? db.prepare('SELECT COUNT(*) AS count FROM runs WHERE repo = ?').get(repo)
+        : db.prepare('SELECT COUNT(*) AS count FROM runs').get();
+    const testResultCountRow = repo
+        ? db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM test_results tr
+      JOIN runs r ON tr.run_id = r.id
+      WHERE r.repo = ?
+    `).get(repo)
+        : db.prepare('SELECT COUNT(*) AS count FROM test_results').get();
+    const flakyTestCountRow = repo
+        ? db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT
+          tr.test_name
+        FROM test_results tr
+        JOIN runs r ON tr.run_id = r.id
+        WHERE r.repo = ?
+        GROUP BY tr.test_name
+        HAVING
+          SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) > 0
+          AND SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) > 0
+      ) t
+    `).get(repo)
+        : db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT
+          r.repo,
+          tr.test_name
+        FROM test_results tr
+        JOIN runs r ON tr.run_id = r.id
+        GROUP BY r.repo, tr.test_name
+        HAVING
+          SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) > 0
+          AND SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) > 0
+      ) t
+    `).get();
+    return {
+        run_count: runCountRow?.count ?? 0,
+        test_result_count: testResultCountRow?.count ?? 0,
+        flaky_test_count: flakyTestCountRow?.count ?? 0,
+        db_path: path,
+        db_size_bytes: statSync(path).size,
+    };
+}
+/** Mark a run as resolved. Deduplicates on (repo, run_id). */
+export function markResolved(repo, runId, fixAction, description, resolvedCommit) {
+    const db = getDb();
+    const existing = db.prepare('SELECT id FROM remediations WHERE repo = ? AND run_id = ?').get(repo, String(runId));
+    if (existing)
+        return;
+    db.prepare('INSERT INTO remediations (repo, run_id, fix_action, description, resolved_at, resolved_commit) VALUES (?, ?, ?, ?, ?, ?)').run(repo, String(runId), fixAction, description, new Date().toISOString(), resolvedCommit ?? null);
+}
+/** Mark a subsequent clean run as verifying the fix. */
+export function markVerified(repo, runId, cleanRunId) {
+    const db = getDb();
+    db.prepare('UPDATE remediations SET verified_clean_run_id = ? WHERE repo = ? AND run_id = ?')
+        .run(String(cleanRunId), repo, String(runId));
+}
+/** Get remediation history for a repo, newest first. */
+export function getRemediations(repo) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT id, repo, run_id, fix_action, description, resolved_at, resolved_commit, verified_clean_run_id
+    FROM remediations
+    WHERE repo = ?
+    ORDER BY id DESC
+  `).all(repo);
+    return rows.map((r) => ({
+        ...r,
+        resolved_commit: r.resolved_commit ?? undefined,
+        verified_clean_run_id: r.verified_clean_run_id ?? undefined,
+        is_verified: !!r.verified_clean_run_id,
+    }));
+}
+/** Close the DB (useful in tests). */
+export function closeDb() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+}