Add --filter flags to stats command (model, date range, test status) (#124)

--model, --since, --until, --passed-only filter runs before aggregating.
9 new tests for filtering logic.

Generated by thinktank Opus (5 agents, ALL pass, 71% convergence).

Closes #78

Co-authored-by: unknown <that-github-user@github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

src/cli.ts

@@ -194,8 +194,17 @@ program
 program
   .command("stats")
   .description("Show aggregate statistics across all thinktank runs")
-  .action(async () => {
-    await stats();
+  .option("--model <name>", "Filter to runs using the specified model")
+  .option("--since <date>", "Show only runs from this date onward (ISO 8601)")
+  .option("--until <date>", "Show only runs up to this date (ISO 8601)")
+  .option("--passed-only", "Show only runs where at least one agent passed tests")
+  .action(async (opts) => {
+    await stats({
+      model: opts.model,
+      since: opts.since,
+      until: opts.until,
+      passedOnly: opts.passedOnly,
+    });
   });
 
 program

src/commands/stats.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { EnsembleResult } from "../types.js";
+import { filterResults } from "./stats.js";
+
+function makeResult(overrides: Partial<EnsembleResult> = {}): EnsembleResult {
+  return {
+    prompt: "test prompt",
+    model: "sonnet",
+    timestamp: "2026-03-15T10:00:00Z",
+    scoring: "copeland",
+    agents: [
+      {
+        id: 1,
+        worktree: "/tmp/w1",
+        status: "success",
+        exitCode: 0,
+        duration: 5000,
+        output: "",
+        diff: "diff",
+        filesChanged: ["a.ts"],
+        linesAdded: 10,
+        linesRemoved: 2,
+      },
+    ],
+    tests: [{ agentId: 1, passed: true, output: "", exitCode: 0 }],
+    convergence: [{ agents: [1], similarity: 0.9, filesChanged: ["a.ts"], description: "group" }],
+    recommended: 1,
+    scores: [],
+    ...overrides,
+  };
+}
+
+describe("filterResults", () => {
+  const results: EnsembleResult[] = [
+    makeResult({ model: "sonnet", timestamp: "2026-03-10T10:00:00Z" }),
+    makeResult({
+      model: "opus",
+      timestamp: "2026-03-15T10:00:00Z",
+      tests: [{ agentId: 1, passed: false, output: "", exitCode: 1 }],
+    }),
+    makeResult({ model: "sonnet", timestamp: "2026-03-20T10:00:00Z" }),
+  ];
+
+  it("returns all results with no filters", () => {
+    const filtered = filterResults(results, {});
+    assert.equal(filtered.length, 3);
+  });
+
+  it("filters by model name (case-insensitive substring)", () => {
+    const filtered = filterResults(results, { model: "Opus" });
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].model, "opus");
+  });
+
+  it("filters by --since date", () => {
+    const filtered = filterResults(results, { since: "2026-03-12" });
+    assert.equal(filtered.length, 2);
+  });
+
+  it("filters by --until date", () => {
+    const filtered = filterResults(results, { until: "2026-03-15T10:00:00Z" });
+    assert.equal(filtered.length, 2);
+  });
+
+  it("filters by --since and --until together", () => {
+    const filtered = filterResults(results, {
+      since: "2026-03-12",
+      until: "2026-03-18",
+    });
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].timestamp, "2026-03-15T10:00:00Z");
+  });
+
+  it("filters by --passed-only", () => {
+    const filtered = filterResults(results, { passedOnly: true });
+    assert.equal(filtered.length, 2);
+    for (const r of filtered) {
+      assert.ok(r.tests.some((t) => t.passed));
+    }
+  });
+
+  it("combines model and passed-only filters", () => {
+    const filtered = filterResults(results, { model: "opus", passedOnly: true });
+    assert.equal(filtered.length, 0);
+  });
+
+  it("combines model and date filters", () => {
+    const filtered = filterResults(results, {
+      model: "sonnet",
+      since: "2026-03-15",
+    });
+    assert.equal(filtered.length, 1);
+    assert.equal(filtered[0].timestamp, "2026-03-20T10:00:00Z");
+  });
+
+  it("returns empty array when no results match", () => {
+    const filtered = filterResults(results, { model: "haiku" });
+    assert.equal(filtered.length, 0);
+  });
+});

