@open-cr-agent/cli 0.1.0

package/dist/review/command.js

@@ -0,0 +1,185 @@
+import { join, relative, resolve } from "node:path";
+import { agentsMdReviewerPlugin, correctnessReviewerPlugin, coverageGaps, defaultSelectionPolicy, docsReviewerPlugin, newSessionId, performanceReviewerPlugin, previewReview, runReview, securityReviewerPlugin, sessionJsonlPlugin, startPlugins, toPlanOutput, } from "@open-cr-agent/core";
+import { opencodeRuntimePlugin } from "@open-cr-agent/runtime-opencode";
+import { githubPlugin } from "@open-cr-agent/vcs-github";
+import { findRepositoryRoot, localGitPlugin } from "@open-cr-agent/vcs-local";
+import { ConfigError } from "./config.js";
+import { renderPlan } from "./plan-render.js";
+import { ProgressPrinter } from "./progress.js";
+import { renderJson, renderText, safeJson } from "./render.js";
+import { localTarget, pullRequestTarget } from "./target.js";
+import { forTerminal } from "./terminal.js";
+export const SESSIONS_DIR = ".ocra/sessions";
+export const EXIT = { ok: 0, blocking: 1, error: 2, incomplete: 3, interrupted: 130 };
+export const BUILTIN_PLUGINS = [
+    localGitPlugin,
+    githubPlugin,
+    opencodeRuntimePlugin,
+    correctnessReviewerPlugin,
+    securityReviewerPlugin,
+    performanceReviewerPlugin,
+    docsReviewerPlugin,
+    agentsMdReviewerPlugin,
+    sessionJsonlPlugin,
+];
+export async function reviewCommand(args, io, deps) {
+    const root = await findRepositoryRoot(deps.cwd);
+    const warn = (message) => io.err.write(`[ocra] Warning: ${forTerminal(message)}\n`);
+    const target = args.pullRequest
+        ? await pullRequestTarget(args.pullRequest, deps.cwd, root, deps.env, warn, deps.fetch, args.ignoreRepoConfig === true)
+        : await localTarget(args, deps.cwd, root, deps.env, warn, deps.fetch);
+    const { config } = target;
+    const session = { dir: join(root, SESSIONS_DIR), id: newSessionId() };
+    // A plan calls no model and writes no session log.
+    const builtins = args.plan
+        ? deps.builtinPlugins.filter((p) => p.name !== sessionJsonlPlugin.name)
+        : deps.builtinPlugins;
+    const registry = await startPlugins([...builtins, ...target.plugins], {
+        settings: args.plan
+            ? config.pluginSettings
+            : { ...config.pluginSettings, [sessionJsonlPlugin.name]: session },
+        env: deps.env,
+        warn,
+    });
+    const vcs = target.createVcs(registry);
+    const overrides = reviewerOverrides(config, args, registry.reviewers.map((r) => r.id));
+    if (args.plan) {
+        const preview = await previewReview({
+            vcs,
+            reviewers: registry.reviewers,
+            reviewerOverrides: overrides,
+            rules: [...registry.rules, ...config.rules],
+            selection: { ...defaultSelectionPolicy, include: config.include, exclude: config.exclude },
+            ...(target.readTrusted ? { readTrusted: target.readTrusted } : {}),
+            ...(args.ultra ? { ultra: true } : {}),
+            ...(config.maxTasks !== undefined ? { maxTasks: config.maxTasks } : {}),
+        });
+        const rendered = args.format === "json" ? `${safeJson(toPlanOutput(preview))}\n` : renderPlan(preview);
+        if (args.output === undefined)
+            io.out.write(rendered);
+        else
+            await deps.writeFile(resolve(deps.cwd, args.output), rendered);
+        return EXIT.ok;
+    }
+    const runtime = registry.createRuntime(config.runtime, { models: config.models, env: deps.env });
+    const progress = new ProgressPrinter(io.err, { heartbeatMs: deps.heartbeatMs, now: deps.now });
+    const interrupt = new AbortController();
+    const stopListening = deps.onInterrupt?.(() => {
+        io.err.write("[ocra] Interrupted: stopping and writing a partial report (Ctrl-C again quits now)\n");
+        interrupt.abort();
+    });
+    let report;
+    try {
+        report = await runReview({
+            signal: interrupt.signal,
+            ...runOptions(config),
+            reviewerOverrides: overrides,
+            ...(args.maxCostUsd !== undefined ? { maxCostUsd: args.maxCostUsd } : {}),
+            ...(args.ultra ? { ultra: true } : {}),
+            ...(args.full ? { fullReview: true } : {}),
+            ...(target.readTrusted ? { readTrusted: target.readTrusted } : {}),
+            vcs,
+            runtime,
+            reviewers: registry.reviewers,
+            rules: [...registry.rules, ...config.rules],
+            onEvent: (event) => {
+                registry.emit(event);
+                progress.onEvent(event);
+            },
+        });
+    }
+    finally {
+        stopListening?.();
+        progress.stop();
+        await runtime.dispose?.();
+    }
+    const sessionDir = relative(deps.cwd, join(session.dir, session.id)) || ".";
+    const rendered = args.format === "json" ? renderJson(report) : renderText(report, sessionDir);
+    if (args.output === undefined) {
+        io.out.write(rendered);
+    }
+    else {
+        await deps.writeFile(resolve(deps.cwd, args.output), rendered);
+        io.err.write(`[ocra] Wrote ${args.output}\n`);
+    }
+    if (interrupt.signal.aborted)
+        return EXIT.interrupted;
+    if (target.publish) {
+        // Stopping halfway could post the inline comments without the summary
+        // that remembers them; a first Ctrl-C only warns.
+        const stopHolding = deps.onInterrupt?.(() => {
+            io.err.write("[ocra] Publishing; Ctrl-C again quits now and may leave the pull request half updated\n");
+        });
+        try {
+            const published = await vcs.publish(report);
+            for (const warning of published.warnings)
+                warn(warning);
+        }
+        finally {
+            stopHolding?.();
+        }
+        io.err.write("[ocra] Published the review to the pull request\n");
+    }
+    return exitCode(report, io.err);
+}
+function runOptions(config) {
+    const options = {
+        selection: { ...defaultSelectionPolicy, include: config.include, exclude: config.exclude },
+    };
+    if (config.concurrency !== undefined)
+        options.concurrency = config.concurrency;
+    if (config.taskTimeoutMinutes !== undefined)
+        options.taskTimeoutMs = config.taskTimeoutMinutes * 60_000;
+    if (config.verify !== undefined)
+        options.verify = config.verify;
+    if (config.judge !== undefined)
+        options.judge = config.judge;
+    if (config.maxCostUsd !== undefined)
+        options.maxCostUsd = config.maxCostUsd;
+    if (config.maxTasks !== undefined)
+        options.maxTasks = config.maxTasks;
+    if (config.runTimeoutMinutes !== undefined)
+        options.runTimeoutMs = config.runTimeoutMinutes * 60_000;
+    return options;
+}
+// --reviewers narrows the run to the named reviewers on top of the config.
+function reviewerOverrides(config, args, registered) {
+    if (args.reviewers === undefined)
+        return config.reviewers;
+    const unknown = args.reviewers.filter((id) => !registered.includes(id));
+    if (unknown.length > 0) {
+        throw new ConfigError(`Unknown reviewer(s): ${unknown.join(", ")} (available: ${registered.join(", ")})`);
+    }
+    const overrides = { ...config.reviewers };
+    for (const id of registered) {
+        if (!args.reviewers.includes(id))
+            overrides[id] = { ...overrides[id], enabled: false };
+    }
+    return overrides;
+}
+function exitCode(report, err) {
+    if (report.tasks.length > 0 && report.tasks.every((t) => t.status !== "completed")) {
+        err.write("[ocra] No review task completed; see the errors above.\n");
+        return EXIT.error;
+    }
+    // Incomplete comes first, even over a blocking verdict: the action lets
+    // exit 1 pass unless fail-on-concerns is set, and a review that missed
+    // files or could not check a critical finding must never pass.
+    const { notReviewed } = coverageGaps(report.coverage);
+    if (notReviewed > 0) {
+        err.write(`[ocra] ${notReviewed} selected file(s) were not reviewed; the review is incomplete.\n`);
+        return EXIT.incomplete;
+    }
+    if (report.unverifiedCriticals > 0) {
+        err.write(`[ocra] ${report.unverifiedCriticals} critical finding(s) could not be verified; the review is incomplete.\n`);
+        return EXIT.incomplete;
+    }
+    if (report.verdict !== "significant_concerns")
+        return EXIT.ok;
+    const override = report.changeRequest.override;
+    if (!override)
+        return EXIT.blocking;
+    err.write(`[ocra] The blocking verdict was overridden by ${forTerminal(override.by)}: ${forTerminal(override.reason)}\n`);
+    return EXIT.ok;
+}
+//# sourceMappingURL=command.js.map

