@open-cr-agent/cli 0.3.0 → 0.5.0

package/dist/review/cloud-memory.js

@@ -0,0 +1,58 @@
+import { memoryEntrySchema } from "@open-cr-agent/core/internal";
+import { VERSION } from "../version.js";
+// The findings the account remembers for one repository (ADR-0028, 4), set
+// from the web. A review applies them with .ocra/memory.json's.
+// The server keeps at most 500 per repository; more is not an answer to trust.
+const MAX_ENTRIES = 500;
+/** The account's entries for the repository; [] and a warning when they cannot be read. */
+export async function fetchAccountMemory(deps, session, repoHash, warn) {
+    let body;
+    try {
+        const res = await deps.fetch(`${session.server}/api/memory?repo=${encodeURIComponent(repoHash)}`, {
+            headers: {
+                authorization: `Bearer ${session.access_token}`,
+                "user-agent": `ocra/${VERSION}`,
+            },
+            signal: AbortSignal.timeout(15_000),
+        });
+        // A server without account memory has none to apply.
+        if (res.status === 404)
+            return [];
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        body = await res.json();
+    }
+    catch (error) {
+        warn(`could not read your ocra Cloud memory (${error instanceof Error ? error.message : "error"}); the review applies the repository's alone`);
+        return [];
+    }
+    return parseAccountMemory(body, warn);
+}
+export function parseAccountMemory(body, warn) {
+    const list = body?.entries;
+    if (!Array.isArray(list)) {
+        warn("ignoring your ocra Cloud memory: the server's answer has no entries");
+        return [];
+    }
+    const entries = [];
+    let refused = 0;
+    for (const raw of list.slice(0, MAX_ENTRIES)) {
+        const r = (typeof raw === "object" && raw !== null ? raw : {});
+        const parsed = memoryEntrySchema.safeParse({
+            fingerprint: r.fingerprint,
+            file: r.file,
+            title: r.title,
+            reason: r.reason,
+            ...(typeof r.createdAt === "string" ? { added: r.createdAt.slice(0, 10) } : {}),
+        });
+        if (parsed.success)
+            entries.push(parsed.data);
+        else
+            refused += 1;
+    }
+    if (refused > 0) {
+        warn(`ignoring ${refused} ocra Cloud memory entr${refused > 1 ? "ies" : "y"} this version of ocra cannot read`);
+    }
+    return entries;
+}
+//# sourceMappingURL=cloud-memory.js.map

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

@@ -0,0 +1,12 @@
+import type { CustomProvider } from "@open-cr-agent/core";
+import { type CloudDeps } from "../cloud.js";
+export declare const CLOUD_PREFIX = "ocra-";
+/** Where the access token travels to the runtime; never a user's variable (OCRA_ is refused in config). */
+export declare const CLOUD_TOKEN_ENV = "OCRA_CLOUD_ACCESS_TOKEN";
+type Env = Readonly<Record<string, string | undefined>>;
+export declare function withCloudProviders(chains: readonly (readonly string[] | undefined)[], providers: Readonly<Record<string, CustomProvider>>, env: Env, deps: CloudDeps | undefined, warn: (message: string) => void): Promise<{
+    providers: Record<string, CustomProvider>;
+    env: Env;
+}>;
+export {};
+//# sourceMappingURL=cloud-providers.d.ts.map

package/dist/review/cloud-providers.js

