@khalilgharbaoui/opencode-claude-code-plugin 0.4.4 → 0.4.6

package/README.md

@@ -172,6 +172,7 @@ The account model IDs are internally suffixed, for example `claude-sonnet-4-6@wo
 | `strictMcpConfig` | boolean | `false` | Pass `--strict-mcp-config` so Claude loads **only** the configured servers and ignores `~/.claude/settings.json`. |
 | `webSearch` | `"claude"` \| `"disabled"` \| `<tool>` | `"claude"` | Routing for Claude's built-in `WebSearch`. See [WebSearch routing](#websearch-routing). |
 | `multiStepContinuation` | boolean | `true` | Append a system-prompt hint nudging Claude to chain tool calls within one turn instead of pausing between subtasks. Each opencode turn boundary requires the user to manually press "continue", so for multi-step tasks this reduces friction. Set `false` to disable. |
+| `autoContinueIncompleteTurns` | boolean \| `"smart"` | `"smart"` | Smartly continue incomplete Claude CLI results inside the same opencode turn. Reduces manual "continue" presses when Claude ends after reasoning/tool activity without a useful final answer. Set `false` to disable. |
 
 ### Overriding model metadata
 
@@ -311,6 +312,7 @@ Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The
 ## Quirks worth knowing
 
 - **Empty text blocks are dropped.** Claude sometimes opens a `content_block_start` for text but never sends a delta. The plugin no longer emits the empty block (which was triggering Anthropic 400s like `cache_control cannot be set for empty text blocks`).
+- **Smart incomplete-turn continuation.** By default, the plugin keeps the current opencode stream open and feeds Claude CLI a small internal continuation message when Claude emits a `result` after reasoning/tool activity without a useful visible answer. It still stops normally on final-looking answers, questions, blockers, errors, aborts, or internal safety-budget exhaustion. Disable with `"autoContinueIncompleteTurns": false`.
 - **`AskUserQuestion`** from the CLI is converted into plain text content rather than forwarded as a tool call.
 - **Wire-inactivity watchdog.** Once the CLI has produced any content, the stream closes gracefully if stdout goes silent for 60 seconds without a `result` message arriving. Resets on every line received, so long mid-turn pauses (Sonnet between text-end and the next tool_use, for example) are tolerated. On a user-initiated abort, the watchdog shortens to 5 seconds.
 - **Per-iteration usage.** When the CLI internally retries with tools, the plugin only counts the last iteration's usage so opencode's context accounting stays accurate.

package/dist/index.d.ts

@@ -116,6 +116,7 @@ interface ClaudeCodeConfig {
     hotReloadMcp?: boolean;
     proxyOpencodeMcpTools?: boolean;
     multiStepContinuation?: boolean;
+    autoContinueIncompleteTurns?: boolean | "smart";
 }
 type WebSearchRouting = "claude" | "disabled" | (string & {});
 interface ClaudeCodeProviderSettings {
@@ -219,6 +220,19 @@ interface ClaudeCodeProviderSettings {
      * decides when to end the turn entirely on its own).
      */
     multiStepContinuation?: boolean;
+    /**
+     * Smartly continue incomplete Claude CLI results inside the same opencode
+     * turn. Claude CLI sometimes emits `result` after reasoning/tool activity
+     * without a useful final answer, which makes opencode stop and wait for the
+     * user to type "continue". With the default `"smart"`, the plugin detects
+     * those incomplete result boundaries, feeds Claude a small continuation
+     * message internally, and keeps the opencode stream open. Final answers,
+     * questions, blockers, errors, aborts, and safety-budget exhaustion still
+     * stop normally.
+     *
+     * Set to `false` to disable.
+     */
+    autoContinueIncompleteTurns?: boolean | "smart";
 }
 type PermissionMode = "acceptEdits" | "auto" | "bypassPermissions" | "default" | "dontAsk" | "plan";
 type ControlRequestBehavior = "allow" | "deny";

package/dist/index.js

@@ -2,7 +2,33 @@
 import { generateId } from "@ai-sdk/provider-utils";
 
 // src/logger.ts
+import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
 var DEBUG = process.env.DEBUG?.includes("opencode-claude-code") ?? false;
+var LOG_DIR = process.env.OPENCODE_CLAUDE_CODE_LOG_DIR ?? join(homedir(), ".local", "share", "opencode-claude-code");
+var LOG_FILE = join(LOG_DIR, "plugin.log");
+var MAX_LOG_BYTES = 5 * 1024 * 1024;
+var fileLoggingDisabled = false;
+function rotateIfNeeded() {
+  try {
+    const stat = statSync(LOG_FILE);
+    if (stat.size > MAX_LOG_BYTES) {
+      renameSync(LOG_FILE, `${LOG_FILE}.1`);
+    }
+  } catch {
+  }
+}
+function writeToFile(line) {
+  if (fileLoggingDisabled) return;
+  try {
+    mkdirSync(dirname(LOG_FILE), { recursive: true });
+    rotateIfNeeded();
+    appendFileSync(LOG_FILE, line + "\n", "utf8");
+  } catch {
+    fileLoggingDisabled = true;
+  }
+}
 function fmt(level, msg, data) {
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const base = `[${ts}] [opencode-claude-code] ${level}: ${msg}`;
@@ -11,21 +37,30 @@ function fmt(level, msg, data) {
   }
   return base;
 }
+function emit(level, msg, data, alwaysStderr = false) {
+  const line = fmt(level, msg, data);
+  if (alwaysStderr || DEBUG) {
+    console.error(line);
+  }
+  writeToFile(line);
+}
 var log = {
   info(msg, data) {
-    if (DEBUG) console.error(fmt("INFO", msg, data));
+    if (DEBUG) emit("INFO", msg, data);
+    else writeToFile(fmt("INFO", msg, data));
   },
   notice(msg, data) {
-    console.error(fmt("NOTICE", msg, data));
+    emit("NOTICE", msg, data, true);
   },
   warn(msg, data) {
-    console.error(fmt("WARN", msg, data));
+    emit("WARN", msg, data, true);
   },
   error(msg, data) {
-    console.error(fmt("ERROR", msg, data));
+    emit("ERROR", msg, data, true);
   },
   debug(msg, data) {
-    if (DEBUG) console.error(fmt("DEBUG", msg, data));
+    if (DEBUG) emit("DEBUG", msg, data);
+    else writeToFile(fmt("DEBUG", msg, data));
   }
 };
 
@@ -1460,9 +1495,9 @@ function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 function hasNewUserContent(prompt) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
@@ -1483,6 +1518,78 @@ function hasNewUserContent(prompt) {
   }
   return false;
 }
+var AUTO_CONTINUE_MAX_ATTEMPTS = 8;
+var AUTO_CONTINUE_MAX_ELAPSED_MS = 10 * 60 * 1e3;
+var AUTO_CONTINUE_NO_PROGRESS_LIMIT = 2;
+var AUTO_CONTINUE_PROMPT = "Continue the task from where you stopped. Do not summarize; keep working until the requested task is complete, you need clarification, or you hit a real blocker.";
+function normalizeVisibleText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function looksLikeQuestion(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (!normalized) return false;
+  if (normalized.endsWith("?")) return true;
+  return /\b(please confirm|can you confirm|should i|would you like|do you want|which option|choose|pick one|need your|need you to|what would you like)\b/.test(normalized);
+}
+function looksLikeBlocker(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (!normalized) return false;
+  return /\b(blocked|blocker|cannot proceed|can't proceed|unable to proceed|need clarification|need more information|permission denied|failed and needs|requires your|manual step|required from you)\b/.test(normalized);
+}
+function looksLikeFinalAnswer(text) {
+  const normalized = normalizeVisibleText(text).toLowerCase();
+  if (normalized.length < 40) return false;
+  if (looksLikeQuestion(normalized) || looksLikeBlocker(normalized)) return false;
+  return /\b(done|completed|fixed|implemented|verified|published|released|sent|delivered|updated)\b/.test(normalized) || /\b(checks?|tests?) passed\b/.test(normalized) || /\b(summary|what changed|verification)\b/.test(normalized);
+}
+function continuationSignature(snapshot) {
+  const text = normalizeVisibleText(snapshot.text).slice(-500);
+  return JSON.stringify({
+    text,
+    reasoning: snapshot.hadReasoning,
+    tools: snapshot.hadToolActivity,
+    proxy: snapshot.hadProxyActivity
+  });
+}
+function shouldAutoContinueIncompleteTurn(state, snapshot) {
+  if (state.enabled === false) return { continue: false, reason: "disabled" };
+  if (snapshot.isError) return { continue: false, reason: "error" };
+  if (state.aborted) return { continue: false, reason: "aborted" };
+  if (state.attempts >= AUTO_CONTINUE_MAX_ATTEMPTS) {
+    return { continue: false, reason: "max-attempts" };
+  }
+  const now = snapshot.now ?? Date.now();
+  if (now - state.startedAt > AUTO_CONTINUE_MAX_ELAPSED_MS) {
+    return { continue: false, reason: "max-elapsed" };
+  }
+  const text = normalizeVisibleText(snapshot.text);
+  const lastText = normalizeVisibleText(snapshot.lastVisibleText);
+  if (looksLikeQuestion(text)) return { continue: false, reason: "question" };
+  if (looksLikeBlocker(text)) return { continue: false, reason: "blocker" };
+  if (looksLikeFinalAnswer(lastText)) {
+    return { continue: false, reason: "final-answer" };
+  }
+  const hadActivity = snapshot.hadReasoning || snapshot.hadToolActivity || snapshot.hadProxyActivity;
+  if (!hadActivity) return { continue: false, reason: "no-activity" };
+  const signature = continuationSignature(snapshot);
+  const noProgress = signature === state.lastSignature;
+  if (noProgress && state.noProgressCount + 1 >= AUTO_CONTINUE_NO_PROGRESS_LIMIT) {
+    return { continue: false, reason: "no-progress" };
+  }
+  if (!text) {
+    return { continue: true, reason: "activity-without-visible-answer" };
+  }
+  return { continue: true, reason: "non-final-progress" };
+}
+function makeAutoContinueMessage() {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text: AUTO_CONTINUE_PROMPT }]
+    }
+  });
+}
 function readPromptFileIfPresent(path5) {
   try {
     const content = readFileSync2(path5, "utf8").trim();
@@ -1494,9 +1601,9 @@ function readPromptFileIfPresent(path5) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join4(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join5(dir, "AGENTS.md"));
     if (content) return content;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -1511,15 +1618,15 @@ blocker. The user can interrupt or abort at any time; turn endings should
 mark meaningful checkpoints, not every completed substep.`;
 function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true) {
   const parts = [];
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config");
-  const globalAgents = readPromptFileIfPresent(join4(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config");
+  const globalAgents = readPromptFileIfPresent(join5(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   if (globalAgents) parts.push(globalAgents);
   if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path5 = join4(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
+  const path5 = join5(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
   try {
     writeFileSync3(path5, content, "utf8");
     return path5;
@@ -2420,6 +2527,17 @@ ${plan}
           let pendingProxyUnsubscribe = null;
           let resultFallbackTimer = null;
           let hasReceivedContent = false;
+          let visibleTextSinceContinue = "";
+          let lastVisibleTextSinceContinue = "";
+          let hadReasoningSinceContinue = false;
+          let hadToolActivitySinceContinue = false;
+          let hadProxyActivitySinceContinue = false;
+          const autoContinueState = {
+            enabled: self.config.autoContinueIncompleteTurns,
+            attempts: 0,
+            startedAt: Date.now(),
+            noProgressCount: 0
+          };
           const clearFallbackTimer = () => {
             if (resultFallbackTimer) {
               clearTimeout(resultFallbackTimer);
@@ -2492,6 +2610,29 @@ ${plan}
             });
             finishWithToolCalls(batch);
           };
+          const noteVisibleText = (text) => {
+            visibleTextSinceContinue += text;
+            lastVisibleTextSinceContinue += text;
+          };
+          const resetLastVisibleTextBlock = () => {
+            lastVisibleTextSinceContinue = "";
+          };
+          const noteReasoning = () => {
+            hadReasoningSinceContinue = true;
+          };
+          const noteToolActivity = () => {
+            hadToolActivitySinceContinue = true;
+          };
+          const noteProxyActivity = () => {
+            hadProxyActivitySinceContinue = true;
+          };
+          const resetAutoContinueWindow = () => {
+            visibleTextSinceContinue = "";
+            lastVisibleTextSinceContinue = "";
+            hadReasoningSinceContinue = false;
+            hadToolActivitySinceContinue = false;
+            hadProxyActivitySinceContinue = false;
+          };
           let gotPartialEvents = false;
           const lineHandler = (line) => {
             if (!line.trim()) return;
@@ -2522,6 +2663,7 @@ ${plan}
                 const block = msg.content_block;
                 const idx = msg.index;
                 if (block.type === "thinking") {
+                  noteReasoning();
                   const reasoningId = generateId();
                   reasoningIds.set(idx, reasoningId);
                   controller.enqueue({
@@ -2532,6 +2674,7 @@ ${plan}
                 }
                 if (block.type === "text") {
                   textBlockIndices.add(idx);
+                  resetLastVisibleTextBlock();
                   if (block.text) {
                     if (!currentTextId) startTextBlock();
                     controller.enqueue({
@@ -2539,10 +2682,12 @@ ${plan}
                       id: currentTextId,
                       delta: block.text
                     });
+                    noteVisibleText(block.text);
                     hasReceivedContent = true;
                   }
                 }
                 if (block.type === "tool_use" && block.id && block.name) {
+                  noteToolActivity();
                   toolCallMap.set(idx, {
                     id: block.id,
                     name: block.name,
@@ -2574,6 +2719,7 @@ ${plan}
                 const delta = msg.delta;
                 const idx = msg.index;
                 if (delta.type === "thinking_delta" && delta.thinking) {
+                  noteReasoning();
                   const reasoningId = reasoningIds.get(idx);
                   if (reasoningId) {
                     controller.enqueue({
@@ -2590,6 +2736,7 @@ ${plan}
                     id: currentTextId,
                     delta: delta.text
                   });
+                  noteVisibleText(delta.text);
                   hasReceivedContent = true;
                 }
                 if (delta.type === "input_json_delta" && delta.partial_json) {
@@ -2712,6 +2859,7 @@ ${plan}
                 }
                 for (const block of msg.message.content) {
                   if (block.type === "text" && block.text) {
+                    resetLastVisibleTextBlock();
                     const blockId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
@@ -2719,9 +2867,11 @@ ${plan}
                       delta: block.text
                     });
                     endTextBlock();
+                    noteVisibleText(block.text);
                     hasReceivedContent = true;
                   }
                   if (block.type === "thinking" && block.thinking) {
+                    noteReasoning();
                     const thinkingId = generateId();
                     controller.enqueue({
                       type: "reasoning-start",
@@ -2738,6 +2888,7 @@ ${plan}
                     });
                   }
                   if (block.type === "tool_use" && block.id && block.name) {
+                    noteToolActivity();
                     const parsedInput = block.input ?? {};
                     toolCallsById.set(block.id, {
                       id: block.id,
@@ -2851,6 +3002,7 @@ ${plan}
                         },
                         providerExecuted: true
                       });
+                      noteToolActivity();
                       log.info("tool result emitted", {
                         toolUseId: block.tool_use_id,
                         name: toolCall.name
@@ -2914,6 +3066,54 @@ ${plan}
                     )
                   );
                 }
+                const autoDecision = shouldAutoContinueIncompleteTurn(
+                  autoContinueState,
+                  {
+                    text: visibleTextSinceContinue,
+                    lastVisibleText: lastVisibleTextSinceContinue,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue,
+                    isError: msg.is_error
+                  }
+                );
+                if (autoDecision.continue) {
+                  const signature = continuationSignature({
+                    text: visibleTextSinceContinue,
+                    lastVisibleText: lastVisibleTextSinceContinue,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue,
+                    isError: msg.is_error
+                  });
+                  autoContinueState.noProgressCount = signature === autoContinueState.lastSignature ? autoContinueState.noProgressCount + 1 : 0;
+                  autoContinueState.lastSignature = signature;
+                  autoContinueState.attempts++;
+                  log.notice("auto-continuing incomplete claude result", {
+                    sessionKey: sk,
+                    reason: autoDecision.reason,
+                    attempts: autoContinueState.attempts,
+                    textLength: visibleTextSinceContinue.length,
+                    lastTextLength: lastVisibleTextSinceContinue.length,
+                    hadReasoning: hadReasoningSinceContinue,
+                    hadToolActivity: hadToolActivitySinceContinue,
+                    hadProxyActivity: hadProxyActivitySinceContinue
+                  });
+                  turnCompleted = false;
+                  resetAutoContinueWindow();
+                  proc.stdin?.write(makeAutoContinueMessage() + "\n");
+                  return;
+                }
+                log.notice("auto-continuation stopped", {
+                  sessionKey: sk,
+                  reason: autoDecision.reason,
+                  attempts: autoContinueState.attempts,
+                  textLength: visibleTextSinceContinue.length,
+                  lastTextLength: lastVisibleTextSinceContinue.length,
+                  hadReasoning: hadReasoningSinceContinue,
+                  hadToolActivity: hadToolActivitySinceContinue,
+                  hadProxyActivity: hadProxyActivitySinceContinue
+                });
                 for (const [idx, reasoningId] of reasoningIds) {
                   if (reasoningStarted.get(idx)) {
                     controller.enqueue({
@@ -3036,6 +3236,8 @@ ${plan}
               toolCallId: call.toolCallId,
               toolName: call.toolName
             });
+            noteProxyActivity();
+            noteToolActivity();
             drainBuffer.push(call);
             if (drainTimer) clearTimeout(drainTimer);
             drainTimer = setTimeout(drainNow, DRAIN_QUIET_MS);
@@ -3043,6 +3245,7 @@ ${plan}
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
             options.abortSignal.addEventListener("abort", () => {
+              autoContinueState.aborted = true;
               if (turnCompleted || controllerClosed) return;
               if (!hasReceivedContent) {
                 log.info(
@@ -3417,8 +3620,8 @@ import {
   rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join5, resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join6, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -3426,14 +3629,14 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join5(xdg, "opencode") : null,
-    join5(homedir3(), ".cache", "opencode"),
-    join5(homedir3(), "Library", "Caches", "opencode")
+    xdg ? join6(xdg, "opencode") : null,
+    join6(homedir4(), ".cache", "opencode"),
+    join6(homedir4(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config");
-  return join5(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join6(homedir4(), ".config");
+  return join6(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
@@ -3476,7 +3679,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync3(cacheRoot)) return;
-  const stalePath = join5(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join6(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -3484,7 +3687,7 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join5(stalePath, "package.json");
+  const pkgJsonPath = join6(stalePath, "package.json");
   if (!existsSync3(pkgJsonPath)) return;
   let pkg = {};
   try {
@@ -3504,7 +3707,7 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join5(cacheRoot, "package.json");
+  const cachePkgJson = join6(cacheRoot, "package.json");
   if (!existsSync3(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync3(cachePkgJson, "utf8"));
@@ -3556,7 +3759,8 @@ function createClaudeCode(settings = {}) {
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
-      multiStepContinuation: settings.multiStepContinuation ?? true
+      multiStepContinuation: settings.multiStepContinuation ?? true,
+      autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart"
     });
   };
   const provider = function(modelId) {