package/dist/review/config.d.ts

@@ -0,0 +1,50 @@
+import { type ModelChains, type RepoRule } from "@open-cr-agent/core";
+import { z } from "zod";
+export declare const CONFIG_PATH = ".ocra/config.json";
+declare const configSchema: z.ZodObject<{
+    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[]>>>;
+        light: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+    }, z.core.$strict>>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    taskTimeoutMinutes: z.ZodOptional<z.ZodNumber>;
+    runTimeoutMinutes: z.ZodOptional<z.ZodNumber>;
+    verify: z.ZodOptional<z.ZodBoolean>;
+    judge: z.ZodOptional<z.ZodBoolean>;
+    maxCostUsd: z.ZodOptional<z.ZodNumber>;
+    maxTasks: z.ZodOptional<z.ZodNumber>;
+    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>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reviewers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        minTier: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            lite: "lite";
+            trivial: "trivial";
+        }>>;
+    }, z.core.$strict>>>;
+    pluginSettings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    extends: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CliConfig = Omit<z.infer<typeof configSchema>, "models"> & {
+    models: ModelChains;
+    rules: RepoRule[];
+};
+export interface LoadOptions {
+    repository: boolean;
+    read?: (path: string) => Promise<string | undefined>;
+    fetch?: typeof fetch;
+    warn?: (message: string) => void;
+}
+export declare class ConfigError extends Error {
+}
+export declare function loadConfig(root: string, env: Readonly<Record<string, string | undefined>>, options?: LoadOptions): Promise<CliConfig>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/review/config.js

