deeper-cli 1.0.6 → 1.2.1

package/dist/cli/index.js

@@ -3285,7 +3285,7 @@ var init_RetryManager = __esm({
         this.baseDelayMs = baseDelayMs;
         this.maxDelayMs = maxDelayMs;
       }
-      async execute(fn, shouldRetry) {
+      async execute(fn, shouldRetry, options) {
         let lastError;
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
           try {
@@ -3298,27 +3298,34 @@ var init_RetryManager = __esm({
             if (shouldRetry && !shouldRetry(lastError, attempt)) {
               break;
             }
-            const delay = Math.min(
-              this.baseDelayMs * Math.pow(2, attempt) + Math.random() * 1e3,
-              this.maxDelayMs
-            );
+            if (!shouldRetry && this.isDefaultNonRetryable(lastError)) {
+              break;
+            }
+            const delay = this.calculateDelay(attempt);
+            if (options?.onRetry) {
+              options.onRetry(lastError, attempt, delay);
+            }
             await this.sleep(delay);
           }
         }
         throw lastError ?? new Error("Max retries exceeded");
       }
       withTimeout(fn, timeoutMs, signal) {
+        const controller = new AbortController();
         return new Promise((resolve48, reject) => {
           const timer = setTimeout(() => {
+            controller.abort();
             reject(new Error(`Request timed out after ${timeoutMs}ms`));
           }, timeoutMs);
           const onAbort = () => {
             clearTimeout(timer);
+            controller.abort();
             reject(new Error("Request was aborted"));
           };
           if (signal) {
             if (signal.aborted) {
               clearTimeout(timer);
+              controller.abort();
               reject(new Error("Request was aborted"));
               return;
             }
@@ -3339,8 +3346,35 @@ var init_RetryManager = __esm({
           });
         });
       }
-      sleep(ms) {
-        return new Promise((resolve48) => setTimeout(resolve48, ms));
+      calculateDelay(attempt) {
+        const exponentialDelay = this.baseDelayMs * Math.pow(2, attempt);
+        const jitter = Math.random() * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, this.maxDelayMs);
+      }
+      isDefaultNonRetryable(error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes("400") && !msg.includes("429")) return true;
+        if (msg.includes("401") || msg.includes("unauthorized")) return true;
+        if (msg.includes("403") || msg.includes("forbidden")) return true;
+        if (msg.includes("404") || msg.includes("not found")) return true;
+        return false;
+      }
+      sleep(ms, signal) {
+        return new Promise((resolve48, reject) => {
+          const timer = setTimeout(resolve48, ms);
+          if (signal) {
+            const onAbort = () => {
+              clearTimeout(timer);
+              reject(new Error("Retry sleep was aborted"));
+            };
+            if (signal.aborted) {
+              clearTimeout(timer);
+              reject(new Error("Retry sleep was aborted"));
+              return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+        });
       }
     };
   }
@@ -3356,21 +3390,31 @@ var init_StreamHandler = __esm({
       thinkingBuffer;
       toolCallBuffer;
       finished;
+      lastYieldedIndex;
       constructor() {
         this.textBuffer = "";
         this.thinkingBuffer = "";
         this.toolCallBuffer = /* @__PURE__ */ new Map();
         this.finished = false;
+        this.lastYieldedIndex = -1;
       }
       reset() {
         this.textBuffer = "";
         this.thinkingBuffer = "";
         this.toolCallBuffer.clear();
         this.finished = false;
+        this.lastYieldedIndex = -1;
       }
       handleEvent(event, data) {
+        if (event === "error") {
+          return { type: "error", error: data || "SSE error event" };
+        }
         if (event === "[DONE]" || data === "[DONE]") {
+          const results = this.finalizePendingToolCalls();
           this.finished = true;
+          if (results.length > 0) {
+            return [...results, { type: "done" }];
+          }
           return { type: "done" };
         }
         if (!data) {
@@ -3385,11 +3429,23 @@ var init_StreamHandler = __esm({
           const choice = choices[0];
           const delta = choice.delta;
           if (!delta) {
+            const finishReason2 = choice.finish_reason;
+            if (finishReason2 === "stop" || finishReason2 === "length" || finishReason2 === "tool_calls") {
+              const results = this.finalizePendingToolCalls();
+              this.finished = true;
+              if (results.length > 0) {
+                return [...results, { type: "done" }];
+              }
+              return { type: "done" };
+            }
             return null;
           }
           if (delta.reasoning_content) {
             const thinkingChunk = delta.reasoning_content;
             this.thinkingBuffer += thinkingChunk;
+            if (this.thinkingBuffer.length > 1e5) {
+              this.thinkingBuffer = this.thinkingBuffer.slice(-8e4);
+            }
             return {
               type: "thinking",
               content: thinkingChunk
@@ -3401,6 +3457,9 @@ var init_StreamHandler = __esm({
           if (delta.content) {
             const textChunk = delta.content;
             this.textBuffer += textChunk;
+            if (this.textBuffer.length > 5e5) {
+              this.textBuffer = this.textBuffer.slice(-4e5);
+            }
             return {
               type: "text",
               content: textChunk
@@ -3408,7 +3467,11 @@ var init_StreamHandler = __esm({
           }
           const finishReason = choice.finish_reason;
           if (finishReason === "stop" || finishReason === "length" || finishReason === "tool_calls") {
+            const results = this.finalizePendingToolCalls();
             this.finished = true;
+            if (results.length > 0) {
+              return [...results, { type: "done" }];
+            }
             return { type: "done" };
           }
         } catch {
@@ -3427,10 +3490,16 @@ var init_StreamHandler = __esm({
       }
       getToolCalls() {
         const result = [];
-        for (let i = 0; i < this.toolCallBuffer.size; i++) {
-          const tc = this.toolCallBuffer.get(i);
-          if (tc) {
-            result.push(tc);
+        const indices = [...this.toolCallBuffer.keys()].sort((a, b2) => a - b2);
+        for (const idx of indices) {
+          const pending = this.toolCallBuffer.get(idx);
+          if (pending) {
+            result.push({
+              id: pending.id,
+              name: pending.name,
+              arguments: this.parseArgsStr(pending.argsStr),
+              index: pending.index
+            });
           }
         }
         return result;
@@ -3448,8 +3517,9 @@ var init_StreamHandler = __esm({
             this.toolCallBuffer.set(index, {
               id: id ?? "",
               name: fn?.name ?? "",
-              arguments: {},
-              index
+              argsStr: "",
+              index,
+              started: false
             });
           }
           const existing = this.toolCallBuffer.get(index);
@@ -3460,24 +3530,71 @@ var init_StreamHandler = __esm({
             existing.name = fn.name;
           }
           if (fn?.arguments) {
-            try {
-              const argsStr = fn.arguments;
-              const parsed = JSON.parse(argsStr);
-              existing.arguments = { ...existing.arguments, ...parsed };
-            } catch {
-              existing.arguments = existing.arguments || {};
+            existing.argsStr += fn.arguments;
+          }
+          if (!existing.started) {
+            existing.started = true;
+            if (this.lastYieldedIndex >= 0) {
+              const prev = this.toolCallBuffer.get(this.lastYieldedIndex);
+              if (prev && prev !== existing) {
+                results.push({
+                  type: "tool_call_end",
+                  tool_call: {
+                    id: prev.id,
+                    name: prev.name,
+                    arguments: this.parseArgsStr(prev.argsStr),
+                    index: prev.index
+                  }
+                });
+              }
             }
+            this.lastYieldedIndex = index;
+            results.push({
+              type: "tool_call_start",
+              tool_call: { id: existing.id, name: existing.name, index: existing.index }
+            });
           }
-          const entry = this.toolCallBuffer.get(index);
-          if (entry) {
+        }
+        return results;
+      }
+      finalizePendingToolCalls() {
+        const results = [];
+        if (this.lastYieldedIndex >= 0) {
+          const last = this.toolCallBuffer.get(this.lastYieldedIndex);
+          if (last) {
             results.push({
-              type: "tool_call",
-              tool_call: { ...entry, arguments: { ...entry.arguments } }
+              type: "tool_call_end",
+              tool_call: {
+                id: last.id,
+                name: last.name,
+                arguments: this.parseArgsStr(last.argsStr),
+                index: last.index
+              }
             });
           }
+          this.lastYieldedIndex = -1;
         }
         return results;
       }
+      parseArgsStr(argsStr) {
+        if (!argsStr) return {};
+        try {
+          return JSON.parse(argsStr);
+        } catch {
+          const trimmed = argsStr.trim();
+          if (trimmed.startsWith("{") && !trimmed.endsWith("}")) {
+            try {
+              return JSON.parse(trimmed + "}");
+            } catch {
+              try {
+                return JSON.parse(trimmed + "}}");
+              } catch {
+              }
+            }
+          }
+          return {};
+        }
+      }
     };
   }
 });
@@ -3582,7 +3699,7 @@ ${data.stack ?? ""}`;
 });
 
 // src/model/DeepSeekClient.ts
-var DEFAULT_TIMEOUT_MS, MAX_RETRIES, DeepSeekClient;
+var DEFAULT_TIMEOUT_MS, MAX_RETRIES, isRetryable, DeepSeekClient;
 var init_DeepSeekClient = __esm({
   "src/model/DeepSeekClient.ts"() {
     "use strict";
@@ -3591,23 +3708,31 @@ var init_DeepSeekClient = __esm({
     init_logger();
     DEFAULT_TIMEOUT_MS = 12e4;
     MAX_RETRIES = 3;
+    isRetryable = (error, _attempt) => {
+      const msg = error.message.toLowerCase();
+      if (msg.includes("429") || msg.includes("rate limit")) return true;
+      if (msg.includes("500") || msg.includes("502") || msg.includes("503") || msg.includes("504")) return true;
+      if (msg.includes("timeout") || msg.includes("abort")) return _attempt < 2;
+      if (msg.includes("econnreset") || msg.includes("econnrefused")) return true;
+      return false;
+    };
     DeepSeekClient = class {
       config;
       retryManager;
       constructor(config) {
         this.config = config;
-        this.retryManager = new RetryManager(config.maxTokens > 0 ? MAX_RETRIES : MAX_RETRIES);
+        this.retryManager = new RetryManager(MAX_RETRIES);
       }
       async chat(messages, tools, overrides) {
         const cfg = this.mergeConfig(overrides);
         const body = this.buildRequestBody(messages, tools, cfg, false);
         const response = await this.retryManager.execute(async () => {
-          const result2 = await this.retryManager.withTimeout(
+          return this.retryManager.withTimeout(
             () => this.makeRequest(cfg, body),
-            cfg.maxTokens > 0 ? DEFAULT_TIMEOUT_MS : DEFAULT_TIMEOUT_MS
+            DEFAULT_TIMEOUT_MS,
+            cfg.signal
           );
-          return result2;
-        }, this.shouldRetry);
+        }, isRetryable);
         const data = await response.json();
         if (!data.choices || data.choices.length === 0) {
           throw new Error("No choices returned from API");
@@ -3626,7 +3751,7 @@ var init_DeepSeekClient = __esm({
           }));
         }
         if (message.reasoning_content) {
-          result.thinking = message.reasoning_content;
+          result.reasoning_content = message.reasoning_content;
         }
         return result;
       }
@@ -3634,16 +3759,12 @@ var init_DeepSeekClient = __esm({
         const cfg = this.mergeConfig(overrides);
         const body = this.buildRequestBody(messages, tools, cfg, true);
         const response = await this.retryManager.execute(async () => {
-          const result = await this.retryManager.withTimeout(
+          return this.retryManager.withTimeout(
             () => this.makeRequest(cfg, body),
-            DEFAULT_TIMEOUT_MS
+            DEFAULT_TIMEOUT_MS,
+            cfg.signal
           );
-          return result;
-        }, this.shouldRetry);
-        if (!response.ok) {
-          const errorBody = await response.text().catch(() => "");
-          throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody}`);
-        }
+        }, isRetryable);
         if (!response.body) {
           throw new Error("Response body is empty");
         }
@@ -3725,6 +3846,12 @@ var init_DeepSeekClient = __esm({
           max_tokens: config.maxTokens,
           stream
         };
+        if (config.think?.enabled) {
+          body.thinking = {
+            type: "enabled",
+            budget_tokens: config.think.budgetTokens
+          };
+        }
         if (tools && tools.length > 0) {
           body.tools = tools.map((tool) => ({
             type: "function",
@@ -3741,7 +3868,7 @@ var init_DeepSeekClient = __esm({
       async makeRequest(config, body) {
         const url = `${config.baseUrl}/v1/chat/completions`;
         logger.debug("DeepSeek API request", { url, model: config.model });
-        const response = await fetch(url, {
+        const fetchOpts = {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -3749,7 +3876,11 @@ var init_DeepSeekClient = __esm({
             "Accept": "application/json"
           },
           body
-        });
+        };
+        if (config.signal) {
+          fetchOpts.signal = config.signal;
+        }
+        const response = await fetch(url, fetchOpts);
         if (!response.ok) {
           const errorBody = await response.text().catch(() => "");
           logger.error("DeepSeek API error", {
@@ -3761,22 +3892,6 @@ var init_DeepSeekClient = __esm({
         }
         return response;
       }
-      shouldRetry(error, attempt) {
-        const message = error.message.toLowerCase();
-        if (message.includes("429") || message.includes("rate limit")) {
-          return true;
-        }
-        if (message.includes("5") && (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504"))) {
-          return true;
-        }
-        if (message.includes("timeout") || message.includes("abort")) {
-          return attempt < 2;
-        }
-        if (message.includes("econnreset") || message.includes("econnrefused")) {
-          return true;
-        }
-        return false;
-      }
       parseArguments(argsStr) {
         try {
           return JSON.parse(argsStr);
@@ -7274,9 +7389,9 @@ var init_format_code = __esm({
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           try {
-            const { execSync: execSync19 } = await import("child_process");
+            const { execSync: execSync20 } = await import("child_process");
             const ext = filePath.split(".").pop() ?? "ts";
-            execSync19(`npx prettier --write "${filePath}"`, {
+            execSync20(`npx prettier --write "${filePath}"`, {
               encoding: "utf-8",
               timeout: 3e4,
               stdio: "pipe"
@@ -8462,25 +8577,25 @@ var init_db_restore = __esm({
         try {
           const engine = params.engine;
           const connection = params.connection;
-          const backupFile = params.backup_file;
+          const backupFile2 = params.backup_file;
           let cmd = "";
           switch (engine) {
             case "sqlite":
-              cmd = `sqlite3 "${connection || "database.db"}" < "${backupFile}"`;
+              cmd = `sqlite3 "${connection || "database.db"}" < "${backupFile2}"`;
               break;
             case "mysql":
-              cmd = `mysql ${connection || ""} < "${backupFile}"`;
+              cmd = `mysql ${connection || ""} < "${backupFile2}"`;
               break;
             case "postgresql":
-              cmd = `psql ${connection || ""} < "${backupFile}"`;
+              cmd = `psql ${connection || ""} < "${backupFile2}"`;
               break;
             default:
               return { success: false, error: `\u4E0D\u652F\u6301\u7684\u6570\u636E\u5E93\u5F15\u64CE: ${engine}`, output: "" };
           }
           try {
             const output = execSync9(cmd, { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
-            return { success: true, output: `\u6062\u590D\u5B8C\u6210: ${backupFile}
-${output || ""}`, metadata: { engine, backupFile } };
+            return { success: true, output: `\u6062\u590D\u5B8C\u6210: ${backupFile2}
+${output || ""}`, metadata: { engine, backupFile: backupFile2 } };
           } catch (err) {
             const e = err;
             return { success: false, error: `\u6062\u590D\u5931\u8D25: ${e.message || String(err)}`, output: "" };
@@ -10616,8 +10731,8 @@ var init_memory_store = __esm({
               if (!key) return { success: false, error: "delete \u9700\u8981 key \u53C2\u6570", output: "" };
               const memPath = join11(MEMORY_DIR, `${key}.json`);
               if (!existsSync51(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
-              const { unlinkSync: unlinkSync2 } = await import("fs");
-              unlinkSync2(memPath);
+              const { unlinkSync: unlinkSync3 } = await import("fs");
+              unlinkSync3(memPath);
               return { success: true, output: `\u8BB0\u5FC6\u5DF2\u5220\u9664: ${key}` };
             }
             case "list": {
@@ -10908,17 +11023,17 @@ var init_notify_user = __esm({
           const output = `${icons[level] || ""} [${level.toUpperCase()}] ${title}: ${message}`;
           try {
             if (process.platform === "win32") {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $notify = New-Object System.Windows.Forms.NotifyIcon; $notify.Icon = [System.Drawing.SystemIcons]::Information; $notify.Visible = $true; $notify.ShowBalloonTip(5000, '${title}', '${message}', [System.Windows.Forms.ToolTipIcon]::${level === "error" ? "Error" : "Info"}); Start-Sleep -Seconds 6; $notify.Dispose()"`, {
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $notify = New-Object System.Windows.Forms.NotifyIcon; $notify.Icon = [System.Drawing.SystemIcons]::Information; $notify.Visible = $true; $notify.ShowBalloonTip(5000, '${title}', '${message}', [System.Windows.Forms.ToolTipIcon]::${level === "error" ? "Error" : "Info"}); Start-Sleep -Seconds 6; $notify.Dispose()"`, {
                 timeout: 1e4,
                 stdio: "ignore"
               });
             } else if (process.platform === "darwin") {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`osascript -e 'display notification "${message}" with title "${title}"'`, { stdio: "ignore" });
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`osascript -e 'display notification "${message}" with title "${title}"'`, { stdio: "ignore" });
             } else {
-              const { execSync: execSync19 } = await import("child_process");
-              execSync19(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
+              const { execSync: execSync20 } = await import("child_process");
+              execSync20(`notify-send "${title}" "${message}"`, { stdio: "ignore" });
             }
             return { success: true, output, metadata: { title, level, notified: true } };
           } catch {
@@ -11259,8 +11374,28 @@ __export(chat_repl_exports, {
 });
 import readline from "readline";
 import process5 from "process";
-import { existsSync as existsSync53, mkdirSync as mkdirSync15, readFileSync as readFileSync37, writeFileSync as writeFileSync14, readdirSync as readdirSync4, statSync as statSync12 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync53, mkdirSync as mkdirSync15, readFileSync as readFileSync37, writeFileSync as writeFileSync14, readdirSync as readdirSync4, statSync as statSync12, copyFileSync as copyFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join12, relative as relative6 } from "path";
+import { execSync as execSync19 } from "child_process";
+function backupFile(filePath) {
+  if (!existsSync53(filePath)) return;
+  try {
+    if (!existsSync53(BACKUP_DIR)) mkdirSync15(BACKUP_DIR, { recursive: true });
+    const rel = relative6(process5.cwd(), filePath).replace(/[/\\]/g, "_");
+    const ts = Date.now();
+    const backupPath = join12(BACKUP_DIR, `${ts}_${rel}`);
+    copyFileSync2(filePath, backupPath);
+    fileBackupStack.push({ path: filePath, backupPath, timestamp: ts });
+    if (fileBackupStack.length > MAX_BACKUPS) {
+      const old = fileBackupStack.shift();
+      try {
+        unlinkSync2(old.backupPath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 function getSkillSystemPrompt() {
   if (!skillEngine) return "";
   return skillEngine.getSystemPrompt();
@@ -11285,7 +11420,7 @@ async function startRepl(opts) {
         let curTc = null;
         let se = null;
         try {
-          const stream = await callApi(opts, msgs, tds, 0, 131072);
+          const stream = await callApi(opts, msgs, tds, 131072);
           GS.api++;
           ce = 0;
           for await (const chunk of stream) {
@@ -11297,10 +11432,11 @@ async function startRepl(opts) {
               const tc = chunk.tool_call;
               if (tc) curTc = { id: tc.id, name: tc.name, argsStr: "" };
             }
-            if (chunk.type === "tool_call_args" && curTc) curTc.argsStr += chunk.content || "";
             if (chunk.type === "tool_call_end" && curTc) {
+              const tcData = chunk.tool_call;
               try {
-                tcs.push({ id: curTc.id, name: curTc.name, args: JSON.parse(curTc.argsStr || "{}") });
+                const args = tcData?.arguments || JSON.parse(curTc.argsStr || "{}");
+                tcs.push({ id: curTc.id, name: curTc.name, args });
               } catch {
                 tcs.push({ id: curTc.id, name: curTc.name, args: {} });
               }
@@ -11337,7 +11473,11 @@ async function startRepl(opts) {
               continue;
             }
             try {
-              const r2 = await tool.execute(tc.args, new AbortController().signal);
+              const ac = new AbortController();
+              const timeout = TOOL_TIMEOUT_MAP[tc.name] || DEFAULT_TOOL_TIMEOUT;
+              const timer = setTimeout(() => ac.abort(), timeout);
+              const r2 = await tool.execute(tc.args, ac.signal);
+              clearTimeout(timer);
               const txt = sanitize(r2.output || "").slice(0, TOOL_RESULT_MAX);
               lh.push({ role: "tool", content: r2.success ? txt : `Error: ${r2.error}`, tool_call_id: tc.id });
               GS.tc++;
@@ -11476,6 +11616,12 @@ ${prevSummary.slice(0, 800)}` });
     return ok;
   };
   const onSigint = () => {
+    if (currentAbortController) {
+      currentAbortController.abort();
+      currentAbortController = null;
+      O(y("\n  \u26A1 \u5DF2\u4E2D\u65AD\u5F53\u524D\u8BF7\u6C42\n"));
+      return;
+    }
     if (resolveLine) {
       const cb = resolveLine;
       resolveLine = null;
@@ -11495,7 +11641,7 @@ ${prevSummary.slice(0, 800)}` });
   };
   rl.on("SIGINT", onSigint);
   const onUCE = (err) => {
-    if (!err.message?.includes("readline")) O(r(`
+    if (!err.message?.includes("readline") && !err.message?.includes("abort")) O(r(`
   \u26A0 ${err.message}`) + "\n");
   };
   process5.on("uncaughtException", onUCE);
@@ -11532,6 +11678,12 @@ ${prevSummary.slice(0, 800)}` });
         O(G("  /mcp") + G("       MCP\u670D\u52A1\u5668") + "\n");
         O(G("  /plan") + G(" <\u4EFB\u52A1> \u5148\u51FA\u65B9\u6848") + "\n");
         O(G("  /spec") + G(" <\u4EFB\u52A1> \u5148\u51FA\u89C4\u683C") + "\n");
+        O(G("  /review") + G(" <\u8DEF\u5F84> \u4EE3\u7801\u5BA1\u67E5") + "\n");
+        O(G("  /fix") + G(" [\u76EE\u6807] \u81EA\u52A8\u4FEE\u590D") + "\n");
+        O(G("  /commit") + G("    \u667A\u80FD\u63D0\u4EA4") + "\n");
+        O(G("  /analyze") + G(" [\u8DEF\u5F84] \u9879\u76EE\u5206\u6790") + "\n");
+        O(G("  /diff") + G(" <\u6587\u4EF6> \u53D8\u66F4\u9884\u89C8") + "\n");
+        O(G("  /undo") + G("      \u64A4\u9500\u64CD\u4F5C") + "\n");
         O(G("  /status") + G("    \u5F53\u524D\u72B6\u6001") + "\n");
         O(G("  /model") + G("     \u6A21\u578B\u8BBE\u7F6E") + "\n");
         O(G("  /config") + G("    \u914D\u7F6E\u7BA1\u7406") + "\n");
@@ -11648,7 +11800,8 @@ ${prevSummary.slice(0, 800)}` });
       if (cmd === "/help") {
         O(c("  /help /clear /quit /save [name] /load|resume [name] /sessions\n"));
         O(c("  /tools [cat] /stats /memory /tasks /model /config /cwd /export /init /mcp /rules\n"));
-        O(c("  /plan <\u4EFB\u52A1> /spec <\u4EFB\u52A1> /status\n\n"));
+        O(c("  /plan <\u4EFB\u52A1> /spec <\u4EFB\u52A1> /review <\u8DEF\u5F84> /fix [\u76EE\u6807]\n"));
+        O(c("  /commit /analyze [\u8DEF\u5F84] /diff <\u6587\u4EF6> /undo /status\n\n"));
         continue;
       }
       if (cmd === "/plan") {
@@ -11692,6 +11845,178 @@ ${prevSummary.slice(0, 800)}` });
         await runLoop(opts, history, tools, sfdefs, confirm);
         continue;
       }
+      if (cmd === "/review") {
+        const target = arg || ".";
+        O(b(c("  Review Mode")) + G(` \u2022 ${target}`) + "\n\n");
+        history.push({ role: "system", content: `[Review Mode]
+\u4F60\u662F\u4E00\u4F4D\u8D44\u6DF1\u4EE3\u7801\u5BA1\u67E5\u4E13\u5BB6\u3002\u8BF7\u5BF9\u6307\u5B9A\u4EE3\u7801\u8FDB\u884C\u5168\u9762\u5BA1\u67E5\uFF1A
+
+1. \u5148\u7528 read_file / glob_find / grep_search \u8BFB\u53D6\u76F8\u5173\u4EE3\u7801
+2. \u4ECE\u4EE5\u4E0B\u7EF4\u5EA6\u9010\u9879\u5BA1\u67E5\u5E76\u8BC4\u5206\uFF081-10\uFF09\uFF1A
+   - \u4EE3\u7801\u8D28\u91CF\uFF1A\u53EF\u8BFB\u6027\u3001\u547D\u540D\u3001\u7ED3\u6784
+   - \u5B89\u5168\u6027\uFF1A\u6CE8\u5165\u3001XSS\u3001\u5BC6\u94A5\u6CC4\u9732\u3001\u6743\u9650\u95EE\u9898
+   - \u6027\u80FD\uFF1AN+1\u67E5\u8BE2\u3001\u5185\u5B58\u6CC4\u6F0F\u3001\u4E0D\u5FC5\u8981\u7684\u8BA1\u7B97
+   - \u53EF\u7EF4\u62A4\u6027\uFF1A\u8026\u5408\u5EA6\u3001\u91CD\u590D\u4EE3\u7801\u3001\u6D4B\u8BD5\u8986\u76D6
+   - \u6700\u4F73\u5B9E\u8DF5\uFF1A\u8BBE\u8BA1\u6A21\u5F0F\u3001SOLID\u539F\u5219\u3001\u9519\u8BEF\u5904\u7406
+3. \u5BF9\u6BCF\u4E2A\u95EE\u9898\u7ED9\u51FA\uFF1A\u6587\u4EF6\u8DEF\u5F84\u3001\u884C\u53F7\u8303\u56F4\u3001\u95EE\u9898\u63CF\u8FF0\u3001\u4FEE\u590D\u5EFA\u8BAE\u3001\u4E25\u91CD\u7A0B\u5EA6(\u{1F534}\u9AD8/\u{1F7E1}\u4E2D/\u{1F7E2}\u4F4E)
+4. \u6700\u540E\u7ED9\u51FA\u603B\u4F53\u8BC4\u5206\u548C\u6539\u8FDB\u4F18\u5148\u7EA7\u5217\u8868
+
+\u5BA1\u67E5\u76EE\u6807\uFF1A${target}` });
+        history.push({ role: "user", content: `\u5BA1\u67E5 ${target} \u7684\u4EE3\u7801\u8D28\u91CF` });
+        const rvdefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, rvdefs, confirm);
+        continue;
+      }
+      if (cmd === "/commit") {
+        O(b(c("  Commit Mode")) + G(" \u2022 \u667A\u80FD\u63D0\u4EA4") + "\n\n");
+        try {
+          const statusOut = execSync19("git status --porcelain", { encoding: "utf-8", timeout: 1e4, cwd: process5.cwd() });
+          if (!statusOut.trim()) {
+            O(y("  \u6CA1\u6709\u672A\u63D0\u4EA4\u7684\u53D8\u66F4\n\n"));
+            continue;
+          }
+          const diffOut = execSync19("git diff --stat", { encoding: "utf-8", timeout: 15e3, cwd: process5.cwd() });
+          const stagedOut = execSync19("git diff --cached --stat", { encoding: "utf-8", timeout: 15e3, cwd: process5.cwd() });
+          const files = statusOut.trim().split("\n").filter(Boolean);
+          O(G(`  ${files.length} \u4E2A\u6587\u4EF6\u53D8\u66F4:
+`));
+          for (const f of files.slice(0, 20)) {
+            const status = f.slice(0, 2).trim();
+            const path = f.slice(3);
+            const icon = status === "M" ? y("M") : status === "A" ? g("A") : status === "D" ? r("D") : status === "?" ? G("?") : c(status);
+            O(G(`    ${icon} ${path.slice(0, 60)}`) + "\n");
+          }
+          if (files.length > 20) O(G(`    \u2026\u8FD8\u6709 ${files.length - 20} \u4E2A`) + "\n");
+          O("\n");
+          history.push({ role: "system", content: `[Commit Mode]
+\u5206\u6790 git \u53D8\u66F4\u5E76\u751F\u6210\u63D0\u4EA4\u4FE1\u606F\uFF1A
+1. \u5148\u7528 run_command \u6267\u884C git diff \u67E5\u770B\u5177\u4F53\u53D8\u66F4\u5185\u5BB9
+2. \u5206\u6790\u53D8\u66F4\u7C7B\u578B\u548C\u8303\u56F4\uFF0C\u751F\u6210\u7B26\u5408 Conventional Commits \u89C4\u8303\u7684\u63D0\u4EA4\u4FE1\u606F
+3. \u683C\u5F0F: type(scope): description
+   - type: feat/fix/refactor/docs/style/test/chore/perf
+   - scope: \u53EF\u9009\uFF0C\u5F71\u54CD\u7684\u6A21\u5757
+4. \u7528 run_command \u6267\u884C git add \u548C git commit
+5. \u5982\u679C\u53D8\u66F4\u8F83\u591A\uFF0C\u5EFA\u8BAE\u5206\u591A\u6B21\u63D0\u4EA4
+
+\u5F53\u524D\u53D8\u66F4\u7EDF\u8BA1\uFF1A
+${diffOut || stagedOut || "\u65E0staged\u53D8\u66F4"}` });
+          history.push({ role: "user", content: "\u5206\u6790\u53D8\u66F4\u5E76\u63D0\u4EA4" });
+          const cmdefs = toolsToDefs(tools);
+          await runLoop(opts, history, tools, cmdefs, confirm);
+        } catch (e) {
+          O(r(`  Git \u64CD\u4F5C\u5931\u8D25: ${e instanceof Error ? e.message.slice(0, 80) : String(e).slice(0, 80)}
+
+`));
+        }
+        continue;
+      }
+      if (cmd === "/analyze") {
+        const target = arg || process5.cwd();
+        O(b(c("  Analyze Mode")) + G(` \u2022 ${target}`) + "\n\n");
+        history.push({ role: "system", content: `[Analyze Mode]
+\u4F60\u662F\u4E00\u4F4D\u9879\u76EE\u67B6\u6784\u5206\u6790\u5E08\u3002\u8BF7\u5BF9\u9879\u76EE\u8FDB\u884C\u5168\u9762\u5206\u6790\uFF1A
+
+1. \u7528 glob_find \u626B\u63CF\u9879\u76EE\u76EE\u5F55\u7ED3\u6784
+2. \u7528 read_file \u8BFB\u53D6 package.json / tsconfig.json / Cargo.toml \u7B49\u914D\u7F6E
+3. \u7528 grep_search / codebase_search \u5206\u6790\u4EE3\u7801\u6A21\u5F0F
+4. \u8F93\u51FA\u4EE5\u4E0B\u5206\u6790\u62A5\u544A\uFF1A
+   - \u{1F4C1} \u9879\u76EE\u7ED3\u6784\u6811\uFF08\u5173\u952E\u76EE\u5F55\u548C\u6587\u4EF6\uFF09
+   - \u{1F6E0} \u6280\u672F\u6808\u8BC6\u522B\uFF08\u8BED\u8A00\u3001\u6846\u67B6\u3001\u5E93\u3001\u5DE5\u5177\u94FE\uFF09
+   - \u{1F4CA} \u4EE3\u7801\u7EDF\u8BA1\uFF08\u6587\u4EF6\u6570\u3001\u4EE3\u7801\u884C\u6570\u4F30\u7B97\u3001\u5404\u8BED\u8A00\u5360\u6BD4\uFF09
+   - \u{1F3D7}\uFE0F \u67B6\u6784\u6A21\u5F0F\uFF08MVC/\u5FAE\u670D\u52A1/\u5355\u4F53/\u63D2\u4EF6\u5F0F\u7B49\uFF09
+   - \u{1F517} \u4F9D\u8D56\u5173\u7CFB\uFF08\u6838\u5FC3\u4F9D\u8D56\u3001\u5F00\u53D1\u4F9D\u8D56\u3001\u7248\u672C\u98CE\u9669\uFF09
+   - \u26A0\uFE0F \u6F5C\u5728\u95EE\u9898\uFF08\u8FC7\u65F6\u4F9D\u8D56\u3001\u5B89\u5168\u98CE\u9669\u3001\u4EE3\u7801\u5F02\u5473\uFF09
+   - \u{1F4A1} \u6539\u8FDB\u5EFA\u8BAE\uFF08\u4F18\u5148\u7EA7\u6392\u5E8F\uFF09
+
+\u5206\u6790\u76EE\u6807\uFF1A${target}` });
+        history.push({ role: "user", content: `\u5206\u6790\u9879\u76EE ${target}` });
+        const andefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, andefs, confirm);
+        continue;
+      }
+      if (cmd === "/fix") {
+        const target = arg || "";
+        O(b(c("  Fix Mode")) + G(" \u2022 \u81EA\u52A8\u4FEE\u590D") + "\n\n");
+        history.push({ role: "system", content: `[Fix Mode]
+\u4F60\u662F\u4E00\u4F4D\u81EA\u52A8\u4FEE\u590D\u5DE5\u7A0B\u5E08\u3002\u8BF7\u6267\u884C\u4EE5\u4E0B\u6D41\u7A0B\uFF1A
+
+1. \u5148\u7528 run_command \u8FD0\u884C\u6784\u5EFA\u547D\u4EE4\uFF08\u5982 npm run build, tsc --noEmit, cargo check \u7B49\uFF09
+2. \u5982\u679C\u6784\u5EFA\u6210\u529F\uFF0C\u8FD0\u884C\u6D4B\u8BD5\uFF08npm test, cargo test \u7B49\uFF09
+3. \u5982\u679C\u6709\u9519\u8BEF\uFF1A
+   a. \u4ED4\u7EC6\u5206\u6790\u9519\u8BEF\u4FE1\u606F\uFF0C\u5B9A\u4F4D\u5230\u5177\u4F53\u6587\u4EF6\u548C\u884C\u53F7
+   b. \u7528 read_file \u8BFB\u53D6\u51FA\u9519\u6587\u4EF6\u7684\u76F8\u5173\u4EE3\u7801
+   c. \u7406\u89E3\u9519\u8BEF\u6839\u56E0\uFF0C\u5236\u5B9A\u4FEE\u590D\u65B9\u6848
+   d. \u7528 edit_file \u7CBE\u786E\u4FEE\u590D\uFF08\u4F18\u5148\u7528 edit \u800C\u975E\u91CD\u5199\u6574\u4E2A\u6587\u4EF6\uFF09
+   e. \u91CD\u65B0\u8FD0\u884C\u6784\u5EFA\u9A8C\u8BC1\u4FEE\u590D
+   f. \u91CD\u590D\u76F4\u5230\u6240\u6709\u9519\u8BEF\u6E05\u9664
+4. \u5982\u679C\u6D4B\u8BD5\u5931\u8D25\uFF0C\u540C\u6837\u5206\u6790\u5E76\u4FEE\u590D
+5. \u6700\u591A\u5C1D\u8BD5\u4FEE\u590D 5 \u8F6E\uFF0C\u907F\u514D\u65E0\u9650\u5FAA\u73AF
+6. \u6BCF\u6B21\u4FEE\u590D\u540E\u90FD\u91CD\u65B0\u9A8C\u8BC1
+
+${target ? `\u4FEE\u590D\u76EE\u6807\uFF1A${target}
+` : "\u81EA\u52A8\u68C0\u6D4B\u5E76\u4FEE\u590D\u6240\u6709\u6784\u5EFA/\u6D4B\u8BD5\u9519\u8BEF"}` });
+        history.push({ role: "user", content: target || "\u68C0\u6D4B\u5E76\u4FEE\u590D\u9879\u76EE\u9519\u8BEF" });
+        const fxdefs = toolsToDefs(tools);
+        await runLoop(opts, history, tools, fxdefs, confirm);
+        continue;
+      }
+      if (cmd === "/diff") {
+        if (!arg) {
+          O(y("  \u7528\u6CD5: /diff <\u6587\u4EF6\u8DEF\u5F84>\n  \u663E\u793A\u6587\u4EF6\u6700\u8FD1\u7684\u53D8\u66F4\n\n"));
+          continue;
+        }
+        const filePath = arg.startsWith("/") || arg.startsWith("\\") || arg.length > 2 ? arg : join12(process5.cwd(), arg);
+        if (fileBackupStack.length === 0) {
+          O(y("  \u6CA1\u6709\u53EF\u7528\u7684\u5907\u4EFD\u8BB0\u5F55\n\n"));
+          continue;
+        }
+        const backups = fileBackupStack.filter((b2) => b2.path === filePath).reverse();
+        if (backups.length === 0) {
+          const allBackups = [...fileBackupStack].reverse();
+          O(G("  \u6700\u8FD1\u7684\u6587\u4EF6\u53D8\u66F4:\n"));
+          for (const b2 of allBackups.slice(0, 10)) {
+            const rel = relative6(process5.cwd(), b2.path);
+            const time = new Date(b2.timestamp).toLocaleTimeString();
+            O(G(`    ${time} ${rel.slice(0, 50)}`) + "\n");
+          }
+          O("\n");
+          continue;
+        }
+        const latest = backups[0];
+        try {
+          const currentContent = existsSync53(filePath) ? readFileSync37(filePath, "utf-8") : "(\u6587\u4EF6\u5DF2\u5220\u9664)";
+          const backupContent = readFileSync37(latest.backupPath, "utf-8");
+          const diffResult = computeSimpleDiff(backupContent, currentContent, filePath);
+          O(b(c("  Diff")) + G(` \u2022 ${relative6(process5.cwd(), filePath)}`) + "\n\n");
+          O(diffResult + "\n\n");
+        } catch {
+          O(y("  \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u8FDB\u884C\u5BF9\u6BD4\n\n"));
+        }
+        continue;
+      }
+      if (cmd === "/undo") {
+        if (fileBackupStack.length === 0) {
+          O(y("  \u6CA1\u6709\u53EF\u64A4\u9500\u7684\u64CD\u4F5C\n\n"));
+          continue;
+        }
+        const last = fileBackupStack[fileBackupStack.length - 1];
+        try {
+          const rel = relative6(process5.cwd(), last.path);
+          copyFileSync2(last.backupPath, last.path);
+          fileBackupStack.pop();
+          try {
+            unlinkSync2(last.backupPath);
+          } catch {
+          }
+          O(g("  \u2713 \u5DF2\u64A4\u9500") + G(` ${rel}`) + "\n");
+          O(G("  \u63D0\u793A: \u53EF\u7EE7\u7EED /undo \u64A4\u9500\u66F4\u591A\u64CD\u4F5C\n\n"));
+        } catch (e) {
+          O(r(`  \u64A4\u9500\u5931\u8D25: ${e instanceof Error ? e.message.slice(0, 60) : String(e).slice(0, 60)}
+
+`));
+        }
+        continue;
+      }
       O(G(`  \u672A\u77E5\u547D\u4EE4: ${cmd} (\u8F93\u5165 /help \u67E5\u770B\u5E2E\u52A9)
 
 `));
@@ -11761,8 +12086,9 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
         thinkAnimIv = null;
       }
     };
+    currentAbortController = new AbortController();
     try {
-      const stream = await callApi(opts, msgs, toolDefs, 0, amax);
+      const stream = await callApi(opts, msgs, toolDefs, amax, currentAbortController.signal);
       GS.api++;
       ce = 0;
       const cols = process5.stdout.columns || 80;
@@ -11801,10 +12127,11 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
           const tc = chunk.tool_call;
           if (tc) curTc = { id: tc.id, name: tc.name, argsStr: "" };
         }
-        if (chunk.type === "tool_call_args" && curTc) curTc.argsStr += chunk.content || "";
         if (chunk.type === "tool_call_end" && curTc) {
+          const tcData = chunk.tool_call;
           try {
-            tcs.push({ id: curTc.id, name: curTc.name, args: JSON.parse(curTc.argsStr || "{}") });
+            const args = tcData?.arguments || JSON.parse(curTc.argsStr || "{}");
+            tcs.push({ id: curTc.id, name: curTc.name, args });
           } catch {
             tcs.push({ id: curTc.id, name: curTc.name, args: {} });
           }
@@ -11818,8 +12145,15 @@ async function runLoop(opts, history, tools, toolDefs, confirm) {
       }
     } catch (e) {
       stopStreamAnim();
-      se = e instanceof Error ? e.message : String(e);
+      const errMsg = e instanceof Error ? e.message : String(e);
+      if (errMsg.includes("abort") || errMsg.includes("cancel")) {
+        se = null;
+        O(y("\n  \u26A1 \u8BF7\u6C42\u5DF2\u53D6\u6D88\n"));
+      } else {
+        se = errMsg;
+      }
     }
+    currentAbortController = null;
     stopStreamAnim();
     Oflush();
     const remaining = md.flush();
@@ -11955,14 +12289,19 @@ async function execTool(tc, tools, opts, confirm) {
     execAnimIv = setInterval(() => {
       rawWrite("\r" + thinkingAnimAt(toolName, toolStart));
     }, 80);
-    const execed = Promise.race([
-      tool.execute(tc.args, new AbortController().signal),
-      new Promise((_, rej) => setTimeout(() => rej(new Error("\u5DE5\u5177\u8D85\u65F6 (30s)")), 3e4))
-    ]);
+    const timeout = TOOL_TIMEOUT_MAP[tc.name] || DEFAULT_TOOL_TIMEOUT;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeout);
+    if (tc.name === "write_file" || tc.name === "edit_file") {
+      const fp = tc.args.file_path || tc.args.path || tc.args.file || "";
+      if (fp) backupFile(fp);
+    }
     let result;
     try {
-      result = await execed;
+      result = await tool.execute(tc.args, ac.signal);
+      clearTimeout(timer);
     } catch (e) {
+      clearTimeout(timer);
       result = { success: false, error: e.message, output: "" };
     }
     stopToolAnim();
@@ -12027,24 +12366,57 @@ async function execTool(tc, tools, opts, confirm) {
 }
 function buildMsgs(history) {
   const r2 = [];
-  let sysContent = `You are DeeperCode V4-Pro, a full-stack coding agent.
-Rules:
-1. Read before write. Use tools to inspect project state first.
-2. Write COMPLETE files. No placeholders like "// ..." or "rest of code".
-3. One write_file = one complete file. Batch independent writes.
-4. Use todo_manager for multi-step tasks. Update status as you progress.
-5. Keep reasoning brief. Prefer action over explanation.
-6. cwd=${process5.cwd()} plat=${process5.platform}
-7. Respond in Chinese when user uses Chinese.`;
+  let sysContent = `You are DeeperCode V4-Pro, an elite full-stack AI coding agent with autonomous execution capability.
+
+## Core Principles
+1. READ BEFORE WRITE \u2014 Always inspect project state before making changes.
+2. COMPLETE CODE \u2014 Write full files. Never use placeholders like "// ..." or "rest of code".
+3. ONE CALL = ONE FILE \u2014 Each write_file contains exactly one complete file. Batch independent writes.
+4. PLAN WITH TODOS \u2014 Use todo_manager for multi-step tasks. Update status as you progress.
+5. ACT OVER EXPLAIN \u2014 Keep reasoning brief. Prefer tool calls over lengthy explanations.
+6. VERIFY AFTER WRITE \u2014 After writing code, run type checks, linters, or tests to confirm correctness.
+7. FIX ERRORS PROACTIVELY \u2014 If a tool returns an error, diagnose and fix it immediately.
+8. PARALLEL WHEN POSSIBLE \u2014 Execute independent tool calls simultaneously for efficiency.
+
+## Smart Editing Strategy
+- For EXISTING files, prefer edit_file over write_file to minimize diff size.
+- For NEW files, use write_file with complete content.
+- Before editing, read the file first to understand its current state.
+- Make targeted, minimal edits rather than rewriting entire files.
+
+## Auto-Verification Loop
+After writing or editing code files, ALWAYS verify the changes:
+1. Run the project's build command (npm run build, tsc --noEmit, cargo check, etc.)
+2. If build fails, read the error output, fix the issues, and re-verify
+3. If tests exist, run them to confirm nothing is broken
+4. Repeat until all checks pass \u2014 do NOT leave the user with broken code
+
+## Error Recovery
+- When a tool call fails, analyze the error message carefully before retrying
+- If the same approach fails twice, try a different strategy
+- For type errors: read the file, understand the types, fix precisely
+- For runtime errors: add proper error handling and logging
+- Never give up after one failure \u2014 adapt and overcome
+
+## Execution Strategy
+- Start by reading relevant files and understanding the codebase structure.
+- Break complex tasks into small, verifiable steps.
+- After each code change, verify it compiles/passes before moving on.
+- When stuck, try a different approach rather than repeating the same failed action.
+- Use subagent for independent subtasks that can run in parallel.
+
+## Context
+- cwd=${process5.cwd()} plat=${process5.platform} arch=${process5.arch}
+- Respond in the same language as the user's input.`;
   const ts = todoSummary(4);
-  if (ts) sysContent += "\n[Remaining]\n" + ts;
+  if (ts) sysContent += "\n[Remaining Tasks]\n" + ts;
   const lastU = history.filter((m) => m.role === "user").pop();
   if (lastU?.content) {
     const hints = xmemory.getProceduralHints(lastU.content || "", 3);
     if (hints) sysContent += "\n" + hints;
   }
   const workCtx = xmemory.getWorkingContext(400);
-  if (workCtx) sysContent += "\n[\u6700\u8FD1\u5DE5\u4F5C]\n" + workCtx;
+  if (workCtx) sysContent += "\n[Recent Work]\n" + workCtx;
   const skillPrompt = getSkillSystemPrompt();
   if (skillPrompt) sysContent += "\n" + skillPrompt;
   r2.push({ role: "system", content: sysContent });
@@ -12094,22 +12466,44 @@ function compressHistory(h) {
   const keep = 6;
   const old = h.slice(0, h.length - keep);
   const recent = h.slice(h.length - keep);
-  let compressed = "";
+  const sections = [];
+  let userParts = [];
+  let assistantParts = [];
+  let toolParts = [];
+  const flushSection = () => {
+    if (userParts.length > 0) sections.push(`[\u7528\u6237] ${userParts.join(" \u2192 ")}`);
+    if (assistantParts.length > 0) sections.push(`[\u52A9\u624B] ${assistantParts.join(" \u2192 ")}`);
+    if (toolParts.length > 0) sections.push(`[\u5DE5\u5177] ${toolParts.join(", ")}`);
+    userParts = [];
+    assistantParts = [];
+    toolParts = [];
+  };
   for (const m of old) {
+    if (m.role === "system") {
+      flushSection();
+      continue;
+    }
     if (m.role === "user" && m.content) {
-      compressed += `[\u7528\u6237] ${m.content.slice(0, 100)}
-`;
-    } else if (m.role === "assistant" && m.content) {
-      compressed += `[\u52A9\u624B] ${m.content.slice(0, 150)}
-`;
+      if (assistantParts.length > 0 || toolParts.length > 0) flushSection();
+      userParts.push(m.content.slice(0, 120));
+    } else if (m.role === "assistant") {
+      if (m.tool_calls && m.tool_calls.length > 0) {
+        const names = m.tool_calls.map((t) => t.name).join(", ");
+        toolParts.push(names);
+      }
+      if (m.content) {
+        assistantParts.push(m.content.slice(0, 150));
+      }
     } else if (m.role === "tool" && m.content) {
-      compressed += `[\u5DE5\u5177] ${m.content.slice(0, 80)}
-`;
+      const isErr = m.content.startsWith("Error:");
+      toolParts.push(isErr ? "\u274C" : "\u2713");
     }
   }
+  flushSection();
+  const compressed = sections.join("\n").slice(0, 4e3);
   h.length = 0;
   h.push({ role: "system", content: `[\u4E0A\u4E0B\u6587\u538B\u7F29\xB7${old.length}\u6761\u6458\u8981]
-${compressed.slice(0, 3e3)}` });
+${compressed}` });
   h.push(...recent);
 }
 function sanitize(t) {
@@ -12119,6 +12513,45 @@ function lastUser(h) {
   for (let i = h.length - 1; i >= 0; i--) if (h[i].role === "user" && h[i].content) return h[i].content;
   return "";
 }
+function computeSimpleDiff(oldText, newText, filePath) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  const result = [];
+  let changeCount = 0;
+  const contextLines = 3;
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+    if (oldLine !== newLine) {
+      changeCount++;
+      const start = Math.max(0, i - contextLines);
+      const end = Math.min(maxLines, i + contextLines + 1);
+      if (result.length === 0 || result[result.length - 1] !== "...") {
+        result.push(G(`  @@ line ${i + 1} @@`));
+      }
+      for (let j = start; j < end; j++) {
+        if (j === i) {
+          if (oldLine !== void 0 && newLine !== void 0) {
+            result.push(r(`  - ${oldLines[j]}`));
+            result.push(g(`  + ${newLines[j]}`));
+          } else if (oldLine !== void 0) {
+            result.push(r(`  - ${oldLines[j]}`));
+          } else {
+            result.push(g(`  + ${newLines[j]}`));
+          }
+        } else if (j < oldLines.length && j < newLines.length) {
+          result.push(G(`    ${oldLines[j]}`));
+        }
+      }
+      result.push(G("  ..."));
+    }
+  }
+  if (changeCount === 0) return G("  (\u65E0\u53D8\u66F4)");
+  const rel = relative6(process5.cwd(), filePath);
+  return `${G(`\u6587\u4EF6: ${rel} (${changeCount} \u5904\u53D8\u66F4)`)}
+${result.join("\n")}`;
+}
 function toolsToDefs(tools) {
   return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
 }
@@ -12145,7 +12578,6 @@ async function listSessions() {
       const data = JSON.parse(readFileSync37(join12(SESSION_DIR, f), "utf-8"));
       const label = f.replace(/^sess_|\.json$/g, "");
       const msgCount = data.messages?.length || 0;
-      const cwd = data.cwd || "?";
       const savedAt = data.savedAt?.slice(0, 16) || "?";
       O(G(`  ${i + 1}. `) + c(label) + G(` \xB7 ${msgCount}\u6761 \xB7 ${savedAt}`) + "\n");
     } catch {
@@ -12320,14 +12752,15 @@ async function loadBuiltinTools() {
   const { builtinTools: builtinTools2 } = await Promise.resolve().then(() => (init_builtin(), builtin_exports));
   return builtinTools2;
 }
-async function callApi(opts, msgs, tools, retry = 0, cmt = 8192) {
+async function callApi(opts, msgs, tools, cmt = 8192, signal) {
   const client = new DeepSeekClient({
     apiKey: opts.apiKey || "",
     model: opts.model || "deepseek-chat",
     baseUrl: opts.baseUrl || "https://api.deepseek.com",
     temperature: opts.temperature ?? 0,
     maxTokens: cmt,
-    think: { enabled: true, budgetTokens: cmt }
+    think: { enabled: true, budgetTokens: cmt },
+    signal
   });
   const chatMsgs = msgs.map((m) => ({
     role: m.role || "user",
@@ -12338,51 +12771,15 @@ async function callApi(opts, msgs, tools, retry = 0, cmt = 8192) {
     reasoning_content: m.reasoning_content,
     thinking: m.thinking
   }));
-  try {
-    const stream = await client.chatStream(chatMsgs, tools.map((t) => ({ name: t.function.name, description: t.function.description, category: "", parameters: t.function.parameters })));
-    return adaptStream(stream);
-  } catch (e) {
-    const m = (e instanceof Error ? e.message : String(e)).toLowerCase();
-    if ((m.includes("timeout") || m.includes("abort") || m.includes("econn") || m.includes("429") || m.includes("500")) && retry < 2) {
-      const d2 = Math.min(1e3 * (retry + 1), 5e3);
-      await new Promise((r2) => setTimeout(r2, d2));
-      return callApi(opts, msgs, tools, retry + 1, cmt);
-    }
-    throw e;
-  }
-}
-async function* adaptStream(stream) {
-  const seen = /* @__PURE__ */ new Set();
-  let hasPending = false;
-  for await (const chunk of stream) {
-    if (chunk.type === "text" || chunk.type === "thinking") {
-      yield { type: chunk.type, content: chunk.content };
-    } else if (chunk.type === "tool_call") {
-      const tc = chunk.tool_call;
-      if (tc) {
-        const key = tc.id || tc.name;
-        const sa = JSON.stringify(tc.arguments || {});
-        if (!seen.has(key)) {
-          if (hasPending) yield { type: "tool_call_end" };
-          seen.add(key);
-          hasPending = true;
-          yield { type: "tool_call_start", tool_call: { id: tc.id, name: tc.name } };
-          yield { type: "tool_call_args", content: sa };
-        } else {
-          yield { type: "tool_call_args", content: sa };
-        }
-      }
-    } else if (chunk.type === "done") {
-      if (hasPending) yield { type: "tool_call_end" };
-      yield { type: "done" };
-      return;
-    } else {
-      yield chunk;
-    }
-  }
-  yield { type: "done" };
+  const stream = await client.chatStream(chatMsgs, tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    category: "",
+    parameters: t.function.parameters
+  })));
+  return stream;
 }
-var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, GS, skillEngine, mcpClient, validator, _fileCache;
+var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, TOOL_TIMEOUT_MAP, DEFAULT_TOOL_TIMEOUT, GS, skillEngine, mcpClient, validator, currentAbortController, BACKUP_DIR, MAX_BACKUPS, fileBackupStack, _fileCache;
 var init_chat_repl = __esm({
   "src/cli/chat-repl.ts"() {
     "use strict";
@@ -12403,10 +12800,38 @@ var init_chat_repl = __esm({
     TOOL_RESULT_MAX = 4e3;
     SESSION_DIR = join12(DEEPER_HOME, "sessions");
     AUTOSAVE_FILE = join12(SESSION_DIR, "_autosave.json");
+    TOOL_TIMEOUT_MAP = {
+      run_command: 12e4,
+      run_async: 12e4,
+      pipe_commands: 12e4,
+      shell_script: 12e4,
+      build_project: 18e4,
+      run_test: 18e4,
+      npm_manage: 12e4,
+      docker_manage: 12e4,
+      project_init: 12e4,
+      web_fetch: 6e4,
+      web_search: 6e4,
+      http_request: 6e4,
+      browser_action: 6e4,
+      screenshot_page: 6e4,
+      sql_query: 6e4,
+      sql_migrate: 12e4,
+      db_backup: 18e4,
+      db_restore: 18e4,
+      secret_scan: 6e4,
+      vulnerability_check: 6e4,
+      subagent: 18e4
+    };
+    DEFAULT_TOOL_TIMEOUT = 3e4;
     GS = { tc: 0, api: 0, ch: 0 };
     skillEngine = null;
     mcpClient = null;
     validator = new ToolValidator();
+    currentAbortController = null;
+    BACKUP_DIR = join12(DEEPER_HOME, "backups");
+    MAX_BACKUPS = 50;
+    fileBackupStack = [];
     _fileCache = /* @__PURE__ */ new Map();
   }
 });