@useatlas/create 0.0.1

package/templates/docker/bin/__tests__/duckdb-ingest.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Integration tests for DuckDB CSV/Parquet ingestion via the CLI.
+ *
+ * Tests the ingestIntoDuckDB, listDuckDBObjects, and profileDuckDB functions
+ * using real DuckDB instances with temporary files.
+ */
+import { describe, it, expect, afterEach } from "bun:test";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { ingestIntoDuckDB, listDuckDBObjects, profileDuckDB } from "../atlas";
+
+let tmpDir: string;
+
+function createTmpDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "atlas-duckdb-test-"));
+  tmpDir = dir;
+  return dir;
+}
+
+function cleanTmpDir(): void {
+  if (tmpDir && fs.existsSync(tmpDir)) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+afterEach(cleanTmpDir);
+
+describe("ingestIntoDuckDB", () => {
+  it("ingests a CSV file and creates a table", async () => {
+    const dir = createTmpDir();
+    const csvPath = path.join(dir, "sales.csv");
+    fs.writeFileSync(csvPath, "id,product,amount\n1,Widget,100\n2,Gadget,250\n3,Widget,75\n");
+
+    const dbPath = path.join(dir, "test.duckdb");
+    const tables = await ingestIntoDuckDB(dbPath, [{ path: csvPath, format: "csv" }]);
+
+    expect(tables).toEqual(["sales"]);
+    expect(fs.existsSync(dbPath)).toBe(true);
+  });
+
+  it("ingests multiple CSV files", async () => {
+    const dir = createTmpDir();
+    const csv1 = path.join(dir, "products.csv");
+    const csv2 = path.join(dir, "orders.csv");
+    fs.writeFileSync(csv1, "id,name,price\n1,Widget,9.99\n2,Gadget,19.99\n");
+    fs.writeFileSync(csv2, "id,product_id,quantity\n1,1,5\n2,2,3\n");
+
+    const dbPath = path.join(dir, "test.duckdb");
+    const tables = await ingestIntoDuckDB(dbPath, [
+      { path: csv1, format: "csv" },
+      { path: csv2, format: "csv" },
+    ]);
+
+    expect(tables).toContain("products");
+    expect(tables).toContain("orders");
+    expect(tables).toHaveLength(2);
+  });
+
+  it("sanitizes table names from file stems", async () => {
+    const dir = createTmpDir();
+    const csvPath = path.join(dir, "my-sales data (2024).csv");
+    fs.writeFileSync(csvPath, "id,amount\n1,100\n");
+
+    const dbPath = path.join(dir, "test.duckdb");
+    const tables = await ingestIntoDuckDB(dbPath, [{ path: csvPath, format: "csv" }]);
+
+    // Non-identifier chars replaced with underscores
+    expect(tables[0]).toMatch(/^[a-z_][a-z0-9_]*$/);
+  });
+
+  it("throws for missing file", async () => {
+    const dir = createTmpDir();
+    const dbPath = path.join(dir, "test.duckdb");
+
+    await expect(
+      ingestIntoDuckDB(dbPath, [{ path: "/nonexistent/file.csv", format: "csv" }])
+    ).rejects.toThrow("File not found");
+  });
+
+  it("ingests a Parquet file", async () => {
+    const dir = createTmpDir();
+    // Create a Parquet file using DuckDB
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { DuckDBInstance } = require("@duckdb/node-api");
+    const inst = await DuckDBInstance.create(":memory:");
+    const c = await inst.connect();
+    const parquetPath = path.join(dir, "data.parquet");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await (c as any).run(`COPY (SELECT 1 AS id, 'test' AS name) TO '${parquetPath.replace(/'/g, "''")}' (FORMAT PARQUET)`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (c as any).disconnectSync();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (inst as any).closeSync();
+
+    const dbPath = path.join(dir, "test.duckdb");
+    const tables = await ingestIntoDuckDB(dbPath, [{ path: parquetPath, format: "parquet" }]);
+    expect(tables).toEqual(["data"]);
+  });
+});
+
+describe("listDuckDBObjects", () => {
+  it("lists tables in a DuckDB database", async () => {
+    const dir = createTmpDir();
+    const csvPath = path.join(dir, "data.csv");
+    fs.writeFileSync(csvPath, "x,y\n1,2\n3,4\n");
+
+    const dbPath = path.join(dir, "test.duckdb");
+    await ingestIntoDuckDB(dbPath, [{ path: csvPath, format: "csv" }]);
+
+    const objects = await listDuckDBObjects(dbPath);
+    expect(objects).toHaveLength(1);
+    expect(objects[0].name).toBe("data");
+    expect(objects[0].type).toBe("table");
+  });
+});
+
+describe("profileDuckDB", () => {
+  it("profiles a table with correct row count and columns", async () => {
+    const dir = createTmpDir();
+    const csvPath = path.join(dir, "employees.csv");
+    fs.writeFileSync(
+      csvPath,
+      "id,name,department,salary\n" +
+      "1,Alice,Engineering,120000\n" +
+      "2,Bob,Sales,95000\n" +
+      "3,Charlie,Engineering,115000\n" +
+      "4,Diana,Marketing,88000\n" +
+      "5,Eve,Sales,92000\n"
+    );
+
+    const dbPath = path.join(dir, "test.duckdb");
+    await ingestIntoDuckDB(dbPath, [{ path: csvPath, format: "csv" }]);
+
+    const profiles = await profileDuckDB(dbPath);
+    expect(profiles).toHaveLength(1);
+
+    const profile = profiles[0];
+    expect(profile.table_name).toBe("employees");
+    expect(profile.row_count).toBe(5);
+    expect(profile.columns.length).toBe(4);
+
+    const nameCol = profile.columns.find((c) => c.name === "name");
+    expect(nameCol).toBeDefined();
+    expect(nameCol!.unique_count).toBe(5);
+
+    const deptCol = profile.columns.find((c) => c.name === "department");
+    expect(deptCol).toBeDefined();
+    // 3 unique departments with 5 rows = 60% cardinality, but <=10 unique → enum-like
+    expect(deptCol!.is_enum_like).toBe(true);
+    expect(deptCol!.sample_values.length).toBeGreaterThan(0);
+  });
+
+  it("respects filterTables parameter", async () => {
+    const dir = createTmpDir();
+    const csv1 = path.join(dir, "a.csv");
+    const csv2 = path.join(dir, "b.csv");
+    fs.writeFileSync(csv1, "x\n1\n2\n");
+    fs.writeFileSync(csv2, "y\n3\n4\n");
+
+    const dbPath = path.join(dir, "test.duckdb");
+    await ingestIntoDuckDB(dbPath, [
+      { path: csv1, format: "csv" },
+      { path: csv2, format: "csv" },
+    ]);
+
+    const profiles = await profileDuckDB(dbPath, ["a"]);
+    expect(profiles).toHaveLength(1);
+    expect(profiles[0].table_name).toBe("a");
+  });
+});

package/templates/docker/bin/__tests__/eval.test.ts

@@ -0,0 +1,434 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import {
+  loadEvalCases,
+  validateCase,
+  filterCases,
+  computeSummary,
+  detectRegressions,
+  type EvalCase,
+  type EvalResult,
+} from "../eval";
+
+// ---------------------------------------------------------------------------
+// Helper: create a temp directory with YAML case files
+// ---------------------------------------------------------------------------
+
+function writeTempCases(
+  cases: Record<string, string>[],
+  schemaDir: string = "simple",
+): string {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-test-"));
+  const schemaDirPath = path.join(tmpDir, schemaDir);
+  fs.mkdirSync(schemaDirPath, { recursive: true });
+
+  for (const c of cases) {
+    const id = c.id ?? "test-001";
+    fs.writeFileSync(
+      path.join(schemaDirPath, `${id}.yml`),
+      Object.entries(c)
+        .map(([k, v]) => {
+          if (k === "tags") return `tags: [${v}]`;
+          if (k === "gold_sql") return `gold_sql: |\n  ${v}`;
+          return `${k}: ${v}`;
+        })
+        .join("\n"),
+    );
+  }
+
+  return tmpDir;
+}
+
+// ---------------------------------------------------------------------------
+// validateCase
+// ---------------------------------------------------------------------------
+
+describe("validateCase", () => {
+  test("rejects missing required field", () => {
+    expect(() =>
+      validateCase({ question: "test", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" }, "test.yml"),
+    ).toThrow('Missing required field "id"');
+  });
+
+  test("rejects invalid schema", () => {
+    expect(() =>
+      validateCase(
+        { id: "t-001", question: "test", schema: "invalid", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).toThrow('Invalid schema "invalid"');
+  });
+
+  test("rejects invalid difficulty", () => {
+    expect(() =>
+      validateCase(
+        { id: "t-001", question: "test", schema: "simple", difficulty: "impossible", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).toThrow('Invalid difficulty "impossible"');
+  });
+
+  test("rejects empty id", () => {
+    expect(() =>
+      validateCase(
+        { id: "  ", question: "test", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).toThrow("Invalid id");
+  });
+
+  test("rejects empty question", () => {
+    expect(() =>
+      validateCase(
+        { id: "t-001", question: "", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).toThrow("question");
+  });
+
+  test("rejects whitespace-only gold_sql", () => {
+    expect(() =>
+      validateCase(
+        { id: "t-001", question: "Q?", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "   " },
+        "test.yml",
+      ),
+    ).toThrow("gold_sql");
+  });
+
+  test("rejects numeric id (YAML auto-casts numbers)", () => {
+    expect(() =>
+      validateCase(
+        { id: 42, question: "Q?", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).toThrow("Invalid id");
+  });
+
+  test("accepts valid case", () => {
+    expect(() =>
+      validateCase(
+        { id: "t-001", question: "How many?", schema: "simple", difficulty: "simple", category: "filter", gold_sql: "SELECT 1" },
+        "test.yml",
+      ),
+    ).not.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadEvalCases
+// ---------------------------------------------------------------------------
+
+describe("loadEvalCases", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  test("loads cases from YAML files", () => {
+    tmpDir = writeTempCases([
+      {
+        id: "sp-001",
+        question: "How many companies?",
+        schema: "simple",
+        difficulty: "simple",
+        category: "aggregation",
+        tags: "companies, count",
+        gold_sql: "SELECT COUNT(*) FROM companies",
+      },
+    ]);
+
+    const cases = loadEvalCases(tmpDir);
+    expect(cases).toHaveLength(1);
+    expect(cases[0].id).toBe("sp-001");
+    expect(cases[0].question).toBe("How many companies?");
+    expect(cases[0].schema).toBe("simple");
+    expect(cases[0].difficulty).toBe("simple");
+    expect(cases[0].category).toBe("aggregation");
+    expect(cases[0].gold_sql).toBe("SELECT COUNT(*) FROM companies");
+  });
+
+  test("loads from multiple schema directories", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-test-"));
+
+    // Simple case
+    const simpleDir = path.join(tmpDir, "simple");
+    fs.mkdirSync(simpleDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(simpleDir, "sp-001.yml"),
+      'id: sp-001\nquestion: "Q1"\nschema: simple\ndifficulty: simple\ncategory: filter\ntags: []\ngold_sql: "SELECT 1"',
+    );
+
+    // Cybersec case
+    const cybersecDir = path.join(tmpDir, "cybersec");
+    fs.mkdirSync(cybersecDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(cybersecDir, "cs-001.yml"),
+      'id: cs-001\nquestion: "Q2"\nschema: cybersec\ndifficulty: medium\ncategory: join\ntags: []\ngold_sql: "SELECT 2"',
+    );
+
+    const cases = loadEvalCases(tmpDir);
+    expect(cases).toHaveLength(2);
+    const schemas = cases.map(c => c.schema).sort();
+    expect(schemas).toEqual(["cybersec", "simple"]);
+  });
+
+  test("throws on missing directory", () => {
+    expect(() => loadEvalCases("/nonexistent/path")).toThrow("Eval cases directory not found");
+  });
+
+  test("returns empty for schema directory with no YAML files", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-test-"));
+    fs.mkdirSync(path.join(tmpDir, "simple"), { recursive: true });
+    const cases = loadEvalCases(tmpDir);
+    expect(cases).toHaveLength(0);
+  });
+
+  test("defaults tags to empty array when missing from YAML", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-test-"));
+    const dir = path.join(tmpDir, "simple");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, "sp-001.yml"),
+      'id: sp-001\nquestion: "Q1"\nschema: simple\ndifficulty: simple\ncategory: filter\ngold_sql: "SELECT 1"',
+    );
+    const cases = loadEvalCases(tmpDir);
+    expect(cases).toHaveLength(1);
+    expect(cases[0].tags).toEqual([]);
+  });
+
+  test("rejects duplicate case IDs across files", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-test-"));
+    const dir = path.join(tmpDir, "simple");
+    fs.mkdirSync(dir, { recursive: true });
+    const yaml = 'id: dup-001\nquestion: "Q"\nschema: simple\ndifficulty: simple\ncategory: filter\ntags: []\ngold_sql: "SELECT 1"';
+    fs.writeFileSync(path.join(dir, "a.yml"), yaml);
+    fs.writeFileSync(path.join(dir, "b.yml"), yaml);
+    expect(() => loadEvalCases(tmpDir)).toThrow('Duplicate eval case id "dup-001"');
+  });
+
+  test("throws on invalid case", () => {
+    tmpDir = writeTempCases([
+      {
+        id: "bad-001",
+        question: "Missing schema",
+        difficulty: "simple",
+        category: "filter",
+        gold_sql: "SELECT 1",
+      } as unknown as Record<string, string>,
+    ]);
+
+    expect(() => loadEvalCases(tmpDir)).toThrow('Missing required field "schema"');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// filterCases
+// ---------------------------------------------------------------------------
+
+describe("filterCases", () => {
+  const cases: EvalCase[] = [
+    { id: "sp-001", question: "Q1", schema: "simple", difficulty: "simple", category: "aggregation", tags: [], gold_sql: "SELECT 1" },
+    { id: "sp-002", question: "Q2", schema: "simple", difficulty: "medium", category: "join", tags: [], gold_sql: "SELECT 2" },
+    { id: "cs-001", question: "Q3", schema: "cybersec", difficulty: "simple", category: "filter", tags: [], gold_sql: "SELECT 3" },
+    { id: "cs-002", question: "Q4", schema: "cybersec", difficulty: "complex", category: "aggregation", tags: [], gold_sql: "SELECT 4" },
+    { id: "ec-001", question: "Q5", schema: "ecommerce", difficulty: "medium", category: "timeseries", tags: [], gold_sql: "SELECT 5" },
+    { id: "sp-skip", question: "Q6", schema: "simple", difficulty: "simple", category: "filter", tags: [], gold_sql: "SELECT 6", skip: true },
+  ];
+
+  test("filters by schema", () => {
+    const result = filterCases(cases, { schema: "cybersec" });
+    expect(result).toHaveLength(2);
+    expect(result.every(c => c.schema === "cybersec")).toBe(true);
+  });
+
+  test("filters by category", () => {
+    const result = filterCases(cases, { category: "aggregation" });
+    expect(result).toHaveLength(2);
+    expect(result.every(c => c.category === "aggregation")).toBe(true);
+  });
+
+  test("filters by difficulty", () => {
+    const result = filterCases(cases, { difficulty: "simple" });
+    expect(result).toHaveLength(2);
+    expect(result.every(c => c.difficulty === "simple")).toBe(true);
+  });
+
+  test("filters by id", () => {
+    const result = filterCases(cases, { id: "cs-001" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("cs-001");
+  });
+
+  test("applies limit", () => {
+    const result = filterCases(cases, { limit: 2 });
+    expect(result).toHaveLength(2);
+  });
+
+  test("excludes skipped cases", () => {
+    const result = filterCases(cases, {});
+    expect(result.find(c => c.id === "sp-skip")).toBeUndefined();
+    expect(result).toHaveLength(5);
+  });
+
+  test("combines filters", () => {
+    const result = filterCases(cases, { schema: "simple", difficulty: "simple" });
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("sp-001");
+  });
+
+  test("limit of 0 returns all cases (no slicing)", () => {
+    const result = filterCases(cases, { limit: 0 });
+    expect(result).toHaveLength(5);
+  });
+
+  test("returns empty on no match", () => {
+    const result = filterCases(cases, { schema: "nonexistent" });
+    expect(result).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeSummary
+// ---------------------------------------------------------------------------
+
+describe("computeSummary", () => {
+  const results: EvalResult[] = [
+    { id: "sp-001", schema: "simple", question: "Q1", category: "aggregation", difficulty: "simple", tags: [], gold_sql: "", predicted_sql: "SELECT 1", match: true, error: null, latency_ms: 1000, tokens: 500, steps: 3 },
+    { id: "sp-002", schema: "simple", question: "Q2", category: "join", difficulty: "medium", tags: [], gold_sql: "", predicted_sql: "SELECT 2", match: false, error: null, latency_ms: 2000, tokens: 800, steps: 5 },
+    { id: "cs-001", schema: "cybersec", question: "Q3", category: "filter", difficulty: "simple", tags: [], gold_sql: "", predicted_sql: null, match: false, error: "timeout", latency_ms: 30000, tokens: 0, steps: 0 },
+    { id: "cs-002", schema: "cybersec", question: "Q4", category: "aggregation", difficulty: "complex", tags: [], gold_sql: "", predicted_sql: "SELECT 4", match: true, error: null, latency_ms: 3000, tokens: 1200, steps: 7 },
+  ];
+
+  test("computes overall accuracy", () => {
+    const summary = computeSummary(results);
+    expect(summary.total).toBe(4);
+    expect(summary.correct).toBe(2);
+    expect(summary.errors).toBe(1);
+    expect(summary.accuracy).toBe(50);
+  });
+
+  test("computes per-schema breakdown", () => {
+    const summary = computeSummary(results);
+    expect(summary.bySchema.get("simple")).toEqual({ total: 2, correct: 1 });
+    expect(summary.bySchema.get("cybersec")).toEqual({ total: 2, correct: 1 });
+  });
+
+  test("computes per-category breakdown", () => {
+    const summary = computeSummary(results);
+    expect(summary.byCategory.get("aggregation")).toEqual({ total: 2, correct: 2 });
+    expect(summary.byCategory.get("join")).toEqual({ total: 1, correct: 0 });
+    expect(summary.byCategory.get("filter")).toEqual({ total: 1, correct: 0 });
+  });
+
+  test("computes per-difficulty breakdown", () => {
+    const summary = computeSummary(results);
+    expect(summary.byDifficulty.get("simple")).toEqual({ total: 2, correct: 1 });
+    expect(summary.byDifficulty.get("medium")).toEqual({ total: 1, correct: 0 });
+    expect(summary.byDifficulty.get("complex")).toEqual({ total: 1, correct: 1 });
+  });
+
+  test("computes token and latency stats", () => {
+    const summary = computeSummary(results);
+    expect(summary.totalTokens).toBe(2500);
+    expect(summary.totalLatencyMs).toBe(36000);
+    expect(summary.avgLatencyMs).toBe(9000);
+  });
+
+  test("handles empty results", () => {
+    const summary = computeSummary([]);
+    expect(summary.total).toBe(0);
+    expect(summary.correct).toBe(0);
+    expect(summary.accuracy).toBe(0);
+    expect(summary.avgLatencyMs).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// detectRegressions
+// ---------------------------------------------------------------------------
+
+describe("detectRegressions", () => {
+  const baseline: EvalResult[] = [
+    { id: "sp-001", schema: "simple", question: "Q1", category: "agg", difficulty: "simple", tags: [], gold_sql: "", predicted_sql: "S1", match: true, error: null, latency_ms: 1000, tokens: 500, steps: 3 },
+    { id: "sp-002", schema: "simple", question: "Q2", category: "join", difficulty: "medium", tags: [], gold_sql: "", predicted_sql: "S2", match: false, error: null, latency_ms: 2000, tokens: 800, steps: 5 },
+    { id: "cs-001", schema: "cybersec", question: "Q3", category: "filter", difficulty: "simple", tags: [], gold_sql: "", predicted_sql: "S3", match: true, error: null, latency_ms: 1500, tokens: 600, steps: 4 },
+  ];
+
+  test("detects regression (was pass, now fail)", () => {
+    const current: EvalResult[] = [
+      { ...baseline[0], match: false, error: "wrong result" },  // sp-001: was PASS → now FAIL
+      { ...baseline[1], match: false },                          // sp-002: was FAIL → still FAIL
+      { ...baseline[2], match: true },                           // cs-001: was PASS → still PASS
+    ];
+
+    const report = detectRegressions(current, baseline);
+    expect(report.regressions).toHaveLength(1);
+    expect(report.regressions[0].id).toBe("sp-001");
+    expect(report.newPasses).toHaveLength(0);
+    expect(report.newCases).toHaveLength(0);
+    expect(report.stable).toBe(2);
+  });
+
+  test("detects new pass (was fail, now pass)", () => {
+    const current: EvalResult[] = [
+      { ...baseline[0], match: true },                           // sp-001: still PASS
+      { ...baseline[1], match: true },                           // sp-002: was FAIL → now PASS
+      { ...baseline[2], match: true },                           // cs-001: still PASS
+    ];
+
+    const report = detectRegressions(current, baseline);
+    expect(report.regressions).toHaveLength(0);
+    expect(report.newPasses).toHaveLength(1);
+    expect(report.newPasses[0].id).toBe("sp-002");
+    expect(report.stable).toBe(2);
+  });
+
+  test("detects new cases (not in baseline)", () => {
+    const current: EvalResult[] = [
+      { ...baseline[0], match: true },
+      { ...baseline[1], match: false },
+      { ...baseline[2], match: true },
+      { id: "ec-001", schema: "ecommerce", question: "New Q", category: "agg", difficulty: "simple", tags: [], gold_sql: "", predicted_sql: "S4", match: true, error: null, latency_ms: 1000, tokens: 500, steps: 3 },
+    ];
+
+    const report = detectRegressions(current, baseline);
+    expect(report.newCases).toHaveLength(1);
+    expect(report.newCases[0].id).toBe("ec-001");
+    expect(report.stable).toBe(3);
+  });
+
+  test("handles empty baseline", () => {
+    const current: EvalResult[] = [
+      { ...baseline[0], match: true },
+    ];
+
+    const report = detectRegressions(current, []);
+    expect(report.newCases).toHaveLength(1);
+    expect(report.regressions).toHaveLength(0);
+    expect(report.stable).toBe(0);
+  });
+
+  test("handles empty current", () => {
+    const report = detectRegressions([], baseline);
+    expect(report.regressions).toHaveLength(0);
+    expect(report.newPasses).toHaveLength(0);
+    expect(report.newCases).toHaveLength(0);
+    expect(report.stable).toBe(0);
+  });
+
+  test("baseline cases absent from current are silently ignored", () => {
+    const current: EvalResult[] = [
+      { ...baseline[0], match: true },
+    ];
+    const report = detectRegressions(current, baseline);
+    expect(report.regressions).toHaveLength(0);
+    expect(report.newPasses).toHaveLength(0);
+    expect(report.newCases).toHaveLength(0);
+    expect(report.stable).toBe(1);
+  });
+});