@open-cr-agent/cli 0.1.2 → 0.3.0

package/dist/review/config.d.ts

@@ -1,7 +1,8 @@
-import { type ModelChains, type RepoRule } from "@open-cr-agent/core";
+import { type CustomProvider, type ModelChains, OcraError, type RepoRule } from "@open-cr-agent/core";
 import { z } from "zod";
 export declare const CONFIG_PATH = ".ocra/config.json";
 declare const configSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
     models: z.ZodDefault<z.ZodObject<{
         top: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
         standard: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
@@ -14,13 +15,20 @@ declare const configSchema: z.ZodObject<{
     judge: z.ZodOptional<z.ZodBoolean>;
     maxCostUsd: z.ZodOptional<z.ZodNumber>;
     maxTasks: z.ZodOptional<z.ZodNumber>;
+    sampling: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
     github: z.ZodDefault<z.ZodObject<{
         requestChanges: z.ZodOptional<z.ZodBoolean>;
         botLogin: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     include: z.ZodDefault<z.ZodArray<z.ZodString>>;
     exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    runtime: z.ZodDefault<z.ZodString>;
+    runtime: z.ZodDefault<z.ZodUnion<[z.ZodEnum<{
+        direct: "direct";
+        opencode: "opencode";
+    }>, z.ZodString]>>;
     plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
     reviewers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -31,19 +39,36 @@ declare const configSchema: z.ZodObject<{
         }>>;
     }, z.core.$strict>>>;
     pluginSettings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodLiteral<"openai-compatible">;
+        baseUrl: z.ZodURL;
+        apiKeyEnv: z.ZodOptional<z.ZodString>;
+        models: z.ZodRecord<z.ZodString, z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cachedInput: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     extends: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export type CliConfig = Omit<z.infer<typeof configSchema>, "models"> & {
+export declare const CONFIG_SCHEMA_ID = "https://ocra.majincheng.com/schema/config.v1.json";
+export declare function configJsonSchema(): Record<string, unknown>;
+export type CliConfig = Omit<z.infer<typeof configSchema>, "models" | "providers"> & {
     models: ModelChains;
+    providers: Record<string, CustomProvider>;
     rules: RepoRule[];
 };
 export interface LoadOptions {
     repository: boolean;
     read?: (path: string) => Promise<string | undefined>;
+    file?: string;
     fetch?: typeof fetch;
     warn?: (message: string) => void;
 }
-export declare class ConfigError extends Error {
+export declare class ConfigError extends OcraError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }
 export declare function loadConfig(root: string, env: Readonly<Record<string, string | undefined>>, options?: LoadOptions): Promise<CliConfig>;
 export {};

package/dist/review/config.js

@@ -1,14 +1,53 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { RISK_TIERS, } from "@open-cr-agent/core";
+import { OcraError, } from "@open-cr-agent/core";
+import { RISK_TIERS } from "@open-cr-agent/core/internal";
 import { z } from "zod";
 import { fetchRemoteConfig, mergeConfig } from "./remote-config.js";
 export const CONFIG_PATH = ".ocra/config.json";
 const modelChain = z
     .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
     .transform((value) => (typeof value === "string" ? [value] : value));
+// Where review code is sent: over https, or plain http only to this machine.
+// OpenCode replaces {env:NAME} and {file:path} anywhere in its configuration,
+// so an address with braces could carry a variable or a file (the checkout's
+// .git/config holds its token) to the endpoint.
+const endpoint = z
+    .url()
+    .refine((value) => {
+    const url = new URL(value);
+    if (url.protocol === "https:")
+        return true;
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    return (url.protocol === "http:" &&
+        (host === "localhost" || host === "::1" || /^127\.\d+\.\d+\.\d+$/.test(host)));
+}, "must be an https URL, or http on this machine (localhost, 127.0.0.1, ::1)")
+    .refine((value) => !/[{}]/.test(value), "must not contain { or }");
+// The platforms' and clouds' credentials never go to a model endpoint; the
+// same prefixes are never passed to the runtime by prefix (server-env.ts).
+const PLATFORM_TOKENS = /^(GITHUB_|GH_|GITLAB_|CI_|ACTIONS_|RUNNER_|AWS_|AZURE_|NPM_|SSH_|OCRA_)/;
+const price = z.number().min(0).max(10_000);
+const providerSchema = z
+    .object({
+    type: z.literal("openai-compatible"),
+    baseUrl: endpoint,
+    apiKeyEnv: z
+        .string()
+        .regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "must be an environment variable name")
+        .refine((name) => !PLATFORM_TOKENS.test(name), "must not name a platform or cloud credential")
+        .optional(),
+    // Prices in US dollars per million tokens; 0 means unpriced.
+    models: z
+        .record(z.string().regex(/^[\w./:@-]{1,200}$/), z.object({ input: price, output: price, cachedInput: price.optional() }).strict())
+        .refine((models) => Object.keys(models).length > 0, "must list at least one model"),
+})
+    .strict();
+// The runtimes ocra ships; a plugin may register another name, so the
+// schema lists these for editors and still accepts any other string.
+const BUILTIN_RUNTIMES = ["opencode", "direct"];
 const configSchema = z
     .object({
+    $schema: z.string().optional(),
     models: z
         .object({ top: modelChain, standard: modelChain, light: modelChain })
         .partial()
@@ -21,6 +60,20 @@ const configSchema = z
     judge: z.boolean().optional(),
     maxCostUsd: z.number().positive().optional(),
     maxTasks: z.number().int().min(1).max(1_000).optional(),
+    // Unset: each provider's default. A seed makes sampling repeatable only
+    // where the provider supports it.
+    sampling: z
+        .object({
+        temperature: z.number().min(0).max(2),
+        seed: z
+            .number()
+            .int()
+            .min(0)
+            .max(2 ** 31 - 1),
+    })
+        .partial()
+        .strict()
+        .optional(),
     github: z
         .object({ requestChanges: z.boolean(), botLogin: z.string().min(1) })
         .partial()
@@ -28,7 +81,7 @@ const configSchema = z
         .default({}),
     include: z.array(z.string().min(1)).default([]),
     exclude: z.array(z.string().min(1)).default([]),
-    runtime: z.string().min(1).default("opencode"),
+    runtime: z.enum(BUILTIN_RUNTIMES).or(z.string().min(1)).default("opencode"),
     plugins: z.array(z.string().min(1)).default([]),
     reviewers: z
         .record(z.string(), z
@@ -40,23 +93,44 @@ const configSchema = z
         .strict())
         .default({}),
     pluginSettings: z.record(z.string(), z.unknown()).default({}),
+    providers: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,39}$/), providerSchema).default({}),
     extends: z.string().min(1).optional(),
 })
     .strict();
