@open-cr-agent/cli 0.3.0 → 0.5.0

package/dist/plugins-command.js

@@ -0,0 +1,183 @@
+import { execFile } from "node:child_process";
+import { access, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { ensureDir, installedEntry, isExactVersion, isPackageName, readAllowed, writeAllowed, } from "./plugin-store.js";
+import { UsageError } from "./review/args.js";
+import { ConfigError } from "./review/config.js";
+import { forTerminal } from "./review/terminal.js";
+// `ocra plugins` (ADR-0027): the user's own decision, on each machine, to
+// let their ocra Cloud account load a third-party plugin, like adding a
+// dependency. The account names packages; only what is allowed here loads.
+export const PLUGINS_USAGE = `Usage: ocra plugins allow <name>@<version>
+       ocra plugins deny <name>
+       ocra plugins list
+
+Your ocra Cloud settings may name plugins; a review loads one only if this
+machine allows it. allow shows the package and who published it, installs that
+exact version with install scripts off into a directory of your own, and
+records its integrity; deny removes it.
+`;
+export async function pluginsCommand(argv, out, deps) {
+    const [action, target, ...extra] = argv;
+    if (action === "--help" || action === "-h" || action === "help") {
+        out.write(PLUGINS_USAGE);
+        return 0;
+    }
+    if (extra.length > 0)
+        throw new UsageError(`Unexpected argument: ${extra[0]}`);
+    if (action === "list" && target === undefined)
+        return list(out, deps.dir);
+    if (action === "allow" && target !== undefined)
+        return allow(target, out, deps);
+    if (action === "deny" && target !== undefined)
+        return deny(target, out, deps);
+    throw new UsageError(action ? `Unknown or incomplete command: plugins ${action}` : "");
+}
+async function list(out, dir) {
+    const allowed = await readAllowed(dir);
+    if (allowed.length === 0) {
+        out.write("No plugins allowed. Allow one with: ocra plugins allow <name>@<version>\n");
+        return 0;
+    }
+    for (const p of allowed)
+        out.write(`${p.name}@${p.version}  ${p.integrity}\n`);
+    out.write(`(installed in ${dir})\n`);
+    return 0;
+}
+export function parseSpec(spec) {
+    const at = spec.lastIndexOf("@");
+    const name = at > 0 ? spec.slice(0, at) : spec;
+    const version = at > 0 ? spec.slice(at + 1) : "";
+    if (!isPackageName(name))
+        throw new UsageError(`Not an npm package name: ${forTerminal(name)}`);
+    if (!isExactVersion(version)) {
+        throw new UsageError(`Name an exact version, such as ${name}@1.2.3: a range or tag could install something else later`);
+    }
+    return { name, version };
+}
+async function allow(spec, out, deps) {
+    const { name, version } = parseSpec(spec);
+    const view = describe(await deps.npm(["view", `${name}@${version}`, "--json"]));
+    if (view.name !== name || view.version !== version) {
+        throw new ConfigError(`npm did not resolve ${name}@${version} to that exact version`);
+    }
+    out.write(forTerminal([
+        `Package:      ${view.name}@${view.version}`,
+        `Published by: ${view.publisher ?? "unknown"}`,
+        `Maintainers:  ${view.maintainers.join(", ") || "unknown"}`,
+        `Integrity:    ${view.integrity ?? "unknown"}`,
+        `Installing into ${deps.dir} with install scripts off`,
+        "",
+    ].join("\n")));
+    await ensureDir(deps.dir);
+    // npm installs into the nearest package.json; one of the directory's own
+    // keeps it from walking up to a project.
+    const manifest = join(deps.dir, "package.json");
+    if (!(await exists(manifest))) {
+        await writeFile(manifest, `${JSON.stringify({ private: true }, null, 2)}\n`, { mode: 0o600 });
+    }
+    await deps.npm([
+        "install",
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        "--save-exact",
+        "--prefix",
+        deps.dir,
+        `${name}@${version}`,
+    ]);
+    const installed = await installedEntry(deps.dir, name);
+    if (installed?.version !== version || !installed.integrity) {
+        throw new ConfigError(`npm did not install ${name}@${version} into ${deps.dir}`);
+    }
+    if (view.integrity && view.integrity !== installed.integrity) {
+        throw new ConfigError(`${name}@${version} installed with another integrity than the registry lists; not allowed`);
+    }
+    const entry = { name, version, integrity: installed.integrity };
+    const allowed = (await readAllowed(deps.dir)).filter((p) => p.name !== name);
+    await writeAllowed(deps.dir, [...allowed, entry]);
+    out.write(`Allowed ${name}@${version}: your ocra Cloud settings can now load it here.\n`);
+    return 0;
+}
+async function deny(name, out, deps) {
+    if (!isPackageName(name))
+        throw new UsageError(`Not an npm package name: ${forTerminal(name)}`);
+    const allowed = await readAllowed(deps.dir);
+    const kept = allowed.filter((p) => p.name !== name);
+    if (kept.length === allowed.length) {
+        out.write(`${name} was not allowed.\n`);
+        return 0;
+    }
+    // The record is what loading checks; removing the files is housekeeping.
+    await writeAllowed(deps.dir, kept);
+    try {
+        await deps.npm([
+            "uninstall",
+            "--ignore-scripts",
+            "--no-audit",
+            "--no-fund",
+            "--prefix",
+            deps.dir,
+            name,
+        ]);
+    }
+    catch {
+        await rm(join(deps.dir, "node_modules", name), { recursive: true, force: true });
+    }
+    out.write(`Denied ${name}: it no longer loads.\n`);
+    return 0;
+}
+function describe(stdout) {
+    let data;
+    try {
+        data = JSON.parse(stdout);
+    }
+    catch {
+        throw new ConfigError("npm view did not answer with JSON");
+    }
+    if (Array.isArray(data))
+        data = data.length === 1 ? data[0] : undefined;
+    if (typeof data !== "object" || data === null) {
+        throw new ConfigError("npm view did not describe one version");
+    }
+    const v = data;
+    const person = (p) => typeof p === "string"
+        ? p
+        : typeof p === "object" && p !== null && typeof p.name === "string"
+            ? p.name
+            : undefined;
+    const integrity = v.dist?.integrity ?? v["dist.integrity"];
+    const publisher = person(v._npmUser);
+    return {
+        ...(typeof v.name === "string" ? { name: v.name } : {}),
+        ...(typeof v.version === "string" ? { version: v.version } : {}),
+        ...(publisher ? { publisher } : {}),
+        maintainers: (Array.isArray(v.maintainers) ? v.maintainers : [])
+            .map(person)
+            .filter((m) => m !== undefined),
+        ...(typeof integrity === "string" ? { integrity } : {}),
+    };
+}
+async function exists(path) {
+    return access(path).then(() => true, () => false);
+}
+// npm on Windows is npm.cmd, which execFile cannot run without a shell; run
+// the npm that ships with this Node directly instead.
+export function defaultNpm(env = process.env) {
+    const [file, prefix] = process.platform === "win32"
+        ? [
+            process.execPath,
+            [join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js")],
+        ]
+        : ["npm", []];
+    return (args) => new Promise((resolve, reject) => {
+        execFile(file, [...prefix, ...args], { env, timeout: 5 * 60_000, maxBuffer: 16 * 1024 * 1024, shell: false }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new ConfigError(`npm ${args[0]} failed: ${forTerminal(String(stderr).trim().split("\n").slice(-3).join(" ") || error.message)}`));
+            }
+            else
+                resolve(String(stdout));
+        });
+    });
+}
+//# sourceMappingURL=plugins-command.js.map

