jinzd-ai-cli 0.4.180 → 0.4.181

package/dist/{batch-OJJI6TKB.js → batch-DG5STMLZ.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   ConfigManager
-} from "./chunk-2UGK2RXK.js";
+} from "./chunk-P2VFMUR5.js";
 import "./chunk-TZQHYZKT.js";
-import "./chunk-KRU4DFRH.js";
+import "./chunk-CPZ7KG3Y.js";
 import "./chunk-PDX44BCA.js";
 
 // src/cli/batch.ts

package/dist/{chunk-WY2DDJTH.js → chunk-4VB6UP4W.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CONFIG_DIR_NAME
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 
 // src/diagnostics/tool-stats.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";

package/dist/{chunk-2TWARH5X.js → chunk-5LK7H45B.js}

@@ -902,6 +902,321 @@ Node.js does not automatically use system proxies. Try one of the following:
 
 // src/providers/openai-compatible.ts
 import OpenAI from "openai";
+
+// src/core/agent-loop.ts
+function partialTagTail(s, tag) {
+  const max = Math.min(s.length, tag.length - 1);
+  for (let len = max; len > 0; len--) {
+    if (s.endsWith(tag.slice(0, len))) return len;
+  }
+  return 0;
+}
+var ThinkTagFilter = class {
+  inThink = false;
+  buf = "";
+  push(raw) {
+    this.buf += raw;
+    let out = "";
+    while (this.buf.length > 0) {
+      if (!this.inThink) {
+        const open = this.buf.indexOf("<think>");
+        if (open === -1) {
+          const keep = partialTagTail(this.buf, "<think>");
+          out += this.buf.slice(0, this.buf.length - keep);
+          this.buf = this.buf.slice(this.buf.length - keep);
+          break;
+        }
+        out += this.buf.slice(0, open);
+        this.buf = this.buf.slice(open + "<think>".length);
+        this.inThink = true;
+      } else {
+        const close = this.buf.indexOf("</think>");
+        if (close === -1) {
+          const keep = partialTagTail(this.buf, "</think>");
+          this.buf = this.buf.slice(this.buf.length - keep);
+          break;
+        }
+        this.buf = this.buf.slice(close + "</think>".length);
+        this.inThink = false;
+      }
+    }
+    return out;
+  }
+  /** 流结束：若仍持留可能的半截 '<think>' 前缀且并未进入 think 块，它是真实文本。 */
+  flush() {
+    if (!this.inThink && this.buf) {
+      const tail = this.buf;
+      this.buf = "";
+      return tail;
+    }
+    this.buf = "";
+    return "";
+  }
+};
+function repairToolCallArguments(raw, onWarn) {
+  const argStr = raw || "{}";
+  try {
+    return JSON.parse(argStr);
+  } catch {
+    const truncated = argStr.trimEnd();
+    const lastComma = truncated.lastIndexOf(",");
+    const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
+    try {
+      const repaired = JSON.parse(fixed);
+      onWarn?.("Tool call JSON was truncated and auto-repaired. Some parameters may be missing.");
+      return repaired;
+    } catch {
+      onWarn?.("Tool call JSON could not be parsed, using empty arguments.");
+      return {};
+    }
+  }
+}
+async function consumeToolCallStream(stream, hooks = {}) {
+  const textParts = [];
+  const accumulators = /* @__PURE__ */ new Map();
+  let usage;
+  let rawContent;
+  let reasoningContent;
+  let finishReason;
+  let aborted = false;
+  const thinkFilter = new ThinkTagFilter();
+  const emitText = (raw) => {
+    const visible = thinkFilter.push(raw);
+    if (visible) {
+      textParts.push(visible);
+      hooks.onText?.(visible);
+    }
+  };
+  try {
+    for await (const event of stream) {
+      if (hooks.signal?.aborted) {
+        aborted = true;
+        break;
+      }
+      switch (event.type) {
+        case "text_delta":
+          emitText(event.delta);
+          break;
+        case "thinking_start":
+          hooks.onThinkingStart?.();
+          break;
+        case "thinking_delta":
+          hooks.onThinkingDelta?.(event.delta);
+          break;
+        case "thinking_end":
+          hooks.onThinkingEnd?.();
+          break;
+        case "tool_call_start":
+          accumulators.set(event.index, { id: event.id, name: event.name, arguments: "" });
+          hooks.onToolCallStart?.(event.index, event.id, event.name);
+          break;
+        case "tool_call_delta": {
+          const acc = accumulators.get(event.index);
+          if (acc) acc.arguments += event.argumentsDelta;
+          break;
+        }
+        case "tool_call_end":
+          break;
+        case "done":
+          if (event.usage) usage = event.usage;
+          if (event.rawContent) rawContent = event.rawContent;
+          if (event.reasoningContent) reasoningContent = event.reasoningContent;
+          if (event.finishReason) finishReason = event.finishReason;
+          break;
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"))) {
+      aborted = true;
+    } else {
+      throw err;
+    }
+  }
+  const tail = thinkFilter.flush();
+  if (tail && !aborted) {
+    textParts.push(tail);
+    hooks.onText?.(tail);
+  }
+  const textContent = textParts.join("");
+  if (aborted) {
+    return { textContent, toolCalls: [], usage, rawContent, reasoningContent, finishReason, aborted };
+  }
+  const toolCalls = [];
+  for (const [, acc] of accumulators) {
+    toolCalls.push({
+      id: acc.id,
+      name: acc.name,
+      arguments: repairToolCallArguments(acc.arguments, hooks.onWarn)
+    });
+  }
+  if (toolCalls.length > 0) {
+    if (rawContent) {
+      toolCalls._rawContent = rawContent;
+    }
+    if (textContent) {
+      toolCalls._streamedText = textContent;
+    }
+  }
+  return { textContent, toolCalls, usage, rawContent, reasoningContent, finishReason, aborted };
+}
+var FREE_ROUND_TOOLS = /* @__PURE__ */ new Set(["write_todos"]);
+var MAX_CONSECUTIVE_FREE_ROUNDS = 3;
+var FreeRoundTracker = class {
+  consecutive = 0;
+  /** 返回 true 表示本轮不消耗有效轮次（调用方执行 round--）。 */
+  apply(toolNames) {
+    const allFree = toolNames.length > 0 && toolNames.every((n) => FREE_ROUND_TOOLS.has(n));
+    if (!allFree) {
+      this.consecutive = 0;
+      return false;
+    }
+    this.consecutive++;
+    return this.consecutive <= MAX_CONSECUTIVE_FREE_ROUNDS;
+  }
+};
+var BudgetWarner = class {
+  constructor(maxToolRounds) {
+    this.maxToolRounds = maxToolRounds;
+    this.noteAt = Math.max(10, Math.floor(maxToolRounds * 0.2));
+    const lowRaw = Math.max(5, Math.floor(maxToolRounds * 0.1));
+    const criticalRaw = Math.max(3, Math.floor(maxToolRounds * 0.05));
+    this.lowAt = Math.min(lowRaw, this.noteAt - 1);
+    this.criticalAt = Math.min(criticalRaw, this.lowAt - 1);
+  }
+  noteAt;
+  lowAt;
+  criticalAt;
+  warnedNote = false;
+  warnedLow = false;
+  warnedCritical = false;
+  check(roundsLeft) {
+    if (!this.warnedCritical && roundsLeft <= this.criticalAt) {
+      this.warnedCritical = true;
+      return {
+        level: "critical",
+        injectMessage: `\u{1F6A8} Critical budget: Only ${roundsLeft} rounds left! Wrap up NOW \u2014 complete the current operation and give a final summary. Do NOT start new tasks.`,
+        displayMessage: `\u{1F6A8} Critical: ${roundsLeft} rounds remaining`
+      };
+    }
+    if (!this.warnedLow && roundsLeft <= this.lowAt) {
+      this.warnedLow = true;
+      return {
+        level: "low",
+        injectMessage: `\u26A0\uFE0F Budget warning: Only ${roundsLeft} tool rounds remaining. Prioritize completing the most critical task. Use efficient approaches (batch edits, fewer reads). If you cannot finish everything, summarize what's done and what remains.`,
+        displayMessage: `\u26A0\uFE0F Low budget: ${roundsLeft} rounds remaining`
+      };
+    }
+    if (!this.warnedNote && roundsLeft <= this.noteAt) {
+      this.warnedNote = true;
+      return {
+        level: "note",
+        injectMessage: `\u{1F4CA} Budget note: ${roundsLeft} tool rounds remaining out of ${this.maxToolRounds}. Plan your remaining work efficiently \u2014 use batch operations (e.g., replaceAll) when possible.`
+      };
+    }
+    return null;
+  }
+};
+var EMPTY_RESPONSE_NUDGE = "Your previous response was empty \u2014 no text and no tool calls. This usually means the context window is nearly full. Please either: (1) continue the task by calling the next tool you need, or (2) give a concise final text summary of what has been accomplished so far and what remains. Do NOT repeat earlier long outputs.";
+function describeFinishReason(fr) {
+  if (fr === "length") return "output limit reached (finish_reason=length)";
+  if (fr === "content_filter") return "content blocked (finish_reason=content_filter)";
+  if (fr) return `empty response (finish_reason=${fr})`;
+  return "empty response";
+}
+function emptyResponseHint(fr) {
+  if (fr === "length") return "Output token limit hit \u2014 try /compact to reduce context, raise maxTokens, or /model to switch.";
+  if (fr === "content_filter") return "Content was blocked by the provider filter.";
+  return "Context window may be exhausted or max_tokens too low.";
+}
+var EmptyResponseGuard = class {
+  retries = 0;
+  onEmpty(canRetry, finishReason) {
+    if (this.retries === 0 && canRetry) {
+      this.retries++;
+      return {
+        action: "nudge",
+        injectMessage: EMPTY_RESPONSE_NUDGE,
+        displayMessage: `\u26A0 ${describeFinishReason(finishReason)} \u2014 nudging AI to continue...`
+      };
+    }
+    return {
+      action: "stop",
+      displayMessage: "\u26A0 AI returned empty responses twice in a row. Stopping agentic loop.",
+      hint: emptyResponseHint(finishReason)
+    };
+  }
+  /** 非空响应到达 → 重置计数（下次空响应仍可 nudge 一次）。 */
+  onNonEmpty() {
+    this.retries = 0;
+  }
+};
+var ContextPressureMonitor = class {
+  warned80 = false;
+  check(requestTokens, contextWindow) {
+    if (contextWindow <= 0) return { action: "ok", ratio: 0 };
+    const ratio = requestTokens / contextWindow;
+    if (ratio >= 0.95) return { action: "abort", ratio };
+    if (ratio >= 0.8 && !this.warned80) {
+      this.warned80 = true;
+      return {
+        action: "warn",
+        ratio,
+        injectMessage: `\u26A0\uFE0F Context pressure: ~${Math.round(ratio * 100)}% of the ${contextWindow.toLocaleString()}-token context window is used. Avoid reading more files or running broad scans. Finish the current critical step, then produce a final summary. Every unnecessary tool call now risks breaking the conversation.`
+      };
+    }
+    return { action: "ok", ratio };
+  }
+};
+function accumulateUsage(total, delta) {
+  if (!delta) return;
+  total.inputTokens += delta.inputTokens;
+  total.outputTokens += delta.outputTokens;
+  total.cacheCreationTokens += delta.cacheCreationTokens ?? 0;
+  total.cacheReadTokens += delta.cacheReadTokens ?? 0;
+}
+function buildRoundBudgetHint(opts) {
+  const pauseHint = opts.autoPauseInterval > 0 ? `
+- Every ${opts.autoPauseInterval} rounds the user will be asked whether to continue \u2014 use this as a natural checkpoint to report progress.` : "";
+  if (opts.planMode) {
+    return `
+
+[Tool Round Budget \u2014 Plan Mode]
+You have a maximum of ${opts.maxToolRounds} tool call rounds. You are in READ-ONLY Plan Mode:
+- Only use: read_file, list_dir, grep_files, glob_files, ask_user, write_todos
+- Do NOT attempt to call bash, write_file, edit_file \u2014 they are disabled
+- Do NOT write shell commands or code blocks as a substitute for tool calls
+- Do NOT read the same file more than once
+- Call write_todos ONCE to present your plan, then give a text summary
+- If the user asks you to execute anything, respond: "Please type /plan execute to switch to execute mode."${pauseHint}`;
+  }
+  return `
+
+[Tool Round Budget]
+You have a maximum of ${opts.maxToolRounds} tool call rounds for this task. Plan efficiently:
+- Prefer batch operations (e.g. global find-and-replace) over repetitive single edits.
+- Do NOT read the same file more than once \u2014 use the content from previous reads.
+- Prioritize the most critical tasks first in case rounds run out.
+- When remaining rounds are low, focus on completing the current task and summarizing.${pauseHint}`;
+}
+function buildRoundsExhaustedPrompt(maxToolRounds) {
+  return `You have used all ${maxToolRounds} tool call rounds. Do not call any more tools. Summarize in text:
+1. What work has been completed so far
+2. What tasks remain unfinished
+3. What the user can do next (e.g. send another request to continue)`;
+}
+function buildUserStopMessage(effectiveRound, maxToolRounds) {
+  return `The user has stopped the task at round ${effectiveRound}/${maxToolRounds}. Do not call any more tools. Summarize what has been completed and what remains.`;
+}
+function summarizeRecentTools(history, interval) {
+  const recent = history.slice(-interval);
+  const counts = /* @__PURE__ */ new Map();
+  for (const rh of recent) {
+    for (const t of rh.tools) counts.set(t, (counts.get(t) || 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => count > 1 ? `${name}\xD7${count}` : name).join(", ");
+}
+
+// src/providers/openai-compatible.ts
 function toUsage(u) {
   if (!u) return void 0;
   const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
@@ -1124,28 +1439,11 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       const reasoningContent = message.reasoning_content;
       if (message.tool_calls && message.tool_calls.length > 0) {
         const toolCalls = message.tool_calls.map((tc) => {
-          const rawArgs = tc.function.arguments || "{}";
-          let parsedArgs;
-          try {
-            parsedArgs = JSON.parse(rawArgs);
-          } catch {
-            const truncated = rawArgs.trimEnd();
-            const lastComma = truncated.lastIndexOf(",");
-            const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
-            try {
-              parsedArgs = JSON.parse(fixed);
-              process.stderr.write(
-                `[warn] Tool call JSON was truncated and auto-repaired. Some parameters may be missing.
-`
-              );
-            } catch {
-              process.stderr.write(
-                `[warn] Tool call JSON could not be parsed, using empty arguments.
-`
-              );
-              parsedArgs = {};
-            }
-          }
+          const parsedArgs = repairToolCallArguments(
+            tc.function.arguments || "{}",
+            (m) => process.stderr.write(`[warn] ${m}
+`)
+          );
           return {
             id: tc.id,
             name: tc.function.name,
@@ -2683,6 +2981,17 @@ var ProviderRegistry = class {
 };
 
 export {
+  ThinkTagFilter,
+  consumeToolCallStream,
+  FreeRoundTracker,
+  BudgetWarner,
+  EmptyResponseGuard,
+  ContextPressureMonitor,
+  accumulateUsage,
+  buildRoundBudgetHint,
+  buildRoundsExhaustedPrompt,
+  buildUserStopMessage,
+  summarizeRecentTools,
   detectsHallucinatedFileOp,
   hadPreviousWriteToolCalls,
   TOOL_CALL_REMINDER,

package/dist/{chunk-FQHEXIYP.js → chunk-6SY45V62.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   truncateForPersist
-} from "./chunk-7WFMYFHC.js";
+} from "./chunk-ORXPLVM7.js";
 import {
   APP_NAME,
   CONFIG_DIR_NAME,
@@ -11,7 +11,7 @@ import {
   MCP_PROTOCOL_VERSION,
   MCP_TOOL_PREFIX,
   VERSION
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 
 // src/mcp/client.ts
 import { spawn } from "child_process";

package/dist/{chunk-KRU4DFRH.js → chunk-CPZ7KG3Y.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/core/constants.ts
-var VERSION = "0.4.180";
+var VERSION = "0.4.181";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/{chunk-H7TXZO6D.js → chunk-D4ZTYYBU.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TEST_TIMEOUT
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 
 // src/tools/builtin/run-tests.ts
 import { execSync, spawnSync } from "child_process";

package/dist/{chunk-YDI22R3P.js → chunk-D774AWKW.js}

@@ -6,7 +6,7 @@ import { platform } from "os";
 import chalk from "chalk";
 
 // src/core/constants.ts
-var VERSION = "0.4.180";
+var VERSION = "0.4.181";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/{chunk-7WFMYFHC.js → chunk-ORXPLVM7.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-HDSKW7Q3.js";
 import {
   runTestsTool
-} from "./chunk-H7TXZO6D.js";
+} from "./chunk-D4ZTYYBU.js";
 import {
   runTool
-} from "./chunk-WY2DDJTH.js";
+} from "./chunk-4VB6UP4W.js";
 import {
   getDangerLevel,
   isFileWriteTool
@@ -25,7 +25,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 import {
   fileCheckpoints
 } from "./chunk-4BKXL7SM.js";

package/dist/{chunk-2UGK2RXK.js → chunk-P2VFMUR5.js}

@@ -8,7 +8,7 @@ import {
   CONFIG_FILE_NAME,
   HISTORY_DIR_NAME,
   PLUGINS_DIR_NAME
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 
 // src/config/config-manager.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";

package/dist/{chunk-ZUUXMR6Z.js → chunk-ZWQ36YFI.js}

@@ -2,7 +2,7 @@
 import {
   CONFIG_DIR_NAME,
   VERSION
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 
 // src/diagnostics/crash-log.ts
 import {

package/dist/{ci-EBN6VQ2Z.js → ci-UXVUG3LC.js}

@@ -6,15 +6,15 @@ import {
 } from "./chunk-HLWUDRBO.js";
 import {
   ProviderRegistry
-} from "./chunk-2TWARH5X.js";
+} from "./chunk-5LK7H45B.js";
 import "./chunk-HIU2SH4V.js";
 import {
   ConfigManager
-} from "./chunk-2UGK2RXK.js";
+} from "./chunk-P2VFMUR5.js";
 import "./chunk-TZQHYZKT.js";
 import {
   VERSION
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 import "./chunk-PDX44BCA.js";
 
 // src/cli/ci.ts

package/dist/{constants-FGPUBYCX.js → constants-5DFFSPWI.js}

@@ -36,7 +36,7 @@ import {
   TEST_TIMEOUT,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 import "./chunk-PDX44BCA.js";
 export {
   AGENTIC_BEHAVIOR_GUIDELINE,

package/dist/{doctor-cli-C54OKMG2.js → doctor-cli-GQBR6RI6.js}

@@ -2,26 +2,26 @@
 import {
   getConfigDirUsage,
   listRecentCrashes
-} from "./chunk-ZUUXMR6Z.js";
+} from "./chunk-ZWQ36YFI.js";
 import {
   ProviderRegistry
-} from "./chunk-2TWARH5X.js";
+} from "./chunk-5LK7H45B.js";
 import {
   getStatsSnapshot,
   getTopFailingTools,
   getTopUsedTools,
   resetStats
-} from "./chunk-WY2DDJTH.js";
+} from "./chunk-4VB6UP4W.js";
 import "./chunk-HIU2SH4V.js";
 import {
   ConfigManager
-} from "./chunk-2UGK2RXK.js";
+} from "./chunk-P2VFMUR5.js";
 import "./chunk-TZQHYZKT.js";
 import {
   DEV_STATE_FILE_NAME,
   MEMORY_FILE_NAME,
   VERSION
-} from "./chunk-KRU4DFRH.js";
+} from "./chunk-CPZ7KG3Y.js";
 import "./chunk-PDX44BCA.js";
 
 // src/diagnostics/doctor-cli.ts