deeper-cli 1.0.4 → 1.0.6

package/dist/cli/index.js

@@ -1831,10 +1831,10 @@ var init_token_count = __esm({
           const messagesJson = params.messages;
           let content = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             content = readFileSync38(abs, "utf-8");
           } else if (text) {
             content = text;
@@ -3271,6 +3271,536 @@ var init_MCPClient = __esm({
   }
 });
 
+// src/model/RetryManager.ts
+var RetryManager;
+var init_RetryManager = __esm({
+  "src/model/RetryManager.ts"() {
+    "use strict";
+    RetryManager = class {
+      maxRetries;
+      baseDelayMs;
+      maxDelayMs;
+      constructor(maxRetries = 3, baseDelayMs = 1e3, maxDelayMs = 3e4) {
+        this.maxRetries = maxRetries;
+        this.baseDelayMs = baseDelayMs;
+        this.maxDelayMs = maxDelayMs;
+      }
+      async execute(fn, shouldRetry) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            return await fn();
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt === this.maxRetries) {
+              break;
+            }
+            if (shouldRetry && !shouldRetry(lastError, attempt)) {
+              break;
+            }
+            const delay = Math.min(
+              this.baseDelayMs * Math.pow(2, attempt) + Math.random() * 1e3,
+              this.maxDelayMs
+            );
+            await this.sleep(delay);
+          }
+        }
+        throw lastError ?? new Error("Max retries exceeded");
+      }
+      withTimeout(fn, timeoutMs, signal) {
+        return new Promise((resolve48, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error(`Request timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error("Request was aborted"));
+          };
+          if (signal) {
+            if (signal.aborted) {
+              clearTimeout(timer);
+              reject(new Error("Request was aborted"));
+              return;
+            }
+            signal.addEventListener("abort", onAbort, { once: true });
+          }
+          fn().then((result) => {
+            clearTimeout(timer);
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            resolve48(result);
+          }).catch((error) => {
+            clearTimeout(timer);
+            if (signal) {
+              signal.removeEventListener("abort", onAbort);
+            }
+            reject(error);
+          });
+        });
+      }
+      sleep(ms) {
+        return new Promise((resolve48) => setTimeout(resolve48, ms));
+      }
+    };
+  }
+});
+
+// src/model/StreamHandler.ts
+var StreamHandler;
+var init_StreamHandler = __esm({
+  "src/model/StreamHandler.ts"() {
+    "use strict";
+    StreamHandler = class {
+      textBuffer;
+      thinkingBuffer;
+      toolCallBuffer;
+      finished;
+      constructor() {
+        this.textBuffer = "";
+        this.thinkingBuffer = "";
+        this.toolCallBuffer = /* @__PURE__ */ new Map();
+        this.finished = false;
+      }
+      reset() {
+        this.textBuffer = "";
+        this.thinkingBuffer = "";
+        this.toolCallBuffer.clear();
+        this.finished = false;
+      }
+      handleEvent(event, data) {
+        if (event === "[DONE]" || data === "[DONE]") {
+          this.finished = true;
+          return { type: "done" };
+        }
+        if (!data) {
+          return null;
+        }
+        try {
+          const parsed = JSON.parse(data);
+          const choices = parsed.choices;
+          if (!choices || choices.length === 0) {
+            return null;
+          }
+          const choice = choices[0];
+          const delta = choice.delta;
+          if (!delta) {
+            return null;
+          }
+          if (delta.reasoning_content) {
+            const thinkingChunk = delta.reasoning_content;
+            this.thinkingBuffer += thinkingChunk;
+            return {
+              type: "thinking",
+              content: thinkingChunk
+            };
+          }
+          if (delta.tool_calls) {
+            return this.handleToolCallsDelta(delta.tool_calls);
+          }
+          if (delta.content) {
+            const textChunk = delta.content;
+            this.textBuffer += textChunk;
+            return {
+              type: "text",
+              content: textChunk
+            };
+          }
+          const finishReason = choice.finish_reason;
+          if (finishReason === "stop" || finishReason === "length" || finishReason === "tool_calls") {
+            this.finished = true;
+            return { type: "done" };
+          }
+        } catch {
+          return {
+            type: "error",
+            error: `Failed to parse SSE data: ${data.slice(0, 200)}`
+          };
+        }
+        return null;
+      }
+      getAccumulatedText() {
+        return this.textBuffer;
+      }
+      getAccumulatedThinking() {
+        return this.thinkingBuffer;
+      }
+      getToolCalls() {
+        const result = [];
+        for (let i = 0; i < this.toolCallBuffer.size; i++) {
+          const tc = this.toolCallBuffer.get(i);
+          if (tc) {
+            result.push(tc);
+          }
+        }
+        return result;
+      }
+      isFinished() {
+        return this.finished;
+      }
+      handleToolCallsDelta(toolCalls) {
+        const results = [];
+        for (const tc of toolCalls) {
+          const index = tc.index;
+          const id = tc.id;
+          const fn = tc.function;
+          if (!this.toolCallBuffer.has(index)) {
+            this.toolCallBuffer.set(index, {
+              id: id ?? "",
+              name: fn?.name ?? "",
+              arguments: {},
+              index
+            });
+          }
+          const existing = this.toolCallBuffer.get(index);
+          if (id) {
+            existing.id = id;
+          }
+          if (fn?.name) {
+            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 || {};
+            }
+          }
+          const entry = this.toolCallBuffer.get(index);
+          if (entry) {
+            results.push({
+              type: "tool_call",
+              tool_call: { ...entry, arguments: { ...entry.arguments } }
+            });
+          }
+        }
+        return results;
+      }
+    };
+  }
+});
+
+// src/core/logger.ts
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
+var LOG_LEVEL_RANK, Logger, logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_constants();
+    LOG_LEVEL_RANK = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    Logger = class {
+      level;
+      logDir;
+      currentLogFile;
+      constructor(level = "info", logDir) {
+        this.level = level;
+        this.logDir = logDir ?? DEEPER_LOGS_DIR;
+        this.currentLogFile = this.generateLogFileName();
+        this.ensureLogDir();
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      debug(message, data) {
+        this.log("debug", message, data);
+      }
+      info(message, data) {
+        this.log("info", message, data);
+      }
+      warn(message, data) {
+        this.log("warn", message, data);
+      }
+      error(message, data) {
+        this.log("error", message, data);
+      }
+      log(level, message, data) {
+        if (LOG_LEVEL_RANK[level] < LOG_LEVEL_RANK[this.level]) {
+          return;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const formatted = this.formatMessage(level, timestamp, message, data);
+        switch (level) {
+          case "error":
+            console.error(formatted);
+            break;
+          case "warn":
+            console.warn(formatted);
+            break;
+          default:
+            console.log(formatted);
+            break;
+        }
+        try {
+          appendFileSync(this.currentLogFile, this.stripAnsi(formatted) + "\n", "utf-8");
+        } catch {
+        }
+      }
+      formatMessage(level, timestamp, message, data) {
+        const levelUpper = level.toUpperCase();
+        const base = `[${timestamp}] [${levelUpper}] ${message}`;
+        if (data !== void 0) {
+          if (typeof data === "string") {
+            return `${base} ${data}`;
+          }
+          if (data instanceof Error) {
+            return `${base} ${data.message}
+${data.stack ?? ""}`;
+          }
+          try {
+            return `${base} ${JSON.stringify(data)}`;
+          } catch {
+            return `${base} [Unserializable data]`;
+          }
+        }
+        return base;
+      }
+      stripAnsi(text) {
+        return text.replace(/\x1b\[[0-9;]*m/g, "");
+      }
+      generateLogFileName() {
+        const now = /* @__PURE__ */ new Date();
+        const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
+        return join7(this.logDir, `deeper-${dateStr}.log`);
+      }
+      ensureLogDir() {
+        const dir = dirname2(this.currentLogFile);
+        if (!existsSync8(dir)) {
+          mkdirSync5(dir, { recursive: true });
+        }
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/model/DeepSeekClient.ts
+var DEFAULT_TIMEOUT_MS, MAX_RETRIES, DeepSeekClient;
+var init_DeepSeekClient = __esm({
+  "src/model/DeepSeekClient.ts"() {
+    "use strict";
+    init_RetryManager();
+    init_StreamHandler();
+    init_logger();
+    DEFAULT_TIMEOUT_MS = 12e4;
+    MAX_RETRIES = 3;
+    DeepSeekClient = class {
+      config;
+      retryManager;
+      constructor(config) {
+        this.config = config;
+        this.retryManager = new RetryManager(config.maxTokens > 0 ? MAX_RETRIES : 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(
+            () => this.makeRequest(cfg, body),
+            cfg.maxTokens > 0 ? DEFAULT_TIMEOUT_MS : DEFAULT_TIMEOUT_MS
+          );
+          return result2;
+        }, this.shouldRetry);
+        const data = await response.json();
+        if (!data.choices || data.choices.length === 0) {
+          throw new Error("No choices returned from API");
+        }
+        const choice = data.choices[0];
+        const message = choice.message;
+        const result = {
+          role: "assistant",
+          content: message.content
+        };
+        if (message.tool_calls) {
+          result.tool_calls = message.tool_calls.map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: this.parseArguments(tc.function.arguments)
+          }));
+        }
+        if (message.reasoning_content) {
+          result.thinking = message.reasoning_content;
+        }
+        return result;
+      }
+      async chatStream(messages, tools, overrides) {
+        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(
+            () => this.makeRequest(cfg, body),
+            DEFAULT_TIMEOUT_MS
+          );
+          return result;
+        }, this.shouldRetry);
+        if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody}`);
+        }
+        if (!response.body) {
+          throw new Error("Response body is empty");
+        }
+        return this.createStreamIterable(response.body);
+      }
+      async *createStreamIterable(body) {
+        const handler = new StreamHandler();
+        let buffer = "";
+        const stream = body;
+        for await (const chunk of stream) {
+          const text = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+          buffer += text;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith(":")) {
+              continue;
+            }
+            if (trimmed.startsWith("data: ")) {
+              const data = trimmed.slice(6);
+              const result = handler.handleEvent("message", data);
+              if (result) {
+                if (Array.isArray(result)) {
+                  for (const r2 of result) yield r2;
+                } else yield result;
+              }
+            } else if (trimmed === "data: [DONE]") {
+              yield { type: "done" };
+              return;
+            }
+          }
+        }
+        if (buffer.trim()) {
+          const trimmed = buffer.trim();
+          if (trimmed.startsWith("data: ")) {
+            const data = trimmed.slice(6);
+            const result = handler.handleEvent("message", data);
+            if (result) {
+              if (Array.isArray(result)) {
+                for (const r2 of result) yield r2;
+              } else yield result;
+            }
+          }
+        }
+        if (!handler.isFinished()) {
+          yield { type: "done" };
+        }
+      }
+      buildRequestBody(messages, tools, config, stream) {
+        const body = {
+          model: config.model,
+          messages: messages.map((m) => {
+            const msg = {
+              role: m.role,
+              content: m.content
+            };
+            if (m.tool_calls) {
+              msg.tool_calls = m.tool_calls.map((tc) => ({
+                id: tc.id,
+                type: "function",
+                function: {
+                  name: tc.name,
+                  arguments: JSON.stringify(tc.arguments)
+                }
+              }));
+            }
+            if (m.tool_call_id) {
+              msg.tool_call_id = m.tool_call_id;
+            }
+            if (m.name) {
+              msg.name = m.name;
+            }
+            const rc = m.reasoning_content || m.thinking;
+            if (rc) msg.reasoning_content = rc;
+            return msg;
+          }),
+          temperature: config.temperature,
+          max_tokens: config.maxTokens,
+          stream
+        };
+        if (tools && tools.length > 0) {
+          body.tools = tools.map((tool) => ({
+            type: "function",
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.parameters
+            }
+          }));
+          body.tool_choice = "auto";
+        }
+        return JSON.stringify(body);
+      }
+      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, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Accept": "application/json"
+          },
+          body
+        });
+        if (!response.ok) {
+          const errorBody = await response.text().catch(() => "");
+          logger.error("DeepSeek API error", {
+            status: response.status,
+            statusText: response.statusText,
+            body: errorBody.slice(0, 500)
+          });
+          throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody.slice(0, 200)}`);
+        }
+        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);
+        } catch {
+          return {};
+        }
+      }
+      mergeConfig(overrides) {
+        if (!overrides) {
+          return this.config;
+        }
+        return {
+          ...this.config,
+          ...overrides,
+          think: {
+            ...this.config.think,
+            ...overrides.think ?? {}
+          }
+        };
+      }
+    };
+  }
+});
+
 // src/ui/ansi.ts
 import process4 from "process";
 function Oflush() {
@@ -3363,7 +3893,7 @@ var init_ansi = __esm({
 });
 
 // src/tools/builtin/filesystem/read_file.ts
-import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync9 } from "fs";
 import { resolve, normalize } from "path";
 var read_file;
 var init_read_file = __esm({
@@ -3387,11 +3917,11 @@ var init_read_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve(params.file_path);
-          if (!existsSync8(filePath)) {
+          if (!existsSync9(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
-          const statSync12 = await import("fs").then((m) => m.statSync);
-          const stat = statSync12(filePath);
+          const statSync13 = await import("fs").then((m) => m.statSync);
+          const stat = statSync13(filePath);
           if (stat.isDirectory()) {
             return { success: false, error: `\u8DEF\u5F84\u662F\u76EE\u5F55\uFF0C\u4E0D\u662F\u6587\u4EF6: ${filePath}`, output: "" };
           }
@@ -3425,9 +3955,9 @@ var init_read_file = __esm({
 });
 
 // src/tools/builtin/filesystem/write_file.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
 import { writeFile as writeFile2, appendFile } from "fs/promises";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve2 } from "path";
 var write_file;
 var init_write_file = __esm({
   "src/tools/builtin/filesystem/write_file.ts"() {
@@ -3458,8 +3988,8 @@ var init_write_file = __esm({
           if (!content.trim() && !append) {
             return { success: false, error: `\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u8DF3\u8FC7\u5199\u5165: ${filePath}`, output: "" };
           }
-          const dir = dirname2(filePath);
-          if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+          const dir = dirname3(filePath);
+          if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
           if (append) {
             await appendFile(filePath, content, "utf-8");
           } else {
@@ -3476,7 +4006,7 @@ var init_write_file = __esm({
 });
 
 // src/tools/builtin/filesystem/edit_file.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync11 } from "fs";
 import { resolve as resolve3 } from "path";
 var edit_file;
 var init_edit_file = __esm({
@@ -3504,7 +4034,7 @@ var init_edit_file = __esm({
           const oldStr = params.old_str;
           const newStr = params.new_str;
           const replaceAll = params.replace_all ?? false;
-          if (!existsSync10(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync11(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const content = readFileSync6(filePath, "utf-8");
           const index = content.indexOf(oldStr);
           if (index === -1) return { success: false, error: "\u672A\u627E\u5230\u5339\u914D\u7684\u5B57\u7B26\u4E32", output: "" };
@@ -3530,7 +4060,7 @@ var init_edit_file = __esm({
 });
 
 // src/tools/builtin/filesystem/delete_file.ts
-import { unlinkSync, existsSync as existsSync11 } from "fs";
+import { unlinkSync, existsSync as existsSync12 } from "fs";
 import { resolve as resolve4 } from "path";
 var delete_file;
 var init_delete_file = __esm({
@@ -3552,7 +4082,7 @@ var init_delete_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve4(params.file_path);
-          if (!existsSync11(filePath)) {
+          if (!existsSync12(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           unlinkSync(filePath);
@@ -3566,8 +4096,8 @@ var init_delete_file = __esm({
 });
 
 // src/tools/builtin/filesystem/list_dir.ts
-import { readdirSync as readdirSync3, existsSync as existsSync12 } from "fs";
-import { resolve as resolve5, join as join7 } from "path";
+import { readdirSync as readdirSync3, existsSync as existsSync13 } from "fs";
+import { resolve as resolve5, join as join8 } from "path";
 var list_dir;
 var init_list_dir = __esm({
   "src/tools/builtin/filesystem/list_dir.ts"() {
@@ -3597,7 +4127,7 @@ var init_list_dir = __esm({
                 const isDir = entry.isDirectory();
                 lines.push(`${prefix}${isDir ? "\u{1F4C1}" : "\u{1F4C4}"} ${entry.name}`);
                 if (isDir && recursive) {
-                  walk2(join7(dir, entry.name), depth + 1, prefix + "  ");
+                  walk2(join8(dir, entry.name), depth + 1, prefix + "  ");
                 }
               }
             } catch {
@@ -3608,10 +4138,10 @@ var init_list_dir = __esm({
           const dirPath = resolve5(params.dir_path);
           const recursive = params.recursive ?? false;
           const maxDepth = params.max_depth ?? 3;
-          if (!existsSync12(dirPath)) {
+          if (!existsSync13(dirPath)) {
             return { success: false, error: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${dirPath}`, output: "" };
           }