package/dist/review/account-plugins.d.ts

@@ -0,0 +1,23 @@
+import type { OcraPlugin } from "@open-cr-agent/core";
+export interface AccountPlugins {
+    plugins: string[];
+    pluginSettings: Record<string, unknown>;
+}
+export declare function parseAccountPlugins(body: unknown, warn: (message: string) => void): AccountPlugins;
+/**
+ * The account's plugins this review loads, and their settings. Only where a
+ * repository's plugins could load (allowed: never for pull or merge requests,
+ * never with --no-repo-config); a package the configuration already lists
+ * loads as the configuration's, and a plugin whose name is taken is skipped.
+ */
+export declare function accountPlugins(account: AccountPlugins, options: {
+    allowed: boolean;
+    configured: readonly string[];
+    taken: readonly OcraPlugin[];
+    dir: string;
+    warn: (message: string) => void;
+}): Promise<{
+    plugins: OcraPlugin[];
+    settings: Record<string, unknown>;
+}>;
+//# sourceMappingURL=account-plugins.d.ts.map

package/dist/review/account-plugins.js

@@ -0,0 +1,54 @@
+import { isPackageName } from "../plugin-store.js";
+import { loadAccountPlugins } from "./plugins.js";
+const MAX_PLUGINS = 50;
+export function parseAccountPlugins(body, warn) {
+    const settings = record(record(body).settings);
+    const listed = Array.isArray(settings.plugins) ? settings.plugins : [];
+    const plugins = [
+        ...new Set(listed.filter((p) => typeof p === "string" && isPackageName(p))),
+    ].slice(0, MAX_PLUGINS);
+    const refused = listed.filter((p) => typeof p !== "string" || !isPackageName(p));
+    if (refused.length > 0 || (settings.plugins !== undefined && !Array.isArray(settings.plugins))) {
+        warn(`ignoring plugins in your ocra Cloud settings that are not npm package names: ${refused.map((p) => JSON.stringify(p)).join(", ") || JSON.stringify(settings.plugins)}`);
+    }
+    if (listed.length > MAX_PLUGINS) {
+        warn(`your ocra Cloud settings name more than ${MAX_PLUGINS} plugins; the rest are ignored`);
+    }
+    return { plugins, pluginSettings: record(settings.pluginSettings) };
+}
+/**
+ * The account's plugins this review loads, and their settings. Only where a
+ * repository's plugins could load (allowed: never for pull or merge requests,
+ * never with --no-repo-config); a package the configuration already lists
+ * loads as the configuration's, and a plugin whose name is taken is skipped.
+ */
+export async function accountPlugins(account, options) {
+    const names = account.plugins.filter((name) => !options.configured.includes(name));
+    if (names.length === 0)
+        return { plugins: [], settings: {} };
+    if (!options.allowed) {
+        options.warn(`plugins from your ocra Cloud settings do not load for pull or merge requests or with --no-repo-config: ${names.join(", ")}`);
+        return { plugins: [], settings: {} };
+    }
+    const taken = new Set(options.taken.map((p) => p.name));
+    const plugins = [];
+    const settings = {};
+    for (const { name, plugin } of await loadAccountPlugins(names, options.dir, options.warn)) {
+        if (taken.has(plugin.name)) {
+            options.warn(`skipping plugin ${name} from your ocra Cloud settings: a plugin named "${plugin.name}" is already loaded`);
+            continue;
+        }
+        taken.add(plugin.name);
+        plugins.push(plugin);
+        if (Object.hasOwn(account.pluginSettings, plugin.name)) {
+            settings[plugin.name] = account.pluginSettings[plugin.name];
+        }
+    }
+    return { plugins, settings };
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+//# sourceMappingURL=account-plugins.js.map

package/dist/review/account-settings.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+declare const SETTINGS: {
+    readonly concurrency: z.ZodOptional<z.ZodNumber>;
+    readonly taskTimeoutMinutes: z.ZodOptional<z.ZodNumber>;
+    readonly runTimeoutMinutes: z.ZodOptional<z.ZodNumber>;
+    readonly maxCostUsd: z.ZodOptional<z.ZodNumber>;
+    readonly maxTasks: z.ZodOptional<z.ZodNumber>;
+    readonly verify: z.ZodOptional<z.ZodBoolean>;
+    readonly judge: z.ZodOptional<z.ZodBoolean>;
+    readonly sampling: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    readonly include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readonly exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readonly rules: z.ZodArray<z.ZodObject<{
+        path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        rule: z.ZodString;
+    }, z.core.$strict>>;
+    readonly ultra: z.ZodBoolean;
+};
+declare const AGENTS: {
+    readonly effort: z.ZodDefault<z.ZodObject<{
+        top: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+        standard: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+        light: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+    }, z.core.$strict>>;
+    readonly 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";
+        }>>;
+        models: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+    }, z.core.$strict>>>;
+    readonly roles: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
+        helper: "helper";
+        judge: "judge";
+        verifier: "verifier";
+    }> & z.core.$partial, z.ZodObject<{
+        models: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+    }, z.core.$strict>>>;
+};
+declare const TOP: {
+    readonly 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>>;
+    readonly runtime: z.ZodEnum<{
+        direct: "direct";
+        opencode: "opencode";
+    }>;
+};
+type Parsed<T extends Record<string, z.ZodType>> = {
+    [K in keyof T]?: z.output<T[K]>;
+};
+export type AccountSettings = Parsed<typeof TOP> & Parsed<typeof AGENTS> & Parsed<typeof SETTINGS> & {
+    version: string | null;
+};
+/** The account's settings, and warnings naming what was refused or ignored. */
+export declare function parseAccountSettings(data: unknown): {
+    settings: AccountSettings;
+    warnings: string[];
+};
+export {};
+//# sourceMappingURL=account-settings.d.ts.map

