canary-test-cli 5.15.0 → 6.0.0

package/dist/engine/guardian/pr-comment.js

@@ -0,0 +1,200 @@
+/**
+ * Deterministic GitHub PR comment poster (Tier 0, agent-free).
+ *
+ * Faithful TypeScript port of `agent/guardian/pr_comment.py`.
+ *
+ * This module posts/updates the single sticky guardian findings comment on a
+ * pull request. It is **deterministic HTTP behind an interface seam** — it
+ * imports no agent/LLM module (SC-11).
+ *
+ * Design:
+ *
+ * - {@link GitHubClient} is the seam every consumer talks to
+ *   (`listComments` / `createComment` / `updateComment`).
+ * - {@link FakeGitHubClient} is the in-memory implementation used by every unit
+ *   test — **no network**. It can simulate a fork read-only token via
+ *   `deny_writes=true` (writes reject with {@link GitHubPermissionError}).
+ * - {@link RestGitHubClient} (Python's private `_RestGitHubClient`) is the thin
+ *   real client. Network lives **only** here and is never exercised in unit
+ *   tests.
+ *
+ * Python→TS nuances:
+ *   - **async**: Python's `urllib` client is synchronous; Node's global `fetch`
+ *     is async. The seam methods are therefore `Promise`-returning, so the
+ *     real client can `await fetch`. The fakes satisfy the async interface by
+ *     being `async` (returning already-resolved values), and
+ *     {@link upsertStickyComment} becomes `async`. The pure helpers
+ *     ({@link findSticky}, {@link degradationAnnotation}) stay synchronous.
+ *   - **error mapping**: `fetch` resolves (does not throw) on a 4xx/5xx status,
+ *     so the 403→{@link GitHubPermissionError} mapping is done off `resp.status`
+ *     rather than off a raised `HTTPError`. As in the oracle, ONLY 403 maps to a
+ *     permission error here; any other non-2xx propagates as a generic error.
+ */
+// Single source of truth for the sticky-comment marker. `pr_check.render`
+// emits the identical literal at the head of a `comment`-format body so
+// `findSticky` can locate the guardian comment for in-place upsert.
+export const STICKY_MARKER = '<!-- canary-pr-guardian -->';
+/**
+ * A client cannot write (fork read-only token → HTTP 403).
+ *
+ * Thrown by write methods so {@link upsertStickyComment} can degrade loudly to
+ * a `::warning::` annotation instead of crashing the job (OT-4).
+ */
+export class GitHubPermissionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubPermissionError';
+    }
+}
+/**
+ * In-memory {@link GitHubClient} for unit tests — no network.
+ *
+ * Seed `comments` to model existing PR comments. Set `deny_writes=true` to
+ * simulate a fork read-only token: `createComment`/`updateComment` then reject
+ * with {@link GitHubPermissionError}.
+ */
+export class FakeGitHubClient {
+    comments;
+    deny_writes;
+    nextId;
+    constructor(init = {}) {
+        this.comments = init.comments ?? [];
+        this.deny_writes = init.deny_writes ?? false;
+        this.nextId = 1000;
+    }
+    async listComments() {
+        return this.comments;
+    }
+    async createComment(body) {
+        if (this.deny_writes) {
+            throw new GitHubPermissionError('read-only token: cannot create comment');
+        }
+        this.nextId += 1;
+        const row = { id: this.nextId, body };
+        this.comments.push(row);
+        return row;
+    }
+    async updateComment(commentId, body) {
+        if (this.deny_writes) {
+            throw new GitHubPermissionError('read-only token: cannot update comment');
+        }
+        for (const row of this.comments) {
+            if (row.id === commentId) {
+                row.body = body;
+                return row;
+            }
+        }
+        throw new Error(`no comment with id ${commentId}`);
+    }
+}
+/** Return the first comment whose body contains `marker`, else `null`. */
+export function findSticky(comments, marker = STICKY_MARKER) {
+    for (const comment of comments) {
+        if ((comment.body ?? '').includes(marker)) {
+            return comment;
+        }
+    }
+    return null;
+}
+/**
+ * Post or update the single sticky guardian comment (SC-9).
+ *
+ * Locates the existing comment by `marker`; updates it in place when present,
+ * otherwise creates a new one. Never stacks duplicates. A read-only token (fork
+ * PR?) degrades loudly to a `degraded` result rather than crashing (OT-4).
+ */
+export async function upsertStickyComment(client, body, marker = STICKY_MARKER) {
+    const existing = findSticky(await client.listComments(), marker);
+    try {
+        if (existing !== null) {
+            const updated = await client.updateComment(existing.id, body);
+            return { action: 'updated', comment_id: updated.id, notice: null };
+        }
+        const created = await client.createComment(body);
+        return { action: 'created', comment_id: created.id, notice: null };
+    }
+    catch (err) {
+        if (err instanceof GitHubPermissionError) {
+            // OT-4 / SC-1+D6: a read-only token (fork PR?) must degrade loudly, not
+            // crash the job. The caller emits `notice` as a `::warning::` annotation.
+            return {
+                action: 'degraded',
+                comment_id: null,
+                notice: 'guardian: read-only token (fork PR?) — findings not posted as ' +
+                    'a comment',
+            };
+        }
+        throw err;
+    }
+}
+/** Return a GitHub Actions `::warning::` annotation line for `notice`. */
+export function degradationAnnotation(notice) {
+    return `::warning::${notice}`;
+}
+/**
+ * Thin real {@link GitHubClient} over the GitHub REST API (`fetch`).
+ *
+ * Python's private `_RestGitHubClient`, exported here (public, like
+ * {@link RestBranchProtectionClient}). Network lives ONLY here; **no unit test
+ * exercises this class**. A 403 (fork read-only token) surfaces as
+ * {@link GitHubPermissionError} so the caller degrades loudly rather than
+ * crashing.
+ *
+ * Comments live on the *issues* endpoint (a PR is an issue):
+ * `https://api.github.com/repos/{repo}/issues/{pr}/comments`.
+ */
+export class RestGitHubClient {
+    repo;
+    prNumber;
+    token;
+    static API = 'https://api.github.com';
+    constructor(repo, prNumber, token) {
+        this.repo = repo;
+        this.prNumber = prNumber;
+        this.token = token;
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            Accept: 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+            'Content-Type': 'application/json',
+            'User-Agent': 'canary-pr-guardian',
+        };
+    }
+    async request(method, url, payload) {
+        const init = { method, headers: this.headers() };
+        if (payload !== undefined) {
+            init.body = JSON.stringify(payload);
+        }
+        const resp = await fetch(url, init);
+        if (!resp.ok) {
+            // As in the oracle, ONLY 403 maps to a permission error; any other
+            // non-2xx propagates (the analog of urllib's HTTPError re-raise).
+            if (resp.status === 403) {
+                throw new GitHubPermissionError(`GitHub API 403 (read-only token / fork PR?): ${url}`);
+            }
+            throw new Error(`GitHub API ${resp.status}: ${url}`);
+        }
+        return resp.json();
+    }
+    async listComments() {
+        const url = `${RestGitHubClient.API}/repos/${this.repo}/issues/${this.prNumber}/comments`;
+        const result = await this.request('GET', url);
+        return Array.isArray(result) ? result : [];
+    }
+    async createComment(body) {
+        const url = `${RestGitHubClient.API}/repos/${this.repo}/issues/${this.prNumber}/comments`;
+        const result = await this.request('POST', url, { body });
+        return isRecord(result) ? result : {};
+    }
+    async updateComment(commentId, body) {
+        const url = `${RestGitHubClient.API}/repos/${this.repo}/issues/comments/${commentId}`;
+        const result = await this.request('PATCH', url, { body });
+        return isRecord(result) ? result : {};
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=pr-comment.js.map

package/dist/engine/guardian/summary-emitter.js

@@ -0,0 +1,94 @@
+/**
+ * Build the Phase 1 impact summary Markdown.
+ *
+ * Faithful TypeScript port of `agent/guardian/summary_emitter.py`. This is the
+ * content posted as a PR comment on the SUT repo after a merge to main. Pure
+ * function: takes gaps and metadata, returns a Markdown string.
+ *
+ * Note: the emoji below are load-bearing output data (they appear verbatim in
+ * the emitted Markdown), so they are retained here despite the usual
+ * no-emoji-in-source convention.
+ */
+import { ChangeType } from './diff-extractor.js';
+import { Severity } from './impact-mapper.js';
+const SEVERITY_EMOJI = {
+    [Severity.CRITICAL]: '🔴',
+    [Severity.HIGH]: '🟠',
+    [Severity.MEDIUM]: '🟡',
+    [Severity.LOW]: '🟢',
+};
+/** Python: `build_summary`. */
+export function buildSummary(gaps, commitSha, suite, healthSnapshot = '') {
+    const shortSha = commitSha.slice(0, 8);
+    if (gaps.length === 0) {
+        return (`## Canary Guardian — Test Impact Summary\n\n` +
+            `**Commit:** ${shortSha}  \n` +
+            `**Suite:** ${suite}\n\n` +
+            `✅ No test impact detected — all existing endpoints and coverage are unchanged.\n`);
+    }
+    const added = gaps.filter((g) => g.change_type === ChangeType.ADDED);
+    const removed = gaps.filter((g) => g.change_type === ChangeType.REMOVED);
+    const changed = gaps.filter((g) => g.change_type === ChangeType.CHANGED);
+    const lines = [
+        '## Canary Guardian — Test Impact Summary\n',
+        `**Commit:** ${shortSha}  \n**Suite:** ${suite}\n`,
+    ];
+    if (added.length) {
+        lines.push('### New endpoints (not yet covered)');
+        for (const g of added) {
+            const sev = SEVERITY_EMOJI[g.severity];
+            const cov = g.affected_tests.length
+                ? `${g.affected_tests.length} existing test(s)`
+                : '**no existing tests**';
+            lines.push(`- ${sev} \`${g.method.toUpperCase()} ${g.path}\` — ${cov}`);
+        }
+        lines.push('');
+    }
+    if (removed.length) {
+        lines.push('### Removed endpoints');
+        for (const g of removed) {
+            const sev = SEVERITY_EMOJI[g.severity];
+            lines.push(`- ${sev} \`${g.method.toUpperCase()} ${g.path}\``);
+            for (const t of g.affected_tests.slice(0, 5)) {
+                lines.push(`  - Affected test: _${t}_`);
+            }
+            if (g.affected_tests.length > 5) {
+                lines.push(`  - … and ${g.affected_tests.length - 5} more`);
+            }
+        }
+        lines.push('');
+    }
+    if (changed.length) {
+        lines.push('### Changed endpoints');
+        for (const g of changed) {
+            const sev = SEVERITY_EMOJI[g.severity];
+            lines.push(`- ${sev} \`${g.method.toUpperCase()} ${g.path}\``);
+            for (const t of g.affected_tests.slice(0, 5)) {
+                lines.push(`  - Affected test: _${t}_`);
+            }
+        }
+        lines.push('');
+    }
+    if (healthSnapshot) {
+        lines.push('### Current health (affected areas)');
+        lines.push(healthSnapshot);
+        lines.push('');
+    }
+    lines.push('### Recommended actions');
+    gaps.slice(0, 10).forEach((g, index) => {
+        const i = index + 1;
+        let action;
+        if (g.change_type === ChangeType.ADDED) {
+            action = `Write test for \`${g.method.toUpperCase()} ${g.path}\` (no coverage)`;
+        }
+        else if (g.change_type === ChangeType.REMOVED) {
+            action = `Remove/update tests for \`${g.method.toUpperCase()} ${g.path}\` (will break)`;
+        }
+        else {
+            action = `Review tests for \`${g.method.toUpperCase()} ${g.path}\` (silent contract drift risk)`;
+        }
+        lines.push(`${i}. ${action}`);
+    });
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=summary-emitter.js.map

package/dist/engine/guardian/tier.js

@@ -0,0 +1,58 @@
+/**
+ * Tier-resolution seam for canary-pr-guardian (SC-5 core).
+ *
+ * Faithful TypeScript port of `agent/guardian/tier.py`.
+ *
+ * Resolves a *requested* guardian tier against the tier an agent runtime can
+ * actually serve, and emits a **loud** degradation notice whenever the effective
+ * tier drops below the request. The capability probe is an interface; the
+ * Phase-3 default ({@link NoAgentProbe}) deterministically reports "no agent"
+ * (tier 0 ceiling) **without importing any agent/LLM module** (SC-11). Phase 4
+ * supplies a real probe ({@link module:./agent-tier}'s `InSessionAgentProbe`)
+ * implementing the same interface -- `resolveTier`'s callers do not change.
+ *
+ * This is the CLI-wave companion the engine's `pr-check.ts` intentionally
+ * deferred (its header notes the tier seam belongs to the CLI wave, alongside
+ * `read_diff`). It lives here so `cli.ts` (pr-check/author-plan) can wire it.
+ */
+// The degradation notice text carries a warning sign (U+26A0) and an em-dash
+// (U+2014) as load-bearing OUTPUT DATA -- it is rendered verbatim into the PR
+// comment footer and the Actions `::warning::` channel, and asserted byte-exact
+// against the Python oracle. Written as escapes to honor the ASCII-source rule.
+const WARNING_SIGN = '\u{26A0}';
+const EM_DASH = '\u{2014}';
+/**
+ * Canonical loud degradation notice (D6 / SC-5).
+ *
+ * Names the requested tier and stays loud -- a tier>0 result must never be
+ * surfaced without this notice when the requested tier is unavailable.
+ */
+function degradationNotice(requested, effective) {
+    return (`${WARNING_SIGN} degraded: tier ${requested} unavailable ` +
+        `(no agent runtime detected) ${EM_DASH} ran tier ${effective}`);
+}
+/**
+ * Deterministic Phase-3 probe: no agent runtime, so tier 0 is the ceiling.
+ *
+ * Imports no agent/LLM module (SC-11).
+ */
+export class NoAgentProbe {
+    availableTier() {
+        return 0;
+    }
+}
+/**
+ * Resolve `requested` against the probe's ceiling, degrading loudly.
+ *
+ * `probe` defaults to {@link NoAgentProbe}. The effective tier is
+ * `min(requested, probe.availableTier())`; a loud {@link degradationNotice} is
+ * attached iff the effective tier is below the request (else `null`).
+ */
+export function resolveTier(requested, probe = null) {
+    const activeProbe = probe ?? new NoAgentProbe();
+    const available = activeProbe.availableTier();
+    const effective = Math.min(requested, available);
+    const notice = effective < requested ? degradationNotice(requested, effective) : null;
+    return { requested, effective, degraded_notice: notice };
+}
+//# sourceMappingURL=tier.js.map

package/dist/engine/history/cli.js

@@ -0,0 +1,303 @@
+/**
+ * CLI subcommands for `canary history` -- faithful port of
+ * `agent/history/cli.py` (the `history_app` Typer sub-app), wired to the
+ * already-ported async history store (`store.ts` / `schema.ts` / `record.ts`).
+ *
+ * Follows the guardian CLI conventions (see `../cli-common.ts`): a
+ * {@link createHistoryCommand} factory wired to an injectable {@link HistoryDeps}
+ * (out/err sinks, env, a store factory), `CliExit` for business exits, and
+ * `normalizeUsageExit` on every command so usage errors exit 2.
+ *
+ * Python->TS fidelity notes:
+ *   - `json.dumps(x, indent=2)` -> {@link jsonIndent2} (byte-exact + ensure_ascii).
+ *   - `rich.print("[green]x[/green]")` -> `pc.green('x')`; picocolors strips color
+ *     on a non-TTY sink, so the plain text is byte-identical to rich's markup
+ *     stripping. Load-bearing glyphs (em-dash, >=) are `\u{...}` escapes.
+ *   - The store query methods are ASYNC (the JS Supabase SDK is Promise-based),
+ *     so every handler that queries is `async` and awaited.
+ *   - INTENTIONAL DEVIATION: `flaky` and `timeline` render with `rich.Table`
+ *     (box-drawing). Reproducing rich's exact box bytes is brittle and there is
+ *     no Python CLI test pinning them, so this port emits a simple aligned text
+ *     table carrying the SAME cell content. `summary`/`push`/`migrate` are NOT
+ *     tables and are reproduced byte-for-byte via picocolors stripping.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { Command, Option } from 'commander';
+import pc from 'picocolors';
+import { CliExit, jsonIndent2, normalizeUsageExit } from '../cli-common.js';
+import { makeRunId } from './schema.js';
+import { makeStore as realMakeStore } from './store.js';
+import { pyFloat } from '../util/round.js';
+const EM_DASH = '\u{2014}';
+const GEQ = '\u{2265}';
+const MDASH_CELL = '\u{2014}'; // rich `r.get("area") or <em-dash>`
+const DEFAULT_HISTORY_FILE = 'test-results/reports/history-v2.jsonl';
+/** Every field of the Python `RunRecord` dataclass (the push/migrate filter). */
+const RUN_FIELDS = [
+    'run_id',
+    'suite',
+    'repo',
+    'branch',
+    'commit_sha',
+    'timestamp',
+    'total',
+    'passed',
+    'failed',
+    'flaky',
+    'skipped',
+    'commit_message',
+    'env',
+    'base_url',
+    'duration_ms',
+];
+/** Every field of the Python `TestResult` dataclass. */
+const RESULT_FIELDS = [
+    'run_id',
+    'suite',
+    'repo',
+    'test_name',
+    'test_file',
+    'status',
+    'area',
+    'failure_category',
+    'error_text',
+    'retry_count',
+    'duration_ms',
+    'tags',
+];
+function pick(src, fields) {
+    const out = {};
+    for (const f of fields) {
+        if (Object.prototype.hasOwnProperty.call(src, f)) {
+            out[f] = src[f];
+        }
+    }
+    return out;
+}
+/** Process-backed defaults for production. */
+export function defaultHistoryDeps() {
+    return {
+        out: (s) => process.stdout.write(`${s}\n`),
+        err: (s) => process.stderr.write(`${s}\n`),
+        env: process.env,
+        makeStore: (dbUrl, ndjsonPath) => realMakeStore(dbUrl, ndjsonPath),
+    };
+}
+// --- a minimal aligned text table (documented rich.Table deviation) ----------
+function renderTable(title, headers, rows, rightAlign) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const pad = (cell, i) => rightAlign[i] ? cell.padStart(widths[i]) : cell.padEnd(widths[i]);
+    const fmt = (cells) => cells.map((c, i) => pad(c, i)).join('  ');
+    const lines = [title, fmt(headers)];
+    lines.push(widths.map((w) => '-'.repeat(w)).join('  '));
+    for (const r of rows)
+        lines.push(fmt(r));
+    return lines;
+}
+async function pushCmd(historyFile, opts, deps) {
+    if (!existsSync(historyFile)) {
+        deps.out(`${pc.red('Not found:')} ${historyFile}`);
+        throw new CliExit(1);
+    }
+    const store = deps.makeStore(opts.dbUrl, historyFile);
+    const records = [];
+    for (const raw of readFileSync(historyFile, 'utf-8').split('\n')) {
+        const line = raw.trim();
+        if (line)
+            records.push(JSON.parse(line));
+    }
+    if (records.length === 0) {
+        deps.out(pc.yellow('No runs found in history file.'));
+        throw new CliExit(0);
+    }
+    const latest = { ...records[records.length - 1] };
+    const testsRaw = latest['tests'] ?? [];
+    delete latest['tests'];
+    const run = pick(latest, RUN_FIELDS);
+    const results = testsRaw.map((t) => pick(t, RESULT_FIELDS));
+    if (opts.dryRun) {
+        deps.out(`${pc.cyan('dry-run:')} would push run ${pc.bold(run.run_id)} (${results.length} tests)`);
+        throw new CliExit(0);
+    }
+    await store.pushRun(run, results);
+    deps.out(`${pc.green('Pushed')} run ${pc.bold(run.run_id)} (${results.length} tests)`);
+}
+async function flakyCmd(opts, deps) {
+    const store = deps.makeStore(opts.dbUrl);
+    const results = await store.queryFlaky(opts.window, opts.suite ?? null, opts.minRate);
+    if (opts.json) {
+        deps.out(jsonIndent2(results));
+        return;
+    }
+    if (results.length === 0) {
+        deps.out(pc.green(`No tests above ${pyFloat(opts.minRate)}% flake rate in the last ${opts.window} runs.`));
+        return;
+    }
+    const rows = results.map((r) => [
+        r.test_name,
+        r.suite ?? '',
+        r.area || MDASH_CELL,
+        // pyFloat so a whole-number rate renders `10.0%` like Python str(float),
+        // not `10%` (JS number has no int/float distinction).
+        `${pyFloat(r.flake_rate_pct)}%`,
+        `${r.flake_count}/${r.total_runs}`,
+    ]);
+    const lines = renderTable(`Flaky Tests (window: ${opts.window} runs, threshold: ${GEQ} ${pyFloat(opts.minRate)}%)`, ['Test', 'Suite', 'Area', 'Flake %', 'Flake/Total'], rows, [false, false, false, true, true]);
+    for (const l of lines)
+        deps.out(l);
+}
+async function timelineCmd(testName, opts, deps) {
+    const store = deps.makeStore(opts.dbUrl);
+    const rows = await store.queryTimeline(testName);
+    if (opts.json) {
+        deps.out(jsonIndent2(rows));
+        return;
+    }
+    if (rows.length === 0) {
+        deps.out(`${pc.yellow('No history found for:')} ${testName}`);
+        return;
+    }
+    const dataRows = rows.map((row) => [
+        row.run_id ?? '',
+        (row.commit_sha ?? '').slice(0, 8),
+        (row.timestamp ?? '').slice(0, 19),
+        row.status ?? '',
+        row.failure_category || MDASH_CELL,
+    ]);
+    const lines = renderTable(`Timeline: ${testName}`, ['Run ID', 'Commit', 'Timestamp', 'Status', 'Category'], dataRows, [false, false, false, false, false]);
+    for (const l of lines)
+        deps.out(l);
+}
+async function summaryCmd(suite, opts, deps) {
+    const store = deps.makeStore(opts.dbUrl);
+    const result = await store.querySummary(suite, opts.runs);
+    if (opts.json) {
+        deps.out(jsonIndent2(result));
+        return;
+    }
+    const total = result.total_runs ?? 0;
+    const avg = result.avg_pass_rate ?? 0.0;
+    const colorize = avg >= 90 ? pc.green : avg >= 70 ? pc.yellow : pc.red;
+    deps.out(`Suite ${pc.bold(suite)} ${EM_DASH} last ${total} runs ${EM_DASH} avg pass rate: ${colorize(`${pyFloat(avg)}%`)}`);
+}
+async function migrateCmd(file, opts, deps) {
+    if (!existsSync(file)) {
+        deps.out(`${pc.red('Not found:')} ${file}`);
+        throw new CliExit(1);
+    }
+    const store = deps.makeStore(opts.dbUrl);
+    let migrated = 0;
+    const skipped = 0;
+    for (const raw of readFileSync(file, 'utf-8').split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue; // JSONDecodeError -> skip (Python does NOT bump `skipped`)
+        }
+        const commit = entry['commit_short'] ?? 'unknown';
+        const tsStr = entry['timestamp'] ?? '';
+        let ts = 0;
+        const parsed = Date.parse(tsStr.replace('Z', '+00:00'));
+        if (!Number.isNaN(parsed))
+            ts = Math.floor(parsed / 1000);
+        const runAgg = entry['run'] ?? {};
+        const run = {
+            run_id: makeRunId(opts.suite, commit, ts || Math.floor(Date.now() / 1000)),
+            suite: opts.suite,
+            repo: opts.repo,
+            branch: entry['branch'] ?? 'unknown',
+            commit_sha: commit,
+            timestamp: tsStr,
+            total: runAgg['total'] ?? 0,
+            passed: runAgg['passed'] ?? 0,
+            failed: runAgg['failed'] ?? 0,
+            flaky: runAgg['flaky'] ?? 0,
+            skipped: runAgg['skipped'] ?? 0,
+        };
+        if (opts.dryRun) {
+            deps.out(`${pc.cyan('dry-run:')} ${run.run_id}`);
+            migrated += 1;
+            continue;
+        }
+        await store.pushRun(run, []);
+        migrated += 1;
+    }
+    deps.out(`${pc.green('Migrated')} ${migrated} runs, skipped ${skipped}`);
+}
+// --- assembly ----------------------------------------------------------------
+/** Build a fresh `history` command wired to `depsInit`. */
+export function createHistoryCommand(depsInit = {}) {
+    const deps = { ...defaultHistoryDeps(), ...depsInit };
+    const program = new Command('history');
+    program
+        .description('Query and manage test run history.')
+        .exitOverride(normalizeUsageExit);
+    program
+        .command('push')
+        .description('Push the most recent run from a local history file to the remote store.')
+        .argument('[history_file]', 'Path to local history-v2.jsonl to push to remote store.', DEFAULT_HISTORY_FILE)
+        .addOption(new Option('--db-url <url>').env('CANARY_HISTORY_DB_URL'))
+        .option('--dry-run', 'Show what would be pushed without pushing.')
+        .action(async (historyFile, opts) => {
+        await pushCmd(historyFile, opts, deps);
+    });
+    program
+        .command('flaky')
+        .description('Show tests ranked by flake rate over the rolling window.')
+        .addOption(new Option('-w, --window <n>', 'Rolling window (number of runs).')
+        .default(30)
+        .argParser((v) => Number.parseInt(v, 10)))
+        .option('-s, --suite <suite>', 'Filter to a specific suite.')
+        .addOption(new Option('--min-rate <pct>', 'Minimum flake rate % to show.')
+        .default(10.0)
+        .argParser((v) => Number.parseFloat(v)))
+        .addOption(new Option('--db-url <url>').env('CANARY_HISTORY_DB_URL'))
+        .option('--json')
+        .action(async (opts) => {
+        await flakyCmd(opts, deps);
+    });
+    program
+        .command('timeline')
+        .description('Show the full run history for a specific test.')
+        .argument('<test_name>', 'Exact test name to trace.')
+        .addOption(new Option('--db-url <url>').env('CANARY_HISTORY_DB_URL'))
+        .option('--json')
+        .action(async (testName, opts) => {
+        await timelineCmd(testName, opts, deps);
+    });
+    program
+        .command('summary')
+        .description('Summarize recent runs for a suite.')
+        .argument('<suite>', 'Suite name (e.g. api, e2e_ui).')
+        .addOption(new Option('-n, --runs <n>', 'Number of most recent runs to summarize.')
+        .default(10)
+        .argParser((v) => Number.parseInt(v, 10)))
+        .addOption(new Option('--db-url <url>').env('CANARY_HISTORY_DB_URL'))
+        .option('--json')
+        .action(async (suite, opts) => {
+        await summaryCmd(suite, opts, deps);
+    });
+    program
+        .command('migrate')
+        .description('Migrate a v1 history.jsonl (aggregate-only) into the v2 store.')
+        .argument('<file>', 'Path to history.jsonl (v1 format) to migrate.')
+        .requiredOption('--suite <suite>', 'Suite name for these records.')
+        .requiredOption('--repo <repo>', 'GitHub repo slug (e.g. acme-corp/api-service).')
+        .addOption(new Option('--db-url <url>').env('CANARY_HISTORY_DB_URL'))
+        .option('--dry-run')
+        .action(async (file, opts) => {
+        await migrateCmd(file, opts, deps);
+    });
+    for (const sub of program.commands) {
+        sub.exitOverride(normalizeUsageExit);
+    }
+    return program;
+}
+/** The production `history` command (process-backed defaults). */
+export const historyCommand = createHistoryCommand();
+//# sourceMappingURL=cli.js.map