@@ -0,0 +1,125 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { RISK_TIERS, } from "@open-cr-agent/core";
+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));
+const configSchema = z
+    .object({
+    models: z
+        .object({ top: modelChain, standard: modelChain, light: modelChain })
+        .partial()
+        .strict()
+        .default({}),
+    concurrency: z.number().int().min(1).max(32).optional(),
+    taskTimeoutMinutes: z.number().positive().optional(),
+    runTimeoutMinutes: z.number().positive().optional(),
+    verify: z.boolean().optional(),
+    judge: z.boolean().optional(),
+    maxCostUsd: z.number().positive().optional(),
+    maxTasks: z.number().int().min(1).max(1_000).optional(),
+    github: z
+        .object({ requestChanges: z.boolean(), botLogin: z.string().min(1) })
+        .partial()
+        .strict()
+        .default({}),
+    include: z.array(z.string().min(1)).default([]),
+    exclude: z.array(z.string().min(1)).default([]),
+    runtime: z.string().min(1).default("opencode"),
+    plugins: z.array(z.string().min(1)).default([]),
+    reviewers: z
+        .record(z.string(), z
+        .object({
+        enabled: z.boolean(),
+        minTier: z.enum(RISK_TIERS),
+    })
+        .partial()
+        .strict())
+        .default({}),
+    pluginSettings: z.record(z.string(), z.unknown()).default({}),
+    extends: z.string().min(1).optional(),
+})
+    .strict();
+const MODEL_ENV = {
+    top: "OCRA_MODEL_TOP",
+    standard: "OCRA_MODEL_STANDARD",
+    light: "OCRA_MODEL_LIGHT",
+};
+export class ConfigError extends Error {
+}
+// 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 models = {};
+    for (const [tier, chain] of Object.entries(parsed.models)) {
+        if (chain)
+            models[tier] = chain;
+    }
+    for (const [tier, name] of Object.entries(MODEL_ENV)) {
+        const chain = (env[name] ?? "")
+            .split(",")
+            .map((m) => m.trim())
+            .filter((m) => m !== "");
+        if (chain.length > 0)
+            models[tier] = chain;
+    }
+    return { ...parsed, models, rules };
+}
+// 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.
+async function readConfigFromDisk(root, path) {
+    try {
+        return await readFile(join(root, path), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function readConfigFile(read, options) {
+    const text = await read(CONFIG_PATH);
+    if (text === undefined)
+        return { config: configSchema.parse({}), rules: [] };
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (error) {
+        throw new ConfigError(`${CONFIG_PATH} is not valid JSON: ${error.message}`);
+    }
+    const local = configSchema.safeParse(data);
+    if (!local.success)
+        throw new ConfigError(`${CONFIG_PATH} 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
+    // review: the repository's own settings still apply.
+    let remote;
+    try {
+        remote = await fetchRemoteConfig(local.data.extends, options.fetch);
+    }
+    catch (error) {
+        // Its limits are lost with it; say so rather than run silently unbounded.
+        const limits = local.data.maxCostUsd === undefined
+            ? "; none of its settings apply, including any spend or task limit"
+            : "; none of its settings apply";
+        options.warn?.(`could not load extends ${local.data.extends}: ${error.message}${limits}`);
+        return { config: local.data, rules: [] };
+    }
+    const merged = configSchema.safeParse(mergeConfig(remote, data));
+    if (!merged.success) {
+        options.warn?.(`ignoring extends ${local.data.extends}: its settings are invalid (${z.prettifyError(merged.error)})`);
+        return { config: local.data, rules: [] };
+    }
+    return { config: merged.data, rules: remote.rules ?? [] };
+}
+//# sourceMappingURL=config.js.map

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

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

package/dist/review/plan-render.js

@@ -0,0 +1,36 @@
+import { forTerminal } from "./terminal.js";
+const number = new Intl.NumberFormat("en-US");
+export function renderPlan(preview) {
+    const lines = [
+        `Plan: ${preview.changeRequest.title}`,
+        `Risk tier: ${preview.tier} · ${preview.selected.length} selected · ${preview.excluded.length} excluded`,
+    ];
+    if (preview.excluded.length > 0) {
+        lines.push("", "Excluded:");
+        for (const e of preview.excluded)
+            lines.push(`  ${e.path}  (${e.reason.replaceAll("_", " ")})`);
+    }
+    lines.push("", `Bundles: ${preview.bundles.length}`);
+    if (preview.groupingSkipped) {
+        lines.push("  (shown per file: a real run lets the light model group related files first)");
+    }
+    preview.bundles.forEach((b, i) => {
+        lines.push(`  ${i + 1}. ${b.label}${b.files.length > 1 || b.files[0] !== b.label ? `: ${b.files.join(", ")}` : ""}`);
+    });
+    lines.push("", `Review tasks: ${preview.tasks.length}`);
+    const width = Math.max(0, ...preview.tasks.map((t) => t.taskId.length));
+    for (const t of preview.tasks) {
+        lines.push(`  ${t.taskId.padEnd(width)}  ~${number.format(t.promptTokens)} prompt tokens${t.planPromptTokens === undefined ? "" : ` + plan ~${number.format(t.planPromptTokens)}`}  ${t.bundle}`);
+    }
+    if (preview.skipped.length > 0) {
+        lines.push("", "Skipped by the review matrix:");
+        for (const s of preview.skipped) {
+            lines.push(`  ${s.reviewer} on ${s.bundle} (${s.reason.replaceAll("_", " ")})`);
+        }
+    }
+    for (const warning of preview.warnings)
+        lines.push(`Warning: ${warning}`);
+    lines.push("", `First prompts: ~${number.format(preview.promptTokens)} input tokens in total${preview.planCalls > 0 ? `, ${preview.planCalls} plan call(s) included` : ""}. This is a floor: agents read files and take several turns, so a run usually uses several times as much, plus verification and judging. No model was called.`);
+    return forTerminal(`${lines.join("\n")}\n`);
+}
+//# sourceMappingURL=plan-render.js.map

package/dist/review/plugins.d.ts

@@ -0,0 +1,3 @@
+import type { OcraPlugin } from "@open-cr-agent/core";
+export declare function loadExternalPlugins(specifiers: readonly string[], root: string): Promise<OcraPlugin[]>;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/review/plugins.js

@@ -0,0 +1,32 @@
+import { createRequire } from "node:module";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ConfigError } from "./config.js";
+// Plugins listed in the repository config execute code, so they are resolved
+// only from the repository's own dependencies or relative paths inside it.
+export async function loadExternalPlugins(specifiers, root) {
+    const plugins = [];
+    for (const specifier of specifiers) {
+        const module = await import(pathToFileURL(resolvePlugin(specifier, root)).href);
+        const plugin = module.default ?? module.plugin;
+        if (!isPlugin(plugin)) {
+            throw new ConfigError(`Plugin "${specifier}" must export an ocra plugin as default or "plugin"`);
+        }
+        plugins.push(plugin);
+    }
+    return plugins;
+}
+function resolvePlugin(specifier, root) {
+    if (specifier.startsWith(".") || isAbsolute(specifier))
+        return resolve(root, specifier);
+    try {
+        return createRequire(join(root, "package.json")).resolve(specifier);
+    }
+    catch {
+        throw new ConfigError(`Cannot find plugin "${specifier}" from ${root}; install it as a dependency`);
+    }
+}
+function isPlugin(value) {
+    return (typeof value === "object" && value !== null && typeof value.name === "string");
+}
+//# sourceMappingURL=plugins.js.map

package/dist/review/progress.d.ts

@@ -0,0 +1,20 @@
+import type { ReviewEvent } from "@open-cr-agent/core";
+export interface Output {
+    write(chunk: string): unknown;
+}
+export interface ProgressOptions {
+    heartbeatMs: number;
+    now: () => number;
+}
+export declare class ProgressPrinter {
+    private readonly err;
+    private readonly options;
+    private lastOutput;
+    private readonly timer;
+    constructor(err: Output, options: ProgressOptions);
+    onEvent(event: ReviewEvent): void;
+    stop(): void;
+    private heartbeat;
+    private print;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/review/progress.js

@@ -0,0 +1,69 @@
+import { forTerminal } from "./terminal.js";
+export class ProgressPrinter {
+    err;
+    options;
+    lastOutput;
+    timer;
+    constructor(err, options) {
+        this.err = err;
+        this.options = options;
+        this.lastOutput = options.now();
+        this.timer = setInterval(() => this.heartbeat(), options.heartbeatMs);
+        this.timer.unref?.();
+    }
+    onEvent(event) {
+        const line = describe(event);
+        if (line !== undefined)
+            this.print(line);
+    }
+    stop() {
+        clearInterval(this.timer);
+    }
+    heartbeat() {
+        const silentMs = this.options.now() - this.lastOutput;
+        if (silentMs >= this.options.heartbeatMs) {
+            this.print(`Model is thinking... (${Math.round(silentMs / 1000)}s since last update)`);
+        }
+    }
+    print(line) {
+        this.lastOutput = this.options.now();
+        this.err.write(`[ocra] ${forTerminal(line)}\n`);
+    }
+}
+function describe(event) {
+    switch (event.type) {
+        case "run_started":
+            return `Reviewing: ${event.changeRequest.title}`;
+        case "files_selected":
+            return `${event.selected} file(s) selected, ${event.excluded} excluded · risk tier: ${event.tier}`;
+        case "files_bundled":
+            return [`${event.bundles} bundle(s) (${event.strategy})`, ...event.warnings].join("\n[ocra] ");
+        case "matrix_planned": {
+            const skipped = event.skipped.length;
+            return `${event.tasks} review task(s)${skipped > 0 ? `, ${skipped} reviewer/bundle pair(s) skipped` : ""}`;
+        }
+        case "verification_finished":
+            return `Verified ${event.checked} finding(s)${event.refuted.length > 0 ? `, dropped ${event.refuted.length} that the code disproves` : ""}`;
+        case "judge_finished": {
+            const j = event.judgement;
+            const changes = j
+                ? ` (merged ${j.merged.length}, dropped ${j.dropped.length}, recalibrated ${j.recalibrated.length})`
+                : "";
+            return `Verdict: ${event.verdict.replaceAll("_", " ")}${changes}`;
+        }
+        case "task_progress":
+            return `${event.taskId} ${event.message}`;
+        case "task_started":
+            return `${event.taskId} started: ${event.bundle} (${event.files.length} file(s))`;
+        case "task_finished": {
+            const { outcome } = event;
+            const seconds = (outcome.durationMs / 1000).toFixed(1);
+            return outcome.status === "completed"
+                ? `${outcome.taskId} completed in ${seconds}s · ${outcome.findings} finding(s)`
+                : `${outcome.taskId} ${outcome.status.replace("_", " ")} after ${seconds}s: ${outcome.error ?? "unknown error"}`;
+        }
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=progress.js.map

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const remoteConfigSchema: z.ZodObject<{
+    models: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        light: "light";
+        standard: "standard";
+        top: "top";
+    }>, z.ZodUnknown>>;
+    concurrency: z.ZodOptional<z.ZodUnknown>;
+    taskTimeoutMinutes: z.ZodOptional<z.ZodUnknown>;
+    runTimeoutMinutes: z.ZodOptional<z.ZodUnknown>;
+    verify: z.ZodOptional<z.ZodUnknown>;
+    judge: z.ZodOptional<z.ZodUnknown>;
+    maxCostUsd: z.ZodOptional<z.ZodUnknown>;
+    maxTasks: z.ZodOptional<z.ZodUnknown>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        rule: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export type RemoteConfig = z.infer<typeof remoteConfigSchema>;
+export declare function fetchRemoteConfig(spec: string, fetchImpl?: typeof fetch): Promise<RemoteConfig>;
+export declare function mergeConfig(remote: RemoteConfig, local: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=remote-config.d.ts.map

package/dist/review/remote-config.js

@@ -0,0 +1,90 @@
+import { createHash } from "node:crypto";
+import { repoRuleSchema } from "@open-cr-agent/core";
+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.
+export const remoteConfigSchema = z
+    .object({
+    models: z.record(z.enum(["top", "standard", "light"]), z.unknown()).optional(),
+    concurrency: z.unknown().optional(),
+    taskTimeoutMinutes: z.unknown().optional(),
+    runTimeoutMinutes: z.unknown().optional(),
+    verify: z.unknown().optional(),
+    judge: z.unknown().optional(),
+    maxCostUsd: z.unknown().optional(),
+    maxTasks: z.unknown().optional(),
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+    reviewers: z.record(z.string(), z.unknown()).optional(),
+    github: z.record(z.string(), z.unknown()).optional(),
+    rules: z.array(repoRuleSchema).max(500).optional(),
+})
+    .strict();
+// "https://example.com/ocra.json#sha256=<hex>": the fragment pins the content.
+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}`);
+    const pinned = fragment?.startsWith("sha256=")
+        ? fragment.slice("sha256=".length).toLowerCase()
+        : undefined;
+    const response = await fetchImpl(url, {
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        headers: { Accept: "application/json" },
+        redirect: "error",
+    });
+    if (!response.ok)
+        throw new Error(`${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`);
+    }
+    const parsed = remoteConfigSchema.safeParse(JSON.parse(body));
+    if (!parsed.success)
+        throw new Error(`${url.href} is invalid: ${z.prettifyError(parsed.error)}`);
+    return parsed.data;
+}
+// Stops reading at the limit instead of buffering whatever the server sends.
+async function readLimited(response, limit, name) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return "";
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > limit) {
+            await reader.cancel();
+            throw new Error(`${name} is larger than 256 KB`);
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+// The repository's own values win; lists and maps are combined.
+export function mergeConfig(remote, local) {
+    const { rules: _rules, ...settings } = remote;
+    const merged = { ...settings, ...local };
+    for (const key of ["models", "reviewers", "github"]) {
+        const a = settings[key];
+        const b = local[key];
+        if (a !== undefined || b !== undefined)
+            merged[key] = { ...(a ?? {}), ...(b ?? {}) };
+    }
+    for (const key of ["include", "exclude"]) {
+        const a = settings[key] ?? [];
+        const b = local[key] ?? [];
+        if (a.length + b.length > 0)
+            merged[key] = [...a, ...b];
+    }
+    return merged;
+}
+//# sourceMappingURL=remote-config.js.map

package/dist/review/render.d.ts

@@ -0,0 +1,5 @@
+import { type ReviewReport, serializeOutput } from "@open-cr-agent/core";
+export declare function renderJson(report: ReviewReport): string;
+export declare const safeJson: typeof serializeOutput;
+export declare function renderText(report: ReviewReport, sessionDir?: string): string;
+//# sourceMappingURL=render.d.ts.map