@expo/code-review-cli 0.2.3 → 0.4.0

package/build/core/opencode.js

@@ -1,6 +1,6 @@
-import { createOpencode } from '@opencode-ai/sdk';
-import { toolMap } from './tools.js';
-import { sleep } from './util.js';
+import { createOpencode } from "@opencode-ai/sdk";
+import { toolMap } from "./tools.js";
+import { errorMessage, sleep } from "./util.js";
 /** Sum token usage across attempts (for per-task/run totals). */
 export function addTokenUsage(into, from) {
     if (!from) {
@@ -21,23 +21,23 @@ const COORDINATOR_TOOLS = toolMap([]);
 // defined here so OpenCode uses this restricted tool set — otherwise the model
 // falls back to a default agent with full tools and crawls the whole repo, which
 // is why the cross-file pass used to wander for its entire time budget.
-export const CROSS_CUTTING_AGENT = 'cross-cutting';
+export const CROSS_CUTTING_AGENT = "cross-cutting";
 // Deliberately NO `glob`/`list`: the cross-file pass is given the changed files'
 // patch paths already, and directory crawling is exactly what made it wander into
 // unrelated packages. `read` (open a known file) + `grep` (find a cross-reference
 // among the changed files) are enough to trace interactions.
-const CROSS_CUTTING_TOOLS = toolMap(['read', 'grep']);
+const CROSS_CUTTING_TOOLS = toolMap(["read", "grep"]);
 // Verifies a finding by re-reading the actual file (adversarial refute pass). Same
 // restricted tool set — it opens the cited file and checks the claim.
-export const VERIFIER_AGENT = 'verifier';
-const VERIFIER_TOOLS = toolMap(['read', 'grep']);
+export const VERIFIER_AGENT = "verifier";
+const VERIFIER_TOOLS = toolMap(["read", "grep"]);
 /** Build the inline OpenCode config (agents + coordinator) from a repo config. */
 export function buildOpencodeConfig(config) {
     const agent = {};
     for (const reviewer of config.agents) {
         agent[reviewer.id] = {
             description: `${reviewer.id} reviewer`,
-            mode: 'all',
+            mode: "all",
             model: reviewer.model,
             temperature: reviewer.temperature,
             prompt: `You are the ${reviewer.id} code reviewer. Follow the user message exactly and return only the requested JSON.`,
@@ -45,37 +45,37 @@ export function buildOpencodeConfig(config) {
         };
     }
     agent[CROSS_CUTTING_AGENT] = {
-        description: 'Cross-file reviewer: issues spanning multiple changed files.',
-        mode: 'all',
+        description: "Cross-file reviewer: issues spanning multiple changed files.",
+        mode: "all",
         // Use the default reviewing model (agents share it unless overridden).
         model: config.agents[0]?.model ?? config.coordinator.model,
         temperature: config.agents[0]?.temperature ?? 0.1,
-        prompt: 'You are the cross-file code reviewer. Follow the user message exactly and return only the requested JSON.',
+        prompt: "You are the cross-file code reviewer. Follow the user message exactly and return only the requested JSON.",
         tools: CROSS_CUTTING_TOOLS,
     };
     agent[VERIFIER_AGENT] = {
-        description: 'Verifies a finding against the real file (adversarial refute pass).',
-        mode: 'all',
+        description: "Verifies a finding against the real file (adversarial refute pass).",
+        mode: "all",
         model: config.agents[0]?.model ?? config.coordinator.model,
         temperature: config.agents[0]?.temperature ?? 0.1,
-        prompt: 'You verify code-review findings against the actual source. Follow the user message exactly and return only the requested JSON.',
+        prompt: "You verify code-review findings against the actual source. Follow the user message exactly and return only the requested JSON.",
         tools: VERIFIER_TOOLS,
     };
-    agent['coordinator'] = {
-        description: 'Consolidates specialist findings into one decision.',
-        mode: 'all',
+    agent["coordinator"] = {
+        description: "Consolidates specialist findings into one decision.",
+        mode: "all",
         model: config.coordinator.model,
         temperature: config.coordinator.temperature,
-        prompt: 'You are the review coordinator. Follow the user message exactly and return only the requested JSON.',
+        prompt: "You are the review coordinator. Follow the user message exactly and return only the requested JSON.",
         tools: COORDINATOR_TOOLS,
     };
-    return { $schema: 'https://opencode.ai/config.json', agent };
+    return { $schema: "https://opencode.ai/config.json", agent };
 }
 /** hey-api style responses come back as { data, error }; unwrap or throw. */
 function unwrap(res) {
-    if (res && typeof res === 'object' && ('data' in res || 'error' in res)) {
+    if (res && typeof res === "object" && ("data" in res || "error" in res)) {
         if (res.error) {
-            throw new Error(typeof res.error === 'string' ? res.error : JSON.stringify(res.error));
+            throw new Error(typeof res.error === "string" ? res.error : JSON.stringify(res.error));
         }
         return res.data;
     }
@@ -84,7 +84,7 @@ function unwrap(res) {
 /** Start an in-process OpenCode server with the given inline config. */
 export async function startOpencode(config) {
     const { client, server } = await createOpencode({
-        hostname: '127.0.0.1',
+        hostname: "127.0.0.1",
         config: config,
     });
     return { client, url: server.url, close: () => server.close() };
@@ -101,11 +101,11 @@ const HEARTBEAT_MS = 45_000;
 const DEFAULT_MAX_WAIT_MS = 8 * 60 * 1000;
 // Extra budget for the "stop and summarize what you have" finalization prompt.
 const FINALIZE_WAIT_MS = 90 * 1000;
-const FINALIZE_PROMPT = 'You have reached your time budget. STOP investigating now — do NOT read, grep, ' +
-    'glob, list, or open any more files, and do not call any tools. Based ONLY on ' +
-    'what you have already examined, reply with the single JSON object exactly as ' +
-    'specified in your instructions, containing whatever findings you are already ' +
-    'confident about. If you have nothing solid, return an empty findings array.';
+const FINALIZE_PROMPT = "You have reached your time budget. STOP investigating now — do NOT read, grep, " +
+    "glob, list, or open any more files, and do not call any tools. Based ONLY on " +
+    "what you have already examined, reply with the single JSON object exactly as " +
+    "specified in your instructions, containing whatever findings you are already " +
+    "confident about. If you have nothing solid, return an empty findings array.";
 /**
  * Internal signal that a poll loop passed its deadline. Carries the best-effort
  * cost/tokens of the in-progress (never-completed) assistant message so a
@@ -115,12 +115,12 @@ class DeadlineReached extends Error {
     cost;
     tokens;
     constructor(cost = 0, tokens) {
-        super('deadline reached');
+        super("deadline reached");
         this.cost = cost;
         this.tokens = tokens;
     }
 }
-const DEADLINE_SENTINEL = Symbol('deadline');
+const DEADLINE_SENTINEL = Symbol("deadline");
 /**
  * Race a promise against the poll deadline. Without this, a stalled message fetch
  * (a wedged/overloaded OpenCode server) blocks the poll loop past its deadline,
@@ -134,7 +134,7 @@ async function raceDeadline(work, deadline) {
         return DEADLINE_SENTINEL;
     }
     let timer;
-    const timeout = new Promise(resolve => {
+    const timeout = new Promise((resolve) => {
         timer = setTimeout(() => resolve(DEADLINE_SENTINEL), remaining);
     });
     try {
@@ -155,7 +155,7 @@ export class AgentTimeoutError extends Error {
     tokens;
     constructor(agent, minutes, cost = 0, tokens) {
         super(`Agent "${agent}" timed out after ${minutes} minutes (including finalize)`);
-        this.name = 'AgentTimeoutError';
+        this.name = "AgentTimeoutError";
         this.cost = cost;
         this.tokens = tokens;
     }
@@ -205,7 +205,7 @@ export async function promptAgent(handle, args) {
         // Soft landing: ask the (same, context-carrying) session to return whatever
         // it has now. Only messages after this point count as the answer.
         const baseline = (await fetchMessages(handle, session.id)).length;
-        args.onActivity?.('time budget reached — asking for findings so far');
+        args.onActivity?.("time budget reached — asking for findings so far");
         await sendSessionPrompt(handle, session.id, {
             agent: args.agent,
             system: args.system,
@@ -235,11 +235,65 @@ export async function promptAgent(handle, args) {
         }
     }
 }
-const CORRECTIVE = '\n\nIMPORTANT: your previous reply could not be parsed. Reply with ONLY the single ' +
-    'JSON object described above — no prose, no code fences, no partial output.';
+const CORRECTIVE = "\n\nIMPORTANT: your previous reply could not be parsed. Reply with ONLY the single " +
+    "JSON object described above — no prose, no code fences, no partial output.";
 // Budget for a corrective "re-emit the JSON" reply — no fresh investigation, so
 // it should return almost immediately.
 const CORRECTIVE_WAIT_MS = 2 * 60 * 1000;
+/** Backoff (ms) before the 2nd and 3rd attempt of a transient-failing model call. */
+const TRANSIENT_BACKOFF_MS = [2_000, 8_000];
+/**
+ * A transient, retryable API failure — a one-off rate-limit (429), server error
+ * (5xx), or network blip — as opposed to a timeout (which means "abandon", see
+ * AgentTimeoutError) or a JSON-parse failure (handled by the corrective re-emit in
+ * promptAndParse). We match on the error text because the OpenCode SDK surfaces
+ * these as plain Errors; an AgentTimeoutError is never transient.
+ */
+const TRANSIENT_PATTERNS = [
+    /\b429\b/,
+    /\b50[0-9]\b/,
+    /rate.?limit/i,
+    /overloaded/i,
+    /too many requests/i,
+    /temporarily unavailable/i,
+    /ETIMEDOUT/i,
+    /ECONNRESET/i,
+    /ECONNREFUSED/i,
+    /ENOTFOUND/i,
+    /EAI_AGAIN/i,
+    /socket hang ?up/i,
+    /network error/i,
+    /fetch failed/i,
+];
+export function isTransientApiError(error) {
+    if (error instanceof AgentTimeoutError) {
+        return false;
+    }
+    const message = errorMessage(error);
+    return TRANSIENT_PATTERNS.some((pattern) => pattern.test(message));
+}
+/**
+ * Run a model call, retrying with bounded backoff on a transient API error. This
+ * is deliberately separate from the timeout path (abandon, never retry) and the
+ * parse-failure path (corrective re-emit): a one-off 429/5xx/network error used to
+ * drop the whole pass with no retry, reported as a coverage gap. Non-transient
+ * errors (incl. AgentTimeoutError) propagate immediately.
+ */
+async function withTransientRetry(label, onActivity, fn) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const waitMs = TRANSIENT_BACKOFF_MS[attempt];
+            if (waitMs === undefined || !isTransientApiError(error)) {
+                throw error;
+            }
+            onActivity?.(`${label}: transient API error (${errorMessage(error)}); retry ${attempt + 1}/${TRANSIENT_BACKOFF_MS.length} in ${Math.round(waitMs / 1000)}s`);
+            await sleep(waitMs);
+        }
+    }
+}
 /**
  * Prompt an agent and parse its reply. On a JSON-parse failure, first retry in
  * the SAME session: the model still holds all the file context it read, so the
@@ -259,7 +313,7 @@ export async function promptAndParse(handle, args, parse) {
         truncated = truncated || (result.truncated ?? false);
         addTokenUsage(tokens, result.tokens);
     };
-    const first = await promptAgent(handle, args);
+    const first = await withTransientRetry(`Agent "${args.agent}"`, args.onActivity, () => promptAgent(handle, args));
     record(first);
     try {
         return { value: parse(first.text), cost, truncated, tokens };
@@ -310,7 +364,7 @@ async function sendSessionPrompt(handle, sessionID, args) {
         body: {
             agent: args.agent,
             system: args.system,
-            parts: [{ type: 'text', text: args.text }],
+            parts: [{ type: "text", text: args.text }],
         },
     }));
 }
@@ -356,11 +410,11 @@ async function pollForCompletion(handle, sessionID, opts) {
             throw new DeadlineReached(lastCost, lastTokens);
         }
         const recent = messages.slice(opts.fromIndex);
-        const assistant = [...recent].reverse().find(message => message.info?.role === 'assistant');
+        const assistant = [...recent].reverse().find((message) => message.info?.role === "assistant");
         if (!assistant) {
             continue;
         }
-        if (typeof assistant.info?.cost === 'number') {
+        if (typeof assistant.info?.cost === "number") {
             lastCost = assistant.info.cost;
         }
         if (assistant.info?.tokens) {
@@ -369,15 +423,15 @@ async function pollForCompletion(handle, sessionID, opts) {
         // Track each distinct tool call once (for the tool-call cap) and, the first
         // time it starts, emit a live line so a long run shows what the agent is doing.
         for (const part of assistant.parts ?? []) {
-            if (part?.type !== 'tool') {
+            if (part?.type !== "tool") {
                 continue;
             }
             const key = part.callID ?? part.id;
             const status = part.state?.status;
-            if (key && status && status !== 'pending' && !opts.reportedTools.has(key)) {
+            if (key && status && status !== "pending" && !opts.reportedTools.has(key)) {
                 opts.reportedTools.add(key);
                 if (opts.onActivity) {
-                    const tool = part.tool ?? 'tool';
+                    const tool = part.tool ?? "tool";
                     const title = part.state?.title;
                     emit(title ? `${tool}: ${title}` : tool);
                 }
@@ -390,9 +444,9 @@ async function pollForCompletion(handle, sessionID, opts) {
         // work is done, so there's nothing to finalize.
         if (assistant.info?.time?.completed != null) {
             const text = (assistant.parts ?? [])
-                .filter(part => part?.type === 'text' && typeof part.text === 'string')
-                .map(part => part.text)
-                .join('\n')
+                .filter((part) => part?.type === "text" && typeof part.text === "string")
+                .map((part) => part.text)
+                .join("\n")
                 .trim();
             return {
                 text,