package/dist/review/account-settings.js

@@ -0,0 +1,106 @@
+import { repoRuleSchema } from "@open-cr-agent/core/internal";
+import { z } from "zod";
+import { CLOUD_PREFIX } from "./cloud-providers.js";
+import { configSchema } from "./config.js";
+// What ocra Cloud's GET /api/preferences may set (ADR-0025, ADR-0027),
+// checked key by key with the configuration file's own schema: a key that
+// does not match is refused alone, and a key this CLI does not know is
+// ignored, so a newer server never breaks an older CLI.
+// Keys that can move code or keys, or decide whose comments are trusted:
+// only a configuration file may set them, whatever the server sends.
+const FORBIDDEN = new Set(["providers", "extends", "github", "botLogin", "$schema"]);
+// The account's rules are bounded (ADR-0027); the repository's are its own.
+const accountRules = z
+    .array(repoRuleSchema.extend({ rule: z.string().min(1).max(2_000) }).strict())
+    .max(50);
+// Account models go through the gateway with the account's stored keys
+// (ADR-0027): a chain naming any other provider could send the code where
+// this machine's own keys reach.
+const cloudModel = (chain) => chain.every((model) => model.startsWith(CLOUD_PREFIX) && model.indexOf("/") > 0);
+const shape = configSchema.shape;
+const SETTINGS = {
+    concurrency: shape.concurrency,
+    taskTimeoutMinutes: shape.taskTimeoutMinutes,
+    runTimeoutMinutes: shape.runTimeoutMinutes,
+    maxCostUsd: shape.maxCostUsd,
+    maxTasks: shape.maxTasks,
+    verify: shape.verify,
+    judge: shape.judge,
+    sampling: shape.sampling,
+    include: shape.include,
+    exclude: shape.exclude,
+    rules: accountRules,
+    // A flag, not a configuration key: the account's default for --ultra,
+    // which the review command applies when the command line leaves it out.
+    ultra: z.boolean(),
+};
+const AGENTS = {
+    effort: shape.effort,
+    reviewers: shape.reviewers.refine((reviewers) => Object.values(reviewers).every((r) => !r.models || cloudModel(r.models)), `models must be ${CLOUD_PREFIX}<provider>/<model>`),
+    roles: shape.roles.refine((roles) => Object.values(roles).every((r) => !r?.models || cloudModel(r.models)), `models must be ${CLOUD_PREFIX}<provider>/<model>`),
+};
+const TOP = {
+    models: shape.models.refine((models) => Object.values(models).every((chain) => !chain || cloudModel(chain)), `models must be ${CLOUD_PREFIX}<provider>/<model>`),
+    // A plugin runtime would load code; the account names a built-in one.
+    runtime: z.enum(["opencode", "direct"]),
+};
+const IGNORED_TOP = new Set(["agents", "settings", "updatedAt", "version"]);
+/** The account's settings, and warnings naming what was refused or ignored. */
+export function parseAccountSettings(data) {
+    const body = record(data);
+    const settings = {
+        version: typeof body.version === "string" ? body.version : null,
+    };
+    const refused = [];
+    const unknown = [];
+    const forbidden = [];
+    const pick = (source, schemas, prefix, known = new Set()) => {
+        for (const [key, value] of Object.entries(source)) {
+            if (isEmpty(value) || known.has(key))
+                continue;
+            const name = `${prefix}${key}`;
+            if (FORBIDDEN.has(key)) {
+                forbidden.push(name);
+                continue;
+            }
+            if (!Object.hasOwn(schemas, key)) {
+                unknown.push(name);
+                continue;
+            }
+            const parsed = schemas[key].safeParse(value);
+            if (parsed.success)
+                Object.assign(settings, { [key]: parsed.data });
+            else
+                refused.push(`${name} (${z.prettifyError(parsed.error).replaceAll("\n", " ")})`);
+        }
+    };
+    pick(body, TOP, "", IGNORED_TOP);
+    pick(record(body.agents), AGENTS, "agents.");
+    // Plugins and their settings are read by account-plugins.ts (ADR-0027, 3).
+    pick(record(body.settings), SETTINGS, "settings.", new Set(["plugins", "pluginSettings"]));
+    const warnings = [];
+    if (refused.length > 0) {
+        warnings.push(`ignoring ocra Cloud settings that do not match this version of ocra: ${refused.join("; ")}`);
+    }
+    if (forbidden.length > 0) {
+        warnings.push(`ignoring ${forbidden.join(", ")} from ocra Cloud: only a configuration file may set ${forbidden.length > 1 ? "them" : "it"}`);
+    }
+    if (unknown.length > 0) {
+        warnings.push(`ignoring ocra Cloud settings this version of ocra does not know: ${unknown.join(", ")}`);
+    }
+    return { settings, warnings };
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+// The server may send a key it has no value for; that sets nothing.
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (Array.isArray(value))
+        return value.length === 0;
+    return typeof value === "object" && Object.keys(value).length === 0;
+}
+//# sourceMappingURL=account-settings.js.map

