opencode-anthropic-fix 0.0.35 → 0.0.37

package/index.mjs

@@ -148,6 +148,16 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
   const IDLE_REFRESH_WINDOW_MS = config.idle_refresh.window_minutes * 60 * 1000;
   const IDLE_REFRESH_MIN_INTERVAL_MS = config.idle_refresh.min_interval_minutes * 60 * 1000;
 
+  // Willow Mode: detect inactivity and suggest context reset.
+  // Named after the willow tree — when idle, the session "droops" and a gentle
+  // nudge suggests starting fresh rather than accumulating stale context.
+  const WILLOW_ENABLED = config.willow_mode?.enabled ?? true;
+  const WILLOW_IDLE_THRESHOLD_MS = (config.willow_mode?.idle_threshold_minutes ?? 30) * 60 * 1000;
+  const WILLOW_COOLDOWN_MS = (config.willow_mode?.cooldown_minutes ?? 60) * 60 * 1000;
+  const WILLOW_MIN_TURNS = config.willow_mode?.min_turns_before_suggest ?? 3;
+  let willowLastRequestTime = Date.now();
+  let willowLastSuggestionTime = 0;
+
   /**
    * Whether OPENCODE_ANTHROPIC_INITIAL_ACCOUNT env var pinned this session to a
    * specific account. When true, syncActiveIndexFromDisk is skipped and strategy
@@ -882,7 +892,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
           "Toggleable presets:",
           "  /anthropic betas add structured-outputs-2025-12-15",
           "  /anthropic betas add context-management-2025-06-27",
-          "  /anthropic betas add tool-examples-2025-10-29",
+          "  /anthropic betas add task-budgets-2026-03-13",
           "  /anthropic betas add web-search-2025-03-05",
           "  /anthropic betas add compact-2026-01-12",
           "  /anthropic betas add mcp-servers-2025-12-04",
@@ -1294,6 +1304,363 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       }
     }
 
+    // /anthropic review [pr <number>|branch <name>|status] — Claude Code Review (Bughunter) results
+    if (primary === "review") {
+      const action = (args[1] || "").toLowerCase();
+
+      /**
+       * Execute a shell command and return { stdout, stderr, code }.
+       * @param {string} cmd
+       * @param {string[]} cmdArgs
+       * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
+       */
+      async function execShell(cmd, cmdArgs) {
+        const { execFile } = await import("node:child_process");
+        return new Promise((resolve) => {
+          execFile(cmd, cmdArgs, { timeout: 30_000, maxBuffer: 2 * 1024 * 1024 }, (err, stdout, stderr) => {
+            resolve({
+              stdout: (stdout || "").trim(),
+              stderr: (stderr || "").trim(),
+              code: err ? err.code || 1 : 0,
+            });
+          });
+        });
+      }
+
+      /**
+       * Parse bughunter severity from check run output text.
+       * @param {string} text
+       * @returns {{ normal: number, nit: number, pre_existing: number } | null}
+       */
+      function parseBughunterSeverity(text) {
+        const m = text.match(/bughunter-severity:\s*(\{[^}]+\})/);
+        if (!m) return null;
+        try {
+          return JSON.parse(m[1]);
+        } catch {
+          return null;
+        }
+      }
+
+      /**
+       * Format a severity object into a human-readable string.
+       * @param {{ normal: number, nit: number, pre_existing: number }} sev
+       */
+      function formatSeverity(sev) {
+        const parts = [];
+        if (sev.normal > 0) parts.push(`🔴 Important: ${sev.normal}`);
+        if (sev.nit > 0) parts.push(`🟡 Nit: ${sev.nit}`);
+        if (sev.pre_existing > 0) parts.push(`🟣 Pre-existing: ${sev.pre_existing}`);
+        if (parts.length === 0) parts.push("No issues found");
+        return parts.join("  |  ");
+      }
+
+      // Check gh CLI availability
+      const ghCheck = await execShell("gh", ["--version"]);
+      if (ghCheck.code !== 0) {
+        await sendCommandMessage(
+          input.sessionID,
+          "▣ Anthropic Review (error)\n\nGitHub CLI (gh) not found. Install it from https://cli.github.com/",
+        );
+        return;
+      }
+
+      // Detect current repo
+      const repoResult = await execShell("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]);
+      if (repoResult.code !== 0 || !repoResult.stdout) {
+        await sendCommandMessage(
+          input.sessionID,
+          "▣ Anthropic Review (error)\n\nCould not detect GitHub repository. Ensure you are in a git repo with a GitHub remote.",
+        );
+        return;
+      }
+      const repo = repoResult.stdout.trim();
+
+      try {
+        // /anthropic review status — check if code review is set up for this repo
+        if (action === "status") {
+          // Check for recent check runs named "Claude Code Review"
+          const checkResult = await execShell("gh", [
+            "api",
+            `repos/${repo}/commits/HEAD/check-runs`,
+            "--jq",
+            '.check_runs[] | select(.name | test("claude|bughunter"; "i")) | .name + " — " + .status + " (" + .conclusion + ")"',
+          ]);
+          const lines = ["▣ Anthropic Review — Status", "", `Repository: ${repo}`, ""];
+          if (checkResult.stdout) {
+            lines.push("Recent Claude check runs:", checkResult.stdout);
+          } else {
+            lines.push(
+              "No Claude Code Review check runs found on HEAD.",
+              "",
+              "Code Review must be enabled by an admin at claude.ai/admin-settings.",
+              "It requires a Teams or Enterprise subscription.",
+            );
+          }
+          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          return;
+        }
+
+        // /anthropic review pr [<number>] — get review results for a PR
+        if (!action || action === "pr") {
+          const prNumber = args[2] ? parseInt(args[2], 10) : null;
+
+          // If no PR number, find the current branch's PR
+          let prRef;
+          if (prNumber) {
+            prRef = String(prNumber);
+          } else {
+            const branchResult = await execShell("git", ["branch", "--show-current"]);
+            const currentBranch = branchResult.stdout.trim();
+            if (!currentBranch) {
+              await sendCommandMessage(
+                input.sessionID,
+                "▣ Anthropic Review (error)\n\nDetached HEAD — specify a PR number: /anthropic review pr <number>",
+              );
+              return;
+            }
+            // Find PR for current branch
+            const prLookup = await execShell("gh", [
+              "pr",
+              "list",
+              "--head",
+              currentBranch,
+              "--json",
+              "number,title,state",
+              "--limit",
+              "1",
+            ]);
+            if (prLookup.code !== 0 || !prLookup.stdout || prLookup.stdout === "[]") {
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Review (error)\n\nNo PR found for branch "${currentBranch}".\nUse: /anthropic review pr <number>`,
+              );
+              return;
+            }
+            const prs = JSON.parse(prLookup.stdout);
+            if (!prs.length) {
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Review (error)\n\nNo PR found for branch "${currentBranch}".`,
+              );
+              return;
+            }
+            prRef = String(prs[0].number);
+          }
+
+          // Get check runs for the PR's head SHA
+          const prData = await execShell("gh", ["pr", "view", prRef, "--json", "number,title,headRefOid,state,url"]);
+          if (prData.code !== 0) {
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Review (error)\n\nCould not fetch PR #${prRef}: ${prData.stderr}`,
+            );
+            return;
+          }
+          const pr = JSON.parse(prData.stdout);
+          const sha = pr.headRefOid;
+
+          // Fetch check runs for this SHA
+          const checksResult = await execShell("gh", [
+            "api",
+            `repos/${repo}/commits/${sha}/check-runs`,
+            "--jq",
+            '.check_runs[] | select(.name | test("claude|bughunter"; "i"))',
+          ]);
+
+          const lines = [
+            "▣ Anthropic Review",
+            "",
+            `PR #${pr.number}: ${pr.title}`,
+            `State: ${pr.state}  |  Commit: ${sha.slice(0, 8)}`,
+            `URL: ${pr.url}`,
+            "",
+          ];
+
+          if (!checksResult.stdout) {
+            lines.push(
+              "No Claude Code Review check runs found for this PR.",
+              "",
+              "Possible reasons:",
+              "  • Code Review not enabled for this repository",
+              "  • Review still in progress (avg ~20 min)",
+              "  • PR is a draft (drafts are not auto-reviewed)",
+            );
+            await sendCommandMessage(input.sessionID, lines.join("\n"));
+            return;
+          }
+
+          // Parse all check runs (could be multiple)
+          const checkRunsRaw = `[${checksResult.stdout.split("\n}\n").join("},\n")}]`
+            .replace(/,\s*]$/, "]")
+            .replace(/}\s*{/g, "},{");
+          let checkRuns;
+          try {
+            checkRuns = JSON.parse(checkRunsRaw);
+            if (!Array.isArray(checkRuns)) checkRuns = [checkRuns];
+          } catch {
+            // Single object
+            try {
+              checkRuns = [JSON.parse(checksResult.stdout)];
+            } catch {
+              lines.push(
+                "Found check run(s) but could not parse output.",
+                "",
+                "Raw:",
+                checksResult.stdout.slice(0, 500),
+              );
+              await sendCommandMessage(input.sessionID, lines.join("\n"));
+              return;
+            }
+          }
+
+          for (const run of checkRuns) {
+            lines.push(`Check: ${run.name}`);
+            lines.push(`  Status: ${run.status}  |  Conclusion: ${run.conclusion || "pending"}`);
+            if (run.html_url) lines.push(`  Details: ${run.html_url}`);
+
+            // Parse bughunter severity
+            const outputText = run.output?.text || "";
+            const severity = parseBughunterSeverity(outputText);
+            if (severity) {
+              lines.push(`  Findings: ${formatSeverity(severity)}`);
+              const total = severity.normal + severity.nit + severity.pre_existing;
+              lines.push(`  Total: ${total} issue${total !== 1 ? "s" : ""}`);
+            } else if (run.status === "completed") {
+              lines.push("  Findings: No bughunter-severity data in output");
+            } else {
+              lines.push("  Review is still in progress...");
+            }
+            lines.push("");
+          }
+
+          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          return;
+        }
+
+        // /anthropic review branch [<name>] — find PR for branch and show review
+        if (action === "branch") {
+          const branchName = args[2] || (await execShell("git", ["branch", "--show-current"])).stdout.trim();
+          if (!branchName) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Review (error)\n\nNo branch specified and HEAD is detached.",
+            );
+            return;
+          }
+
+          const prLookup = await execShell("gh", [
+            "pr",
+            "list",
+            "--head",
+            branchName,
+            "--json",
+            "number,title,state,headRefOid,url",
+            "--limit",
+            "5",
+          ]);
+          if (prLookup.code !== 0 || !prLookup.stdout || prLookup.stdout === "[]") {
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Review (error)\n\nNo PRs found for branch "${branchName}".`,
+            );
+            return;
+          }
+          const prs = JSON.parse(prLookup.stdout);
+          if (!prs.length) {
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Review (error)\n\nNo PRs found for branch "${branchName}".`,
+            );
+            return;
+          }
+
+          const lines = ["▣ Anthropic Review — Branch", "", `Branch: ${branchName}`, ""];
+
+          for (const pr of prs) {
+            lines.push(`PR #${pr.number}: ${pr.title} (${pr.state})`);
+
+            // Fetch check runs
+            const checksResult = await execShell("gh", [
+              "api",
+              `repos/${repo}/commits/${pr.headRefOid}/check-runs`,
+              "--jq",
+              '.check_runs[] | select(.name | test("claude|bughunter"; "i"))',
+            ]);
+
+            if (!checksResult.stdout) {
+              lines.push("  No Claude Code Review check runs found.", "");
+              continue;
+            }
+
+            // Try to parse individual run
+            let checkRuns;
+            try {
+              const raw = `[${checksResult.stdout.split("\n}\n").join("},\n")}]`
+                .replace(/,\s*]$/, "]")
+                .replace(/}\s*{/g, "},{");
+              checkRuns = JSON.parse(raw);
+              if (!Array.isArray(checkRuns)) checkRuns = [checkRuns];
+            } catch {
+              try {
+                checkRuns = [JSON.parse(checksResult.stdout)];
+              } catch {
+                lines.push("  Could not parse check run output.", "");
+                continue;
+              }
+            }
+
+            for (const run of checkRuns) {
+              lines.push(`  Check: ${run.name} — ${run.status} (${run.conclusion || "pending"})`);
+              const outputText = run.output?.text || "";
+              const severity = parseBughunterSeverity(outputText);
+              if (severity) {
+                lines.push(`  ${formatSeverity(severity)}`);
+              }
+            }
+            lines.push("");
+          }
+
+          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          return;
+        }
+
+        // /anthropic review help
+        const helpLines = [
+          "▣ Anthropic Review (Claude Code Review / Bughunter)",
+          "",
+          "Fetch and display code review results from Claude's automated PR reviewer.",
+          "",
+          "Usage:",
+          "  /anthropic review                    Review for current branch's PR",
+          "  /anthropic review pr <number>        Review for a specific PR",
+          "  /anthropic review branch [<name>]    Review for PRs on a branch",
+          "  /anthropic review status             Check if review is configured",
+          "",
+          "Severity levels:",
+          "  🔴 Important — bugs that should be fixed before merge",
+          "  🟡 Nit — minor issues, worth fixing but not blocking",
+          "  🟣 Pre-existing — bugs in codebase not introduced by this PR",
+          "",
+          "Requirements:",
+          "  • GitHub CLI (gh) must be installed and authenticated",
+          "  • Code Review must be enabled at claude.ai/admin-settings",
+          "  • Requires Teams or Enterprise subscription",
+          "",
+          "Machine-readable severity from check runs:",
+          '  gh api repos/OWNER/REPO/check-runs/ID --jq \'.output.text | split("bughunter-severity: ")[1] | split(" -->")[0] | fromjson\'',
+        ];
+        await sendCommandMessage(input.sessionID, helpLines.join("\n"));
+        return;
+      } catch (err) {
+        await sendCommandMessage(
+          input.sessionID,
+          `▣ Anthropic Review (error)\n\n${err instanceof Error ? err.message : String(err)}`,
+        );
+        return;
+      }
+    }
+
     // Interactive CLI command is not compatible with slash flow.
     if (primary === "manage" || primary === "mg") {
       await sendCommandMessage(
@@ -1653,12 +2020,16 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       if (!input.command) input.command = {};
       input.command["anthropic"] = {
         template: "/anthropic",
-        description: "Manage Anthropic auth, config, and betas (usage, login, config, set, betas, switch)",
+        description: "Manage Anthropic auth, config, betas, review (usage, login, config, set, betas, review, switch)",
       };
     },
     "command.execute.before": async (input, output) => {
       if (input.command !== "anthropic") return;
 
+      // Signal that this command is fully handled by the plugin —
+      // do NOT forward it to the agent for further processing.
+      output.noReply = true;
+
       try {
         await handleAnthropicSlashCommand(input);
       } catch (err) {
@@ -1788,6 +2159,26 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 await accountManager.syncActiveIndexFromDisk();
               }
 
+              // Willow Mode: if the session has been idle for longer than the
+              // configured threshold and has enough turns, show a gentle toast
+              // suggesting the user consider starting a fresh context.
+              if (WILLOW_ENABLED && showUsageToast) {
+                const now = Date.now();
+                const idleMs = now - willowLastRequestTime;
+                const cooldownOk = now - willowLastSuggestionTime >= WILLOW_COOLDOWN_MS;
+                if (idleMs >= WILLOW_IDLE_THRESHOLD_MS && cooldownOk && sessionMetrics.turns >= WILLOW_MIN_TURNS) {
+                  const idleMin = Math.round(idleMs / 60_000);
+                  willowLastSuggestionTime = now;
+                  toast(
+                    `🌿 Idle for ${idleMin}m with ${sessionMetrics.turns} turns of context. Consider /clear for a fresh start.`,
+                    "info",
+                    { debounceKey: "willow-idle" },
+                  ).catch(() => {});
+                  debugLog("willow mode: idle return detected", { idleMin, turns: sessionMetrics.turns });
+                }
+                willowLastRequestTime = now;
+              }
+
               // Try each account at most once. If the error is account-specific,
               // switch to the next account. If it's service-wide, return immediately.
               // QA fix M9: use enabled account count, not total (disabled accounts can't serve requests)
@@ -2060,9 +2451,41 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     ...requestInit,
                     body,
                     headers: requestHeaders,
+                    // Disable keepalive when a previous ECONNRESET/EPIPE was detected
+                    // to force a fresh TCP connection and avoid stale socket reuse.
+                    ...(requestInit._disableKeepalive ? { keepalive: false, agent: false } : {}),
                   });
                 } catch (err) {
                   const fetchError = err instanceof Error ? err : new Error(String(err));
+                  const errMsg = fetchError.message || "";
+                  const errCode = /** @type {any} */ (fetchError).code || "";
+
+                  // ECONNRESET/EPIPE recovery: these indicate a stale TCP connection
+                  // (server closed it while we were writing/reading). Disable keepalive
+                  // on the next attempt to force a fresh connection.
+                  const isConnectionReset =
+                    errCode === "ECONNRESET" ||
+                    errCode === "EPIPE" ||
+                    errCode === "ECONNABORTED" ||
+                    errMsg.includes("ECONNRESET") ||
+                    errMsg.includes("EPIPE") ||
+                    errMsg.includes("socket hang up") ||
+                    errMsg.includes("network socket disconnected");
+
+                  if (isConnectionReset) {
+                    requestInit._disableKeepalive = true;
+                    debugLog("connection reset detected, disabling keepalive for retry", {
+                      code: errCode,
+                      message: errMsg,
+                    });
+                    // Don't mark the account as failed — this is a transport issue, not auth.
+                    // Retry the same account with keepalive disabled.
+                    if (accountManager && account) {
+                      lastError = fetchError;
+                      attempt--; // Don't consume an account slot
+                      continue;
+                    }
+                  }
 
                   if (accountManager && account) {
                     accountManager.markFailure(account);
@@ -3133,17 +3556,21 @@ process.once("beforeExit", () => {
 // Request building helpers (extracted from original fetch interceptor)
 // ---------------------------------------------------------------------------
 
-const FALLBACK_CLAUDE_CLI_VERSION = "2.1.84";
+const FALLBACK_CLAUDE_CLI_VERSION = "2.1.88";
 const CLAUDE_CODE_NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
-const CLAUDE_CODE_BUILD_TIME = "2026-03-25T23:48:41Z";
+const CLAUDE_CODE_BUILD_TIME = "2026-03-30T21:59:52Z";
 
-// The @anthropic-ai/sdk version bundled with Claude Code v2.1.84.
+// The @anthropic-ai/sdk version bundled with Claude Code v2.1.88.
 // This is distinct from the CLI version and goes in X-Stainless-Package-Version.
-// Verified by extracting VERSION="0.208.0" from the bundled cli.js of v2.1.84.
+// Verified by extracting VERSION="0.208.0" from the bundled cli.js of all versions .83-.88.
 const ANTHROPIC_SDK_VERSION = "0.208.0";
 
 // Map of CLI version → bundled SDK version (update when CLI version changes)
 const CLI_TO_SDK_VERSION = new Map([
+  ["2.1.88", "0.208.0"],
+  ["2.1.87", "0.208.0"],
+  ["2.1.86", "0.208.0"],
+  ["2.1.85", "0.208.0"],
   ["2.1.84", "0.208.0"],
   ["2.1.83", "0.208.0"],
   ["2.1.81", "0.208.0"],
@@ -3240,6 +3667,8 @@ const BETA_SHORTCUTS = new Map([
   ["fast", "fast-mode-2026-02-01"],
   ["fast-mode", "fast-mode-2026-02-01"],
   ["opus-fast", "fast-mode-2026-02-01"],
+  ["task-budgets", "task-budgets-2026-03-13"],
+  ["budgets", "task-budgets-2026-03-13"],
 ]);
 const STAINLESS_HELPER_KEYS = [
   "x_stainless_helper",
@@ -3962,9 +4391,6 @@ function buildAnthropicBetaHeader(
     betas.push("structured-outputs-2025-12-15");
   }
 
-  // Tool examples — always-on in Claude Code
-  betas.push("tool-examples-2025-10-29");
-
   // Web search — for models that support it
   if (supportsWebSearch(model)) {
     betas.push("web-search-2025-03-05");
@@ -4367,6 +4793,17 @@ function transformRequestBody(body, signature, runtime, betaHeader) {
         return msg;
       });
     }
+    // Task budgets: when the task-budgets beta is active, preserve or inject output_config.
+    // The beta unlocks output_config.max_output_tokens for per-task budget control.
+    // Model-router compatibility: the beta header + output_config body are forwarded as-is.
+    if (betaHeader && betaHeader.includes("task-budgets-2026-03-13")) {
+      if (!parsed.output_config) {
+        // Default: set a reasonable per-task output budget for long-running agentic tasks.
+        // Claude Code tasks typically need generous output budgets.
+        parsed.output_config = { max_output_tokens: 16384 };
+      }
+    }
+
     // Fast mode: inject speed parameter for supported models
     const fastModeEnabled = signature.fastMode && !isFalsyEnv(process.env.OPENCODE_ANTHROPIC_DISABLE_FAST_MODE);
     if (fastModeEnabled && parsed.model && (isOpus46Model(parsed.model) || isSonnet46Model(parsed.model))) {

package/lib/config.mjs

@@ -154,6 +154,18 @@ export const DEFAULT_CONFIG = {
     escalation_threshold: 150_000,
     deescalation_threshold: 100_000,
   },
+  /** Willow Mode: detect inactivity and suggest context reset. */
+  willow_mode: {
+    /** Enable idle detection and context-reset suggestions. */
+    enabled: true,
+    /** Minutes of inactivity before suggesting a fresh context. */
+    idle_threshold_minutes: 30,
+    /** Minimum minutes between willow suggestions (to avoid nagging). */
+    cooldown_minutes: 60,
+    /** Minimum turns in the current session before suggesting reset
+     *  (no point suggesting reset at the start of a session). */
+    min_turns_before_suggest: 3,
+  },
 };
 
 export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
@@ -181,6 +193,7 @@ function createDefaultConfig() {
     headers: { ...DEFAULT_CONFIG.headers, overrides: {}, disable: [] },
     cc_credential_reuse: { ...DEFAULT_CONFIG.cc_credential_reuse },
     adaptive_context: { ...DEFAULT_CONFIG.adaptive_context },
+    willow_mode: { ...DEFAULT_CONFIG.willow_mode },
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [