@kirrosh/zond 0.21.0 → 0.23.0

package/src/db/queries/runs.ts

@@ -0,0 +1,235 @@
+import { getDb, withDbRetry } from "../schema.ts";
+import type { TestRunResult } from "../../core/runner/types.ts";
+import type { CreateRunOpts, RunRecord, RunSummary, RunFilters } from "./types.ts";
+
+function buildRunFilterSQL(filters: RunFilters): { where: string; params: unknown[] } {
+  const clauses: string[] = [];
+  const params: unknown[] = [];
+
+  if (filters.status === "has_failures") {
+    clauses.push("r.failed > 0");
+  } else if (filters.status === "all_passed") {
+    clauses.push("r.failed = 0 AND r.total > 0");
+  }
+
+  if (filters.environment) {
+    clauses.push("r.environment = ?");
+    params.push(filters.environment);
+  }
+
+  if (filters.date_from) {
+    clauses.push("r.started_at >= ?");
+    params.push(filters.date_from);
+  }
+
+  if (filters.date_to) {
+    clauses.push("r.started_at <= ?");
+    params.push(filters.date_to + "T23:59:59");
+  }
+
+  if (filters.test_name) {
+    clauses.push("r.id IN (SELECT DISTINCT run_id FROM results WHERE test_name LIKE ?)");
+    params.push(`%${filters.test_name}%`);
+  }
+
+  if (filters.trigger) {
+    clauses.push("r.trigger = ?");
+    params.push(filters.trigger);
+  }
+
+  const where = clauses.length > 0 ? "WHERE " + clauses.join(" AND ") : "";
+  return { where, params };
+}
+
+export function createRun(opts: CreateRunOpts): number {
+  const db = getDb();
+  const stmt = db.prepare(`
+    INSERT INTO runs (started_at, environment, trigger, commit_sha, branch, collection_id, session_id, tags, run_kind)
+    VALUES ($started_at, $environment, $trigger, $commit_sha, $branch, $collection_id, $session_id, $tags, $run_kind)
+  `);
+  const result = withDbRetry("createRun", () => stmt.run({
+    $started_at: opts.started_at,
+    $environment: opts.environment ?? null,
+    $trigger: opts.trigger ?? "manual",
+    $commit_sha: opts.commit_sha ?? null,
+    $branch: opts.branch ?? null,
+    $collection_id: opts.collection_id ?? null,
+    $session_id: opts.session_id ?? null,
+    $tags: opts.tags && opts.tags.length > 0 ? JSON.stringify(opts.tags) : null,
+    // ARV-55: default 'regular' here too — DB default would also catch it,
+    // but spelling it out keeps INSERTs idempotent and matches the type.
+    $run_kind: opts.run_kind ?? "regular",
+  }));
+  return Number(result.lastInsertRowid);
+}
+
+/** Decode the JSON-encoded `tags` column into a string array. Returns null
+ *  if the column is null or unparseable (legacy rows / corruption). */
+function decodeTags(raw: unknown): string[] | null {
+  if (raw == null) return null;
+  if (typeof raw !== "string") return null;
+  try {
+    const v = JSON.parse(raw);
+    if (Array.isArray(v) && v.every((x) => typeof x === "string")) return v;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function decodeRunKind(raw: unknown): "regular" | "probe" | "check" {
+  // Migration v10 backfills legacy rows; this is a belt-and-suspenders
+  // normaliser for any value SQLite returns from `run_kind`.
+  if (raw === "probe" || raw === "check") return raw;
+  return "regular";
+}
+
+function decodeRunRow(row: unknown): RunRecord | null {
+  if (!row || typeof row !== "object") return null;
+  const r = row as Record<string, unknown> & { tags?: unknown; run_kind?: unknown };
+  return {
+    ...(r as unknown as RunRecord),
+    tags: decodeTags(r.tags),
+    run_kind: decodeRunKind(r.run_kind),
+  };
+}
+
+export function finalizeRun(runId: number, results: TestRunResult[]): void {
+  const db = getDb();
+
+  const total = results.reduce((s, r) => s + r.total, 0);
+  const passed = results.reduce((s, r) => s + r.passed, 0);
+  const failed = results.reduce((s, r) => s + r.failed, 0);
+  const skipped = results.reduce((s, r) => s + r.skipped, 0);
+
+  const started = results[0]?.started_at ?? new Date().toISOString();
+  const finished = results[results.length - 1]?.finished_at ?? new Date().toISOString();
+  const durationMs = new Date(finished).getTime() - new Date(started).getTime();
+
+  const stmt = db.prepare(`
+    UPDATE runs
+    SET finished_at = $finished_at,
+        total       = $total,
+        passed      = $passed,
+        failed      = $failed,
+        skipped     = $skipped,
+        duration_ms = $duration_ms
+    WHERE id = $id
+  `);
+  withDbRetry("finalizeRun", () => stmt.run({
+    $finished_at: finished,
+    $total: total,
+    $passed: passed,
+    $failed: failed,
+    $skipped: skipped,
+    $duration_ms: durationMs,
+    $id: runId,
+  }));
+}
+
+export function getRunById(runId: number): RunRecord | null {
+  const db = getDb();
+  const row = db.query("SELECT * FROM runs WHERE id = ?").get(runId);
+  return decodeRunRow(row);
+}
+
+/** TASK-274: list runs of a collection with optional time-window or
+ *  tag-membership filters, ordered by started_at ASC (matches the
+ *  session-based loader so coverage union order is stable). NULL collection
+ *  is intentionally excluded — for tag/since selectors the user has
+ *  pinpointed an API, ad-hoc/probe runs should be tagged or use --union
+ *  session to be picked up. */
+export function listRunsByCollectionFiltered(
+  collectionId: number,
+  filters: { since?: string; tag?: string; limit?: number },
+): RunRecord[] {
+  const db = getDb();
+  const clauses: string[] = ["collection_id = ?", "finished_at IS NOT NULL"];
+  const params: unknown[] = [collectionId];
+  if (filters.since) {
+    clauses.push("started_at >= ?");
+    params.push(filters.since);
+  }
+  if (filters.tag) {
+    // tags is a JSON array of strings — match exact element via LIKE on the
+    // serialised form. Cheap and correct for our small N (one row per run);
+    // a JSON1-table-function approach would be overkill here.
+    clauses.push("tags LIKE ?");
+    params.push(`%"${filters.tag.replace(/[\\%_]/g, "\\$&")}"%`);
+  }
+  const limitClause = filters.limit && filters.limit > 0 ? ` LIMIT ${filters.limit}` : "";
+  const rows = db.query(
+    `SELECT * FROM runs WHERE ${clauses.join(" AND ")} ORDER BY started_at ASC${limitClause}`,
+  ).all(...(params as (string | number)[]));
+  const out: RunRecord[] = [];
+  for (const r of rows) {
+    const decoded = decodeRunRow(r);
+    if (decoded) out.push(decoded);
+  }
+  return out;
+}
+
+export function listRuns(limit = 20, offset = 0, filters?: RunFilters): RunSummary[] {
+  const db = getDb();
+  if (filters && Object.values(filters).some(Boolean)) {
+    const { where, params } = buildRunFilterSQL(filters);
+    return db.query(`
+      SELECT r.id, r.started_at, r.finished_at, r.total, r.passed, r.failed, r.skipped, r.environment, r.duration_ms, r.collection_id, r.session_id
+      FROM runs r
+      ${where}
+      ORDER BY r.started_at DESC
+      LIMIT ? OFFSET ?
+    `).all(...(params as (string | number)[]), limit, offset) as RunSummary[];
+  }
+  return db.query(`
+    SELECT id, started_at, finished_at, total, passed, failed, skipped, environment, duration_ms, collection_id, session_id
+    FROM runs
+    ORDER BY started_at DESC
+    LIMIT ? OFFSET ?
+  `).all(limit, offset) as RunSummary[];
+}
+
+/** TASK-266: latest run with at least one failure (for `zond db diagnose`
+ *  default and `zond-triage` skill). Returns null when no failing run exists. */
+export function getLatestFailingRunId(): number | null {
+  const db = getDb();
+  const row = db.query(`
+    SELECT id FROM runs
+    WHERE failed > 0
+    ORDER BY started_at DESC
+    LIMIT 1
+  `).get() as { id: number } | undefined;
+  return row?.id ?? null;
+}
+
+/** TASK-266: latest run regardless of status (for `--latest`). */
+export function getLatestRunId(): number | null {
+  const db = getDb();
+  const row = db.query(`
+    SELECT id FROM runs
+    ORDER BY started_at DESC
+    LIMIT 1
+  `).get() as { id: number } | undefined;
+  return row?.id ?? null;
+}
+
+export function deleteRun(runId: number): boolean {
+  const db = getDb();
+  // results are cascade-deleted via FK; but SQLite FK delete cascade requires explicit config
+  return withDbRetry("deleteRun", () => {
+    db.prepare("DELETE FROM results WHERE run_id = ?").run(runId);
+    const result = db.prepare("DELETE FROM runs WHERE id = ?").run(runId);
+    return result.changes > 0;
+  });
+}
+
+export function countRuns(filters?: RunFilters): number {
+  const db = getDb();
+  if (filters && Object.values(filters).some(Boolean)) {
+    const { where, params } = buildRunFilterSQL(filters);
+    const row = db.query(`SELECT COUNT(*) AS cnt FROM runs r ${where}`).get(...(params as (string | number)[])) as { cnt: number };
+    return row.cnt;
+  }
+  const row = db.query("SELECT COUNT(*) AS cnt FROM runs").get() as { cnt: number };
+  return row.cnt;
+}

package/src/db/queries/sessions.ts

@@ -0,0 +1,42 @@
+import { getDb } from "../schema.ts";
+import type { RunSummary, SessionSummary } from "./types.ts";
+
+export function listSessions(limit = 20, offset = 0): SessionSummary[] {
+  const db = getDb();
+  return db.query(`
+    SELECT
+      session_id,
+      MIN(started_at)        AS started_at,
+      MAX(finished_at)       AS finished_at,
+      COUNT(*)               AS run_count,
+      COALESCE(SUM(total), 0)   AS total,
+      COALESCE(SUM(passed), 0)  AS passed,
+      COALESCE(SUM(failed), 0)  AS failed,
+      COALESCE(SUM(skipped), 0) AS skipped,
+      SUM(duration_ms)       AS duration_ms,
+      MAX(environment)       AS environment
+    FROM runs
+    WHERE session_id IS NOT NULL
+    GROUP BY session_id
+    ORDER BY started_at DESC
+    LIMIT ? OFFSET ?
+  `).all(limit, offset) as SessionSummary[];
+}
+
+export function countSessions(): number {
+  const db = getDb();
+  const row = db.query(
+    "SELECT COUNT(DISTINCT session_id) AS cnt FROM runs WHERE session_id IS NOT NULL",
+  ).get() as { cnt: number };
+  return row.cnt;
+}
+
+export function listRunsBySession(sessionId: string): RunSummary[] {
+  const db = getDb();
+  return db.query(`
+    SELECT id, started_at, finished_at, total, passed, failed, skipped, environment, duration_ms, collection_id, session_id
+    FROM runs
+    WHERE session_id = ?
+    ORDER BY started_at ASC
+  `).all(sessionId) as RunSummary[];
+}

package/src/db/queries/settings.ts

@@ -0,0 +1,28 @@
+/**
+ * Generic key-value settings table. The two helpers are currently
+ * unused by any caller — kept as the canonical access point so future
+ * features (UI prefs, ephemeral run state) can use them without
+ * re-rolling SQL. See TASK-179 / TASK-187.
+ */
+import { getDb } from "../schema.ts";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- intentional: see file docstring
+function getSetting(key: string): string | null {
+  const db = getDb();
+  const row = db.query("SELECT value FROM settings WHERE key = ?").get(key) as { value: string } | null;
+  return row?.value ?? null;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- intentional: see file docstring
+function setSetting(key: string, value: string): void {
+  const db = getDb();
+  db.prepare(`
+    INSERT INTO settings (key, value) VALUES ($key, $value)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run({ $key: key, $value: value });
+}
+
+// Reference the helpers so module-private code keeps tsc/knip happy
+// while we leave the slot reserved for future settings consumers.
+void getSetting;
+void setSetting;

package/src/db/queries/types.ts

@@ -0,0 +1,172 @@
+/**
+ * Shared types and helpers for the per-domain query modules
+ * (`runs.ts`, `sessions.ts`, `results.ts`, `collections.ts`,
+ * `dashboard.ts`, `settings.ts`). Centralised here so domains can
+ * import each other's record shapes without circular deps.
+ */
+import { resolve } from "path";
+
+export function normalizePath(p: string): string {
+  return resolve(p).replace(/\\/g, "/");
+}
+
+export interface CreateRunOpts {
+  started_at: string;
+  environment?: string;
+  trigger?: string;
+  commit_sha?: string;
+  branch?: string;
+  collection_id?: number;
+  session_id?: string;
+  /** TASK-274: union of suite-level tags actually executed in the run, plus
+   *  any explicit `--tag <x>` filters from the CLI. Persisted as a JSON
+   *  array string so `coverage --union tag:<name>` can filter run-rows. */
+  tags?: string[];
+  /** ARV-55: 'regular' (default) | 'probe' | 'check'. Determines whether
+   *  coverage's default query picks the run up. Callers compute the kind
+   *  via `detectRunKind(suite_files)` before insert; INSERT defaults to
+   *  'regular' for legacy code paths that don't know about it yet. */
+  run_kind?: import("../../core/runner/run-kind.ts").RunKind;
+}
+
+export interface RunRecord {
+  id: number;
+  started_at: string;
+  finished_at: string | null;
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  trigger: string;
+  commit_sha: string | null;
+  branch: string | null;
+  environment: string | null;
+  duration_ms: number | null;
+  collection_id: number | null;
+  session_id: string | null;
+  /** TASK-274: tag list captured at run time (JSON-encoded in DB). null
+   *  on legacy rows persisted before migration v9. */
+  tags: string[] | null;
+  /** ARV-55: 'regular' | 'probe' | 'check'. Persisted as TEXT NOT NULL
+   *  (default 'regular'); old rows are backfilled by migration v10. */
+  run_kind: import("../../core/runner/run-kind.ts").RunKind;
+}
+
+export interface RunSummary {
+  id: number;
+  started_at: string;
+  finished_at: string | null;
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  environment: string | null;
+  duration_ms: number | null;
+  collection_id: number | null;
+  session_id: string | null;
+}
+
+export interface SessionSummary {
+  session_id: string;
+  started_at: string;
+  finished_at: string | null;
+  run_count: number;
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  duration_ms: number | null;
+  environment: string | null;
+}
+
+export interface CollectionRecord {
+  id: number;
+  name: string;
+  base_dir: string | null;
+  test_path: string;
+  openapi_spec: string | null;
+  created_at: string;
+}
+
+export interface CollectionSummary {
+  id: number;
+  name: string;
+  base_dir: string | null;
+  test_path: string;
+  openapi_spec: string | null;
+  created_at: string;
+  total_runs: number;
+  pass_rate: number;
+  last_run_at: string | null;
+  last_run_passed: number;
+  last_run_failed: number;
+  last_run_total: number;
+}
+
+export interface CreateCollectionOpts {
+  name: string;
+  base_dir?: string;
+  test_path: string;
+  openapi_spec?: string;
+}
+
+export interface StoredStepResult {
+  id: number;
+  run_id: number;
+  suite_name: string;
+  test_name: string;
+  status: string;
+  duration_ms: number;
+  request_method: string | null;
+  request_url: string | null;
+  request_body: string | null;
+  response_status: number | null;
+  response_body: string | null;
+  response_headers: string | null;
+  error_message: string | null;
+  assertions: import("../../core/runner/types.ts").AssertionResult[];
+  captures: Record<string, unknown>;
+  suite_file: string | null;
+  provenance: import("../../core/parser/types.ts").SourceMetadata | null;
+  failure_class: import("../../core/diagnostics/failure-class.ts").FailureClass | null;
+  failure_class_reason: string | null;
+  spec_pointer: string | null;
+  spec_excerpt: string | null;
+}
+
+export interface RunFilters {
+  status?: string;
+  environment?: string;
+  date_from?: string;
+  date_to?: string;
+  test_name?: string;
+  /** TASK-116: filter by run origin — "ci" (CI runs only) or "manual"
+   *  (interactive / probe / ad-hoc). Also accepts arbitrary trigger
+   *  strings if the workspace introduces custom ones. */
+  trigger?: string;
+}
+
+export interface DashboardStats {
+  totalRuns: number;
+  totalTests: number;
+  overallPassRate: number;
+  avgDuration: number;
+}
+
+export interface PassRateTrendPoint {
+  run_id: number;
+  started_at: string;
+  pass_rate: number;
+}
+
+export interface SlowestTest {
+  suite_name: string;
+  test_name: string;
+  avg_duration: number;
+}
+
+export interface FlakyTest {
+  suite_name: string;
+  test_name: string;
+  distinct_statuses: number;
+}