src/commands/stats.ts

@@ -3,7 +3,47 @@ import { join } from "node:path";
 import pc from "picocolors";
 import type { EnsembleResult } from "../types.js";
 
-export async function stats(): Promise<void> {
+export interface StatsOptions {
+  model?: string;
+  since?: string;
+  until?: string;
+  passedOnly?: boolean;
+}
+
+export function filterResults(results: EnsembleResult[], opts: StatsOptions): EnsembleResult[] {
+  let filtered = results;
+
+  if (opts.model) {
+    const model = opts.model.toLowerCase();
+    filtered = filtered.filter((r) => r.model.toLowerCase().includes(model));
+  }
+
+  if (opts.since) {
+    const since = new Date(opts.since);
+    if (Number.isNaN(since.getTime())) {
+      console.log(pc.red(`  Invalid --since date: ${opts.since}`));
+      process.exit(1);
+    }
+    filtered = filtered.filter((r) => new Date(r.timestamp) >= since);
+  }
+
+  if (opts.until) {
+    const until = new Date(opts.until);
+    if (Number.isNaN(until.getTime())) {
+      console.log(pc.red(`  Invalid --until date: ${opts.until}`));
+      process.exit(1);
+    }
+    filtered = filtered.filter((r) => new Date(r.timestamp) <= until);
+  }
+
+  if (opts.passedOnly) {
+    filtered = filtered.filter((r) => r.tests.some((t) => t.passed));
+  }
+
+  return filtered;
+}
+
+export async function stats(opts: StatsOptions = {}): Promise<void> {
   let files: string[];
   try {
     const entries = await readdir(".thinktank");
@@ -18,16 +58,23 @@ export async function stats(): Promise<void> {
     return;
   }
 
-  const results: EnsembleResult[] = [];
+  const allResults: EnsembleResult[] = [];
   for (const file of files) {
     try {
       const raw = await readFile(join(".thinktank", file), "utf-8");
-      results.push(JSON.parse(raw) as EnsembleResult);
+      allResults.push(JSON.parse(raw) as EnsembleResult);
     } catch {
       // skip malformed files
     }
   }
 
+  const results = filterResults(allResults, opts);
+
+  if (results.length === 0) {
+    console.log(pc.yellow("  No runs match the specified filters."));
+    return;
+  }
+
   const totalRuns = results.length;
   const avgAgents = results.reduce((sum, r) => sum + r.agents.length, 0) / totalRuns;
 
@@ -43,9 +90,19 @@ export async function stats(): Promise<void> {
       ? testPassRates.reduce((sum, r) => sum + r, 0) / testPassRates.length
       : null;
 
+  const hasFilters = opts.model || opts.since || opts.until || opts.passedOnly;
+
   console.log();
   console.log(pc.bold("  thinktank stats"));
   console.log(pc.dim("  ─────────────────────────────"));
+  if (hasFilters) {
+    const parts: string[] = [];
+    if (opts.model) parts.push(`model=${pc.cyan(opts.model)}`);
+    if (opts.since) parts.push(`since=${pc.cyan(opts.since)}`);
+    if (opts.until) parts.push(`until=${pc.cyan(opts.until)}`);
+    if (opts.passedOnly) parts.push(pc.cyan("passed-only"));
+    console.log(`  Filters:             ${parts.join(pc.dim(", "))}`);
+  }
   console.log(`  Total runs:          ${pc.cyan(String(totalRuns))}`);
   console.log(`  Avg agents/run:      ${pc.cyan(avgAgents.toFixed(1))}`);
   console.log(`  Avg convergence:     ${pc.cyan((avgConvergence * 100).toFixed(1) + "%")}`);