package/dist/review/args.d.ts

@@ -25,12 +25,13 @@ export interface ReviewArgs {
     plan?: true;
     importSarif?: string[];
     configFile?: string;
+    noUpload?: true;
     temperature?: number;
     seed?: number;
 }
 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  --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  -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

package/dist/review/args.js

@@ -35,6 +35,8 @@ Options:
                      .ocra/config.json; it applies with --no-repo-config too
   --no-repo-config   Ignore .ocra/config.json and its plugins (for untrusted
                      code); models come from OCRA_MODEL_* variables or --config
+  --no-upload        When signed in to ocra Cloud, do not send this review's
+                     counts (verdict, numbers of findings, files, tokens)
   -h, --help         Show help
 `;
 export function parseReviewArgs(argv) {
@@ -70,6 +72,8 @@ export function parseReviewArgs(argv) {
         args.output = values.output;
     if (values["no-repo-config"])
         args.ignoreRepoConfig = true;
+    if (values["no-upload"])
+        args.noUpload = true;
     if (values.ultra)
         args.ultra = true;
     if (values.full) {
@@ -137,6 +141,7 @@ function parse(argv) {
             format: { type: "string" },
             output: { type: "string" },
             "no-repo-config": { type: "boolean" },
+            "no-upload": { type: "boolean" },
             config: { type: "string" },
             reviewers: { type: "string" },
             "max-cost-usd": { type: "string" },

package/dist/review/cloud-findings.d.ts

@@ -0,0 +1,31 @@
+import type { ReviewReport, Severity, Verification } from "@open-cr-agent/core";
+export type SharedFinding = {
+    fingerprint: string;
+    reviewer: string;
+    severity: Severity;
+    category: string;
+    verification: Verification;
+    file: string;
+    lineStart: number | null;
+    lineEnd: number | null;
+    title: string;
+    body: string;
+    suggestion: string | null;
+    code: string;
+    redacted?: true;
+    truncated?: true;
+};
+export declare const MAX_FINDINGS = 200;
+export declare const MAX_FIELD = 4096;
+export declare const MAX_TOTAL_BYTES = 262144;
+export declare const REDACTED = "[redacted]";
+export declare function redact(text: string): {
+    text: string;
+    redacted: boolean;
+};
+/** The report's findings as uploaded, redacted and bounded; `left` counts those not sent. */
+export declare function sharedFindings(report: Pick<ReviewReport, "findings">): {
+    findings: SharedFinding[];
+    left: number;
+};
+//# sourceMappingURL=cloud-findings.d.ts.map

package/dist/review/cloud-findings.js

@@ -0,0 +1,80 @@
+export const MAX_FINDINGS = 200;
+export const MAX_FIELD = 4_096;
+export const MAX_TOTAL_BYTES = 262_144;
+// The same patterns as the server's (ocra-cloud src/redact.ts); the two
+// evolve together so the web never shows what this pass would have hidden.
+const PATTERNS = [
+    /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g,
+    /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g,
+    /\b(ghp|gho|ghs|ghu|ghr)_[A-Za-z0-9]{20,}\b/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+    /\bglpat-[A-Za-z0-9_-]{20,}\b/g,
+    /\bsk-(ant-|or-|proj-)?[A-Za-z0-9_-]{20,}\b/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
+    /\bAIza[0-9A-Za-z_-]{35}\b/g,
+    /\bnpm_[A-Za-z0-9]{36}\b/g,
+];
+// A long run mixing lower and upper case and digits: a likely key. A hex
+// digest (one case) and a path (has a slash) are left alone.
+const LONG_RUN = /\b[A-Za-z0-9+/_-]{32,}={0,2}/g;
+const looksRandom = (s) => /[a-z]/.test(s) && /[A-Z]/.test(s) && /\d/.test(s) && !s.includes("/");
+export const REDACTED = "[redacted]";
+export function redact(text) {
+    let out = text;
+    for (const pattern of PATTERNS)
+        out = out.replace(pattern, REDACTED);
+    out = out.replace(LONG_RUN, (m) => (looksRandom(m) ? REDACTED : m));
+    return { text: out, redacted: out !== text };
+}
+/** The report's findings as uploaded, redacted and bounded; `left` counts those not sent. */
+export function sharedFindings(report) {
+    const findings = [];
+    let total = 0;
+    for (const finding of report.findings.slice(0, MAX_FINDINGS)) {
+        const shared = share(finding);
+        const size = textBytes(shared);
+        if (total + size > MAX_TOTAL_BYTES)
+            break;
+        total += size;
+        findings.push(shared);
+    }
+    return { findings, left: report.findings.length - findings.length };
+}
+function share(f) {
+    let redacted = false;
+    let truncated = false;
+    const text = (value) => {
+        const r = redact(value);
+        redacted ||= r.redacted;
+        if (r.text.length <= MAX_FIELD)
+            return r.text;
+        truncated = true;
+        const cut = r.text.slice(0, MAX_FIELD);
+        // Never leave half of a surrogate pair at the cut.
+        return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
+    };
+    const shared = {
+        fingerprint: f.fingerprint,
+        reviewer: f.reviewer,
+        severity: f.severity,
+        category: f.category,
+        verification: f.verification ?? "unchecked",
+        file: f.file,
+        lineStart: f.lineRange?.start ?? null,
+        lineEnd: f.lineRange?.end ?? null,
+        title: text(f.title),
+        body: text(f.body),
+        suggestion: f.suggestion === undefined ? null : text(f.suggestion),
+        code: text(f.existingCode),
+    };
+    if (redacted)
+        shared.redacted = true;
+    if (truncated)
+        shared.truncated = true;
+    return shared;
+}
+// Bytes as sent, escapes included, so the body stays under the server's limit.
+function textBytes(f) {
+    return [f.title, f.body, f.suggestion ?? "", f.code].reduce((sum, s) => sum + Buffer.byteLength(JSON.stringify(s)), 0);
+}
+//# sourceMappingURL=cloud-findings.js.map

package/dist/review/cloud-memory.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryEntry } from "@open-cr-agent/core";
+import type { CloudDeps, Credentials } from "../cloud.js";
+/** The account's entries for the repository; [] and a warning when they cannot be read. */
+export declare function fetchAccountMemory(deps: Pick<CloudDeps, "fetch">, session: Pick<Credentials, "server" | "access_token">, repoHash: string, warn: (message: string) => void): Promise<MemoryEntry[]>;
+export declare function parseAccountMemory(body: unknown, warn: (message: string) => void): MemoryEntry[];
+//# sourceMappingURL=cloud-memory.d.ts.map