+export const CONFIG_SCHEMA_ID = "https://ocra.majincheng.com/schema/config.v1.json";
+// JSON Schema (draft 2020-12) of .ocra/config.json, for editors: what a
+// file may say, so defaults are optional and model chains take either form.
+export function configJsonSchema() {
+    const generated = z.toJSONSchema(configSchema, { target: "draft-2020-12", io: "input" });
+    const { $schema, ...rest } = generated;
+    return {
+        $schema,
+        $id: CONFIG_SCHEMA_ID,
+        title: "ocra configuration",
+        description: "The .ocra/config.json file of a repository, or a file passed with --config. Unknown keys are rejected.",
+        ...rest,
+    };
+}
 const MODEL_ENV = {
     top: "OCRA_MODEL_TOP",
     standard: "OCRA_MODEL_STANDARD",
     light: "OCRA_MODEL_LIGHT",
 };
-export class ConfigError extends Error {
+export class ConfigError extends OcraError {
+    constructor(message, options) {
+        super("CONFIG_INVALID", message, options);
+        this.name = "ConfigError";
+    }
 }
 // Without the repository's file, only defaults and environment variables
 // apply: that file can name plugins, and plugins run code.
 export async function loadConfig(root, env, options = { repository: true }) {
     const read = options.read ?? ((path) => readConfigFromDisk(root, path));
-    const { config: parsed, rules } = options.repository
-        ? await readConfigFile(read, options)
-        : { config: configSchema.parse({}), rules: [] };
+    const { config: parsed, rules } = options.file
+        ? await readConfigFile(ownFile(options.file), options, options.file)
+        : options.repository
+            ? await readConfigFile(read, options, CONFIG_PATH)
+            : { config: configSchema.parse({}), rules: [] };
     const models = {};
     for (const [tier, chain] of Object.entries(parsed.models)) {
         if (chain)
@@ -70,11 +144,50 @@ export async function loadConfig(root, env, options = { repository: true }) {
         if (chain.length > 0)
             models[tier] = chain;
     }
-    return { ...parsed, models, rules };
+    for (const model of unpriced(parsed.providers, models)) {
+        options.warn?.(`${model} has a price of 0: reported cost and --max-cost-usd do not count its tokens`);
+    }
+    return { ...parsed, models, providers: toProviders(parsed.providers), rules };
+}
+function toProviders(declared) {
+    return Object.fromEntries(Object.entries(declared).map(([id, p]) => [
+        id,
+        {
+            baseUrl: p.baseUrl,
+            ...(p.apiKeyEnv ? { apiKeyEnv: p.apiKeyEnv } : {}),
+            models: Object.fromEntries(Object.entries(p.models).map(([model, price]) => [
+                model,
+                {
+                    input: price.input,
+                    output: price.output,
+                    ...(price.cachedInput === undefined ? {} : { cachedInput: price.cachedInput }),
+                },
+            ])),
+        },
+    ]));
+}
+// Models of declared providers, named in a chain, priced at 0 per token.
+function unpriced(providers, models) {
+    const named = new Set(Object.values(models).flat());
+    return [...named].filter((model) => {
+        const slash = model.indexOf("/");
+        const price = providers[model.slice(0, slash)]?.models[model.slice(slash + 1)];
+        return price !== undefined && price.input === 0 && price.output === 0;
+    });
 }
 // The user's own checkout, read like any local file (links followed): unlike
 // the review's reads, which never follow links (vcs-local), this is trusted
 // configuration, and --no-repo-config skips it for code that is not.
+function ownFile(file) {
+    return async () => {
+        try {
+            return await readFile(file, "utf8");
+        }
+        catch (error) {
+            throw new ConfigError(`cannot read ${file}: ${error.message}`, { cause: error });
+        }
+    };
+}
 async function readConfigFromDisk(root, path) {
     try {
         return await readFile(join(root, path), "utf8");
@@ -85,7 +198,7 @@ async function readConfigFromDisk(root, path) {
         throw error;
     }
 }
-async function readConfigFile(read, options) {
+async function readConfigFile(read, options, label) {
     const text = await read(CONFIG_PATH);
     if (text === undefined)
         return { config: configSchema.parse({}), rules: [] };
@@ -94,11 +207,13 @@ async function readConfigFile(read, options) {
         data = JSON.parse(text);
     }
     catch (error) {
-        throw new ConfigError(`${CONFIG_PATH} is not valid JSON: ${error.message}`);
+        throw new ConfigError(`${label} is not valid JSON: ${error.message}`, {
+            cause: error,
+        });
     }
     const local = configSchema.safeParse(data);
     if (!local.success)
-        throw new ConfigError(`${CONFIG_PATH} is invalid: ${z.prettifyError(local.error)}`);
+        throw new ConfigError(`${label} is invalid: ${z.prettifyError(local.error)}`);
     if (!local.data.extends)
         return { config: local.data, rules: [] };
     // A shared configuration that cannot be loaded costs its defaults, not the

package/dist/review/plan-render.d.ts

@@ -1,3 +1,3 @@
-import type { ReviewPreview } from "@open-cr-agent/core";
+import type { ReviewPreview } from "@open-cr-agent/core/internal";
 export declare function renderPlan(preview: ReviewPreview): string;
 //# sourceMappingURL=plan-render.d.ts.map

package/dist/review/progress.js

@@ -33,7 +33,7 @@ export class ProgressPrinter {
 function describe(event) {
     switch (event.type) {
         case "run_started":
-            return `Reviewing: ${event.changeRequest.title}`;
+            return `Reviewing: ${event.changeRequest.title} · run ${event.runId}`;
         case "files_selected":
             return `${event.selected} file(s) selected, ${event.excluded} excluded · risk tier: ${event.tier}`;
         case "files_bundled":

package/dist/review/provenance.d.ts

@@ -0,0 +1,6 @@
+import type { Sampling } from "@open-cr-agent/core";
+import type { ReviewArgs } from "./args.js";
+import type { CliConfig } from "./config.js";
+export declare function requestedSampling(config: CliConfig, args: ReviewArgs): Sampling;
+export declare function configHash(config: CliConfig, args: ReviewArgs): string;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/review/provenance.js

@@ -0,0 +1,38 @@
+import { stableHash } from "@open-cr-agent/core/internal";
+// The sampling a review asks for: the configuration's, with --temperature
+// and --seed on top.
+export function requestedSampling(config, args) {
+    const temperature = args.temperature ?? config.sampling?.temperature;
+    const seed = args.seed ?? config.sampling?.seed;
+    return {
+        ...(temperature === undefined ? {} : { temperature }),
+        ...(seed === undefined ? {} : { seed }),
+    };
+}
+// The effective configuration and the flags that change what is reviewed
+// and how, so two runs can tell they were set up alike. Keys are names of
+// environment variables, never their values; a password written into a
+// URL is dropped. Sampling is recorded on its own.
+export function configHash(config, args) {
+    const { sampling: _, providers, extends: shared, ...rest } = config;
+    return stableHash({
+        ...rest,
+        ...(shared === undefined ? {} : { extends: withoutCredentials(shared) }),
+        providers: Object.fromEntries(Object.entries(providers).map(([id, p]) => [
+            id,
+            { ...p, baseUrl: withoutCredentials(p.baseUrl) },
+        ])),
+        flags: { reviewers: args.reviewers, ultra: args.ultra, maxCostUsd: args.maxCostUsd },
+    });
+}
+function withoutCredentials(value) {
+    if (!URL.canParse(value))
+        return value;
+    const url = new URL(value);
+    if (url.username === "" && url.password === "")
+        return value;
+    url.username = "";
+    url.password = "";
+    return url.toString();
+}
+//# sourceMappingURL=provenance.js.map

package/dist/review/remote-config.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const remoteConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
     models: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
         light: "light";
         standard: "standard";
@@ -16,6 +17,7 @@ export declare const remoteConfigSchema: z.ZodObject<{
     exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
     reviewers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     github: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
         path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
         rule: z.ZodString;

package/dist/review/remote-config.js

@@ -1,12 +1,15 @@
 import { createHash } from "node:crypto";
-import { repoRuleSchema } from "@open-cr-agent/core";
+import { OcraError } from "@open-cr-agent/core";
+import { repoRuleSchema } from "@open-cr-agent/core/internal";
 import { z } from "zod";
 const MAX_BYTES = 256 * 1024;
 const TIMEOUT_MS = 10_000;
-// What a shared configuration may set: settings and rules, never plugins or
-// a runtime, because it is fetched from outside the repository.
+// What a shared configuration may set: settings, rules and model providers
+// (a company gateway, for example), never plugins or a runtime, because it
+// is fetched from outside the repository.
 export const remoteConfigSchema = z
     .object({
+    $schema: z.string().optional(),
     models: z.record(z.enum(["top", "standard", "light"]), z.unknown()).optional(),
     concurrency: z.unknown().optional(),
     taskTimeoutMinutes: z.unknown().optional(),
@@ -19,6 +22,7 @@ export const remoteConfigSchema = z
     exclude: z.array(z.string()).optional(),
     reviewers: z.record(z.string(), z.unknown()).optional(),
     github: z.record(z.string(), z.unknown()).optional(),
+    providers: z.record(z.string(), z.unknown()).optional(),
     rules: z.array(repoRuleSchema).max(500).optional(),
 })
     .strict();
@@ -27,7 +31,7 @@ export async function fetchRemoteConfig(spec, fetchImpl = fetch) {
     const [address = "", fragment] = spec.split("#", 2);
     const url = new URL(address);
     if (url.protocol !== "https:")
-        throw new Error(`extends must be an https URL, got ${url.protocol}`);
+        throw new OcraError("CONFIG_INVALID", `extends must be an https URL, got ${url.protocol}`);
     const pinned = fragment?.startsWith("sha256=")
         ? fragment.slice("sha256=".length).toLowerCase()
         : undefined;
@@ -37,16 +41,22 @@ export async function fetchRemoteConfig(spec, fetchImpl = fetch) {
         redirect: "error",
     });
     if (!response.ok)
-        throw new Error(`${url.href} answered ${response.status}`);
+        throw new OcraError("CONFIG_INVALID", `${url.href} answered ${response.status}`);
     const body = await readLimited(response, MAX_BYTES, url.href);
     if (pinned !== undefined) {
         const actual = createHash("sha256").update(body).digest("hex");
         if (actual !== pinned)
-            throw new Error(`${url.href} does not match its pinned sha256`);
+            throw new OcraError("CONFIG_INVALID", `${url.href} does not match its pinned sha256`);
     }
     const parsed = remoteConfigSchema.safeParse(JSON.parse(body));
     if (!parsed.success)
-        throw new Error(`${url.href} is invalid: ${z.prettifyError(parsed.error)}`);
+        throw new OcraError("CONFIG_INVALID", `${url.href} is invalid: ${z.prettifyError(parsed.error)}`);
+    // A provider decides where the code under review goes: unpinned, whoever
+    // serves the file could send it to an endpoint of their choosing.
+    if (pinned === undefined && Object.keys(parsed.data.providers ?? {}).length > 0) {
+        const digest = createHash("sha256").update(body).digest("hex");
+        throw new OcraError("CONFIG_INVALID", `${url.href} declares providers, which a shared configuration may do only when pinned; check its content, then extend "${address}#sha256=${digest}"`);
+    }
     return parsed.data;
 }
 // Stops reading at the limit instead of buffering whatever the server sends.
@@ -63,7 +73,7 @@ async function readLimited(response, limit, name) {
         size += value.byteLength;
         if (size > limit) {
             await reader.cancel();
-            throw new Error(`${name} is larger than 256 KB`);
+            throw new OcraError("CONFIG_INVALID", `${name} is larger than 256 KB`);
         }
         chunks.push(value);
     }
@@ -73,7 +83,7 @@ async function readLimited(response, limit, name) {
 export function mergeConfig(remote, local) {
     const { rules: _rules, ...settings } = remote;
     const merged = { ...settings, ...local };
-    for (const key of ["models", "reviewers", "github"]) {
+    for (const key of ["models", "reviewers", "github", "providers"]) {
         const a = settings[key];
         const b = local[key];
         if (a !== undefined || b !== undefined)

package/dist/review/render.d.ts

@@ -1,4 +1,5 @@
-import { type ReviewReport, serializeOutput } from "@open-cr-agent/core";
+import { type ReviewReport } from "@open-cr-agent/core";
+import { serializeOutput } from "@open-cr-agent/core/internal";
 export declare function renderJson(report: ReviewReport): string;
 export declare const safeJson: typeof serializeOutput;
 export declare function renderText(report: ReviewReport, sessionDir?: string): string;

package/dist/review/render.js

@@ -1,4 +1,5 @@
-import { coverageGaps, serializeOutput, toReportOutput, } from "@open-cr-agent/core";
+import { coverageGaps, toReportOutput, } from "@open-cr-agent/core";
+import { serializeOutput } from "@open-cr-agent/core/internal";
 import { forTerminal } from "./terminal.js";
 const SEVERITIES = ["critical", "warning", "suggestion"];
 const VERIFICATION = {
@@ -14,7 +15,7 @@ export function renderJson(report) {
 export const safeJson = serializeOutput;
 export function renderText(report, sessionDir) {
     const incomplete = report.tasks.filter((t) => t.status !== "completed");
-    const { notReviewed, nothingReviewed } = coverageGaps(report.coverage);
+    const { notReviewed, nothingReviewed } = coverageGaps(report);
     const lines = [
         `Review: ${report.changeRequest.title}`,
         coverageLine(report),
@@ -79,12 +80,14 @@ export function renderText(report, sessionDir) {
         lines.push(`Incomplete: ${incomplete.length} of ${report.tasks.length} review task(s) did not finish.`);
     }
     if (notReviewed > 0) {
-        lines.push(`Incomplete: ${notReviewed} selected file(s) were not reviewed.`);
+        const limit = report.spendLimit?.reached
+            ? `; the spend limit of $${report.spendLimit.usd} was reached`
+            : "";
+        lines.push(`Incomplete: ${notReviewed} selected file(s) were not reviewed${limit}.`);
     }
     for (const warning of report.warnings)
         lines.push(`Warning: ${warning}`);
-    if (sessionDir)
-        lines.push(`Session: ${sessionDir}`);
+    lines.push(`Run: ${report.runId}${sessionDir ? ` (${sessionDir})` : ""}`);
     return forTerminal(`${lines.join("\n")}\n`);
 }
 function emptyMessage(report, nothingReviewed, notReviewed) {
@@ -111,7 +114,7 @@ function coverageLine(report) {
         `Risk tier: ${report.tier}`,
         `${count("reviewed")} reviewed`,
         `${count("failed")} failed`,
-        ...(unreviewed > 0 ? [`${unreviewed} not covered by any reviewer`] : []),
+        ...(unreviewed > 0 ? [`${unreviewed} not started`] : []),
         ...(count("unchanged") > 0 ? [`${count("unchanged")} unchanged since the last review`] : []),
         `${count("excluded")} excluded`,
     ].join(" · ");
@@ -147,6 +150,12 @@ function groupByFile(findings) {
 function summaryLine(report) {
     const counts = SEVERITIES.map((s) => `${report.findings.filter((f) => f.severity === s).length} ${s}`);
     const { inputTokens, cachedTokens, outputTokens, reasoningTokens, costUsd } = report.usage;
-    return `${report.findings.length} finding(s) (${counts.join(", ")}) · tokens: ${inputTokens} in (${cachedTokens} cached), ${outputTokens} out, ${reasoningTokens} reasoning · $${costUsd.toFixed(4)}`;
+    return `${report.findings.length} finding(s) (${counts.join(", ")}) · tokens: ${inputTokens} in (${cachedTokens} cached), ${outputTokens} out, ${reasoningTokens} reasoning · $${costUsd.toFixed(4)}${spendLimit(report)}`;
+}
+function spendLimit(report) {
+    const limit = report.spendLimit;
+    if (!limit)
+        return "";
+    return ` of $${limit.usd}${limit.reached ? " (limit reached)" : ""}`;
 }
 //# sourceMappingURL=render.js.map

package/dist/review/runtimes.d.ts

@@ -0,0 +1,5 @@
+import { type OcraPlugin } from "@open-cr-agent/core";
+export type RuntimeLoaders = Readonly<Record<string, () => Promise<OcraPlugin>>>;
+export declare const BUILTIN_RUNTIMES: RuntimeLoaders;
+export declare function loadRuntime(runtime: string, packageName: string, load: () => Promise<OcraPlugin>): Promise<OcraPlugin>;
+//# sourceMappingURL=runtimes.d.ts.map

package/dist/review/runtimes.js

@@ -0,0 +1,29 @@
+import { OcraError } from "@open-cr-agent/core";
+import { VERSION } from "../version.js";
+export const BUILTIN_RUNTIMES = {
+    opencode: () => loadRuntime("opencode", "@open-cr-agent/runtime-opencode", async () => (await import("@open-cr-agent/runtime-opencode")).opencodeRuntimePlugin),
+    direct: () => loadRuntime("direct", "@open-cr-agent/runtime-direct", async () => (await import("@open-cr-agent/runtime-direct")).directRuntimePlugin),
+};
+export async function loadRuntime(runtime, packageName, load) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (!isMissingPackage(error, packageName))
+            throw error;
+        const other = runtime === "direct" ? "opencode" : "direct";
+        throw new OcraError("RUNTIME_START_FAILED", `The ${runtime} runtime needs ${packageName}, which is not installed ` +
+            "(an optional dependency of @open-cr-agent/cli, left out by --omit=optional). " +
+            `Install it next to ocra with npm install ${packageName}@${VERSION} (-g for a global ocra), ` +
+            `or set "runtime": "${other}" in the configuration.`, { cause: error });
+    }
+}
+// Node reports a bare specifier it cannot resolve as ERR_MODULE_NOT_FOUND,
+// naming the package; a module missing inside the package names another.
+function isMissingPackage(error, packageName) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    return code === "ERR_MODULE_NOT_FOUND" && error.message.includes(`'${packageName}'`);
+}
+//# sourceMappingURL=runtimes.js.map

package/dist/review/sarif-input.d.ts

@@ -0,0 +1,4 @@
+import { type SarifLog } from "@open-cr-agent/core";
+export declare const MAX_SARIF_BYTES: number;
+export declare function loadSarifLogs(paths: readonly string[], cwd: string): Promise<SarifLog[]>;
+//# sourceMappingURL=sarif-input.d.ts.map

package/dist/review/sarif-input.js

@@ -0,0 +1,34 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parseSarifLog } from "@open-cr-agent/core";
+import { ConfigError } from "./config.js";
+// A log is untrusted input like everything else that reaches the review; it
+// is bounded before it is parsed.
+export const MAX_SARIF_BYTES = 20 * 1024 * 1024;
+export async function loadSarifLogs(paths, cwd) {
+    const logs = [];
+    for (const path of paths) {
+        const file = resolve(cwd, path);
+        let text;
+        try {
+            const { size } = await stat(file);
+            if (size > MAX_SARIF_BYTES) {
+                throw new ConfigError(`--import-sarif ${path}: larger than ${MAX_SARIF_BYTES} bytes`);
+            }
+            text = await readFile(file, "utf8");
+        }
+        catch (error) {
+            if (error instanceof ConfigError)
+                throw error;
+            throw new ConfigError(`--import-sarif ${path}: ${error.message}`);
+        }
+        try {
+            logs.push(parseSarifLog(text));
+        }
+        catch (error) {
+            throw new ConfigError(`--import-sarif ${path}: ${error.message}`);
+        }
+    }
+    return logs;
+}
+//# sourceMappingURL=sarif-input.js.map

package/dist/review/sarif.d.ts

@@ -0,0 +1,4 @@
+import { type ReviewReport } from "@open-cr-agent/core";
+export declare function renderSarif(report: ReviewReport, version: string): string;
+export declare function plainText(text: string): string;
+//# sourceMappingURL=sarif.d.ts.map