@open-cr-agent/cli 0.2.0 → 0.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 `ocra` is the command line of [Open-CR-Agent](https://github.com/jma49/Open-CR-Agent), an open-source multi-agent code reviewer for local changes and GitHub pull requests. Deterministic code selects and bundles the files, matches rules and anchors comments; LLM reviewers make the judgment calls, and a verification pass checks what they report.
 
-This is an early 0.x release: options and output may change between minor versions. What the reviews find and miss is measured on the [quality page](https://ocra.majincheng.com/en/docs/quality).
+This is an early 0.x release: options and output may change between minor versions. What the reviews find and miss is measured on the [quality page](https://ocracloud.com/en/docs/quality).
 
 ## Install
 
@@ -34,8 +34,8 @@ Pull requests can also be reviewed by the GitHub Action: inline comments, one su
 
 ## Documentation
 
-- [Quickstart](https://ocra.majincheng.com/en/docs/quickstart) and the manual, in [English](https://ocra.majincheng.com/en/docs) and [中文](https://ocra.majincheng.com/zh/docs)
-- [GitHub pull requests](https://ocra.majincheng.com/en/docs/github)
+- [Quickstart](https://ocracloud.com/en/docs/quickstart) and the manual, in [English](https://ocracloud.com/en/docs) and [中文](https://ocracloud.com/zh/docs)
+- [GitHub pull requests](https://ocracloud.com/en/docs/github)
 - [Changelog](https://github.com/jma49/Open-CR-Agent/blob/main/CHANGELOG.md) and [issues](https://github.com/jma49/Open-CR-Agent/issues)
 
 ## License

package/dist/cloud.d.ts

@@ -0,0 +1,32 @@
+import type { Output } from "./review/progress.js";
+/** ocra Cloud's address; OCRA_CLOUD_URL names another server. */
+export declare const DEFAULT_CLOUD_URL = "https://app.ocracloud.com";
+export declare const LOGIN_USAGE: string;
+export type Credentials = {
+    server: string;
+    login: string;
+    access_token: string;
+    refresh_token: string;
+    /** Epoch milliseconds when the access token expires. */
+    expires_at: number;
+};
+export type CloudDeps = {
+    env: Readonly<Record<string, string | undefined>>;
+    fetch: typeof fetch;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    openBrowser: (url: string) => void;
+    credentialsPath: string;
+    clientName: string;
+};
+export declare function defaultCloudDeps(env?: CloudDeps["env"]): CloudDeps;
+export declare function credentialsPath(env: CloudDeps["env"]): string;
+export declare function readCredentials(path: string): Promise<Credentials | undefined>;
+/**
+ * The saved session with a live access token, refreshed (and saved) when
+ * it has expired or is about to; undefined when not signed in or the
+ * session was revoked.
+ */
+export declare function cloudSession(deps: CloudDeps, minValidityMs?: number): Promise<Credentials | undefined>;
+export declare function cloudCommand(command: "login" | "logout" | "whoami", argv: string[], out: Output, err: Output, deps: CloudDeps): Promise<number>;
+//# sourceMappingURL=cloud.d.ts.map

package/dist/cloud.js

@@ -0,0 +1,262 @@
+import { spawn } from "node:child_process";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+import { errorMessage } from "@open-cr-agent/core/internal";
+import { UsageError } from "./review/args.js";
+import { forTerminal } from "./review/terminal.js";
+import { VERSION } from "./version.js";
+// ocra Cloud sign-in (ADR-0024): `ocra login` runs the OAuth device flow
+// (RFC 8628) against ocra Cloud, `ocra whoami` shows the account, and
+// `ocra logout` ends the session. Nothing here runs unless one of these
+// commands is used: a self-hosted user never sees a login prompt.
+/** ocra Cloud's address; OCRA_CLOUD_URL names another server. */
+export const DEFAULT_CLOUD_URL = "https://app.ocracloud.com";
+export const LOGIN_USAGE = `Usage: ocra login [--no-browser]
+       ocra logout
+       ocra whoami
+
+Sign in to ocra Cloud with GitHub, so reviews can use the model keys stored
+there. ocra login shows a code, opens the browser to confirm it, and saves the
+session to ${credentialsHint()} (readable only by you).
+
+Environment:
+  OCRA_CLOUD=off   Disable ocra Cloud: these commands refuse to run
+  OCRA_CLOUD_URL   Another ocra Cloud server (default ${DEFAULT_CLOUD_URL})
+`;
+export function defaultCloudDeps(env = process.env) {
+    return {
+        env,
+        fetch: globalThis.fetch,
+        now: Date.now,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        openBrowser,
+        credentialsPath: credentialsPath(env),
+        clientName: `${hostname()} (ocra ${VERSION})`,
+    };
+}
+function credentialsHint() {
+    return process.platform === "win32"
+        ? "%APPDATA%\\ocra\\credentials.json"
+        : "~/.config/ocra/credentials.json";
+}
+export function credentialsPath(env) {
+    const base = process.platform === "win32"
+        ? (env.APPDATA ?? join(homedir(), "AppData", "Roaming"))
+        : (env.XDG_CONFIG_HOME ?? join(homedir(), ".config"));
+    return join(base, "ocra", "credentials.json");
+}
+function cloudUrl(env) {
+    const named = env.OCRA_CLOUD_URL || DEFAULT_CLOUD_URL;
+    let url;
+    try {
+        url = new URL(named);
+    }
+    catch {
+        throw new UsageError(`OCRA_CLOUD_URL is not a URL: ${named}`);
+    }
+    if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+        throw new UsageError(`OCRA_CLOUD_URL must use https: ${url}`);
+    }
+    return url.origin;
+}
+function openBrowser(url) {
+    const [cmd, args] = process.platform === "darwin"
+        ? ["open", [url]]
+        : process.platform === "win32"
+            ? ["cmd", ["/c", "start", "", url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // The URL is printed as well; a missing opener is not an error.
+    }
+}
+export async function readCredentials(path) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const c = JSON.parse(text);
+    if (!c.server || !c.access_token || !c.refresh_token || typeof c.expires_at !== "number") {
+        return undefined;
+    }
+    return c;
+}
+async function writeCredentials(path, c) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(c, null, 2)}\n`, { mode: 0o600 });
+    // writeFile keeps the mode of a file that already exists.
+    await chmod(path, 0o600);
+}
+async function postJson(deps, url, body, token) {
+    const res = await deps.fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "user-agent": `ocra/${VERSION}`,
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30_000),
+    });
+    return {
+        status: res.status,
+        body: (await res.json().catch(() => ({}))),
+    };
+}
+async function fetchMe(deps, server, token) {
+    const res = await deps.fetch(`${server}/api/me`, {
+        headers: { authorization: `Bearer ${token}`, "user-agent": `ocra/${VERSION}` },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (res.status === 401)
+        return undefined;
+    if (!res.ok)
+        throw new Error(`ocra Cloud answered ${res.status}`);
+    return (await res.json());
+}
+/**
+ * The saved session with a live access token, refreshed (and saved) when
+ * it has expired or is about to; undefined when not signed in or the
+ * session was revoked.
+ */
+export async function cloudSession(deps, minValidityMs = 60_000) {
+    const saved = await readCredentials(deps.credentialsPath);
+    if (!saved)
+        return undefined;
+    if (saved.expires_at - deps.now() > minValidityMs)
+        return saved;
+    const { status, body } = await postJson(deps, `${saved.server}/api/device/refresh`, {
+        refresh_token: saved.refresh_token,
+    });
+    const t = body;
+    if (status !== 200 || !t.access_token || !t.refresh_token || !t.expires_in)
+        return undefined;
+    const next = {
+        ...saved,
+        access_token: t.access_token,
+        refresh_token: t.refresh_token,
+        expires_at: deps.now() + t.expires_in * 1000,
+    };
+    await writeCredentials(deps.credentialsPath, next);
+    return next;
+}
+export async function cloudCommand(command, argv, out, err, deps) {
+    const { values } = parseArgs({
+        args: argv,
+        strict: true,
+        options: { "no-browser": { type: "boolean" }, help: { type: "boolean", short: "h" } },
+    });
+    if (values.help) {
+        out.write(LOGIN_USAGE);
+        return 0;
+    }
+    if (deps.env.OCRA_CLOUD === "off") {
+        err.write("ocra Cloud is off (OCRA_CLOUD=off).\n");
+        return 2;
+    }
+    if (command === "whoami")
+        return whoami(out, err, deps);
+    if (command === "logout")
+        return logout(out, deps);
+    return login(out, err, deps, !values["no-browser"]);
+}
+async function whoami(out, err, deps) {
+    const session = await cloudSession(deps);
+    if (!session) {
+        err.write("Not signed in. Run ocra login.\n");
+        return 1;
+    }
+    const me = await fetchMe(deps, session.server, session.access_token);
+    if (!me) {
+        err.write("The saved session was revoked. Run ocra login.\n");
+        return 1;
+    }
+    out.write(forTerminal(`${me.login} on ${session.server}\n`));
+    return 0;
+}
+async function logout(out, deps) {
+    const saved = await readCredentials(deps.credentialsPath);
+    if (saved) {
+        // Ends the session on the server too; the local file goes either way.
+        const session = await cloudSession(deps).catch(() => undefined);
+        if (session) {
+            await postJson(deps, `${session.server}/api/auth/logout`, {}, session.access_token).catch(() => { });
+        }
+    }
+    await rm(deps.credentialsPath, { force: true });
+    out.write(saved ? "Signed out.\n" : "Not signed in.\n");
+    return 0;
+}
+async function login(out, err, deps, browser) {
+    const server = cloudUrl(deps.env);
+    const start = await postJson(deps, `${server}/api/device/code`, { client_name: deps.clientName });
+    const code = start.body;
+    if (start.status !== 200 ||
+        !code.device_code ||
+        !code.user_code ||
+        !code.verification_uri_complete) {
+        err.write(`ocra Cloud did not start a login (HTTP ${start.status}). Try again in a minute.\n`);
+        return 2;
+    }
+    out.write(forTerminal(`Confirm this code in your browser: ${code.user_code}\n` +
+        `  ${code.verification_uri_complete}\n` +
+        `(or open ${code.verification_uri} and type it)\n\nWaiting for approval...\n`));
+    if (browser)
+        deps.openBrowser(code.verification_uri_complete);
+    let interval = (code.interval ?? 5) * 1000;
+    const deadline = deps.now() + (code.expires_in ?? 600) * 1000;
+    while (deps.now() < deadline) {
+        await deps.sleep(interval);
+        let answer;
+        try {
+            answer = await postJson(deps, `${server}/api/device/token`, {
+                device_code: code.device_code,
+            });
+        }
+        catch (error) {
+            // A dropped connection is retried on the next tick.
+            err.write(forTerminal(`(${errorMessage(error)}; retrying)\n`));
+            continue;
+        }
+        const t = answer.body;
+        if (answer.status === 200 && t.access_token && t.refresh_token && t.expires_in) {
+            const me = await fetchMe(deps, server, t.access_token);
+            const credentials = {
+                server,
+                login: me?.login ?? "",
+                access_token: t.access_token,
+                refresh_token: t.refresh_token,
+                expires_at: deps.now() + t.expires_in * 1000,
+            };
+            await writeCredentials(deps.credentialsPath, credentials);
+            out.write(forTerminal(`Signed in as ${credentials.login}.\n`));
+            return 0;
+        }
+        if (t.error === "authorization_pending")
+            continue;
+        if (t.error === "slow_down") {
+            interval = typeof t.interval === "number" ? t.interval * 1000 : interval + 5000;
+            continue;
+        }
+        if (t.error === "access_denied") {
+            err.write("Login denied in the browser.\n");
+            return 1;
+        }
+        if (t.error === "expired_token")
+            break;
+        err.write(forTerminal(`Login failed: ${t.error ?? `HTTP ${answer.status}`}\n`));
+        return 2;
+    }
+    err.write("The code expired before it was confirmed. Run ocra login again.\n");
+    return 1;
+}
+//# sourceMappingURL=cloud.js.map

package/dist/memory.js

@@ -2,8 +2,8 @@ import { constants, existsSync } from "node:fs";
 import { lstat, mkdir, open, readdir, readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { MEMORY_PATH, parseMemory, serializeMemory, } from "@open-cr-agent/core";
-import { findRepositoryRoot } from "@open-cr-agent/vcs-local";
+import { MEMORY_PATH, parseMemory, serializeMemory } from "@open-cr-agent/core/internal";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
 import { UsageError } from "./review/args.js";
 import { SESSIONS_DIR } from "./review/command.js";
 import { forTerminal } from "./review/terminal.js";

package/dist/metrics.d.ts

@@ -0,0 +1,47 @@
+import { type Severity, type Verification } from "@open-cr-agent/core";
+import type { Output } from "./review/progress.js";
+export declare const METRICS_VERSION = 1;
+export declare const METRICS_USAGE = "Usage: ocra metrics [options]\n\nCounts over the finished reviews in .ocra/sessions: runs, cost, findings,\nwhat reviewers later fixed or dismissed, per reviewer. Reads each session's\nreport.json (report version 1); nothing calls a model.\n\nOptions:\n  --sessions <dir>     Sessions directory (default: .ocra/sessions of this repository)\n  --since <date>       Only runs started at or after this ISO 8601 date\n  --format <text|json> Output format (default: text); the JSON carries \"version\": 1\n  -h, --help           Show help\n";
+export interface ReviewerMetrics {
+    tasks: number;
+    failedTasks: number;
+    findings: number;
+    costUsd: number;
+    fixed: number;
+    dismissed: number;
+    acceptanceRate: number | null;
+}
+export interface Metrics {
+    version: typeof METRICS_VERSION;
+    sessionsDir: string;
+    since?: string;
+    runs: {
+        total: number;
+        byVerdict: Record<string, number>;
+        incomplete: number;
+        unreadable: number;
+    };
+    cost: {
+        usd: number;
+        inputTokens: number;
+        outputTokens: number;
+        usdPerRun: number | null;
+    };
+    findings: {
+        reported: number;
+        unique: number;
+        bySeverity: Record<Severity, number>;
+        byVerification: Record<Verification, number>;
+    };
+    outcomes: {
+        fixed: number;
+        dismissed: number;
+        acceptanceRate: number | null;
+    };
+    reviewers: Record<string, ReviewerMetrics>;
+}
+export declare function metricsCommand(argv: string[], out: Output, cwd: string): Promise<number>;
+export declare function sessionStart(id: string): Date | undefined;
+export declare function collectMetrics(sessionsDir: string, since?: Date): Promise<Metrics>;
+export declare function renderMetrics(m: Metrics): string;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.js

@@ -0,0 +1,227 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { reportOutputSchema, } from "@open-cr-agent/core";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
+import { UsageError } from "./review/args.js";
+import { SESSIONS_DIR } from "./review/command.js";
+import { forTerminal } from "./review/terminal.js";
+export const METRICS_VERSION = 1;
+export const METRICS_USAGE = `Usage: ocra metrics [options]
+
+Counts over the finished reviews in ${SESSIONS_DIR}: runs, cost, findings,
+what reviewers later fixed or dismissed, per reviewer. Reads each session's
+report.json (report version 1); nothing calls a model.
+
+Options:
+  --sessions <dir>     Sessions directory (default: ${SESSIONS_DIR} of this repository)
+  --since <date>       Only runs started at or after this ISO 8601 date
+  --format <text|json> Output format (default: text); the JSON carries "version": ${METRICS_VERSION}
+  -h, --help           Show help
+`;
+export async function metricsCommand(argv, out, cwd) {
+    const { values } = parseArgs({
+        args: argv,
+        allowPositionals: false,
+        strict: true,
+        options: {
+            sessions: { type: "string" },
+            since: { type: "string" },
+            format: { type: "string" },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    if (values.help) {
+        out.write(METRICS_USAGE);
+        return 0;
+    }
+    const format = values.format ?? "text";
+    if (format !== "text" && format !== "json")
+        throw new UsageError("--format must be text or json");
+    const since = values.since === undefined ? undefined : parseSince(values.since);
+    const sessionsDir = values.sessions
+        ? resolve(cwd, values.sessions)
+        : join(await findRepositoryRoot(cwd), SESSIONS_DIR);
+    const metrics = await collectMetrics(sessionsDir, since);
+    out.write(format === "json" ? `${JSON.stringify(metrics, null, 2)}\n` : renderMetrics(metrics));
+    return 0;
+}
+function parseSince(text) {
+    const date = new Date(text);
+    if (Number.isNaN(date.getTime()))
+        throw new UsageError(`--since needs an ISO 8601 date, not "${text}"`);
+    return date;
+}
+// A session directory is named by its run id, whose first part is the start
+// time (newRunId in core); that is what --since compares against.
+export function sessionStart(id) {
+    const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z/.exec(id);
+    if (!m)
+        return undefined;
+    const [, y, mo, d, h, mi, s] = m;
+    return new Date(`${y}-${mo}-${d}T${h}:${mi}:${s}Z`);
+}
+export async function collectMetrics(sessionsDir, since) {
+    const names = (await readdir(sessionsDir).catch(() => []))
+        .filter((n) => !n.startsWith("."))
+        .filter((n) => {
+        const start = sessionStart(n);
+        return since === undefined || (start !== undefined && start >= since);
+    })
+        .sort();
+    const reports = [];
+    let unreadable = 0;
+    for (const name of names) {
+        const report = await readReport(join(sessionsDir, name, "report.json"));
+        if (report)
+            reports.push(report);
+        else
+            unreadable += 1;
+    }
+    return aggregate(reports, {
+        sessionsDir,
+        unreadable,
+        ...(since ? { since: since.toISOString() } : {}),
+    });
+}
+async function readReport(path) {
+    let data;
+    try {
+        data = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const parsed = reportOutputSchema.safeParse(data);
+    return parsed.success ? parsed.data : undefined;
+}
+function aggregate(reports, meta) {
+    const byVerdict = {};
+    const bySeverity = { critical: 0, warning: 0, suggestion: 0 };
+    const byVerification = { confirmed: 0, uncertain: 0, unchecked: 0 };
+    const reviewers = new Map();
+    const reviewerOf = new Map();
+    const unique = new Set();
+    const fixed = new Set();
+    const dismissed = new Set();
+    let incomplete = 0;
+    let reported = 0;
+    let usd = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const forReviewer = (id) => {
+        let r = reviewers.get(id);
+        if (!r) {
+            r = {
+                tasks: 0,
+                failedTasks: 0,
+                findings: 0,
+                costUsd: 0,
+                fixed: 0,
+                dismissed: 0,
+                acceptanceRate: null,
+            };
+            reviewers.set(id, r);
+        }
+        return r;
+    };
+    for (const report of reports) {
+        byVerdict[report.verdict] = (byVerdict[report.verdict] ?? 0) + 1;
+        if (report.coverage.some((c) => c.status === "failed" || c.status === "unreviewed"))
+            incomplete += 1;
+        usd += report.usage.costUsd;
+        inputTokens += report.usage.inputTokens;
+        outputTokens += report.usage.outputTokens;
+        for (const task of report.tasks) {
+            const r = forReviewer(task.reviewer);
+            r.tasks += 1;
+            if (task.status === "failed" || task.status === "timed_out")
+                r.failedTasks += 1;
+            r.costUsd += task.usage.costUsd;
+        }
+        for (const finding of report.findings) {
+            reported += 1;
+            unique.add(finding.fingerprint);
+            bySeverity[finding.severity] += 1;
+            byVerification[finding.verification] += 1;
+            forReviewer(finding.reviewer).findings += 1;
+            if (!reviewerOf.has(finding.fingerprint))
+                reviewerOf.set(finding.fingerprint, finding.reviewer);
+        }
+        for (const f of report.rereview?.fixed ?? [])
+            fixed.add(f.fingerprint);
+        for (const f of report.rereview?.dismissed ?? [])
+            dismissed.add(f.fingerprint);
+    }
+    // A fingerprint can be dismissed in one review and gone in a later one:
+    // the reviewer's decision stands.
+    for (const fp of dismissed)
+        fixed.delete(fp);
+    for (const fp of fixed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            forReviewer(reviewer).fixed += 1;
+    }
+    for (const fp of dismissed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            forReviewer(reviewer).dismissed += 1;
+    }
+    for (const r of reviewers.values())
+        r.acceptanceRate = rate(r.fixed, r.dismissed);
+    return {
+        version: METRICS_VERSION,
+        sessionsDir: meta.sessionsDir,
+        ...(meta.since ? { since: meta.since } : {}),
+        runs: { total: reports.length, byVerdict, incomplete, unreadable: meta.unreadable },
+        cost: {
+            usd,
+            inputTokens,
+            outputTokens,
+            usdPerRun: reports.length > 0 ? usd / reports.length : null,
+        },
+        findings: { reported, unique: unique.size, bySeverity, byVerification },
+        outcomes: {
+            fixed: fixed.size,
+            dismissed: dismissed.size,
+            acceptanceRate: rate(fixed.size, dismissed.size),
+        },
+        reviewers: Object.fromEntries([...reviewers].sort(([a], [b]) => a.localeCompare(b))),
+    };
+}
+function rate(fixed, dismissed) {
+    return fixed + dismissed > 0 ? fixed / (fixed + dismissed) : null;
+}
+const percent = (value) => (value === null ? "n/a" : `${Math.round(value * 100)}%`);
+const dollars = (value) => (value === null ? "n/a" : `$${value.toFixed(2)}`);
+export function renderMetrics(m) {
+    const lines = [
+        `Runs: ${m.runs.total}${m.since ? ` since ${m.since}` : ""} (${m.runs.incomplete} incomplete, ${m.runs.unreadable} unreadable)`,
+        `  by verdict: ${entries(m.runs.byVerdict)}`,
+        `Cost: ${dollars(m.cost.usd)} total, ${dollars(m.cost.usdPerRun)} per run · ${m.cost.inputTokens} in / ${m.cost.outputTokens} out tokens`,
+        `Findings: ${m.findings.reported} reported, ${m.findings.unique} unique`,
+        `  by severity: ${entries(m.findings.bySeverity)}`,
+        `  by verification: ${entries(m.findings.byVerification)}`,
+        `Outcomes: ${m.outcomes.fixed} fixed, ${m.outcomes.dismissed} dismissed, acceptance ${percent(m.outcomes.acceptanceRate)}`,
+        "",
+        "Reviewer           Tasks  Failed  Findings  Cost      Fixed  Dismissed  Acceptance",
+    ];
+    for (const [id, r] of Object.entries(m.reviewers)) {
+        lines.push([
+            id.padEnd(18),
+            String(r.tasks).padStart(5),
+            String(r.failedTasks).padStart(7),
+            String(r.findings).padStart(9),
+            dollars(r.costUsd).padStart(9),
+            String(r.fixed).padStart(6),
+            String(r.dismissed).padStart(10),
+            percent(r.acceptanceRate).padStart(11),
+        ].join(" "));
+    }
+    return `${forTerminal(lines.join("\n"))}\n`;
+}
+function entries(record) {
+    const parts = Object.entries(record).filter(([, n]) => n > 0);
+    return parts.length === 0 ? "none" : parts.map(([k, n]) => `${k} ${n}`).join(", ");
+}
+//# sourceMappingURL=metrics.js.map

package/dist/review/args.d.ts

@@ -1,3 +1,4 @@
+import { OcraError } from "@open-cr-agent/core";
 import type { LocalTarget } from "@open-cr-agent/vcs-local";
 export type OutputFormat = "text" | "json" | "sarif";
 export interface PullRequestTarget {
@@ -22,9 +23,15 @@ export interface ReviewArgs {
     ultra?: true;
     full?: true;
     plan?: true;
+    importSarif?: string[];
+    configFile?: string;
+    noUpload?: true;
+    temperature?: number;
+    seed?: number;
 }
-export declare class UsageError extends Error {
+export declare class UsageError extends OcraError {
+    constructor(message: string);
 }
-export declare const REVIEW_USAGE = "Usage: ocra review [options]\n\nReviews uncommitted changes by default.\n\nOptions:\n  --from <ref>       Review changes on --to since it diverged from <ref>\n  --to <ref>         End of the range (default: HEAD)\n  --commit <sha>     Review a single commit\n  --pr <number>      Review a GitHub pull request (needs GITHUB_TOKEN)\n  --repo <owner/name>  Repository of --pr (default: GITHUB_REPOSITORY or origin)\n  --mr <iid>         Review a GitLab merge request (needs GITLAB_TOKEN)\n  --project <id|path>  Project of --mr (default: CI_PROJECT_ID or origin)\n  --publish          With --pr or --mr: post the review to it\n  --full             With --pr or --mr: review every file, not only what\n                     changed since the previous review\n  --format <format>  text (default), json, or sarif (SARIF 2.1.0; not with --plan)\n  --output <file>    Write the result to a file instead of stdout\n  --reviewers <ids>  Run only these reviewers (comma-separated)\n  --max-cost-usd <n> Spend limit: reviews use 80%, verification and judging the rest\n  --plan             Show files, bundles, review tasks and prompt sizes; call no model\n  --ultra            Favor recall: all reviewers at every tier, two samples each (about 2x cost)\n  --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted\n                     code); models come from OCRA_MODEL_* variables\n  -h, --help         Show help\n";
+export declare const REVIEW_USAGE = "Usage: ocra review [options]\n\nReviews uncommitted changes by default.\n\nOptions:\n  --from <ref>       Review changes on --to since it diverged from <ref>\n  --to <ref>         End of the range (default: HEAD)\n  --commit <sha>     Review a single commit\n  --pr <number>      Review a GitHub pull request (needs GITHUB_TOKEN)\n  --repo <owner/name>  Repository of --pr (default: GITHUB_REPOSITORY or origin)\n  --mr <iid>         Review a GitLab merge request (needs GITLAB_TOKEN)\n  --project <id|path>  Project of --mr (default: CI_PROJECT_ID or origin)\n  --publish          With --pr or --mr: post the review to it\n  --full             With --pr or --mr: review every file, not only what\n                     changed since the previous review\n  --format <format>  text (default), json, or sarif (SARIF 2.1.0; not with --plan)\n  --output <file>    Write the result to a file instead of stdout\n  --reviewers <ids>  Run only these reviewers (comma-separated)\n  --max-cost-usd <n> Spend limit: reviews use 80%, verification and judging the rest\n  --import-sarif <file>  Add the results of a SARIF 2.1.0 log (Semgrep, CodeQL, \u2026)\n                     that fall on the change; repeatable; not with --plan\n  --plan             Show files, bundles, review tasks and prompt sizes; call no model\n  --ultra            Favor recall: all reviewers at every tier, two samples each (about 2x cost)\n  --temperature <n>  Sampling temperature, 0 to 2 (default: the provider's, or sampling in config)\n  --seed <n>         Sampling seed, where the runtime and provider support one\n  --config <file>    Read this configuration file instead of the repository's\n                     .ocra/config.json; it applies with --no-repo-config too\n  --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted\n                     code); models come from OCRA_MODEL_* variables or --config\n  --no-upload        When signed in to ocra Cloud, do not send this review's\n                     counts (verdict, numbers of findings, files, tokens)\n  -h, --help         Show help\n";
 export declare function parseReviewArgs(argv: string[]): ReviewArgs | "help";
 //# sourceMappingURL=args.d.ts.map