@@ -0,0 +1,60 @@
+import { OcraError } from "@open-cr-agent/core";
+import { cloudSession } from "../cloud.js";
+// Models named ocra-<provider>/<model> go through the ocra Cloud gateway with
+// the key stored there for <provider> (ADR-0024). Each such provider becomes
+// an OpenAI-compatible endpoint declared for this run, authorized by the
+// signed-in session's access token. Without such a model nothing here reads
+// the session or touches the network.
+export const CLOUD_PREFIX = "ocra-";
+/** Where the access token travels to the runtime; never a user's variable (OCRA_ is refused in config). */
+export const CLOUD_TOKEN_ENV = "OCRA_CLOUD_ACCESS_TOKEN";
+// A review may run for half an hour; start it with a token that outlives it.
+const MIN_TOKEN_MS = 35 * 60_000;
+// chains: every chain of the run, the tiers' and the agents' own.
+export async function withCloudProviders(chains, providers, env, deps, warn) {
+    const wanted = new Map();
+    for (const model of chains.flatMap((chain) => chain ?? [])) {
+        const slash = model.indexOf("/");
+        const id = model.slice(0, slash);
+        if (slash < 0 || !id.startsWith(CLOUD_PREFIX) || providers[id])
+            continue;
+        const set = wanted.get(id) ?? new Set();
+        set.add(model.slice(slash + 1));
+        wanted.set(id, set);
+    }
+    if (wanted.size === 0)
+        return { providers: { ...providers }, env };
+    const names = [...wanted.keys()].join(", ");
+    if (env.OCRA_CLOUD === "off") {
+        throw new OcraError("CONFIG_INVALID", `Models name ocra Cloud (${names}) but OCRA_CLOUD=off`);
+    }
+    const session = deps && (await cloudSession(deps, MIN_TOKEN_MS));
+    if (!session) {
+        throw new OcraError("CONFIG_CREDENTIALS_MISSING", `Models name ocra Cloud (${names}): sign in with ocra login`);
+    }
+    const res = await deps.fetch(`${session.server}/api/providers`, {
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!res.ok) {
+        throw new OcraError("RUNTIME_START_FAILED", `ocra Cloud answered ${res.status} for its providers`);
+    }
+    const listed = (await res.json()).providers ?? [];
+    const declared = { ...providers };
+    for (const [id, modelIds] of wanted) {
+        const name = id.slice(CLOUD_PREFIX.length);
+        const chat = listed
+            .find((p) => p.name === name)
+            ?.paths.find((path) => path.endsWith("/chat/completions"));
+        if (!chat) {
+            throw new OcraError("CONFIG_INVALID", `ocra Cloud has no OpenAI-compatible chat endpoint for "${name}" (named by ${id})`);
+        }
+        declared[id] = {
+            baseUrl: `${session.server}/api/gateway/${name}${chat.slice(0, -"/chat/completions".length)}`,
+            apiKeyEnv: CLOUD_TOKEN_ENV,
+            models: Object.fromEntries([...modelIds].map((m) => [m, { input: 0, output: 0 }])),
+        };
+    }
+    warn(`${names}: models through ocra Cloud are not priced, so reported cost and --max-cost-usd do not count them`);
+    return { providers: declared, env: { ...env, [CLOUD_TOKEN_ENV]: session.access_token } };
+}
+//# sourceMappingURL=cloud-providers.js.map

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

@@ -0,0 +1,19 @@
+import type { MemoryEntry, ReviewReport } from "@open-cr-agent/core";
+import { type CloudDeps } from "../cloud.js";
+import { type ReviewSource } from "./cloud-upload.js";
+import type { Output } from "./progress.js";
+export type CloudReview = {
+    repoHash: string;
+    shareFindings: boolean;
+    memory: MemoryEntry[];
+};
+/** Undefined when the saved session is gone; a failure to reach ocra Cloud is one warning. */
+export declare function prepareCloudReview(root: string, deps: CloudDeps, warn: (message: string) => void): Promise<CloudReview | undefined>;
+/** Sends the counts, and the findings when the account shares them. */
+export declare function sendToCloud(report: ReviewReport, cloud: CloudReview, deps: CloudDeps, run: {
+    source: ReviewSource;
+    durationMs: number;
+    err: Output;
+    warn: (message: string) => void;
+}): Promise<void>;
+//# sourceMappingURL=cloud-review.d.ts.map

package/dist/review/cloud-review.js

@@ -0,0 +1,51 @@
+import { fetchAccountSalt, saveAccountSalt } from "../account-salt.js";
+import { cloudSession } from "../cloud.js";
+import { sharedFindings } from "./cloud-findings.js";
+import { fetchAccountMemory } from "./cloud-memory.js";
+import { repoHash, uploadOf, uploadReview } from "./cloud-upload.js";
+/** Undefined when the saved session is gone; a failure to reach ocra Cloud is one warning. */
+export async function prepareCloudReview(root, deps, warn) {
+    let session;
+    let salt;
+    try {
+        session = await cloudSession(deps);
+        if (!session)
+            return undefined;
+        salt = await fetchAccountSalt(deps, session.server, session.access_token);
+    }
+    catch (error) {
+        // This machine's salt still groups the counts. Findings and the
+        // account's memory are keyed by the account's hash when it shares
+        // findings, so without its answer neither can be matched: none is sent
+        // and none applied.
+        warn(`could not read your ocra Cloud account (${error instanceof Error ? error.message : "error"}); this review sends no findings and applies no account memory`);
+        return {
+            repoHash: await repoHash(root, deps.credentialsPath),
+            shareFindings: false,
+            memory: [],
+        };
+    }
+    await saveAccountSalt(deps.credentialsPath, salt);
+    const hash = await repoHash(root, deps.credentialsPath, salt ?? undefined);
+    return {
+        repoHash: hash,
+        shareFindings: salt !== null,
+        memory: await fetchAccountMemory(deps, session, hash, warn),
+    };
+}
+/** Sends the counts, and the findings when the account shares them. */
+export async function sendToCloud(report, cloud, deps, run) {
+    const upload = uploadOf(report, run.source, cloud.repoHash, run.durationMs);
+    const shared = cloud.shareFindings ? sharedFindings(report) : undefined;
+    const sent = await uploadReview(upload, deps, run.warn, shared?.findings);
+    if (!sent)
+        return;
+    if (sent.findings > 0) {
+        const left = shared?.left ? ` (${shared.left} left out by the size limit)` : "";
+        run.err.write(`[ocra] Sent this review's counts and ${sent.findings} finding(s) to ocra Cloud${left} (--no-upload to skip)\n`);
+    }
+    else {
+        run.err.write("[ocra] Sent this review's counts to ocra Cloud (--no-upload to skip)\n");
+    }
+}
+//# sourceMappingURL=cloud-review.js.map

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

@@ -0,0 +1,16 @@
+import { type CloudDeps } from "../cloud.js";
+import { type AccountPlugins } from "./account-plugins.js";
+import { type AccountSettings } from "./account-settings.js";
+import type { CliConfig } from "./config.js";
+export declare const ACCOUNT_SCALARS: readonly ["concurrency", "taskTimeoutMinutes", "runTimeoutMinutes", "maxCostUsd", "maxTasks", "verify", "judge", "sampling"];
+/** The account's settings; undefined when signed out or unreachable (a warning says which). */
+export declare function fetchAccountSettings(deps: CloudDeps, warn: (message: string) => void): Promise<{
+    settings?: AccountSettings;
+    plugins: AccountPlugins;
+} | undefined>;
+/** The configuration with the account's settings under it, and what they filled in. */
+export declare function layerAccountSettings(config: CliConfig, account: AccountSettings): {
+    config: CliConfig;
+    filled: string[];
+};
+//# sourceMappingURL=cloud-settings.d.ts.map

package/dist/review/cloud-settings.js

@@ -0,0 +1,118 @@
+import { cloudSession } from "../cloud.js";
+import { VERSION } from "../version.js";
+import { parseAccountPlugins } from "./account-plugins.js";
+import { parseAccountSettings } from "./account-settings.js";
+// ocra Cloud's account settings fill what the repository's configuration
+// leaves out (ADR-0025, ADR-0027): a tier's models and effort, a reviewer's
+// or role's whole entry, the runtime and each limit. What the configuration
+// sets always wins; include, exclude and rules combine, the repository's
+// first.
+const TIERS = ["top", "standard", "light"];
+// Each set by the configuration or else by the account, whole.
+export const ACCOUNT_SCALARS = [
+    "concurrency",
+    "taskTimeoutMinutes",
+    "runTimeoutMinutes",
+    "maxCostUsd",
+    "maxTasks",
+    "verify",
+    "judge",
+    "sampling",
+];
+/** The account's settings; undefined when signed out or unreachable (a warning says which). */
+export async function fetchAccountSettings(deps, warn) {
+    let body;
+    try {
+        const session = await cloudSession(deps);
+        if (!session)
+            return undefined;
+        const res = await deps.fetch(`${session.server}/api/preferences`, {
+            headers: { authorization: `Bearer ${session.access_token}`, "user-agent": `ocra/${VERSION}` },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            warn(`could not read your ocra Cloud settings (HTTP ${res.status}); the review uses the repository's`);
+            return undefined;
+        }
+        body = await res.json();
+    }
+    catch (error) {
+        warn(`could not read your ocra Cloud settings (${error.message}); the review uses the repository's`);
+        return undefined;
+    }
+    if (typeof body !== "object" || body === null) {
+        warn("ignoring your ocra Cloud settings: the server's answer is not an object");
+        return undefined;
+    }
+    const { settings, warnings } = parseAccountSettings(body);
+    for (const warning of warnings)
+        warn(warning);
+    return { ...(settings ? { settings } : {}), plugins: parseAccountPlugins(body, warn) };
+}
+/** The configuration with the account's settings under it, and what they filled in. */
+export function layerAccountSettings(config, account) {
+    const filled = [];
+    const models = { ...config.models };
+    const effort = { ...config.effort };
+    for (const tier of TIERS) {
+        const chain = account.models?.[tier];
+        if (!config.models[tier]?.length && chain) {
+            models[tier] = chain;
+            filled.push(`models.${tier}`);
+        }
+        const level = account.effort?.[tier];
+        if (config.effort[tier] === undefined && level !== undefined) {
+            effort[tier] = level;
+            filled.push(`effort.${tier}`);
+        }
+    }
+    const reviewers = { ...config.reviewers };
+    for (const [id, entry] of Object.entries(account.reviewers ?? {})) {
+        if (reviewers[id] === undefined) {
+            reviewers[id] = entry;
+            filled.push(`reviewers.${id}`);
+        }
+    }
+    const roles = { ...config.roles };
+    for (const [role, entry] of Object.entries(account.roles ?? {})) {
+        if (roles[role] === undefined && entry) {
+            roles[role] = entry;
+            filled.push(`roles.${role}`);
+        }
+    }
+    const out = {
+        ...config,
+        models,
+        effort,
+        reviewers,
+        roles,
+        accountSettings: { version: account.version },
+    };
+    if (!config.runtimeSet && account.runtime) {
+        out.runtime = account.runtime;
+        out.runtimeSet = true;
+        filled.push("runtime");
+    }
+    for (const key of ACCOUNT_SCALARS) {
+        if (config[key] === undefined && account[key] !== undefined) {
+            Object.assign(out, { [key]: account[key] });
+            filled.push(key);
+        }
+    }
+    for (const key of ["include", "exclude"]) {
+        const added = (account[key] ?? []).filter((glob) => !config[key].includes(glob));
+        if (added.length > 0) {
+            out[key] = [...config[key], ...added];
+            filled.push(key);
+        }
+    }
+    if (account.rules?.length) {
+        out.rules = [
+            ...config.rules,
+            ...account.rules.map((rule) => ({ ...rule, source: "account" })),
+        ];
+        filled.push("rules");
+    }
+    return { config: out, filled };
+}
+//# sourceMappingURL=cloud-settings.js.map

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

@@ -0,0 +1,60 @@
+import { type ReviewReport, type Severity, type Verification } from "@open-cr-agent/core";
+import { type CloudDeps } from "../cloud.js";
+import type { SharedFinding } from "./cloud-findings.js";
+export type ReviewSource = "local" | "github" | "gitlab";
+export type ReviewerCounts = {
+    tasks: number;
+    failedTasks: number;
+    findings: Record<Severity, number>;
+    costUsd: number;
+    fixed: number;
+    dismissed: number;
+};
+export type ReviewUpload = {
+    runId: string;
+    repoHash: string;
+    source: ReviewSource;
+    tier: string;
+    verdict: string;
+    complete: boolean;
+    findings: {
+        critical: number;
+        warning: number;
+        suggestion: number;
+    };
+    files: {
+        reviewed: number;
+        notReviewed: number;
+    };
+    tasks: {
+        completed: number;
+        failed: number;
+    };
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        costUsd: number;
+    };
+    durationMs: number;
+    ocraVersion: string;
+    reviewers?: Record<string, ReviewerCounts>;
+    verification?: Record<Verification, number>;
+    outcomes?: {
+        fixed: number;
+        dismissed: number;
+    };
+};
+export declare function uploadOf(report: ReviewReport, source: ReviewSource, repoHash: string, durationMs: number): ReviewUpload;
+/** The repository's hash, salted with the account's salt when given, else this machine's. */
+export declare function repoHash(root: string, credentialsPath: string, accountSalt?: string): Promise<string>;
+/** Whether this run talks to ocra Cloud at all: signed in, not turned off. */
+export declare function cloudEnabled(deps: CloudDeps): Promise<boolean>;
+/**
+ * Sends the counts, and the findings when given; answers how many findings
+ * the server kept, or undefined when it took nothing. A failure is a
+ * warning, never a failed review.
+ */
+export declare function uploadReview(upload: ReviewUpload, deps: CloudDeps, warn: (message: string) => void, findings?: readonly SharedFinding[]): Promise<{
+    findings: number;
+} | undefined>;
+//# sourceMappingURL=cloud-upload.d.ts.map

package/dist/review/cloud-upload.js

@@ -0,0 +1,180 @@
+import { execFile } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { coverageGaps, } from "@open-cr-agent/core";
+import { verificationSchema } from "@open-cr-agent/core/internal";
+import { cloudSession, readCredentials } from "../cloud.js";
+import { VERSION } from "../version.js";
+// After a review, a signed-in CLI sends ocra Cloud its counts (ADR-0024):
+// the verdict, how many findings of each severity, files and tasks, tokens
+// and time. A path, a title, a finding's text or code go only when the
+// account shares findings (ADR-0028, cloud-findings.ts). The repository is
+// a salted hash, so the server can group reviews of one repository without
+// learning which it is: the salt stays on this machine, or is the account's
+// while it shares findings, so the hash matches on all its machines.
+const run = promisify(execFile);
+export function uploadOf(report, source, repoHash, durationMs) {
+    const severity = (s) => report.findings.filter((f) => f.severity === s).length;
+    const gaps = coverageGaps(report);
+    return {
+        runId: report.runId,
+        repoHash,
+        source,
+        tier: report.tier,
+        verdict: report.verdict,
+        complete: gaps.notReviewed === 0,
+        findings: {
+            critical: severity("critical"),
+            warning: severity("warning"),
+            suggestion: severity("suggestion"),
+        },
+        files: {
+            reviewed: report.coverage.filter((c) => c.status === "reviewed").length,
+            notReviewed: gaps.notReviewed,
+        },
+        tasks: {
+            completed: report.tasks.filter((t) => t.status === "completed").length,
+            failed: report.tasks.filter((t) => t.status === "failed").length,
+        },
+        usage: {
+            inputTokens: report.usage.inputTokens,
+            outputTokens: report.usage.outputTokens,
+            costUsd: report.usage.costUsd ?? 0,
+        },
+        durationMs: Math.round(durationMs),
+        ocraVersion: VERSION,
+        ...perReviewer(report),
+    };
+}
+// Counted as `ocra metrics` counts one report: a failed or timed-out task is
+// failed, a finding without a verification is unchecked, a dismissal outranks
+// a fix, and a fixed or dismissed finding is attributed to the reviewer of a
+// finding with its fingerprint in this report, or to none.
+function perReviewer(report) {
+    const reviewers = new Map();
+    const of = (id) => {
+        let r = reviewers.get(id);
+        if (!r) {
+            r = {
+                tasks: 0,
+                failedTasks: 0,
+                findings: { critical: 0, warning: 0, suggestion: 0 },
+                costUsd: 0,
+                fixed: 0,
+                dismissed: 0,
+            };
+            reviewers.set(id, r);
+        }
+        return r;
+    };
+    for (const task of report.tasks) {
+        const r = of(task.reviewer);
+        r.tasks += 1;
+        if (task.status === "failed" || task.status === "timed_out")
+            r.failedTasks += 1;
+        r.costUsd += task.usage.costUsd;
+    }
+    const verification = Object.fromEntries(verificationSchema.options.map((v) => [v, 0]));
+    const reviewerOf = new Map();
+    for (const finding of report.findings) {
+        of(finding.reviewer).findings[finding.severity] += 1;
+        verification[finding.verification ?? "unchecked"] += 1;
+        if (!reviewerOf.has(finding.fingerprint))
+            reviewerOf.set(finding.fingerprint, finding.reviewer);
+    }
+    const dismissed = new Set((report.rereview?.dismissed ?? []).map((f) => f.fingerprint));
+    const fixed = new Set((report.rereview?.fixed ?? []).map((f) => f.fingerprint).filter((fp) => !dismissed.has(fp)));
+    for (const fp of fixed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            of(reviewer).fixed += 1;
+    }
+    for (const fp of dismissed) {
+        const reviewer = reviewerOf.get(fp);
+        if (reviewer)
+            of(reviewer).dismissed += 1;
+    }
+    return {
+        reviewers: Object.fromEntries([...reviewers].sort(([a], [b]) => a.localeCompare(b))),
+        verification,
+        outcomes: { fixed: fixed.size, dismissed: dismissed.size },
+    };
+}
+/** The repository's origin without credentials, or its root path when it has none. */
+async function repositoryId(root) {
+    try {
+        const { stdout } = await run("git", ["-C", root, "remote", "get-url", "origin"], {
+            timeout: 10_000,
+        });
+        const url = stdout.trim();
+        return url
+            .replace(/^[a-z+]+:\/\/[^@/]*@/i, (m) => m.slice(0, m.indexOf("//") + 2))
+            .replace(/\.git$/, "")
+            .toLowerCase();
+    }
+    catch {
+        return root;
+    }
+}
+/** This machine's random salt, kept beside the credentials, made on first use. */
+async function machineSalt(credentialsPath) {
+    const path = join(dirname(credentialsPath), "upload-salt");
+    try {
+        const existing = (await readFile(path, "utf8")).trim();
+        if (/^[0-9a-f]{64}$/.test(existing))
+            return existing;
+    }
+    catch { }
+    const fresh = randomBytes(32).toString("hex");
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${fresh}\n`, { mode: 0o600 });
+    return fresh;
+}
+/** The repository's hash, salted with the account's salt when given, else this machine's. */
+export async function repoHash(root, credentialsPath, accountSalt) {
+    const salt = accountSalt ?? (await machineSalt(credentialsPath));
+    return createHash("sha256")
+        .update(`${salt}:${await repositoryId(root)}`)
+        .digest("hex");
+}
+/** Whether this run talks to ocra Cloud at all: signed in, not turned off. */
+export async function cloudEnabled(deps) {
+    return (deps.env.OCRA_CLOUD !== "off" && (await readCredentials(deps.credentialsPath)) !== undefined);
+}
+/**
+ * Sends the counts, and the findings when given; answers how many findings
+ * the server kept, or undefined when it took nothing. A failure is a
+ * warning, never a failed review.
+ */
+export async function uploadReview(upload, deps, warn, findings) {
+    try {
+        const session = await cloudSession(deps);
+        if (!session)
+            return undefined;
+        const res = await deps.fetch(`${session.server}/api/reviews`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${session.access_token}`,
+                "user-agent": `ocra/${VERSION}`,
+            },
+            // The counts stay in `findings`; the shared list goes in `findingList`.
+            body: JSON.stringify(findings ? { ...upload, findingList: findings } : upload),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            warn(`ocra Cloud did not take the review's counts (HTTP ${res.status})`);
+            return undefined;
+        }
+        const answer = (await res.json().catch(() => ({})));
+        const kept = answer.findings;
+        return { findings: typeof kept === "number" && Number.isInteger(kept) && kept > 0 ? kept : 0 };
+    }
+    catch (error) {
+        warn(`could not send the review's counts to ocra Cloud: ${error instanceof Error ? error.name : "error"}`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=cloud-upload.js.map

package/dist/review/command.d.ts

@@ -1,4 +1,6 @@
 import { type OcraPlugin } from "@open-cr-agent/core";
+import type { CloudDeps } from "../cloud.js";
+import type { NpmRunner } from "../plugins-command.js";
 import type { ReviewArgs } from "./args.js";
 import { type Output } from "./progress.js";
 import type { RuntimeLoaders } from "./runtimes.js";
@@ -20,6 +22,8 @@ export interface ReviewDeps {
     now(): number;
     heartbeatMs: number;
     fetch?: typeof fetch;
+    cloud?: CloudDeps;
+    npm?: NpmRunner;
     onInterrupt?(handler: () => void): () => void;
 }
 export declare function reviewCommand(args: ReviewArgs, io: {