-          const { statSync: statSync12 } = await import("fs");
+          const { statSync: statSync13 } = await import("fs");
           const lines = [];
           walk2(dirPath, 1, "");
           return { success: true, output: lines.join("\n"), metadata: { path: dirPath, entries: lines.length } };
@@ -3674,8 +4204,8 @@ var init_glob_find = __esm({
 });
 
 // src/tools/builtin/filesystem/move_file.ts
-import { renameSync, existsSync as existsSync13 } from "fs";
-import { resolve as resolve7, dirname as dirname3 } from "path";
+import { renameSync, existsSync as existsSync14 } from "fs";
+import { resolve as resolve7, dirname as dirname4 } from "path";
 var move_file;
 var init_move_file = __esm({
   "src/tools/builtin/filesystem/move_file.ts"() {
@@ -3698,13 +4228,13 @@ var init_move_file = __esm({
         try {
           const source = resolve7(params.source);
           const dest = resolve7(params.destination);
-          if (!existsSync13(source)) {
+          if (!existsSync14(source)) {
             return { success: false, error: `\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728: ${source}`, output: "" };
           }
-          const destDir = dirname3(dest);
-          const { mkdirSync: mkdirSync15 } = await import("fs");
-          if (!existsSync13(destDir)) {
-            mkdirSync15(destDir, { recursive: true });
+          const destDir = dirname4(dest);
+          const { mkdirSync: mkdirSync16 } = await import("fs");
+          if (!existsSync14(destDir)) {
+            mkdirSync16(destDir, { recursive: true });
           }
           renameSync(source, dest);
           return { success: true, output: `\u5DF2\u79FB\u52A8: ${source} -> ${dest}` };
@@ -3717,8 +4247,8 @@ var init_move_file = __esm({
 });
 
 // src/tools/builtin/filesystem/copy_file.ts
-import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve8, dirname as dirname4 } from "path";
+import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve8, dirname as dirname5 } from "path";
 var copy_file;
 var init_copy_file = __esm({
   "src/tools/builtin/filesystem/copy_file.ts"() {
@@ -3741,12 +4271,12 @@ var init_copy_file = __esm({
         try {
           const source = resolve8(params.source);
           const dest = resolve8(params.destination);
-          if (!existsSync14(source)) {
+          if (!existsSync15(source)) {
             return { success: false, error: `\u6E90\u6587\u4EF6\u4E0D\u5B58\u5728: ${source}`, output: "" };
           }
-          const destDir = dirname4(dest);
-          if (!existsSync14(destDir)) {
-            mkdirSync6(destDir, { recursive: true });
+          const destDir = dirname5(dest);
+          if (!existsSync15(destDir)) {
+            mkdirSync7(destDir, { recursive: true });
           }
           copyFileSync(source, dest);
           return { success: true, output: `\u5DF2\u590D\u5236: ${source} -> ${dest}` };
@@ -3759,7 +4289,7 @@ var init_copy_file = __esm({
 });
 
 // src/tools/builtin/filesystem/create_dir.ts
-import { mkdirSync as mkdirSync7, existsSync as existsSync15 } from "fs";
+import { mkdirSync as mkdirSync8, existsSync as existsSync16 } from "fs";
 import { resolve as resolve9 } from "path";
 var create_dir;
 var init_create_dir = __esm({
@@ -3781,10 +4311,10 @@ var init_create_dir = __esm({
       async execute(params) {
         try {
           const dirPath = resolve9(params.dir_path);
-          if (existsSync15(dirPath)) {
+          if (existsSync16(dirPath)) {
             return { success: true, output: `\u76EE\u5F55\u5DF2\u5B58\u5728: ${dirPath}` };
           }
-          mkdirSync7(dirPath, { recursive: true });
+          mkdirSync8(dirPath, { recursive: true });
           return { success: true, output: `\u76EE\u5F55\u5DF2\u521B\u5EFA: ${dirPath}` };
         } catch (err) {
           return { success: false, error: err.message, output: "" };
@@ -3795,7 +4325,7 @@ var init_create_dir = __esm({
 });
 
 // src/tools/builtin/filesystem/file_info.ts
-import { statSync, existsSync as existsSync16 } from "fs";
+import { statSync, existsSync as existsSync17 } from "fs";
 import { resolve as resolve10, basename } from "path";
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -3823,7 +4353,7 @@ var init_file_info = __esm({
       async execute(params) {
         try {
           const filePath = resolve10(params.file_path);
-          if (!existsSync16(filePath)) {
+          if (!existsSync17(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const stat = statSync(filePath);
@@ -3852,7 +4382,7 @@ var init_file_info = __esm({
 });
 
 // src/tools/builtin/filesystem/watch_file.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { resolve as resolve11 } from "path";
 var watch_file;
 var init_watch_file = __esm({
@@ -3874,7 +4404,7 @@ var init_watch_file = __esm({
       async execute(params) {
         try {
           const filePath = resolve11(params.file_path);
-          if (!existsSync17(filePath)) {
+          if (!existsSync18(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           return {
@@ -3891,7 +4421,7 @@ var init_watch_file = __esm({
 });
 
 // src/tools/builtin/filesystem/batch_read.ts
-import { readFileSync as readFileSync7, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync19 } from "fs";
 import { resolve as resolve12 } from "path";
 var batch_read;
 var init_batch_read = __esm({
@@ -3919,7 +4449,7 @@ var init_batch_read = __esm({
           for (const p of paths) {
             const abs = resolve12(p);
             try {
-              if (!existsSync18(abs)) {
+              if (!existsSync19(abs)) {
                 results[p] = { content: "", error: "\u6587\u4EF6\u4E0D\u5B58\u5728" };
                 continue;
               }
@@ -3952,9 +4482,9 @@ ${r2.content}`;
 });
 
 // src/tools/builtin/filesystem/batch_write.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9 } from "fs";
 import { writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve13, dirname as dirname5 } from "path";
+import { resolve as resolve13, dirname as dirname6 } from "path";
 var batch_write;
 var init_batch_write = __esm({
   "src/tools/builtin/filesystem/batch_write.ts"() {
@@ -4001,9 +4531,9 @@ var init_batch_write = __esm({
               skipped.push(`${abs} (\u5185\u5BB9\u8FC7\u5927)`);
               continue;
             }
-            const dir = dirname5(abs);
-            if (!existsSync19(dir)) {
-              mkdirSync8(dir, { recursive: true });
+            const dir = dirname6(abs);
+            if (!existsSync20(dir)) {
+              mkdirSync9(dir, { recursive: true });
             }
             await writeFile3(abs, content, "utf-8");
             results.push(abs);
@@ -4025,7 +4555,7 @@ var init_batch_write = __esm({
 });
 
 // src/tools/builtin/filesystem/diff_files.ts
-import { readFileSync as readFileSync8, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync21 } from "fs";
 import { resolve as resolve14 } from "path";
 var diff_files;
 var init_diff_files = __esm({
@@ -4051,8 +4581,8 @@ var init_diff_files = __esm({
           const fileA = resolve14(params.file_a);
           const fileB = resolve14(params.file_b);
           const contextLines = params.context_lines ?? 3;
-          if (!existsSync20(fileA)) return { success: false, error: `\u6587\u4EF6A\u4E0D\u5B58\u5728: ${fileA}`, output: "" };
-          if (!existsSync20(fileB)) return { success: false, error: `\u6587\u4EF6B\u4E0D\u5B58\u5728: ${fileB}`, output: "" };
+          if (!existsSync21(fileA)) return { success: false, error: `\u6587\u4EF6A\u4E0D\u5B58\u5728: ${fileA}`, output: "" };
+          if (!existsSync21(fileB)) return { success: false, error: `\u6587\u4EF6B\u4E0D\u5B58\u5728: ${fileB}`, output: "" };
           const contentA = readFileSync8(fileA, "utf-8");
           const contentB = readFileSync8(fileB, "utf-8");
           const Diff = await import("diff");
@@ -4083,7 +4613,7 @@ var init_diff_files = __esm({
 });
 
 // src/tools/builtin/filesystem/merge_files.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync21 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync22 } from "fs";
 import { resolve as resolve15 } from "path";
 var merge_files;
 var init_merge_files = __esm({
@@ -4112,7 +4642,7 @@ var init_merge_files = __esm({
           const parts = [];
           for (const p of paths) {
             const abs = resolve15(p);
-            if (!existsSync21(abs)) {
+            if (!existsSync22(abs)) {
               return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             }
             parts.push(readFileSync9(abs, "utf-8"));
@@ -4133,7 +4663,7 @@ var init_merge_files = __esm({
 });
 
 // src/tools/builtin/search/grep_search.ts
-import { readFileSync as readFileSync10, existsSync as existsSync22, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync23, statSync as statSync2 } from "fs";
 import { resolve as resolve16 } from "path";
 var grep_search;
 var init_grep_search = __esm({
@@ -4198,7 +4728,7 @@ var init_grep_search = __esm({
           const maxFileSize = 5 * 1024 * 1024;
           if (filePath) {
             const abs = resolve16(filePath);
-            if (existsSync22(abs)) searchFile2(abs);
+            if (existsSync23(abs)) searchFile2(abs);
           } else if (dirPath) {
             const fg2 = await import("fast-glob");
             const pattern2 = glob ? `**/${glob}` : "**/*";
@@ -4671,7 +5201,7 @@ var init_fuzzy_find = __esm({
 });
 
 // src/tools/builtin/search/regex_find.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync6, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync6, existsSync as existsSync29 } from "fs";
 import { resolve as resolve23 } from "path";
 var regex_find;
 var init_regex_find = __esm({
@@ -4737,7 +5267,7 @@ var init_regex_find = __esm({
           }
           if (filePath) {
             const abs = resolve23(filePath);
-            if (existsSync28(abs)) await processFile(abs);
+            if (existsSync29(abs)) await processFile(abs);
           } else if (dirPath) {
             const fg2 = await import("fast-glob");
             const files = await fg2.default(filePattern, {
@@ -5315,7 +5845,7 @@ ${stderr}` : ""),
 });
 
 // src/tools/builtin/shell/shell_script.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import { exec as execCb2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { resolve as resolve24 } from "path";
@@ -5346,7 +5876,7 @@ var init_shell_script = __esm({
           const args = params.args ?? [];
           const cwd = params.cwd ?? process.cwd();
           const timeout = params.timeout_ms ?? 3e4;
-          if (!existsSync29(scriptPath)) {
+          if (!existsSync30(scriptPath)) {
             return { success: false, error: `\u811A\u672C\u6587\u4EF6\u4E0D\u5B58\u5728: ${scriptPath}`, output: "" };
           }
           const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : process.env.SHELL || "/bin/sh";
@@ -6017,8 +6547,8 @@ var init_http_request = __esm({
 });
 
 // src/tools/builtin/network/download_file.ts
-import { createWriteStream, existsSync as existsSync30, mkdirSync as mkdirSync9 } from "fs";
-import { dirname as dirname6, resolve as resolve25 } from "path";
+import { createWriteStream, existsSync as existsSync31, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname7, resolve as resolve25 } from "path";
 import { pipeline } from "stream/promises";
 function formatSize2(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -6049,9 +6579,9 @@ var init_download_file = __esm({
           const url = params.url;
           const filePath = resolve25(params.file_path);
           const timeout = params.timeout_ms ?? 6e4;
-          const dir = dirname6(filePath);
-          if (!existsSync30(dir)) {
-            mkdirSync9(dir, { recursive: true });
+          const dir = dirname7(filePath);
+          if (!existsSync31(dir)) {
+            mkdirSync10(dir, { recursive: true });
           }
           const controller = new AbortController();
           const timer = setTimeout(() => controller.abort(), timeout);
@@ -6631,7 +7161,7 @@ var init_proxy_request = __esm({
 });
 
 // src/tools/builtin/code/parse_ast.ts
-import { readFileSync as readFileSync18, existsSync as existsSync31 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync32 } from "fs";
 import { resolve as resolve26 } from "path";
 var parse_ast;
 var init_parse_ast = __esm({
@@ -6655,7 +7185,7 @@ var init_parse_ast = __esm({
         try {
           const filePath = resolve26(params.file_path);
           const language = params.language ?? "typescript";
-          if (!existsSync31(filePath)) {
+          if (!existsSync32(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync18(filePath, "utf-8");
@@ -6716,7 +7246,7 @@ var init_parse_ast = __esm({
 });
 
 // src/tools/builtin/code/format_code.ts
-import { readFileSync as readFileSync19, existsSync as existsSync32 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync33 } from "fs";
 import { resolve as resolve27 } from "path";
 var format_code;
 var init_format_code = __esm({
@@ -6740,7 +7270,7 @@ var init_format_code = __esm({
         try {
           const filePath = resolve27(params.file_path);
           const language = params.language ?? "typescript";
-          if (!existsSync32(filePath)) {
+          if (!existsSync33(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           try {
@@ -6964,7 +7494,7 @@ var init_generate_code = __esm({
 });
 
 // src/tools/builtin/code/refactor_code.ts
-import { readFileSync as readFileSync20, existsSync as existsSync33 } from "fs";
+import { readFileSync as readFileSync20, existsSync as existsSync34 } from "fs";
 import { resolve as resolve30 } from "path";
 function escapeRegex3(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -6995,7 +7525,7 @@ var init_refactor_code = __esm({
           const action = params.action;
           const target = params.target;
           const newName = params.new_name;
-          if (!existsSync33(filePath)) {
+          if (!existsSync34(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync20(filePath, "utf-8");
@@ -7032,7 +7562,7 @@ var init_refactor_code = __esm({
 });
 
 // src/tools/builtin/code/extract_function.ts
-import { readFileSync as readFileSync21, existsSync as existsSync34 } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync35 } from "fs";
 import { resolve as resolve31 } from "path";
 function escapeRegex4(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -7059,7 +7589,7 @@ var init_extract_function = __esm({
         try {
           const filePath = resolve31(params.file_path);
           const funcName = params.function_name;
-          if (!existsSync34(filePath)) {
+          if (!existsSync35(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync21(filePath, "utf-8");
@@ -7187,7 +7717,7 @@ var init_analyze_deps = __esm({
 });
 
 // src/tools/builtin/code/import_organizer.ts
-import { readFileSync as readFileSync23, existsSync as existsSync36 } from "fs";
+import { readFileSync as readFileSync23, existsSync as existsSync37 } from "fs";
 import { resolve as resolve33 } from "path";
 var import_organizer;
 var init_import_organizer = __esm({
@@ -7215,7 +7745,7 @@ var init_import_organizer = __esm({
           const groupBy = params.group_by ?? "source";
           const sort = params.sort ?? true;
           const removeUnused = params.remove_unused ?? false;
-          if (!existsSync36(filePath)) {
+          if (!existsSync37(filePath)) {
             return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           }
           const content = readFileSync23(filePath, "utf-8");
@@ -7390,10 +7920,10 @@ var init_code_metrics = __esm({
 });
 
 // src/core/bugscan.ts
-import { existsSync as existsSync38, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync25, statSync as statSync10 } from "fs";
 import { extname, basename as basename3 } from "path";
 function analyzeFile(filePath) {
-  if (!existsSync38(filePath)) return [];
+  if (!existsSync39(filePath)) return [];
   try {
     if (statSync10(filePath).size > MAX_FILE_SIZE) return [];
   } catch {
@@ -7529,7 +8059,7 @@ var init_bugscan = __esm({
 
 // src/tools/builtin/code/bug_scan.ts
 import { statSync as statSync11 } from "fs";
-import { isAbsolute, join as join8 } from "path";
+import { isAbsolute, join as join9 } from "path";
 import fg from "fast-glob";
 var MAX_FILES, EXTENSIONS, SEVERITY_ORDER, bug_scan;
 var init_bug_scan = __esm({
@@ -7559,7 +8089,7 @@ var init_bug_scan = __esm({
           const target = params.path;
           const recursive = params.recursive ?? false;
           const minSeverity = params.severity ?? "warning";
-          const absPath = isAbsolute(target) ? target : join8(process.cwd(), target);
+          const absPath = isAbsolute(target) ? target : join9(process.cwd(), target);
           let isFile = false;
           try {
             isFile = statSync11(absPath).isFile();
@@ -8124,10 +8654,10 @@ var init_json_parse = __esm({
           const query = params.query;
           let jsonContent = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             jsonContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             jsonContent = content;
@@ -8181,10 +8711,10 @@ var init_csv_parse = __esm({
           const delimiter = params.delimiter ?? ",";
           const hasHeader = params.has_header ?? true;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             csvContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             csvContent = content;
@@ -8268,10 +8798,10 @@ var init_xml_parse = __esm({
           const filePath = params.file_path;
           const content = params.content;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             xmlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             xmlContent = content;
@@ -8313,10 +8843,10 @@ var init_yaml_parse = __esm({
           const filePath = params.file_path;
           const content = params.content;
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             yamlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             yamlContent = content;
@@ -8359,10 +8889,10 @@ var init_toml_parse = __esm({
           const filePath = params.file_path;
           let tomlContent = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             tomlContent = readFileSync38(abs, "utf-8");
           } else if (content) {
             tomlContent = content;
@@ -8411,10 +8941,10 @@ var init_data_transform = __esm({
           const output = params.output;
           let inputStr = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             inputStr = readFileSync38(abs, "utf-8");
           } else if (data) {
             inputStr = data;
@@ -8623,7 +9153,7 @@ var init_data_diff = __esm({
 });
 
 // src/tools/builtin/data/template_render.ts
-import { readFileSync as readFileSync26, existsSync as existsSync39, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync40, writeFileSync as writeFileSync8 } from "fs";
 import { resolve as resolve35 } from "path";
 function escapeRegex5(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -8657,7 +9187,7 @@ var init_template_render = __esm({
           let template = "";
           if (filePath) {
             const abs = resolve35(filePath);
-            if (!existsSync39(abs)) return { success: false, error: `\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync40(abs)) return { success: false, error: `\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             template = readFileSync26(abs, "utf-8");
           } else if (templateStr) {
             template = templateStr;
@@ -8833,8 +9363,8 @@ ${results.join("\n")}
 });
 
 // src/tools/builtin/security/encrypt_file.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync9, existsSync as existsSync41, mkdirSync as mkdirSync10 } from "fs";
-import { resolve as resolve37, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync9, existsSync as existsSync42, mkdirSync as mkdirSync11 } from "fs";
+import { resolve as resolve37, dirname as dirname8 } from "path";
 var encrypt_file;
 var init_encrypt_file = __esm({
   "src/tools/builtin/security/encrypt_file.ts"() {
@@ -8861,15 +9391,15 @@ var init_encrypt_file = __esm({
           const output = resolve37(params.output);
           const password = params.password;
           const algorithm = params.algorithm ?? "aes-256-cbc";
-          if (!existsSync41(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync42(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const crypto = await import("crypto");
           const content = readFileSync28(filePath);
           const key = crypto.scryptSync(password || "default-secret-key", "salt", algorithm === "aes-256-cbc" ? 32 : 16);
           const iv = crypto.randomBytes(16);
           const cipher = crypto.createCipheriv(algorithm, key, iv);
           const encrypted = Buffer.concat([iv, cipher.update(content), cipher.final()]);
-          const outDir = dirname7(output);
-          if (!existsSync41(outDir)) mkdirSync10(outDir, { recursive: true });
+          const outDir = dirname8(output);
+          if (!existsSync42(outDir)) mkdirSync11(outDir, { recursive: true });
           writeFileSync9(output, encrypted);
           return {
             success: true,
@@ -8885,8 +9415,8 @@ var init_encrypt_file = __esm({
 });
 
 // src/tools/builtin/security/decrypt_file.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync10, existsSync as existsSync42, mkdirSync as mkdirSync11 } from "fs";
-import { resolve as resolve38, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync10, existsSync as existsSync43, mkdirSync as mkdirSync12 } from "fs";
+import { resolve as resolve38, dirname as dirname9 } from "path";
 var decrypt_file;
 var init_decrypt_file = __esm({
   "src/tools/builtin/security/decrypt_file.ts"() {
@@ -8913,7 +9443,7 @@ var init_decrypt_file = __esm({
           const output = resolve38(params.output);
           const password = params.password;
           const algorithm = params.algorithm ?? "aes-256-cbc";
-          if (!existsSync42(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
+          if (!existsSync43(filePath)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, output: "" };
           const crypto = await import("crypto");
           const encrypted = readFileSync29(filePath);
           const iv = encrypted.subarray(0, 16);
@@ -8921,8 +9451,8 @@ var init_decrypt_file = __esm({
           const key = crypto.scryptSync(password || "default-secret-key", "salt", algorithm === "aes-256-cbc" ? 32 : 16);
           const decipher = crypto.createDecipheriv(algorithm, key, iv);
           const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
-          const outDir = dirname8(output);
-          if (!existsSync42(outDir)) mkdirSync11(outDir, { recursive: true });
+          const outDir = dirname9(output);
+          if (!existsSync43(outDir)) mkdirSync12(outDir, { recursive: true });
           writeFileSync10(output, decrypted);
           return {
             success: true,
@@ -8939,7 +9469,7 @@ var init_decrypt_file = __esm({
 
 // src/tools/builtin/security/hash_generate.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync30, existsSync as existsSync43 } from "fs";
+import { readFileSync as readFileSync30, existsSync as existsSync44 } from "fs";
 import { resolve as resolve39 } from "path";
 var hash_generate;
 var init_hash_generate = __esm({
@@ -8968,7 +9498,7 @@ var init_hash_generate = __esm({
           let hash;
           if (filePath) {
             const abs = resolve39(filePath);
-            if (!existsSync43(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync44(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             const fileContent = readFileSync30(abs);
             hash = createHash(algorithm).update(fileContent).digest("hex");
           } else if (content) {
@@ -9254,7 +9784,7 @@ ${output.slice(0, 5e3)}`,
 
 // src/tools/builtin/project/build_project.ts
 import { execSync as execSync14 } from "child_process";
-import { readFileSync as readFileSync31, existsSync as existsSync44 } from "fs";
+import { readFileSync as readFileSync31, existsSync as existsSync45 } from "fs";
 import { resolve as resolve40 } from "path";
 var build_project;
 var init_build_project = __esm({
@@ -9282,7 +9812,7 @@ var init_build_project = __esm({
           const tool = params.tool ?? "auto";
           let cmd = "";
           const pkgPath = resolve40(cwd, "package.json");
-          if (tool === "auto" && existsSync44(pkgPath)) {
+          if (tool === "auto" && existsSync45(pkgPath)) {
             const pkg = JSON.parse(readFileSync31(pkgPath, "utf-8"));
             const scripts = pkg.scripts || {};
             if (scripts.build) cmd = `npm run build`;
@@ -9332,7 +9862,7 @@ ${output.slice(0, 1e4)}`,
 
 // src/tools/builtin/project/run_test.ts
 import { execSync as execSync15 } from "child_process";
-import { readFileSync as readFileSync32, existsSync as existsSync45 } from "fs";
+import { readFileSync as readFileSync32, existsSync as existsSync46 } from "fs";
 import { resolve as resolve41 } from "path";
 var run_test;
 var init_run_test = __esm({
@@ -9363,7 +9893,7 @@ var init_run_test = __esm({
           let cmd = "";
           if (runner === "auto") {
             const pkgPath = resolve41(cwd, "package.json");
-            if (existsSync45(pkgPath)) {
+            if (existsSync46(pkgPath)) {
               const pkg = JSON.parse(readFileSync32(pkgPath, "utf-8"));
               const scripts = pkg.scripts || {};
               if (scripts.test) cmd = `npm run test`;
@@ -9482,7 +10012,7 @@ ${output.slice(0, 1e4)}`,
 });
 
 // src/tools/builtin/project/env_manage.ts
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync11, existsSync as existsSync46 } from "fs";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync11, existsSync as existsSync47 } from "fs";
 import { resolve as resolve42 } from "path";
 var env_manage;
 var init_env_manage = __esm({
@@ -9514,14 +10044,14 @@ var init_env_manage = __esm({
           if (action === "list_envs") {
             const cwd = process.cwd();
             const envs = [".env", ".env.local", ".env.development", ".env.production", ".env.test"];
-            const found = envs.filter((f) => existsSync46(resolve42(cwd, f)));
+            const found = envs.filter((f) => existsSync47(resolve42(cwd, f)));
             return {
               success: true,
               output: found.join("\n") || "\u672A\u627E\u5230 .env \u6587\u4EF6",
               metadata: { files: found }
             };
           }
-          if (!existsSync46(abs)) {
+          if (!existsSync47(abs)) {
             if (action === "set" && key && value !== void 0) {
               writeFileSync11(abs, `${key}=${value}`, "utf-8");
               return { success: true, output: `\u5DF2\u521B\u5EFA ${filePath} \u5E76\u8BBE\u7F6E ${key}=${value}` };
@@ -9568,7 +10098,7 @@ var init_env_manage = __esm({
 });
 
 // src/tools/builtin/project/config_manage.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync12, existsSync as existsSync47 } from "fs";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync12, existsSync as existsSync48 } from "fs";
 import { resolve as resolve43 } from "path";
 var config_manage;
 var init_config_manage = __esm({
@@ -9608,7 +10138,7 @@ var init_config_manage = __esm({
               ".prettierrc"
             ];
             const cwd = process.cwd();
-            const found = configs.filter((f) => existsSync47(resolve43(cwd, f)));
+            const found = configs.filter((f) => existsSync48(resolve43(cwd, f)));
             return {
               success: true,
               output: `\u9879\u76EE\u914D\u7F6E\u6587\u4EF6:
@@ -9627,7 +10157,7 @@ NODE_ENV=development
             return { success: false, error: "\u7F3A\u5C11 file_path \u53C2\u6570", output: "" };
           }
           const abs = resolve43(filePath);
-          if (!existsSync47(abs)) {
+          if (!existsSync48(abs)) {
             return { success: false, error: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
           }
           if (action === "read") {
@@ -9680,7 +10210,7 @@ NODE_ENV=development
 
 // src/tools/builtin/project/docker_manage.ts
 import { execSync as execSync17 } from "child_process";
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { resolve as resolve44 } from "path";
 var docker_manage;
 var init_docker_manage = __esm({
@@ -9716,7 +10246,7 @@ var init_docker_manage = __esm({
           switch (action) {
             case "build": {
               const dockerfile = resolve44(cwd, "Dockerfile");
-              if (!existsSync48(dockerfile)) {
+              if (!existsSync49(dockerfile)) {
                 return { success: false, error: `Dockerfile \u4E0D\u5B58\u5728: ${dockerfile}`, output: "" };
               }
               cmd = `docker build ${options} -t ${image || "app"} .`;
@@ -9811,10 +10341,10 @@ var init_context_summarize = __esm({
           const maxLength = params.max_length ?? 500;
           let content = "";
           if (filePath) {
-            const { readFileSync: readFileSync38, existsSync: existsSync53 } = await import("fs");
+            const { readFileSync: readFileSync38, existsSync: existsSync54 } = await import("fs");
             const { resolve: resolve48 } = await import("path");
             const abs = resolve48(filePath);
-            if (!existsSync53(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
+            if (!existsSync54(abs)) return { success: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
             content = readFileSync38(abs, "utf-8");
           } else if (text) {
             content = text;
@@ -9917,9 +10447,9 @@ ${list.join("\n")}`,
 });
 
 // src/tools/builtin/ai/skill_create.ts
-import { mkdirSync as mkdirSync12, existsSync as existsSync49 } from "fs";
+import { mkdirSync as mkdirSync13, existsSync as existsSync50 } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var skill_create;
 var init_skill_create = __esm({
   "src/tools/builtin/ai/skill_create.ts"() {
@@ -9947,8 +10477,8 @@ var init_skill_create = __esm({
           const description = params.description || `${name} \u6280\u80FD`;
           const prompt = params.prompt;
           const triggers = params.triggers || [];
-          const skillDir = join9(DEEPER_SKILLS_DIR, name);
-          if (!existsSync49(skillDir)) mkdirSync12(skillDir, { recursive: true });
+          const skillDir = join10(DEEPER_SKILLS_DIR, name);
+          if (!existsSync50(skillDir)) mkdirSync13(skillDir, { recursive: true });
           const yaml = [
             `name: ${name}`,
             `description: ${description}`,
@@ -9962,7 +10492,7 @@ ${yaml}
 ---
 
 ${prompt}`;
-          await writeFile4(join9(skillDir, "skill.md"), md, "utf-8");
+          await writeFile4(join10(skillDir, "skill.md"), md, "utf-8");
           return {
             success: true,
             output: `Skill "${name}" \u5DF2\u521B\u5EFA
@@ -10036,13 +10566,13 @@ var init_tool_create = __esm({
 });
 
 // src/tools/builtin/ai/memory_store.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync13, existsSync as existsSync50, mkdirSync as mkdirSync13 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync13, existsSync as existsSync51, mkdirSync as mkdirSync14 } from "fs";
+import { join as join11 } from "path";
 var MEMORY_DIR, memory_store;
 var init_memory_store = __esm({
   "src/tools/builtin/ai/memory_store.ts"() {
     "use strict";
-    MEMORY_DIR = join10(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".deepercode", "memories");
+    MEMORY_DIR = join11(process.env.HOME || process.env.USERPROFILE || process.cwd(), ".deepercode", "memories");
     memory_store = {
       name: "memory_store",
       description: "\u6301\u4E45\u5316\u8BB0\u5FC6\u5B58\u50A8",
@@ -10065,27 +10595,27 @@ var init_memory_store = __esm({
           const key = params.key;
           const value = params.value;
           const query = params.query;
-          if (!existsSync50(MEMORY_DIR)) {
-            mkdirSync13(MEMORY_DIR, { recursive: true });
+          if (!existsSync51(MEMORY_DIR)) {
+            mkdirSync14(MEMORY_DIR, { recursive: true });
           }
           switch (action) {
             case "set": {
               if (!key || value === void 0) return { success: false, error: "set \u9700\u8981 key \u548C value \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
+              const memPath = join11(MEMORY_DIR, `${key}.json`);
               writeFileSync13(memPath, JSON.stringify({ key, value, timestamp: Date.now() }), "utf-8");
               return { success: true, output: `\u8BB0\u5FC6\u5DF2\u4FDD\u5B58: ${key}` };
             }
             case "get": {
               if (!key) return { success: false, error: "get \u9700\u8981 key \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
-              if (!existsSync50(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
+              const memPath = join11(MEMORY_DIR, `${key}.json`);
+              if (!existsSync51(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, output: "" };
               const data = JSON.parse(readFileSync35(memPath, "utf-8"));
               return { success: true, output: data.value };
             }
             case "delete": {
               if (!key) return { success: false, error: "delete \u9700\u8981 key \u53C2\u6570", output: "" };
-              const memPath = join10(MEMORY_DIR, `${key}.json`);
-              if (!existsSync50(memPath)) return { success: false, error: `\u8BB0\u5FC6\u4E0D\u5B58\u5728: ${key}`, 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);
               return { success: true, output: `\u8BB0\u5FC6\u5DF2\u5220\u9664: ${key}` };
@@ -10106,7 +10636,7 @@ var init_memory_store = __esm({
               const files = readdirSync5(MEMORY_DIR).filter((f) => f.endsWith(".json"));
               const matches = [];
               for (const f of files) {
-                const data = JSON.parse(readFileSync35(join10(MEMORY_DIR, f), "utf-8"));
+                const data = JSON.parse(readFileSync35(join11(MEMORY_DIR, f), "utf-8"));
                 if (data.value.includes(query) || data.key.includes(query)) {
                   matches.push(`${data.key}: ${data.value.slice(0, 200)}`);
                 }
@@ -10403,7 +10933,7 @@ var init_notify_user = __esm({
 });
 
 // src/tools/builtin/system/log_viewer.ts
-import { readFileSync as readFileSync36, existsSync as existsSync51 } from "fs";
+import { readFileSync as readFileSync36, existsSync as existsSync52 } from "fs";
 import { resolve as resolve47 } from "path";
 var log_viewer;
 var init_log_viewer = __esm({
@@ -10434,7 +10964,7 @@ var init_log_viewer = __esm({
           if (action !== "clear" && !filePath) {
             const defaultLogs = ["npm-debug.log", "yarn-error.log", ".log", "logs/"];
             const cwd = process.cwd();
-            const found = defaultLogs.filter((f) => existsSync51(resolve47(cwd, f)));
+            const found = defaultLogs.filter((f) => existsSync52(resolve47(cwd, f)));
             return {
               success: true,
               output: `\u8BF7\u6307\u5B9A file_path\u3002\u9879\u76EE\u76EE\u5F55\u4E2D\u7684\u65E5\u5FD7\u6587\u4EF6:
@@ -10447,7 +10977,7 @@ ${found.length > 0 ? found.join("\n") : "  (\u672A\u627E\u5230)"}`
             writeFileSync15(abs, "", "utf-8");
             return { success: true, output: `\u65E5\u5FD7\u5DF2\u6E05\u7A7A: ${abs}` };
           }
-          if (!existsSync51(abs)) {
+          if (!existsSync52(abs)) {
             return { success: false, error: `\u65E5\u5FD7\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`, output: "" };
           }
           const content = readFileSync36(abs, "utf-8");
@@ -10729,8 +11259,8 @@ __export(chat_repl_exports, {
 });
 import readline from "readline";
 import process5 from "process";
-import { existsSync as existsSync52, mkdirSync as mkdirSync14, readFileSync as readFileSync37, writeFileSync as writeFileSync14, readdirSync as readdirSync4 } from "fs";
-import { join as join11 } from "path";
+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";
 function getSkillSystemPrompt() {
   if (!skillEngine) return "";
   return skillEngine.getSystemPrompt();
@@ -10843,7 +11373,7 @@ async function startRepl(opts) {
     }
   });
   const history = [];
-  if (!existsSync52(SESSION_DIR)) mkdirSync14(SESSION_DIR, { recursive: true });
+  if (!existsSync53(SESSION_DIR)) mkdirSync15(SESSION_DIR, { recursive: true });
   const sid = `sess_${Date.now()}`;
   setSessionId(sid);
   await xmemory.load();
@@ -10903,13 +11433,14 @@ ${prevSummary.slice(0, 800)}` });
   };
   drawHeader();
   let resizeTimer = null;
-  process5.stdout.on("resize", () => {
+  const onResize = () => {
     if (resizeTimer) return;
     resizeTimer = setTimeout(() => {
       resizeTimer = null;
       Oflush();
     }, 200);
-  });
+  };
+  process5.stdout.on("resize", onResize);
   let resolveLine = null;
   let running = true;
   const rl = readline.createInterface({ input: process5.stdin, output: process5.stdout, terminal: true });
@@ -10944,7 +11475,7 @@ ${prevSummary.slice(0, 800)}` });
     else showPrompt();
     return ok;
   };
-  rl.on("SIGINT", () => {
+  const onSigint = () => {
     if (resolveLine) {
       const cb = resolveLine;
       resolveLine = null;
@@ -10952,22 +11483,28 @@ ${prevSummary.slice(0, 800)}` });
       return;
     }
     Oflush();
+    process5.stdout.removeListener("resize", onResize);
+    process5.removeListener("uncaughtException", onUCE);
+    process5.removeListener("unhandledRejection", onUHR);
     xmemory.save().then(() => {
       O("\n" + y("\u518D\u89C1\uFF01") + "\n");
       running = false;
       rl.close();
       process5.exit(0);
     });
-  });
-  process5.on("uncaughtException", (err) => {
+  };
+  rl.on("SIGINT", onSigint);
+  const onUCE = (err) => {
     if (!err.message?.includes("readline")) O(r(`
   \u26A0 ${err.message}`) + "\n");
-  });
-  process5.on("unhandledRejection", (reason) => {
+  };
+  process5.on("uncaughtException", onUCE);
+  const onUHR = (reason) => {
     const m = reason instanceof Error ? reason.message : String(reason);
     if (!m.includes("readline") && !m.includes("Abort") && !m.includes("timeout")) O(r(`
   \u26A0 ${m}`) + "\n");
-  });
+  };
+  process5.on("unhandledRejection", onUHR);
   while (running) {
     currentPrompt = c("\u276F ");
     const tasks = getTodos();
@@ -11089,11 +11626,11 @@ ${prevSummary.slice(0, 800)}` });
         continue;
       }
       if (cmd === "/rules") {
-        const projectRules = join11(process5.cwd(), ".deeper", "rules.md");
-        const globalRules = join11(DEEPER_HOME, "rules.md");
+        const projectRules = join12(process5.cwd(), ".deeper", "rules.md");
+        const globalRules = join12(DEEPER_HOME, "rules.md");
         O(b(c("  Rules")) + "\n");
         const showRules = (label, path) => {
-          if (existsSync52(path)) {
+          if (existsSync53(path)) {
             const content = readFileSync37(path, "utf-8");
             O(G(`  ${label}: `) + c(path) + G(` (${content.split("\n").length}\u884C)`) + "\n");
             const lines = content.split("\n").slice(0, 8);
@@ -11169,6 +11706,9 @@ ${prevSummary.slice(0, 800)}` });
   }
   rl.close();
   Oflush();
+  process5.stdout.removeListener("resize", onResize);
+  process5.removeListener("uncaughtException", onUCE);
+  process5.removeListener("unhandledRejection", onUHR);
   await xmemory.save();
   if (mcpClient) mcpClient.disconnectAll();
   Oflush();
@@ -11508,35 +12048,17 @@ Rules:
   const skillPrompt = getSkillSystemPrompt();
   if (skillPrompt) sysContent += "\n" + skillPrompt;
   r2.push({ role: "system", content: sysContent });
-  try {
-    const deeperMd = join11(process5.cwd(), "deeper.md");
-    if (existsSync52(deeperMd)) {
-      const ctx = readFileSync37(deeperMd, "utf-8").slice(0, 4e3);
-      if (ctx.trim() && !ctx.includes("<!-- \u586B\u5199")) {
-        r2.push({ role: "system", content: `[\u9879\u76EE\u4E0A\u4E0B\u6587 deeper.md]
-${ctx}` });
-      }
-    }
-  } catch {
-  }
-  try {
-    const rulesFile = join11(process5.cwd(), ".deeper", "rules.md");
-    if (existsSync52(rulesFile)) {
-      const rules = readFileSync37(rulesFile, "utf-8").slice(0, 4e3);
-      if (rules.trim()) r2.push({ role: "system", content: `[\u9879\u76EE\u89C4\u5219 rules.md]
-${rules}` });
-    }
-  } catch {
-  }
-  try {
-    const globalRules = join11(DEEPER_HOME, "rules.md");
-    if (existsSync52(globalRules)) {
-      const rules = readFileSync37(globalRules, "utf-8").slice(0, 2e3);
-      if (rules.trim()) r2.push({ role: "system", content: `[\u5168\u5C40\u89C4\u5219]
-${rules}` });
-    }
-  } catch {
-  }
+  const deeperCtx = cachedRead(join12(process5.cwd(), "deeper.md"));
+  if (deeperCtx && deeperCtx.trim() && !deeperCtx.includes("<!-- \u586B\u5199")) {
+    r2.push({ role: "system", content: `[\u9879\u76EE\u4E0A\u4E0B\u6587 deeper.md]
+${deeperCtx}` });
+  }
+  const projRules = cachedRead(join12(process5.cwd(), ".deeper", "rules.md"));
+  if (projRules && projRules.trim()) r2.push({ role: "system", content: `[\u9879\u76EE\u89C4\u5219 rules.md]
+${projRules}` });
+  const globalRules = cachedRead(join12(DEEPER_HOME, "rules.md"), 2e3);
+  if (globalRules && globalRules.trim()) r2.push({ role: "system", content: `[\u5168\u5C40\u89C4\u5219]
+${globalRules}` });
   for (const m of history.slice(-30)) {
     const e = { role: m.role };
     if (m.content != null) e.content = (m.content || "").slice(0, 8e3);
@@ -11554,6 +12076,19 @@ ${rules}` });
 function trimHistory(h, max) {
   while (h.length > max) h.shift();
 }
+function cachedRead(path, maxLen = 4e3) {
+  if (!existsSync53(path)) return null;
+  try {
+    const st = statSync12(path);
+    const cached = _fileCache.get(path);
+    if (cached && cached.mtime === st.mtimeMs) return cached.content;
+    const content = readFileSync37(path, "utf-8").slice(0, maxLen);
+    _fileCache.set(path, { mtime: st.mtimeMs, content });
+    return content;
+  } catch {
+    return null;
+  }
+}
 function compressHistory(h) {
   if (h.length <= 6) return;
   const keep = 6;
@@ -11589,12 +12124,12 @@ function toolsToDefs(tools) {
 }
 async function saveSession(history, name) {
   const label = name || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const file = join11(SESSION_DIR, `sess_${label}.json`);
+  const file = join12(SESSION_DIR, `sess_${label}.json`);
   writeFileSync14(file, JSON.stringify({ savedAt: (/* @__PURE__ */ new Date()).toISOString(), cwd: process5.cwd(), messages: history }, null, 2), "utf-8");
   O(g(`\u5DF2\u4FDD\u5B58: sess_${label}`) + "\n\n");
 }
 async function listSessions() {
-  if (!existsSync52(SESSION_DIR)) {
+  if (!existsSync53(SESSION_DIR)) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
@@ -11607,7 +12142,7 @@ async function listSessions() {
   for (let i = 0; i < Math.min(files.length, 15); i++) {
     const f = files[i];
     try {
-      const data = JSON.parse(readFileSync37(join11(SESSION_DIR, f), "utf-8"));
+      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 || "?";
@@ -11621,8 +12156,8 @@ async function listSessions() {
   O("\n  \u52A0\u8F7D: /load <name> | \u6062\u590D: /resume\n\n");
 }
 async function loadNamedSession(history, name) {
-  const file = join11(SESSION_DIR, `sess_${name}.json`);
-  if (!existsSync52(file)) {
+  const file = join12(SESSION_DIR, `sess_${name}.json`);
+  if (!existsSync53(file)) {
     O(r(`\u4F1A\u8BDD\u4E0D\u5B58\u5728: ${name}
 
 `));
@@ -11635,7 +12170,7 @@ async function loadNamedSession(history, name) {
   O(g(`\u5DF2\u52A0\u8F7D: ${name}`) + "\n\n");
 }
 async function loadLatestSession(history) {
-  if (!existsSync52(SESSION_DIR)) {
+  if (!existsSync53(SESSION_DIR)) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
@@ -11644,7 +12179,7 @@ async function loadLatestSession(history) {
     O(r("\u65E0\u4FDD\u5B58\u7684\u4F1A\u8BDD\n\n"));
     return;
   }
-  const file = join11(SESSION_DIR, files[0]);
+  const file = join12(SESSION_DIR, files[0]);
   const data = JSON.parse(readFileSync37(file, "utf-8"));
   const label = files[0].replace(/^sess_|\.json$/g, "");
   history.push({ role: "system", content: `[\u5DF2\u52A0\u8F7D: ${label} (${data.messages?.length || 0} \u6761)]` });
@@ -11653,13 +12188,13 @@ async function loadLatestSession(history) {
   O(g(`\u5DF2\u52A0\u8F7D: ${label}`) + "\n\n");
 }
 async function exportHistory(history) {
-  const file = join11(process5.cwd(), `deeper-export-${Date.now()}.json`);
+  const file = join12(process5.cwd(), `deeper-export-${Date.now()}.json`);
   writeFileSync14(file, JSON.stringify(history, null, 2), "utf-8");
   O(g(`\u5DF2\u5BFC\u51FA: ${file}`) + "\n\n");
 }
 async function initProject() {
-  const file = join11(process5.cwd(), "deeper.md");
-  if (existsSync52(file)) {
+  const file = join12(process5.cwd(), "deeper.md");
+  if (existsSync53(file)) {
     O(y("  deeper.md \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\n\n"));
     return;
   }
@@ -11786,98 +12321,68 @@ async function loadBuiltinTools() {
   return builtinTools2;
 }
 async function callApi(opts, msgs, tools, retry = 0, cmt = 8192) {
-  const MR = 2, TO = 9e4;
-  const ac = new AbortController();
-  const t = setTimeout(() => ac.abort(), TO);
+  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 }
+  });
+  const chatMsgs = msgs.map((m) => ({
+    role: m.role || "user",
+    content: m.content != null ? String(m.content) : null,
+    tool_calls: m.tool_calls,
+    tool_call_id: m.tool_call_id,
+    name: m.name,
+    reasoning_content: m.reasoning_content,
+    thinking: m.thinking
+  }));
   try {
-    const resp = await fetch(`${opts.baseUrl}/v1/chat/completions`, {
-      method: "POST",
-      signal: ac.signal,
-      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${opts.apiKey}` },
-      body: JSON.stringify({
-        model: opts.model,
-        messages: msgs,
-        tools: tools.length > 0 ? tools : void 0,
-        tool_choice: tools.length > 0 ? "auto" : void 0,
-        stream: true,
-        max_tokens: cmt,
-        temperature: opts.temperature
-      })
-    });
-    if (!resp.ok) {
-      const et = await resp.text().catch(() => "");
-      if (resp.status === 401) throw new Error('API Key \u65E0\u6548: deeper config set api_key "sk-xxx"');
-      if ((resp.status === 429 || resp.status >= 500) && retry < MR) {
-        const d2 = Math.min(1e3 * (retry + 1), 5e3);
-        await new Promise((r2) => setTimeout(r2, d2));
-        return callApi(opts, msgs, tools, retry + 1, cmt);
-      }
-      throw new Error(`HTTP ${resp.status}: ${et.slice(0, 200)}`);
-    }
-    if (!resp.body) throw new Error("\u7A7A\u54CD\u5E94");
-    return sseIter(resp.body);
+    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")) && retry < MR) {
+    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;
-  } finally {
-    clearTimeout(t);
   }
 }
-async function* sseIter(body) {
-  const reader = body.getReader();
-  const dec = new TextDecoder();
-  let buf = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += dec.decode(value, { stream: true });
-      if (buf.length > 65536) buf = buf.slice(-32768);
-      const lines = buf.split("\n");
-      buf = lines.pop() || "";
-      for (const line of lines) {
-        const tr = line.trim();
-        if (!tr || tr.startsWith(":")) continue;
-        if (!tr.startsWith("data: ")) continue;
-        const d2 = tr.slice(6).trim();
-        if (d2 === "[DONE]") {
-          yield { type: "done" };
-          return;
-        }
-        try {
-          const p = JSON.parse(d2);
-          const ch = p.choices?.[0];
-          if (!ch) continue;
-          const dl = ch.delta;
-          if (dl?.content) yield { type: "text", content: dl.content };
-          if (dl?.reasoning_content) yield { type: "thinking", content: dl.reasoning_content };
-          if (dl?.tool_calls) for (const tc of dl.tool_calls) {
-            if (tc.id) yield { type: "tool_call_start", tool_call: { id: tc.id, name: tc.function?.name || "" } };
-            if (tc.function?.arguments) yield { type: "tool_call_args", content: tc.function.arguments };
-            if (tc.id && tc.function?.arguments) yield { type: "tool_call_end" };
-          }
-          if (ch.finish_reason === "tool_calls") yield { type: "tool_call_end" };
-        } catch {
+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 };
         }
       }
-    }
-  } catch (e) {
-    if (e instanceof Error && e.name === "AbortError") {
-    } else yield { type: "error", error: e instanceof Error ? e.message : String(e) };
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
+    } else if (chunk.type === "done") {
+      if (hasPending) yield { type: "tool_call_end" };
+      yield { type: "done" };
+      return;
+    } else {
+      yield chunk;
     }
   }
   yield { type: "done" };
 }
-var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, GS, skillEngine, mcpClient, validator;
+var MAX_HISTORY, CONTEXT_LIMIT, CTX_WARN, TOOL_RESULT_MAX, SESSION_DIR, AUTOSAVE_FILE, GS, skillEngine, mcpClient, validator, _fileCache;
 var init_chat_repl = __esm({
   "src/cli/chat-repl.ts"() {
     "use strict";
@@ -11890,17 +12395,19 @@ var init_chat_repl = __esm({
     init_token_count();
     init_SkillEngine();
     init_MCPClient();
+    init_DeepSeekClient();
     init_ansi();
     MAX_HISTORY = 60;
     CONTEXT_LIMIT = 1048576;
     CTX_WARN = 786432;
     TOOL_RESULT_MAX = 4e3;
-    SESSION_DIR = join11(DEEPER_HOME, "sessions");
-    AUTOSAVE_FILE = join11(SESSION_DIR, "_autosave.json");
+    SESSION_DIR = join12(DEEPER_HOME, "sessions");
+    AUTOSAVE_FILE = join12(SESSION_DIR, "_autosave.json");
     GS = { tc: 0, api: 0, ch: 0 };
     skillEngine = null;
     mcpClient = null;
     validator = new ToolValidator();
+    _fileCache = /* @__PURE__ */ new Map();
   }
 });