jinzd-ai-cli 0.3.6 → 0.4.0

package/dist/chunk-MXMU4PSC.js

@@ -0,0 +1,2531 @@
+#!/usr/bin/env node
+import {
+  CONFIG_DIR_NAME,
+  MEMORY_FILE_NAME,
+  SUBAGENT_ALLOWED_TOOLS,
+  SUBAGENT_DEFAULT_MAX_ROUNDS,
+  SUBAGENT_MAX_ROUNDS_LIMIT,
+  runTestsTool
+} from "./chunk-SX52VL4D.js";
+
+// src/tools/builtin/bash.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { platform } from "os";
+import { resolve } from "path";
+
+// src/tools/undo-stack.ts
+import { readFileSync, writeFileSync, unlinkSync, rmdirSync, existsSync } from "fs";
+var MAX_UNDO_DEPTH = 20;
+var UndoStack = class {
+  stack = [];
+  /**
+   * 在执行文件写入操作之前调用，保存当前状态。
+   * @param filePath 将要被写入的文件路径
+   * @param description 操作描述，如 "write_file: src/index.ts"
+   */
+  push(filePath, description) {
+    let previousContent = null;
+    if (existsSync(filePath)) {
+      try {
+        previousContent = readFileSync(filePath, "utf-8");
+      } catch {
+        return;
+      }
+    }
+    this.pushEntry({
+      filePath,
+      previousContent,
+      description,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * 推入一个新建文件的条目（previousContent=null），undo 时删除该文件。
+   * 用于 bash 工具执行后检测到的新建文件。
+   */
+  pushNewFile(filePath, description) {
+    this.pushEntry({
+      filePath,
+      previousContent: null,
+      description,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * 推入一个新建目录的条目（previousContent=null, isDirectory=true），
+   * undo 时尝试 rmdir（仅空目录可删）。
+   */
+  pushNewDir(dirPath, description) {
+    this.pushEntry({
+      filePath: dirPath,
+      previousContent: null,
+      description,
+      timestamp: /* @__PURE__ */ new Date(),
+      isDirectory: true
+    });
+  }
+  /** 内部统一入栈方法，含溢出裁剪 */
+  pushEntry(entry) {
+    this.stack.push(entry);
+    if (this.stack.length > MAX_UNDO_DEPTH) {
+      this.stack.shift();
+    }
+  }
+  /**
+   * 弹出并执行最近一次撤销操作。
+   * @returns 撤销结果描述，或 null（栈为空时）
+   */
+  undo() {
+    const entry = this.stack.pop();
+    if (!entry) return null;
+    try {
+      if (entry.previousContent === null) {
+        if (entry.isDirectory) {
+          if (existsSync(entry.filePath)) {
+            try {
+              rmdirSync(entry.filePath);
+              return { entry, result: `Removed newly created directory: ${entry.filePath}` };
+            } catch {
+              return { entry, result: `Cannot remove directory (not empty): ${entry.filePath}` };
+            }
+          }
+          return { entry, result: `Directory already removed: ${entry.filePath}` };
+        } else {
+          if (existsSync(entry.filePath)) {
+            unlinkSync(entry.filePath);
+          }
+          return { entry, result: `Deleted newly created file: ${entry.filePath}` };
+        }
+      } else {
+        writeFileSync(entry.filePath, entry.previousContent, "utf-8");
+        const lines = entry.previousContent.split("\n").length;
+        return {
+          entry,
+          result: `Restored ${entry.filePath} to previous state (${lines} lines)`
+        };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { entry, result: `Undo failed: ${msg}` };
+    }
+  }
+  /** 查看栈顶条目（不弹出），用于 /undo 显示预览 */
+  peek() {
+    return this.stack[this.stack.length - 1] ?? null;
+  }
+  /** 当前栈深度 */
+  get depth() {
+    return this.stack.length;
+  }
+  /** 返回栈的拷贝（所有文件修改记录），供 /diff 命令使用 */
+  getHistory() {
+    return [...this.stack];
+  }
+  /** 清空撤销栈（新会话时调用） */
+  clear() {
+    this.stack = [];
+  }
+};
+var undoStack = new UndoStack();
+
+// src/tools/builtin/bash.ts
+var IS_WINDOWS = platform() === "win32";
+var SHELL = IS_WINDOWS ? "powershell.exe" : process.env["SHELL"] ?? "/bin/bash";
+var persistentCwd = process.cwd();
+var bashTool = {
+  definition: {
+    name: "bash",
+    description: IS_WINDOWS ? `Execute commands in PowerShell. Supports mkdir, ls, cat, python, etc.
+Important rules:
+1. Each bash call runs in an independent subprocess; cd commands do not persist. To run in a specific directory, use the cwd parameter, or combine commands: e.g. "cd mydir; ls" or "mkdir mydir; cd mydir; New-Item file.txt".
+2. If a command fails (returns an error or non-zero exit code), stop immediately, report the error to the user, and do not retry the same or similar commands.
+3. Multiple commands can be combined with semicolons in a single call to reduce rounds.
+4. To delete directories, use Remove-Item -Recurse (the system will automatically optimize to a more reliable method).
+5. IMPORTANT: On Windows, "curl" is an alias for Invoke-WebRequest and does NOT support curl flags like -s, -X, -H. Use Invoke-RestMethod instead for HTTP requests. Example: Invoke-RestMethod -Uri "http://localhost:3000/api/health" -Method Get
+6. For long-running server commands (node server.js, npm run dev, etc.), use Start-Process -NoNewWindow to run in background, otherwise the tool will block until timeout.` : `Execute commands in ${SHELL}.
+Important rules:
+1. Each bash call runs in an independent subprocess; cd commands do not persist. To run in a specific directory, use the cwd parameter, or combine commands: e.g. "cd mydir && ls" or "mkdir -p mydir && touch mydir/file.txt".
+2. If a command fails (returns an error or non-zero exit code), stop immediately, report the error to the user, and do not retry the same or similar commands.
+3. Multiple commands can be combined with && in a single call to reduce rounds.
+4. For long-running server commands (node server.js, npm start, npm run dev, etc.), run in background with & or nohup, otherwise the tool will block until timeout.`,
+    parameters: {
+      command: {
+        type: "string",
+        description: IS_WINDOWS ? `PowerShell command to execute. Combine multiple commands with semicolons, e.g.: "mkdir mydir; Set-Content mydir/file.txt 'content'"` : `${SHELL} command to execute. Combine multiple commands with &&, e.g.: "mkdir -p mydir && echo 'content' > mydir/file.txt"`,
+        required: true
+      },
+      cwd: {
+        type: "string",
+        description: "Working directory for the command (absolute or relative path). Once set, subsequent commands will also use this directory.",
+        required: false
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds, defaults to 30000",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const command = String(args["command"] ?? "");
+    const MAX_TIMEOUT = 3e5;
+    const timeout = Math.min(Math.max(Number(args["timeout"] ?? 3e4), 1e3), MAX_TIMEOUT);
+    const cwdArg = args["cwd"] ? String(args["cwd"]) : void 0;
+    if (!command.trim()) {
+      throw new Error("command is required");
+    }
+    if (!existsSync2(persistentCwd)) {
+      const fallback = process.cwd();
+      process.stderr.write(
+        `[bash] Previous cwd "${persistentCwd}" no longer exists, reset to "${fallback}"
+`
+      );
+      persistentCwd = fallback;
+    }
+    let effectiveCwd = persistentCwd;
+    if (cwdArg) {
+      const resolved = resolve(persistentCwd, cwdArg);
+      if (!existsSync2(resolved)) {
+        throw new Error(
+          `cwd directory does not exist: "${resolved}". Create it first (e.g. mkdir -p "${resolved}") before specifying it as cwd.`
+        );
+      }
+      effectiveCwd = resolved;
+      persistentCwd = resolved;
+    }
+    let actualCommand;
+    if (IS_WINDOWS) {
+      const fixedCommand = fixWindowsDeleteCommand(command);
+      actualCommand = `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; $OutputEncoding = [System.Text.Encoding]::UTF8; ${fixedCommand}`;
+    } else {
+      actualCommand = command;
+    }
+    const beforeSnapshot = snapshotDir(effectiveCwd);
+    const parsedTargets = parseCreationTargets(command, effectiveCwd);
+    const parsedTargetsBefore = /* @__PURE__ */ new Map();
+    for (const t of parsedTargets) {
+      parsedTargetsBefore.set(t, existsSync2(t));
+    }
+    try {
+      const output = execSync(actualCommand, {
+        timeout,
+        encoding: IS_WINDOWS ? "buffer" : "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: effectiveCwd,
+        shell: SHELL,
+        env: {
+          ...process.env,
+          PYTHONUTF8: "1",
+          PYTHONIOENCODING: "utf-8"
+        }
+      });
+      updateCwdFromCommand(command, effectiveCwd);
+      pushBashUndoEntries(beforeSnapshot, parsedTargetsBefore, effectiveCwd);
+      const result = IS_WINDOWS && Buffer.isBuffer(output) ? output.toString("utf-8") : output;
+      return result || "(command completed with no output)";
+    } catch (err) {
+      pushBashUndoEntries(beforeSnapshot, parsedTargetsBefore, effectiveCwd);
+      if (err && typeof err === "object" && "status" in err) {
+        const execErr = err;
+        const stderr = IS_WINDOWS && Buffer.isBuffer(execErr.stderr) ? execErr.stderr.toString("utf-8").trim() : execErr.stderr?.toString().trim() ?? "";
+        const stdout = IS_WINDOWS && Buffer.isBuffer(execErr.stdout) ? execErr.stdout.toString("utf-8").trim() : execErr.stdout?.toString().trim() ?? "";
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        throw new Error(
+          `Exit code ${execErr.status}:
+${combined || (execErr.message ?? "Unknown error")}
+
+[Command failed. Report this error to the user. Do not retry with variant commands.]`
+        );
+      }
+      throw err;
+    }
+  }
+};
+function fixWindowsDeleteCommand(command) {
+  return command.replace(
+    /Remove-Item\b([^;\n]*)/gi,
+    (match, args) => {
+      if (!/recurse/i.test(args)) return match;
+      let pathValue = "";
+      const pathMatch = args.match(/-Path\s+(['"]?)([^'";\s]+)\1/i) ?? args.match(/(?:^|\s)(['"]?)([^'";\s-][^'";\s]*)\1/);
+      if (pathMatch) {
+        pathValue = pathMatch[2] ?? "";
+      }
+      if (!pathValue) return match;
+      const safePath = pathValue.replace(/"/g, '\\"');
+      return `cmd /c rmdir /s /q "${safePath}"`;
+    }
+  );
+}
+function snapshotDir(dir) {
+  try {
+    return new Set(readdirSync(dir).map((name) => resolve(dir, name)));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function parseCreationTargets(command, cwd) {
+  const targets = [];
+  for (const m of command.matchAll(/(?:echo|cat|printf)\s+[^>]*>\s*(['"]?)([^\s;&|'"]+)\1/g)) {
+    if (m[2]) targets.push(resolve(cwd, m[2]));
+  }
+  for (const m of command.matchAll(/\btouch\s+((?:['"]?[^\s;&|'"]+['"]?\s*)+)/g)) {
+    for (const f of m[1].trim().split(/\s+/)) {
+      const clean = f.replace(/^['"]|['"]$/g, "");
+      if (clean && !clean.startsWith("-")) targets.push(resolve(cwd, clean));
+    }
+  }
+  for (const m of command.matchAll(/\bmkdir\s+(?:-\w+\s+)*((?:['"]?[^\s;&|'"]+['"]?\s*)+)/g)) {
+    for (const d of m[1].trim().split(/\s+/)) {
+      const clean = d.replace(/^['"]|['"]$/g, "");
+      if (clean && !clean.startsWith("-")) targets.push(resolve(cwd, clean));
+    }
+  }
+  for (const m of command.matchAll(/\bcp\s+(?:-\w+\s+)*['"]?[^\s;&|'"]+['"]?\s+(['"]?)([^\s;&|'"]+)\1/g)) {
+    if (m[2]) targets.push(resolve(cwd, m[2]));
+  }
+  for (const m of command.matchAll(/\bNew-Item\s+(?:-(?:Path|ItemType)\s+\w+\s+)*['"]?([^\s;&|'"]+)['"]?/gi)) {
+    if (m[1] && !m[1].startsWith("-")) targets.push(resolve(cwd, m[1]));
+  }
+  return [...new Set(targets)];
+}
+function pushBashUndoEntries(beforeSnapshot, parsedTargetsBefore, cwd) {
+  const tracked = /* @__PURE__ */ new Set();
+  const afterSnapshot = snapshotDir(cwd);
+  for (const absPath of afterSnapshot) {
+    if (!beforeSnapshot.has(absPath)) {
+      try {
+        const st = statSync(absPath);
+        if (st.isDirectory()) {
+          undoStack.pushNewDir(absPath, `bash (new dir): ${absPath}`);
+        } else {
+          undoStack.pushNewFile(absPath, `bash (new file): ${absPath}`);
+        }
+        tracked.add(absPath);
+      } catch {
+      }
+    }
+  }
+  for (const [target, existedBefore] of parsedTargetsBefore) {
+    if (!existedBefore && !tracked.has(target) && existsSync2(target)) {
+      try {
+        const st = statSync(target);
+        if (st.isDirectory()) {
+          undoStack.pushNewDir(target, `bash (new dir): ${target}`);
+        } else {
+          undoStack.pushNewFile(target, `bash (new file): ${target}`);
+        }
+      } catch {
+      }
+    }
+  }
+}
+function updateCwdFromCommand(command, baseCwd) {
+  const cdMatches = [...command.matchAll(/(?:^|[;&|])\s*cd\s+(['"]?)([^\s;&|'"]+)\1/g)];
+  if (cdMatches.length === 0) return;
+  const lastMatch = cdMatches[cdMatches.length - 1];
+  const target = lastMatch?.[2];
+  if (!target || target.startsWith("$") || target === "~") return;
+  try {
+    const newDir = resolve(baseCwd, target);
+    if (existsSync2(newDir)) {
+      persistentCwd = newDir;
+    }
+  } catch {
+  }
+}
+
+// src/tools/builtin/read-file.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2, readdirSync as readdirSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { extname, resolve as resolve2, basename, sep, dirname } from "path";
+import { homedir } from "os";
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+function getSensitiveWarning(normalizedPath) {
+  const home = homedir();
+  const p = normalizedPath.toLowerCase();
+  const base = basename(normalizedPath).toLowerCase();
+  if (normalizedPath.startsWith(home) && p.includes(".aicli") && base === "config.json") {
+    return "[\u26A0 Security Warning: This file contains API keys. Be careful not to share this content.]\n\n";
+  }
+  if (base === ".env" || base.startsWith(".env.") || base.endsWith(".env")) {
+    return "[\u26A0 Security Warning: .env files may contain secrets and credentials.]\n\n";
+  }
+  if (normalizedPath.includes(`${sep}.ssh${sep}`) && (base.startsWith("id_") || base === "identity")) {
+    return "[\u26A0 Security Warning: This may be an SSH private key.]\n\n";
+  }
+  if (base === "credentials" && p.includes(".aws")) {
+    return "[\u26A0 Security Warning: This file contains AWS credentials.]\n\n";
+  }
+  return "";
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".7z",
+  ".rar",
+  ".bz2",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".tiff",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".wav",
+  ".flac",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".dat",
+  ".wasm",
+  ".class",
+  ".pyc"
+]);
+function isBinaryBuffer(buf) {
+  const sample = buf.subarray(0, 512);
+  let nullCount = 0;
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) nullCount++;
+  }
+  return nullCount / sample.length > 0.1;
+}
+function findSimilarFiles(filePath) {
+  const targetName = basename(filePath).toLowerCase();
+  if (!targetName) return [];
+  const cwd = process.cwd();
+  const candidates = [];
+  try {
+    for (const entry of readdirSync2(cwd, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.toLowerCase() === targetName) {
+        candidates.push(entry.name);
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        try {
+          const subDir = resolve2(cwd, entry.name);
+          for (const sub of readdirSync2(subDir, { withFileTypes: true })) {
+            if (sub.isFile() && sub.name.toLowerCase() === targetName) {
+              candidates.push(`${entry.name}/${sub.name}`);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return candidates.slice(0, 5);
+}
+function tryExtractPdfText(absPath) {
+  try {
+    const output = execSync2(`pdftotext "${absPath}" -`, {
+      timeout: 15e3,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (output.trim().length > 0) return output;
+  } catch {
+  }
+  try {
+    const pyScript = `import sys; exec("try:\\n from pdfminer.high_level import extract_text\\n print(extract_text(sys.argv[1]))\\nexcept: pass")`;
+    const output = execSync2(`python -c "${pyScript}" "${absPath}"`, {
+      timeout: 15e3,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, PYTHONUTF8: "1", PYTHONIOENCODING: "utf-8" }
+    });
+    if (output.trim().length > 0) return output;
+  } catch {
+  }
+  return null;
+}
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "Read text file contents. Automatically detects binary files (PDF/images/etc) and returns a hint instead of garbled output.",
+    parameters: {
+      path: {
+        type: "string",
+        description: "File path (absolute or relative to current working directory)",
+        required: true
+      },
+      encoding: {
+        type: "string",
+        description: "Encoding format, defaults to utf-8",
+        enum: ["utf-8", "utf8", "ascii", "base64"],
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    if (!filePath) throw new Error("path is required");
+    const normalizedPath = resolve2(filePath);
+    if (!existsSync3(normalizedPath)) {
+      const suggestions = findSimilarFiles(filePath);
+      if (suggestions.length > 0) {
+        throw new Error(
+          `File not found: ${filePath}
+Current working directory: ${process.cwd()}
+Found similar files, did you mean:
+` + suggestions.map((s) => `  \u2192 ${s}`).join("\n") + `
+Please retry with the correct relative path.`
+        );
+      }
+      throw new Error(
+        `File not found: ${filePath}
+Current working directory: ${process.cwd()}
+Please use list_dir to verify the file path and retry.`
+      );
+    }
+    const { size } = statSync2(normalizedPath);
+    if (size > MAX_FILE_BYTES) {
+      const mb = (size / 1024 / 1024).toFixed(1);
+      return `[File too large: ${filePath} (${mb} MB)]
+Exceeds single read limit of ${MAX_FILE_BYTES / 1024 / 1024} MB.
+Use the bash tool to read in segments, e.g.:
+  head -n 100 "${normalizedPath}"   # first 100 lines
+  tail -n 100 "${normalizedPath}"   # last 100 lines
+  sed -n '200,300p' "${normalizedPath}"  # lines 200-300`;
+    }
+    const sensitiveWarning = getSensitiveWarning(normalizedPath);
+    const ext = extname(normalizedPath).toLowerCase();
+    if (ext === ".pdf") {
+      const pdfText = tryExtractPdfText(normalizedPath);
+      if (pdfText) {
+        const lines2 = pdfText.split("\n").length;
+        return `[PDF extracted: ${filePath} | ${lines2} lines]
+
+${pdfText}`;
+      }
+      const dir = dirname(normalizedPath);
+      const nameNoExt = basename(normalizedPath, ext);
+      const textAlts = [".md", ".txt", ".html"].map((e) => resolve2(dir, nameNoExt + e)).filter(existsSync3);
+      if (textAlts.length > 0) {
+        return `[PDF file: ${filePath}]
+Cannot extract text from this PDF, but found alternative text versions:
+` + textAlts.map((p) => `  \u2192 ${basename(p)}`).join("\n") + `
+Please use read_file to read the above files.`;
+      }
+      return `[PDF file: ${filePath}]
+Cannot extract text from this PDF (requires pdftotext or pdfminer.six).
+Suggestion: read existing text versions (.md / .txt) in the project, or install extraction tools via bash and retry.`;
+    }
+    if (BINARY_EXTENSIONS.has(ext)) {
+      return `[Binary file: ${filePath} (${ext})]
+This is a binary file and cannot be read as text. If there is a text version (.md / .txt) in the project, please read that instead.`;
+    }
+    const buf = readFileSync2(normalizedPath);
+    if (encoding === "base64") {
+      return `[File: ${filePath} | base64]
+
+${buf.toString("base64")}`;
+    }
+    if (isBinaryBuffer(buf)) {
+      return `[Binary file: ${filePath}]
+This file contains binary data and cannot be read as text.
+If needed, use the bash tool to run an appropriate conversion program.`;
+    }
+    const content = buf.toString(encoding);
+    const lines = content.split("\n").length;
+    return `${sensitiveWarning}[File: ${filePath} | ${lines} lines]
+
+${content}`;
+  }
+};
+
+// src/tools/builtin/write-file.ts
+import { writeFileSync as writeFileSync2, appendFileSync, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+var writeFileTool = {
+  definition: {
+    name: "write_file",
+    description: `Write content to a file. Creates the file if it doesn't exist, overwrites (append=false) or appends (append=true). Automatically creates parent directories.
+Important: For long content (over 500 lines or 3000 chars), you MUST split into multiple calls using append=true, each no more than 300 lines, to avoid truncation. First call uses append=false (overwrite), subsequent calls use append=true.`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "File path",
+        required: true
+      },
+      content: {
+        type: "string",
+        description: "Content to write",
+        required: true
+      },
+      append: {
+        type: "string",
+        description: "Whether to append. true=append to end, false=overwrite (default). Long files must be written in segments with append.",
+        required: false
+      },
+      encoding: {
+        type: "string",
+        description: "Encoding format, defaults to utf-8",
+        required: false
+      }
+    },
+    dangerous: false
+    // executor 会将 write_file 标记为 'write' 级别
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const content = String(args["content"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    const appendMode = String(args["append"] ?? "false").toLowerCase() === "true";
+    if (!filePath) throw new Error("path is required");
+    undoStack.push(filePath, `write_file${appendMode ? " (append)" : ""}: ${filePath}`);
+    mkdirSync(dirname2(filePath), { recursive: true });
+    if (appendMode) {
+      appendFileSync(filePath, content, encoding);
+    } else {
+      writeFileSync2(filePath, content, encoding);
+    }
+    const lines = content.split("\n").length;
+    const mode = appendMode ? "appended" : "written";
+    return `File ${mode}: ${filePath} (${lines} lines, ${content.length} bytes)`;
+  }
+};
+
+// src/tools/builtin/edit-file.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
+function similarityScore(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+  const getBigrams = (s) => {
+    const bigrams = /* @__PURE__ */ new Map();
+    for (let i = 0; i < s.length - 1; i++) {
+      const bigram = s.slice(i, i + 2);
+      bigrams.set(bigram, (bigrams.get(bigram) ?? 0) + 1);
+    }
+    return bigrams;
+  };
+  const aBigrams = getBigrams(a.toLowerCase());
+  const bBigrams = getBigrams(b.toLowerCase());
+  let intersection = 0;
+  for (const [bigram, count] of aBigrams) {
+    intersection += Math.min(count, bBigrams.get(bigram) ?? 0);
+  }
+  return 2 * intersection / (a.length - 1 + b.length - 1);
+}
+function findSimilarLines(fileContent, searchStr, maxResults = 3) {
+  if (fileContent.length > 5e5) return [];
+  const fileLines = fileContent.split("\n");
+  const searchLines = searchStr.split("\n");
+  const firstSearchLine = searchLines[0].trim();
+  if (!firstSearchLine || firstSearchLine.length < 3) return [];
+  const candidates = [];
+  for (let i = 0; i < fileLines.length; i++) {
+    const trimmed = fileLines[i].trim();
+    if (!trimmed || trimmed.length < 3) continue;
+    const score = similarityScore(trimmed, firstSearchLine);
+    if (score > 0.4) {
+      candidates.push({ line: i + 1, text: fileLines[i], score });
+    }
+  }
+  return candidates.sort((a, b) => b.score - a.score).slice(0, maxResults).map((c) => `  Line ${c.line}: ${c.text.slice(0, 120)}`);
+}
+function findWhitespaceTolerant(fileLines, searchLines) {
+  const trimmedSearch = searchLines.map((l) => l.trim());
+  let matchStart = -1;
+  let matchCount = 0;
+  for (let i = 0; i <= fileLines.length - trimmedSearch.length; i++) {
+    let allMatch = true;
+    for (let j = 0; j < trimmedSearch.length; j++) {
+      if (fileLines[i + j].trim() !== trimmedSearch[j]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      matchCount++;
+      if (matchStart === -1) matchStart = i;
+      if (matchCount > 1) break;
+    }
+  }
+  return { matchStart, matchCount };
+}
+var editFileTool = {
+  definition: {
+    name: "edit_file",
+    description: `Precisely edit file contents. Supports three modes:
+1. String replace (most common): Provide old_str and new_str to replace an exact match. old_str must appear exactly once in the file (unless replace_all is true).
+2. Line insert: Provide insert_after_line (1-based line number) and insert_content to insert after that line.
+3. Line delete: Provide delete_from_line and delete_to_line (inclusive) to delete that range.
+Optional ignore_whitespace: true to match ignoring indentation differences.
+Optional replace_all: true to replace ALL occurrences of old_str in the file at once (saves tool rounds when renaming variables/functions).
+Note: Path can be absolute or relative to the current working directory.`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "File path to edit",
+        required: true
+      },
+      old_str: {
+        type: "string",
+        description: "[Replace mode] Original string to replace, must appear exactly once (include enough context for uniqueness)",
+        required: false
+      },
+      new_str: {
+        type: "string",
+        description: "[Replace mode] New replacement string, can be empty to delete old_str",
+        required: false
+      },
+      ignore_whitespace: {
+        type: "boolean",
+        description: "[Replace mode] Whether to ignore leading/trailing whitespace per line when matching, defaults to false",
+        required: false
+      },
+      replace_all: {
+        type: "boolean",
+        description: "[Replace mode] Replace ALL occurrences of old_str instead of requiring unique match. Useful for renaming variables/functions across the file in one call.",
+        required: false
+      },
+      insert_after_line: {
+        type: "number",
+        description: "[Insert mode] Insert after this line number (1-based), 0 means insert at the beginning",
+        required: false
+      },
+      insert_content: {
+        type: "string",
+        description: "[Insert mode] Content to insert (no need to add newlines manually)",
+        required: false
+      },
+      delete_from_line: {
+        type: "number",
+        description: "[Delete mode] Start deleting from this line (1-based)",
+        required: false
+      },
+      delete_to_line: {
+        type: "number",
+        description: "[Delete mode] Delete up to and including this line (1-based)",
+        required: false
+      },
+      encoding: {
+        type: "string",
+        description: "File encoding, defaults to utf-8",
+        required: false
+      }
+    },
+    dangerous: false
+    // executor 中 edit_file 按 write 级别处理
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    if (!filePath) throw new Error("path is required");
+    if (!existsSync4(filePath)) throw new Error(`File not found: ${filePath}`);
+    const original = readFileSync3(filePath, encoding);
+    if (args["old_str"] !== void 0) {
+      const oldStr = String(args["old_str"]);
+      const newStr = String(args["new_str"] ?? "");
+      const ignoreWs = Boolean(args["ignore_whitespace"]);
+      const replaceAll = Boolean(args["replace_all"]);
+      if (oldStr === "") throw new Error("old_str cannot be empty");
+      if (ignoreWs) {
+        const fileLines = original.split("\n");
+        const searchLines = oldStr.split("\n");
+        const { matchStart, matchCount } = findWhitespaceTolerant(fileLines, searchLines);
+        if (matchStart === -1) {
+          const similar = findSimilarLines(original, oldStr);
+          const hint = similar.length > 0 ? `
+Similar lines found (did you mean?):
+${similar.join("\n")}` : "";
+          return `ERROR: old_str not found in file (even with whitespace ignored).
+File has ${fileLines.length} lines.${hint}
+Please read the file first and use exact text.`;
+        }
+        if (matchCount > 1) {
+          return `ERROR: old_str matches multiple locations with whitespace-tolerant matching. Please include more surrounding context to make it unique.`;
+        }
+        undoStack.push(filePath, `edit_file (ws-replace): ${filePath}`);
+        const before = fileLines.slice(0, matchStart);
+        const after = fileLines.slice(matchStart + searchLines.length);
+        const updated2 = [...before, newStr, ...after].join("\n");
+        writeFileSync3(filePath, updated2, encoding);
+        return `Successfully edited ${filePath} (whitespace-tolerant match)
+  Location: around line ${matchStart + 1}
+  Replaced: ${searchLines.length} line(s) \u2192 ${newStr.split("\n").length} line(s)
+  Old: ${truncatePreview(oldStr)}
+  New: ${truncatePreview(newStr)}`;
+      }
+      if (replaceAll) {
+        const occurrences = original.split(oldStr).length - 1;
+        if (occurrences === 0) {
+          const similar = findSimilarLines(original, oldStr);
+          const hint = similar.length > 0 ? `
+Similar lines found (did you mean?):
+${similar.join("\n")}` : "";
+          return `ERROR: old_str not found in file.${hint}
+Please read the file first and use exact text.`;
+        }
+        undoStack.push(filePath, `edit_file (replace_all): ${filePath}`);
+        const updated2 = original.split(oldStr).join(newStr);
+        writeFileSync3(filePath, updated2, encoding);
+        return `Successfully edited ${filePath} (replace_all)
+  Replaced: ${occurrences} occurrence(s) of ${truncatePreview(oldStr)}
+  With: ${truncatePreview(newStr)}`;
+      }
+      const firstIndex = original.indexOf(oldStr);
+      if (firstIndex === -1) {
+        const lines = original.split("\n");
+        const similar = findSimilarLines(original, oldStr);
+        const hint = similar.length > 0 ? `
+Similar lines found (did you mean?):
+${similar.join("\n")}` : "";
+        return `ERROR: old_str not found in file.
+File has ${lines.length} lines.${hint}
+Please read the file first and use exact text including whitespace/indentation.
+Tip: You can also try ignore_whitespace: true to match ignoring indentation differences.`;
+      }
+      const secondIndex = original.indexOf(oldStr, firstIndex + 1);
+      if (secondIndex !== -1) {
+        return `ERROR: old_str appears multiple times in file (at least at positions ${firstIndex} and ${secondIndex}). Please include more surrounding context to make it unique.`;
+      }
+      undoStack.push(filePath, `edit_file (replace): ${filePath}`);
+      const updated = original.slice(0, firstIndex) + newStr + original.slice(firstIndex + oldStr.length);
+      writeFileSync3(filePath, updated, encoding);
+      const oldLines = oldStr.split("\n").length;
+      const newLines = newStr.split("\n").length;
+      const linesBefore = original.slice(0, firstIndex).split("\n").length;
+      return `Successfully edited ${filePath}
+  Location: around line ${linesBefore}
+  Replaced: ${oldLines} line(s) \u2192 ${newLines} line(s)
+  Old: ${truncatePreview(oldStr)}
+  New: ${truncatePreview(newStr)}`;
+    }
+    if (args["insert_after_line"] !== void 0) {
+      const afterLine = Number(args["insert_after_line"]);
+      const content = String(args["insert_content"] ?? "");
+      const lines = original.split("\n");
+      if (afterLine < 0 || afterLine > lines.length) {
+        throw new Error(`insert_after_line ${afterLine} is out of range (file has ${lines.length} lines)`);
+      }
+      undoStack.push(filePath, `edit_file (insert): ${filePath}`);
+      lines.splice(afterLine, 0, content);
+      writeFileSync3(filePath, lines.join("\n"), encoding);
+      return `Successfully inserted ${content.split("\n").length} line(s) after line ${afterLine} in ${filePath}`;
+    }
+    if (args["delete_from_line"] !== void 0) {
+      const fromLine = Number(args["delete_from_line"]);
+      const toLine = Number(args["delete_to_line"] ?? args["delete_from_line"]);
+      const lines = original.split("\n");
+      if (fromLine < 1 || toLine < fromLine || toLine > lines.length) {
+        throw new Error(
+          `Invalid line range: ${fromLine}-${toLine} (file has ${lines.length} lines, lines are 1-indexed)`
+        );
+      }
+      undoStack.push(filePath, `edit_file (delete): ${filePath}`);
+      const deleted = lines.splice(fromLine - 1, toLine - fromLine + 1);
+      writeFileSync3(filePath, lines.join("\n"), encoding);
+      return `Successfully deleted lines ${fromLine}-${toLine} (${deleted.length} lines) from ${filePath}`;
+    }
+    throw new Error(
+      "No operation specified. Provide either: (old_str + new_str) for replace, (insert_after_line + insert_content) for insert, or (delete_from_line + delete_to_line) for delete."
+    );
+  }
+};
+function truncatePreview(str, maxLen = 80) {
+  const oneLine = str.replace(/\n/g, "\u21B5");
+  if (oneLine.length <= maxLen) return JSON.stringify(str);
+  return JSON.stringify(oneLine.slice(0, maxLen)) + "...";
+}
+
+// src/tools/builtin/list-dir.ts
+import { readdirSync as readdirSync3, statSync as statSync3, existsSync as existsSync5 } from "fs";
+import { join, basename as basename2 } from "path";
+var listDirTool = {
+  definition: {
+    name: "list_dir",
+    description: "List directory contents showing file names, types and sizes.",
+    parameters: {
+      path: {
+        type: "string",
+        description: "Directory path, defaults to current working directory",
+        required: false
+      },
+      recursive: {
+        type: "boolean",
+        description: "Whether to recursively list subdirectories, defaults to false",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const dirPath = String(args["path"] ?? process.cwd());
+    const recursive = Boolean(args["recursive"] ?? false);
+    if (!existsSync5(dirPath)) {
+      const targetName = basename2(dirPath).toLowerCase();
+      const cwd = process.cwd();
+      const suggestions = [];
+      try {
+        for (const entry of readdirSync3(cwd, { withFileTypes: true })) {
+          if (entry.isDirectory() && entry.name.toLowerCase() === targetName) {
+            suggestions.push(entry.name);
+          }
+        }
+      } catch {
+      }
+      if (suggestions.length > 0) {
+        throw new Error(
+          `Directory not found: ${dirPath}
+Current working directory: ${cwd}
+Found similar directories:
+` + suggestions.map((s) => `  \u2192 ${s}`).join("\n") + `
+Please retry with the correct relative path.`
+        );
+      }
+      throw new Error(
+        `Directory not found: ${dirPath}
+Current working directory: ${cwd}
+Please use list_dir (without path) to see the current directory structure first.`
+      );
+    }
+    const lines = [`Directory: ${dirPath}
+`];
+    listRecursive(dirPath, "", recursive, lines);
+    return lines.join("\n");
+  }
+};
+function listRecursive(basePath, indent, recursive, lines) {
+  let entries;
+  try {
+    entries = readdirSync3(basePath, { withFileTypes: true });
+  } catch {
+    lines.push(`${indent}(permission denied)`);
+    return;
+  }
+  const sorted = entries.sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of sorted) {
+    const USEFUL_DOT_ENTRIES = /* @__PURE__ */ new Set([".github", ".vscode", ".idea", ".gitignore", ".gitattributes", ".editorconfig", ".eslintrc", ".prettierrc", ".npmrc"]);
+    if (entry.name === "node_modules" || entry.name.startsWith(".") && !USEFUL_DOT_ENTRIES.has(entry.name) && !entry.name.startsWith(".env")) {
+      if (entry.isDirectory()) {
+        lines.push(`${indent}\u{1F4C1} ${entry.name}/  (skipped)`);
+      }
+      continue;
+    }
+    if (entry.isDirectory()) {
+      lines.push(`${indent}\u{1F4C1} ${entry.name}/`);
+      if (recursive) {
+        listRecursive(join(basePath, entry.name), indent + "  ", true, lines);
+      }
+    } else {
+      try {
+        const stat = statSync3(join(basePath, entry.name));
+        const size = formatSize(stat.size);
+        lines.push(`${indent}\u{1F4C4} ${entry.name}  (${size})`);
+      } catch {
+        lines.push(`${indent}\u{1F4C4} ${entry.name}`);
+      }
+    }
+  }
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+// src/tools/builtin/grep-files.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4, existsSync as existsSync6 } from "fs";
+import { join as join2, relative } from "path";
+var grepFilesTool = {
+  definition: {
+    name: "grep_files",
+    description: `Search for matching text or code in files, returning matching lines with line numbers. Use cases:
+- Find function/class definitions (e.g. "function handleChat" or "class ProviderRegistry")
+- Find all usages of a variable or string
+- Check impact scope before modifying code
+Supports regex. Automatically skips node_modules, dist, .git directories.`,
+    parameters: {
+      pattern: {
+        type: "string",
+        description: 'Search pattern, supports regex (e.g. "function\\s+\\w+" or literal "import React")',
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "Search root directory, defaults to current working directory",
+        required: false
+      },
+      file_pattern: {
+        type: "string",
+        description: 'Filename filter with simple wildcards (e.g. "*.ts", "*.py", "*.json"), defaults to all text files',
+        required: false
+      },
+      ignore_case: {
+        type: "boolean",
+        description: "Whether to ignore case, defaults to false",
+        required: false
+      },
+      context_lines: {
+        type: "number",
+        description: "Number of context lines before/after each match, defaults to 0 (match line only)",
+        required: false
+      },
+      max_results: {
+        type: "number",
+        description: "Maximum number of results, defaults to 50",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const pattern = String(args["pattern"] ?? "");
+    const rootPath = String(args["path"] ?? process.cwd());
+    const filePattern = args["file_pattern"] ? String(args["file_pattern"]) : void 0;
+    const ignoreCase = Boolean(args["ignore_case"] ?? false);
+    const contextLines = Math.max(0, Number(args["context_lines"] ?? 0));
+    const maxResults = Math.max(1, Number(args["max_results"] ?? 50));
+    if (!pattern) throw new Error("pattern is required");
+    if (!existsSync6(rootPath)) throw new Error(`Path not found: ${rootPath}`);
+    let regex;
+    try {
+      regex = new RegExp(pattern, ignoreCase ? "gi" : "g");
+    } catch {
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      regex = new RegExp(escaped, ignoreCase ? "gi" : "g");
+    }
+    const results = [];
+    const stat = statSync4(rootPath);
+    if (stat.isFile()) {
+      searchInFile(rootPath, rootPath, regex, contextLines, maxResults, results);
+    } else {
+      collectFiles(rootPath, filePattern, results, regex, contextLines, maxResults, rootPath);
+    }
+    if (results.length === 0) {
+      return `No matches found for pattern: ${pattern}
+Searched in: ${rootPath}${filePattern ? `
+File filter: ${filePattern}` : ""}`;
+    }
+    const lines = [
+      `Found ${results.length} match(es) for: ${pattern}`,
+      `Searched in: ${rootPath}`,
+      ""
+    ];
+    let currentFile = "";
+    for (const r of results) {
+      if (r.file !== currentFile) {
+        if (currentFile) lines.push("");
+        lines.push(`\u2500\u2500 ${r.file} \u2500\u2500`);
+        currentFile = r.file;
+      }
+      if (r.contextBefore) {
+        for (const [ln, text] of r.contextBefore) {
+          lines.push(`  ${String(ln).padStart(4)}\u2502 ${text}`);
+        }
+      }
+      lines.push(`\u25B6 ${String(r.lineNumber).padStart(4)}\u2502 ${r.lineText}`);
+      if (r.contextAfter) {
+        for (const [ln, text] of r.contextAfter) {
+          lines.push(`  ${String(ln).padStart(4)}\u2502 ${text}`);
+        }
+      }
+    }
+    if (results.length >= maxResults) {
+      lines.push("");
+      lines.push(`(Results truncated at ${maxResults}. Use max_results or narrow your search.)`);
+    }
+    return lines.join("\n");
+  }
+};
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", ".next", "__pycache__", ".cache", "coverage", ".nyc_output"]);
+var BINARY_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".ico", ".woff", ".woff2", ".ttf", ".eot", ".otf", ".mp3", ".mp4", ".wav", ".zip", ".tar", ".gz", ".rar", ".7z", ".exe", ".dll", ".so", ".dylib", ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"]);
+function matchesFilePattern(filename, pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i").test(filename);
+}
+function isBinary(filename) {
+  const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase();
+  return BINARY_EXTS.has(ext);
+}
+function collectFiles(dirPath, filePattern, results, regex, contextLines, maxResults, rootPath) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = readdirSync4(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) return;
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      collectFiles(join2(dirPath, entry.name), filePattern, results, regex, contextLines, maxResults, rootPath);
+    } else if (entry.isFile()) {
+      if (isBinary(entry.name)) continue;
+      if (filePattern && !matchesFilePattern(entry.name, filePattern)) continue;
+      const fullPath = join2(dirPath, entry.name);
+      const relPath = relative(rootPath, fullPath);
+      searchInFile(fullPath, relPath, regex, contextLines, maxResults, results);
+    }
+  }
+}
+function searchInFile(fullPath, displayPath, regex, contextLines, maxResults, results) {
+  try {
+    const stat = statSync4(fullPath);
+    if (stat.size > 1e6) return;
+  } catch {
+    return;
+  }
+  let content;
+  try {
+    content = readFileSync4(fullPath, "utf-8");
+  } catch {
+    return;
+  }
+  const lines = content.split("\n");
+  regex.lastIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (results.length >= maxResults) return;
+    regex.lastIndex = 0;
+    if (regex.test(lines[i])) {
+      const result = {
+        file: displayPath,
+        lineNumber: i + 1,
+        lineText: lines[i].trimEnd()
+      };
+      if (contextLines > 0) {
+        result.contextBefore = [];
+        result.contextAfter = [];
+        for (let c = Math.max(0, i - contextLines); c < i; c++) {
+          result.contextBefore.push([c + 1, lines[c].trimEnd()]);
+        }
+        for (let c = i + 1; c <= Math.min(lines.length - 1, i + contextLines); c++) {
+          result.contextAfter.push([c + 1, lines[c].trimEnd()]);
+        }
+      }
+      results.push(result);
+    }
+  }
+}
+
+// src/tools/builtin/glob-files.ts
+import { readdirSync as readdirSync5, statSync as statSync5, existsSync as existsSync7 } from "fs";
+import { join as join3, relative as relative2, basename as basename3 } from "path";
+var globFilesTool = {
+  definition: {
+    name: "glob_files",
+    description: `Find files by name or path pattern, returning a list of matching file paths. Use cases:
+- Find all files of a type (e.g. "**/*.ts" for all TypeScript files)
+- Find files by name (e.g. "**/index.ts" or "package.json")
+- Find files in a directory (e.g. "src/components/**")
+Results sorted by most recent modification time. Automatically skips node_modules, dist, .git directories.`,
+    parameters: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern, e.g. "**/*.ts", "src/**/*.tsx", "**/package.json", "*.md"',
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "Search root directory, defaults to current working directory",
+        required: false
+      },
+      max_results: {
+        type: "number",
+        description: "Maximum number of files to return, defaults to 100",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const pattern = String(args["pattern"] ?? "");
+    const rootPath = String(args["path"] ?? process.cwd());
+    const maxResults = Math.max(1, Number(args["max_results"] ?? 100));
+    if (!pattern) throw new Error("pattern is required");
+    if (!existsSync7(rootPath)) throw new Error(`Path not found: ${rootPath}`);
+    const regex = globToRegex(pattern);
+    const matches = [];
+    collectMatchingFiles(rootPath, rootPath, regex, matches, maxResults);
+    if (matches.length === 0) {
+      return `No files matched pattern: ${pattern}
+Searched in: ${rootPath}`;
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    const lines = [
+      `Found ${matches.length} file(s) matching: ${pattern}`,
+      `Searched in: ${rootPath}`,
+      "",
+      ...matches.map((m) => m.relPath)
+    ];
+    if (matches.length >= maxResults) {
+      lines.push("");
+      lines.push(`(Results truncated at ${maxResults}. Use max_results or narrow your pattern.)`);
+    }
+    return lines.join("\n");
+  }
+};
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "dist-cjs",
+  "release",
+  ".next",
+  "__pycache__",
+  ".cache",
+  "coverage",
+  ".nyc_output",
+  ".turbo",
+  ".vite",
+  "build",
+  "out"
+]);
+function globToRegex(pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  let regStr = "";
+  let i = 0;
+  while (i < normalized.length) {
+    const ch = normalized[i];
+    if (ch === "*" && normalized[i + 1] === "*") {
+      regStr += ".*";
+      i += 2;
+      if (normalized[i] === "/") i++;
+    } else if (ch === "*") {
+      regStr += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      regStr += "[^/]";
+      i++;
+    } else if (".+^${}()|[]\\".includes(ch)) {
+      regStr += "\\" + ch;
+      i++;
+    } else {
+      regStr += ch;
+      i++;
+    }
+  }
+  if (!normalized.includes("/")) {
+    return new RegExp(`(^|/)${regStr}$`, "i");
+  }
+  return new RegExp(`(^|/)${regStr}$`, "i");
+}
+function collectMatchingFiles(dirPath, rootPath, regex, results, maxResults) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = readdirSync5(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) break;
+    const fullPath = join3(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
+      collectMatchingFiles(fullPath, rootPath, regex, results, maxResults);
+    } else if (entry.isFile()) {
+      const relPath = relative2(rootPath, fullPath).replace(/\\/g, "/");
+      if (regex.test(relPath) || regex.test(basename3(relPath))) {
+        try {
+          const stat = statSync5(fullPath);
+          results.push({ relPath, absPath: fullPath, mtime: stat.mtimeMs });
+        } catch {
+          results.push({ relPath, absPath: fullPath, mtime: 0 });
+        }
+      }
+    }
+  }
+}
+
+// src/tools/builtin/run-interactive.ts
+import { spawn } from "child_process";
+import { platform as platform2 } from "os";
+var IS_WINDOWS2 = platform2() === "win32";
+var runInteractiveTool = {
+  definition: {
+    name: "run_interactive",
+    description: `Run a CLI program that requires stdin interaction (e.g. Python games, Q&A scripts, menu programs). Pre-provide all input lines via stdin_lines array; the program consumes them sequentially and returns full output. [Important] args must be a string array like ["workspace/guess.py"], not a string. [Guessing strategy] For 1-100 guessing: start at 50, use binary search \u2014 at most 7 guesses. Example stdin_lines: ["50","25","37","43","40","41","n"] ("n"=don't play again). Windows Python path: C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe`,
+    parameters: {
+      executable: {
+        type: "string",
+        description: 'Full path or command name of the executable, e.g. "python", "C:\\\\Users\\\\Jinzd\\\\anaconda3\\\\envs\\\\python312\\\\python.exe", "node"',
+        required: true
+      },
+      args: {
+        type: "array",
+        description: 'Arguments array for the executable, e.g. ["workspace/guess.py"] or ["-c", "print(1)"]',
+        items: { type: "string" },
+        required: true
+      },
+      stdin_lines: {
+        type: "array",
+        description: `Input lines to feed to the program's stdin in order. E.g. for a guessing game: ["50", "25", "37"]. Each line gets a newline appended automatically.`,
+        items: { type: "string" },
+        required: true
+      },
+      timeout: {
+        type: "number",
+        description: "Overall timeout in milliseconds, defaults to 20000 (20s)",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const executable = String(args["executable"] ?? "").trim();
+    const rawArgs = args["args"];
+    let argsTypeWarning = "";
+    const cmdArgs = Array.isArray(rawArgs) ? rawArgs.map(String) : typeof rawArgs === "string" && rawArgs.trim() ? (() => {
+      argsTypeWarning = `[Warning] "args" should be an array but got string: ${JSON.stringify(rawArgs)}. Applied fallback.
+`;
+      process.stderr.write(argsTypeWarning);
+      return [rawArgs.trim()];
+    })() : [];
+    const rawStdin = args["stdin_lines"];
+    let stdinTypeWarning = "";
+    const stdinLines = Array.isArray(rawStdin) ? rawStdin.map(String) : typeof rawStdin === "string" && rawStdin.trim() ? (() => {
+      stdinTypeWarning = `[Warning] "stdin_lines" should be an array but got string: ${JSON.stringify(rawStdin.slice(0, 80))}. Applied fallback.
+`;
+      process.stderr.write(stdinTypeWarning);
+      return rawStdin.split(",").map((s) => s.trim()).filter(Boolean);
+    })() : [];
+    const timeout = Math.min(Math.max(Number(args["timeout"] ?? 2e4), 1e3), 3e5);
+    if (!executable) {
+      throw new Error("executable is required");
+    }
+    const env = {
+      ...process.env,
+      // 强制 Python UTF-8 模式，修复 Windows 中文乱码
+      PYTHONUTF8: "1",
+      PYTHONIOENCODING: "utf-8",
+      PYTHONDONTWRITEBYTECODE: "1"
+    };
+    const prefixWarnings = [argsTypeWarning, stdinTypeWarning].filter(Boolean).join("");
+    return new Promise((resolve4) => {
+      const child = spawn(executable, cmdArgs.map(String), {
+        cwd: process.cwd(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.setEncoding("utf-8");
+      child.stderr.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      let lineIdx = 0;
+      const writeNextLine = () => {
+        if (lineIdx < stdinLines.length && !child.stdin.destroyed) {
+          const line = stdinLines[lineIdx++] + (IS_WINDOWS2 ? "\r\n" : "\n");
+          const canContinue = child.stdin.write(line);
+          if (canContinue) {
+            setTimeout(writeNextLine, 150);
+          } else {
+            child.stdin.once("drain", () => setTimeout(writeNextLine, 150));
+          }
+        } else if (!child.stdin.destroyed) {
+          child.stdin.end();
+        }
+      };
+      setTimeout(writeNextLine, 400);
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve4(`${prefixWarnings}[Timeout after ${timeout}ms]
+${buildOutput(stdout, stderr)}`);
+      }, timeout);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const output = buildOutput(stdout, stderr);
+        if (code !== 0 && code !== null) {
+          resolve4(`${prefixWarnings}Exit code ${code}:
+${output}`);
+        } else {
+          resolve4(`${prefixWarnings}${output || "(no output)"}`);
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve4(
+          `${prefixWarnings}Failed to start process "${executable}": ${err.message}
+Hint: On Windows, use the full path to the executable, e.g.:
+  C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe`
+        );
+      });
+    });
+  }
+};
+function buildOutput(stdout, stderr) {
+  const parts = [];
+  if (stdout.trim()) parts.push(stdout);
+  if (stderr.trim()) parts.push(`[stderr]
+${stderr}`);
+  return parts.join("\n") || "(no output)";
+}
+
+// src/tools/builtin/web-fetch.ts
+import { promises as dnsPromises } from "dns";
+function htmlToText(html) {
+  const HTML_REGEX_LIMIT = 2e5;
+  if (html.length > HTML_REGEX_LIMIT) {
+    html = html.slice(0, HTML_REGEX_LIMIT);
+  }
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<noscript[\s\S]*?<\/noscript>/gi, "").replace(/<svg[\s\S]*?<\/svg>/gi, "");
+  text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_m, lvl, content) => {
+    const prefix = "#".repeat(Number(lvl));
+    return `
+${prefix} ${stripTags(content).trim()}
+`;
+  });
+  text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_m, code) => {
+    return "\n```\n" + stripTags(code) + "\n```\n";
+  });
+  text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_m, item) => {
+    return `
+- ${stripTags(item).trim()}`;
+  });
+  text = text.replace(/<\/(p|div|section|article|blockquote|tr)>/gi, "\n");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_m, href, label) => {
+    const l = stripTags(label).trim();
+    if (href.startsWith("http") && l && l !== href) return `[${l}](${href})`;
+    return l || href;
+  });
+  text = stripTags(text);
+  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.split("\n").map((l) => l.trimEnd()).join("\n");
+  return text.trim();
+}
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, "");
+}
+function extractTitle(html) {
+  const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return m ? stripTags(m[1]).trim() : "";
+}
+function extractDescription(html) {
+  const m = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']+)["']/i) ?? html.match(/<meta[^>]+content=["']([^"']+)["'][^>]+name=["']description["']/i);
+  return m ? m[1].trim() : "";
+}
+var MAX_OUTPUT = 16e3;
+function isPrivateHost(hostname) {
+  const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h === "0.0.0.0" || h === "::1") return true;
+  if (h.startsWith("fe80:")) return true;
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (m) {
+    const [o1, o2] = [Number(m[1]), Number(m[2])];
+    if (o1 === 127) return true;
+    if (o1 === 10) return true;
+    if (o1 === 172 && o2 >= 16 && o2 <= 31) return true;
+    if (o1 === 192 && o2 === 168) return true;
+    if (o1 === 169 && o2 === 254) return true;
+    if (o1 === 0) return true;
+  }
+  return false;
+}
+async function resolveAndCheck(hostname) {
+  const h = hostname.replace(/^\[|\]$/g, "");
+  if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h) || h.includes(":")) return;
+  try {
+    const { address } = await dnsPromises.lookup(h);
+    if (isPrivateHost(address)) {
+      throw new Error(`Blocked: "${hostname}" resolves to private address ${address}. web_fetch is restricted to public URLs.`);
+    }
+  } catch (e) {
+    if (e.message.startsWith("Blocked:")) throw e;
+  }
+}
+var webFetchTool = {
+  definition: {
+    name: "web_fetch",
+    description: "Fetch a URL and return its content as plain text / Markdown. Use this to read documentation, API references, READMEs, articles, or any public web page. Follows redirects automatically. Returns the first ~16000 characters of extracted text.",
+    parameters: {
+      url: {
+        type: "string",
+        description: "The full URL to fetch (must start with http:// or https://)",
+        required: true
+      },
+      selector: {
+        type: "string",
+        description: "Optional: keyword to search in the extracted text. If provided, returns only the paragraphs / sections that contain this keyword (case-insensitive).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const url = String(args["url"] ?? "").trim();
+    const selector = args["selector"] ? String(args["selector"]).trim() : "";
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      throw new Error(`Invalid URL: "${url}". URL must start with http:// or https://`);
+    }
+    try {
+      const parsedUrl = new URL(url);
+      if (isPrivateHost(parsedUrl.hostname)) {
+        throw new Error(`Blocked: "${url}" resolves to a private/internal address. web_fetch is restricted to public URLs.`);
+      }
+      await resolveAndCheck(parsedUrl.hostname);
+    } catch (e) {
+      if (e.message.startsWith("Blocked:")) throw e;
+      throw new Error(`Invalid URL: "${url}"`);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2e4);
+    let rawHtml;
+    let finalUrl;
+    let contentType;
+    const MAX_REDIRECTS = 10;
+    const FETCH_HEADERS = {
+      "User-Agent": "Mozilla/5.0 (compatible; ai-cli/1.0; +https://github.com/ai-cli)",
+      Accept: "text/html,application/xhtml+xml,text/plain,*/*",
+      "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8"
+    };
+    try {
+      let currentUrl = url;
+      let resp = null;
+      for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        const parsedHop = new URL(currentUrl);
+        if (isPrivateHost(parsedHop.hostname)) {
+          throw new Error(`Blocked: redirect to private/internal address "${currentUrl}".`);
+        }
+        await resolveAndCheck(parsedHop.hostname);
+        const r = await fetch(currentUrl, {
+          signal: controller.signal,
+          headers: FETCH_HEADERS,
+          redirect: "manual"
+          // 手动控制重定向
+        });
+        if (r.status >= 300 && r.status < 400) {
+          if (hop >= MAX_REDIRECTS) {
+            throw new Error(`Too many redirects (>${MAX_REDIRECTS}): ${url}`);
+          }
+          const location = r.headers.get("Location");
+          if (!location) {
+            resp = r;
+            break;
+          }
+          currentUrl = new URL(location, currentUrl).href;
+          continue;
+        }
+        resp = r;
+        break;
+      }
+      clearTimeout(timeoutId);
+      if (!resp) throw new Error(`Too many redirects (>${MAX_REDIRECTS}): ${url}`);
+      finalUrl = currentUrl;
+      contentType = resp.headers.get("content-type") ?? "";
+      if (!resp.ok) {
+        throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+      }
+      const buf = await resp.arrayBuffer();
+      rawHtml = new TextDecoder("utf-8", { fatal: false }).decode(buf.slice(0, 2e6));
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        throw new Error(`Request timed out after 20s: ${url}`);
+      }
+      throw err;
+    }
+    let text;
+    if (contentType.includes("text/plain") || contentType.includes("application/json")) {
+      text = rawHtml;
+    } else {
+      const title = extractTitle(rawHtml);
+      const desc = extractDescription(rawHtml);
+      let body = htmlToText(rawHtml);
+      const header = [
+        title ? `# ${title}` : "",
+        desc ? `> ${desc}` : "",
+        `Source: ${finalUrl}`,
+        ""
+      ].filter(Boolean).join("\n");
+      text = header + "\n\n" + body;
+    }
+    if (selector) {
+      const lower = selector.toLowerCase();
+      const paragraphs = text.split("\n\n");
+      const matched = paragraphs.filter((p) => p.toLowerCase().includes(lower));
+      if (matched.length > 0) {
+        text = `[Filtered by keyword: "${selector}"]
+
+` + matched.join("\n\n");
+      } else {
+        text = `[No paragraphs contain keyword: "${selector}"]
+
+` + text;
+      }
+    }
+    if (text.length > MAX_OUTPUT) {
+      const kept = text.slice(0, MAX_OUTPUT);
+      text = kept + `
+
+... [Content truncated: ${text.length} chars total, returning first ${MAX_OUTPUT} chars. Use the selector parameter to narrow scope for more details] ...`;
+    }
+    return text;
+  }
+};
+
+// src/tools/builtin/save-last-response.ts
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+var lastResponseStore = { content: "" };
+var saveLastResponseTool = {
+  definition: {
+    name: "save_last_response",
+    description: `Tool for generating and saving large documents (exams, reports, long articles) to a file.
+
+[Usage] When the user requests generating and saving a large document, call this tool with the target path:
+  - The system will automatically initiate a streaming generation request, outputting content to both terminal and disk (tee mode)
+  - No need to output content first then call \u2014 the system handles "generate + save" in one step
+  - Only the file path is passed as a parameter, content is NOT passed via arguments, avoiding API argument truncation
+
+[Warning] Do NOT use write_file to save large content \u2014 write_file's content parameter gets truncated by the API for large documents, resulting in incomplete files.
+
+[Use cases] Exam papers (600-700 lines, 15-25KB), technical reports, long articles \u2014 any content over 2KB.`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "File path to save to (including filename), e.g. reports/2026-summary.md",
+        required: true
+      }
+    },
+    dangerous: false
+    // getDangerLevel 中标记为 write
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    if (!filePath) throw new Error("path is required");
+    const content = lastResponseStore.content;
+    if (!content) {
+      throw new Error("No content to save: AI has not produced any response yet, or the last response was empty.");
+    }
+    undoStack.push(filePath, `save_last_response: ${filePath}`);
+    mkdirSync2(dirname3(filePath), { recursive: true });
+    writeFileSync4(filePath, content, "utf-8");
+    const lines = content.split("\n").length;
+    return `File saved: ${filePath} (${lines} lines, ${content.length} bytes)`;
+  }
+};
+
+// src/tools/builtin/save-memory.ts
+import { existsSync as existsSync8, statSync as statSync6, appendFileSync as appendFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+function getMemoryFilePath() {
+  return join4(homedir2(), CONFIG_DIR_NAME, MEMORY_FILE_NAME);
+}
+function formatTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+var saveMemoryTool = {
+  definition: {
+    name: "save_memory",
+    description: "Save important information to persistent memory that survives across sessions. Use this to remember: user preferences, coding style, project architecture decisions, recurring patterns, key findings, or any knowledge worth preserving. Keep each memory entry concise (1-3 sentences). The content will be automatically timestamped.",
+    parameters: {
+      content: {
+        type: "string",
+        description: "The information to save to persistent memory. Keep it concise and actionable.",
+        required: true
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const content = String(args["content"] ?? "").trim();
+    if (!content) throw new Error("content is required");
+    const memoryPath = getMemoryFilePath();
+    const configDir = join4(homedir2(), CONFIG_DIR_NAME);
+    if (!existsSync8(configDir)) {
+      mkdirSync3(configDir, { recursive: true });
+    }
+    const timestamp = formatTimestamp();
+    const entry = `
+## ${timestamp}
+${content}
+`;
+    appendFileSync2(memoryPath, entry, "utf-8");
+    const byteSize = statSync6(memoryPath).size;
+    return `Memory saved successfully. File size: ${byteSize} bytes in ${MEMORY_FILE_NAME}`;
+  }
+};
+
+// src/tools/builtin/ask-user.ts
+import chalk from "chalk";
+var askUserContext = {
+  prompting: false
+};
+var askUserTool = {
+  definition: {
+    name: "ask_user",
+    description: "Ask the user a question and wait for their text response. Use this when you need clarification, confirmation, or any information from the user before proceeding with a task. The user will see the question in the terminal and can type a response. Returns the user's answer as text.",
+    parameters: {
+      question: {
+        type: "string",
+        description: "The question to ask the user. Be clear and specific.",
+        required: true
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const question = String(args["question"] ?? "").trim();
+    if (!question) throw new Error("question parameter is required");
+    if (!askUserContext.rl) {
+      throw new Error("ask_user is not available in this context (readline not initialized)");
+    }
+    const answer = await promptUser(askUserContext.rl, question);
+    if (answer === null) {
+      return "User did not respond (cancelled).";
+    }
+    return `User response: ${answer}`;
+  }
+};
+function promptUser(rl, question) {
+  const rlAny = rl;
+  const savedOutput = rlAny.output;
+  rlAny.output = process.stdout;
+  rl.resume();
+  askUserContext.prompting = true;
+  console.log();
+  console.log(chalk.cyan("\u2753 ") + chalk.bold(question));
+  process.stdout.write(chalk.cyan("> "));
+  return new Promise((resolve4) => {
+    let completed = false;
+    const cleanup = (answer) => {
+      if (completed) return;
+      completed = true;
+      rl.removeListener("line", onLine);
+      askUserContext.cancelFn = void 0;
+      rl.pause();
+      rlAny.output = savedOutput;
+      askUserContext.prompting = false;
+      resolve4(answer);
+    };
+    const onLine = (line) => {
+      cleanup(line);
+    };
+    askUserContext.cancelFn = () => {
+      process.stdout.write(chalk.gray("\n(cancelled)\n"));
+      cleanup(null);
+    };
+    rl.once("line", onLine);
+  });
+}
+
+// src/tools/builtin/write-todos.ts
+import chalk2 from "chalk";
+var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+var currentTodos = [];
+var writeTodosTool = {
+  definition: {
+    name: "write_todos",
+    description: `Create or update a task list to track progress on complex tasks. Pass the COMPLETE list of todos each time (full replacement, not incremental). The list will be rendered in the terminal so the user can see progress. Use this proactively when working on multi-step tasks to show the user what you're doing.
+Parameter format: JSON array string, e.g. [{"title":"Read config","status":"completed"},{"title":"Parse args","status":"in_progress"},{"title":"Run tests","status":"pending"}]
+Valid statuses: pending, in_progress, completed.`,
+    parameters: {
+      todos: {
+        type: "string",
+        description: 'JSON array of todo objects. Each object must have "title" (string) and "status" ("pending"|"in_progress"|"completed"). Example: [{"title":"Step 1","status":"completed"},{"title":"Step 2","status":"in_progress"}]',
+        required: true
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const raw = args["todos"];
+    let parsed;
+    if (typeof raw === "string") {
+      const trimmed = raw.trim();
+      if (!trimmed) throw new Error("todos parameter is required");
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (err) {
+        throw new Error(`Invalid JSON in todos parameter: ${err.message}`);
+      }
+    } else if (Array.isArray(raw)) {
+      parsed = raw;
+    } else {
+      throw new Error("todos parameter must be a JSON array string");
+    }
+    if (!Array.isArray(parsed)) {
+      throw new Error("todos must be a JSON array");
+    }
+    const todos = parsed.map((item, i) => {
+      if (typeof item !== "object" || item === null) {
+        throw new Error(`todos[${i}] must be an object`);
+      }
+      const obj = item;
+      const title = String(obj["title"] ?? "").trim();
+      const status = String(obj["status"] ?? "").trim();
+      if (!title) throw new Error(`todos[${i}].title is required`);
+      if (!VALID_STATUSES.has(status)) {
+        throw new Error(`todos[${i}].status must be one of: pending, in_progress, completed (got "${status}")`);
+      }
+      return { title, status };
+    });
+    currentTodos = todos;
+    renderTodoList(todos);
+    const completed = todos.filter((t) => t.status === "completed").length;
+    const inProgress = todos.filter((t) => t.status === "in_progress").length;
+    const pending = todos.filter((t) => t.status === "pending").length;
+    return `Todo list updated: ${todos.length} items (${completed} completed, ${inProgress} in progress, ${pending} pending)`;
+  }
+};
+function renderTodoList(todos) {
+  const completed = todos.filter((t) => t.status === "completed").length;
+  const total = todos.length;
+  console.log();
+  console.log(
+    chalk2.bold.cyan("\u{1F4CB} Todo List") + chalk2.dim(` (${completed}/${total} completed)`)
+  );
+  console.log(chalk2.dim("  " + "\u2500".repeat(40)));
+  for (const todo of todos) {
+    let icon;
+    let text;
+    switch (todo.status) {
+      case "completed":
+        icon = chalk2.green("  \u2713 ");
+        text = chalk2.strikethrough.gray(todo.title);
+        break;
+      case "in_progress":
+        icon = chalk2.yellow("  \u2192 ");
+        text = chalk2.white(todo.title);
+        break;
+      case "pending":
+      default:
+        icon = chalk2.gray("  \u25CB ");
+        text = chalk2.gray(todo.title);
+        break;
+    }
+    console.log(icon + text);
+  }
+  console.log();
+}
+
+// src/config/env-loader.ts
+var ENV_KEY_MAP = {
+  claude: "AICLI_API_KEY_CLAUDE",
+  gemini: "AICLI_API_KEY_GEMINI",
+  deepseek: "AICLI_API_KEY_DEEPSEEK",
+  zhipu: "AICLI_API_KEY_ZHIPU",
+  kimi: "AICLI_API_KEY_KIMI",
+  openai: "AICLI_API_KEY_OPENAI",
+  openrouter: "AICLI_API_KEY_OPENROUTER",
+  "google-search": "AICLI_API_KEY_GOOGLESEARCH"
+};
+var EnvLoader = class {
+  /**
+   * 读取指定 provider 的 API Key 环境变量。
+   * 优先级：固定映射（如 AICLI_API_KEY_CLAUDE）> 动态格式（AICLI_API_KEY_<ID大写>）
+   * 自定义 provider 示例：id="siliconflow" → 读取 AICLI_API_KEY_SILICONFLOW
+   */
+  static getApiKey(providerId) {
+    const fixedEnvVar = ENV_KEY_MAP[providerId];
+    if (fixedEnvVar) {
+      const val = process.env[fixedEnvVar];
+      if (val) return val;
+    }
+    const dynamicEnvVar = `AICLI_API_KEY_${providerId.toUpperCase().replace(/-/g, "_")}`;
+    return process.env[dynamicEnvVar] || void 0;
+  }
+  static getDefaultProvider() {
+    return process.env["AICLI_PROVIDER"] || void 0;
+  }
+  static isStreamingDisabled() {
+    return process.env["AICLI_NO_STREAM"] === "1";
+  }
+  /** Google Custom Search Engine ID (cx) 环境变量 */
+  static getGoogleSearchEngineId() {
+    return process.env["AICLI_GOOGLE_CX"] || void 0;
+  }
+};
+
+// src/tools/builtin/google-search.ts
+var GOOGLE_SEARCH_API = "https://www.googleapis.com/customsearch/v1";
+var REQUEST_TIMEOUT_MS = 15e3;
+var MAX_RESULTS = 10;
+var DEFAULT_RESULTS = 5;
+var googleSearchContext = {};
+var googleSearchTool = {
+  definition: {
+    name: "google_search",
+    description: "Search the web using Google Custom Search API. Returns titles, URLs, and descriptions of search results. Use this to look up current information, verify facts, find documentation, or research topics that require up-to-date web data.",
+    parameters: {
+      query: {
+        type: "string",
+        description: "The search query string.",
+        required: true
+      },
+      num_results: {
+        type: "number",
+        description: "Number of results to return (1-10, default 5).",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const query = String(args["query"] ?? "").trim();
+    if (!query) throw new Error("query parameter is required");
+    const numResults = Math.min(
+      Math.max(Math.floor(Number(args["num_results"] ?? DEFAULT_RESULTS)), 1),
+      MAX_RESULTS
+    );
+    const { apiKey, cx } = resolveConfig();
+    const url = new URL(GOOGLE_SEARCH_API);
+    url.searchParams.set("key", apiKey);
+    url.searchParams.set("cx", cx);
+    url.searchParams.set("q", query);
+    url.searchParams.set("num", String(numResults));
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "Accept": "application/json"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "");
+        if (response.status === 403) {
+          throw new Error(
+            `Google Search API 403 Forbidden \u2014 Invalid API Key or daily free quota exceeded (100/day).
+Please check your API Key and Search Engine ID configuration.`
+          );
+        }
+        if (response.status === 429) {
+          throw new Error("Google Search API 429 \u2014 Too many requests, please try again later.");
+        }
+        throw new Error(
+          `Google Search API error: HTTP ${response.status} ${response.statusText}
+${errorBody.slice(0, 500)}`
+        );
+      }
+      const data = await response.json();
+      return formatResults(query, data, numResults);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Google Search request timed out (${REQUEST_TIMEOUT_MS / 1e3}s). Please check your network or proxy configuration.`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+function resolveConfig() {
+  let apiKey;
+  let cx;
+  if (googleSearchContext.configManager) {
+    apiKey = googleSearchContext.configManager.getApiKey("google-search");
+    cx = EnvLoader.getGoogleSearchEngineId() ?? googleSearchContext.configManager.get("googleSearchEngineId");
+  } else {
+    apiKey = EnvLoader.getApiKey("google-search");
+    cx = EnvLoader.getGoogleSearchEngineId();
+  }
+  if (!apiKey) {
+    throw new Error(
+      'Google Search API Key not configured.\nConfigure via one of:\n  1. Run /config \u2192 Configure Google Search\n  2. Set env var AICLI_API_KEY_GOOGLESEARCH\n  3. Add apiKeys["google-search"] to ~/.aicli/config.json'
+    );
+  }
+  if (!cx) {
+    throw new Error(
+      "Google Search Engine ID (cx) not configured.\nConfigure via one of:\n  1. Run /config \u2192 Configure Google Search\n  2. Set env var AICLI_GOOGLE_CX\n  3. Add googleSearchEngineId to ~/.aicli/config.json\n\nGet one at: https://programmablesearchengine.google.com/ \u2192 Create search engine \u2192 Copy Search Engine ID"
+    );
+  }
+  return { apiKey, cx };
+}
+function formatResults(query, data, requested) {
+  const items = data.items ?? [];
+  if (items.length === 0) {
+    const info2 = data.searchInformation;
+    return `No results found for: "${query}"` + (info2 ? ` (searched ${info2.formattedTotalResults ?? "0"} pages in ${info2.formattedSearchTime ?? "?"}s)` : "");
+  }
+  const info = data.searchInformation;
+  const header = `Search results for "${query}" (${items.length} of ~${info?.formattedTotalResults ?? "?"} results):
+`;
+  const results = items.map((item, i) => {
+    const title = item.title ?? "Untitled";
+    const link = item.link ?? "";
+    const snippet = item.snippet ?? "";
+    return `${i + 1}. **${title}**
+   URL: ${link}
+   ${snippet}`;
+  });
+  return header + "\n" + results.join("\n\n");
+}
+
+// src/tools/types.ts
+function isFileWriteTool(name) {
+  return name === "write_file" || name === "edit_file";
+}
+function getDangerLevel(toolName, args) {
+  if (toolName.startsWith("mcp__")) return "safe";
+  if (toolName === "bash") {
+    const cmd = String(args["command"] ?? "");
+    if (/\brm\s+[^\n]*(?:-\w*[rRfF]\w*|--recursive|--force)\b/.test(cmd)) return "destructive";
+    if (/\brm\s+\S/.test(cmd)) return "destructive";
+    if (/\brmdir\b|\bformat\b|\bmkfs\b/.test(cmd)) return "destructive";
+    if (/\bRemove-Item\b.*(?:-Recurse|-Force)|\bri\s+.*-(?:Recurse|Force)\b|\brd\s+\/s\b|\brmdir\s+\/s\b/i.test(cmd)) return "destructive";
+    if (/\bdel\s+\S/.test(cmd)) return "destructive";
+    if (/\becho\b.*>>?|\btee\b|\bcp\b|\bmv\b/.test(cmd)) return "write";
+    if (/\bSet-Content\b|\bOut-File\b|\bAdd-Content\b|\bCopy-Item\b|\bMove-Item\b/i.test(cmd)) return "write";
+    return "safe";
+  }
+  if (toolName === "write_file") return "write";
+  if (toolName === "edit_file") return "write";
+  if (toolName === "save_last_response") return "write";
+  if (toolName === "run_interactive") {
+    const exe = String(args["executable"] ?? "").toLowerCase();
+    if (/\b(rm|rmdir|del|format|mkfs|Remove-Item)\b/i.test(exe)) return "destructive";
+    if (/\b(bash|sh|zsh|cmd|powershell|pwsh|python|node|ruby|perl)\b/i.test(exe)) return "write";
+    return "write";
+  }
+  if (toolName === "read_file" || toolName === "list_dir" || toolName === "grep_files" || toolName === "glob_files" || toolName === "web_fetch" || toolName === "save_memory" || toolName === "ask_user" || toolName === "write_todos" || toolName === "google_search" || toolName === "spawn_agent" || toolName === "run_tests") return "safe";
+  return "write";
+}
+function schemaToJsonSchema(schema) {
+  const result = {
+    type: schema.type,
+    description: schema.description
+  };
+  if (schema.enum) result["enum"] = schema.enum;
+  if (schema.items) result["items"] = schemaToJsonSchema(schema.items);
+  if (schema.properties) {
+    result["properties"] = Object.fromEntries(
+      Object.entries(schema.properties).map(([k, v]) => [k, schemaToJsonSchema(v)])
+    );
+  }
+  return result;
+}
+
+// src/tools/truncate.ts
+var DEFAULT_MAX_TOOL_OUTPUT_CHARS = 12e3;
+function getMaxOutputChars(contextWindow) {
+  if (!contextWindow || contextWindow <= 0) return DEFAULT_MAX_TOOL_OUTPUT_CHARS;
+  return Math.max(DEFAULT_MAX_TOOL_OUTPUT_CHARS, Math.min(Math.floor(contextWindow / 4), 12e4));
+}
+var activeMaxChars = DEFAULT_MAX_TOOL_OUTPUT_CHARS;
+function setContextWindow(contextWindow) {
+  activeMaxChars = getMaxOutputChars(contextWindow);
+}
+function getActiveMaxChars() {
+  return activeMaxChars;
+}
+function truncateOutput(content, toolName, maxChars) {
+  const limit = maxChars ?? activeMaxChars;
+  if (content.length <= limit) return content;
+  const keepHead = Math.floor(limit * 0.7);
+  const keepTail = Math.floor(limit * 0.2);
+  const omitted = content.length - keepHead - keepTail;
+  const lines = content.split("\n").length;
+  const head = content.slice(0, keepHead);
+  const tail = content.slice(content.length - keepTail);
+  return head + `
+
+... [Output truncated: ${content.length} chars / ${lines} lines total, ${omitted} chars omitted. Use read_file to view full content in segments` + (toolName === "bash" ? ", or narrow the command scope" : "") + `] ...
+
+` + tail;
+}
+
+// src/repl/theme.ts
+import chalk3 from "chalk";
+var DARK_THEME = {
+  prompt: chalk3.green,
+  info: chalk3.cyan,
+  warning: chalk3.yellow,
+  error: chalk3.red,
+  success: chalk3.green,
+  dim: chalk3.dim,
+  accent: chalk3.cyan,
+  toolCall: chalk3.yellow,
+  toolResult: chalk3.green,
+  heading: chalk3.bold.cyan
+};
+var LIGHT_THEME = {
+  prompt: chalk3.blue,
+  info: chalk3.blueBright,
+  warning: chalk3.yellow,
+  error: chalk3.red,
+  success: chalk3.green,
+  dim: chalk3.gray,
+  accent: chalk3.blueBright,
+  toolCall: chalk3.magenta,
+  toolResult: chalk3.green,
+  heading: chalk3.bold.blue
+};
+function resolveColor(name) {
+  if (name.startsWith("#")) return chalk3.hex(name);
+  const parts = name.split(".");
+  let result = chalk3;
+  for (const part of parts) {
+    const obj = result;
+    if (obj && typeof obj[part] !== "undefined") {
+      result = obj[part];
+    }
+  }
+  if (typeof result !== "function") {
+    process.stderr.write(`[theme] Warning: unrecognized color "${name}", using default.
+`);
+    return chalk3;
+  }
+  return result;
+}
+function buildCustomTheme(base, overrides) {
+  if (!overrides) return base;
+  const result = { ...base };
+  for (const [key, colorName] of Object.entries(overrides)) {
+    if (key in result && colorName) {
+      result[key] = resolveColor(colorName);
+    }
+  }
+  return result;
+}
+var _currentTheme = DARK_THEME;
+function initTheme(themeId = "dark", customColors) {
+  switch (themeId) {
+    case "light":
+      _currentTheme = LIGHT_THEME;
+      break;
+    case "custom":
+      _currentTheme = buildCustomTheme(DARK_THEME, customColors);
+      break;
+    default:
+      _currentTheme = DARK_THEME;
+  }
+}
+var theme = new Proxy(DARK_THEME, {
+  get(_target, prop) {
+    return _currentTheme[prop];
+  }
+});
+
+// src/tools/builtin/spawn-agent.ts
+var spawnAgentContext = {
+  provider: null,
+  model: "",
+  systemPrompt: void 0,
+  modelParams: {},
+  configManager: null
+};
+var PREFIX = theme.dim("  \u2503 ");
+var SubAgentExecutor = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  round = 0;
+  totalRounds = 0;
+  setRoundInfo(current, total) {
+    this.round = current;
+    this.totalRounds = total;
+  }
+  async execute(call) {
+    const tool = this.registry.get(call.name);
+    if (!tool) {
+      return {
+        callId: call.id,
+        content: `Unknown tool: ${call.name}`,
+        isError: true
+      };
+    }
+    const dangerLevel = getDangerLevel(call.name, call.arguments);
+    if (dangerLevel === "destructive") {
+      this.printPrefixed(
+        theme.error("\u26A0 BLOCKED: ") + `Destructive operation ${call.name} not allowed in sub-agent`
+      );
+      return {
+        callId: call.id,
+        content: "Destructive operations are not allowed in sub-agents.",
+        isError: true
+      };
+    }
+    this.printToolCall(call, dangerLevel);
+    try {
+      const rawContent = await tool.execute(call.arguments);
+      const content = truncateOutput(rawContent, call.name);
+      const wasTruncated = content !== rawContent;
+      this.printToolResult(call.name, rawContent, false, wasTruncated);
+      return { callId: call.id, content, isError: false };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.printToolResult(call.name, message, true, false);
+      return { callId: call.id, content: message, isError: true };
+    }
+  }
+  async executeAll(calls) {
+    const results = [];
+    for (const call of calls) {
+      results.push(await this.execute(call));
+    }
+    return results;
+  }
+  // ── 带前缀的终端输出 ──
+  printPrefixed(text) {
+    for (const line of text.split("\n")) {
+      console.log(PREFIX + line);
+    }
+  }
+  printToolCall(call, dangerLevel) {
+    console.log(PREFIX);
+    const icon = dangerLevel === "write" ? theme.warning("\u270E Tool: ") : theme.toolCall("\u2699 Tool: ");
+    const roundBadge = this.totalRounds > 0 ? theme.dim(` [${this.round}/${this.totalRounds}]`) : "";
+    console.log(PREFIX + icon + call.name + roundBadge);
+    for (const [key, val] of Object.entries(call.arguments)) {
+      let valStr;
+      if (Array.isArray(val)) {
+        const json = JSON.stringify(val);
+        valStr = json.length > 160 ? json.slice(0, 160) + "..." : json;
+      } else if (typeof val === "string" && val.length > 120) {
+        valStr = val.slice(0, 120) + "...";
+      } else {
+        valStr = String(val);
+      }
+      console.log(PREFIX + theme.dim(`  ${key}: `) + valStr);
+    }
+  }
+  printToolResult(name, content, isError, wasTruncated) {
+    if (isError) {
+      console.log(
+        PREFIX + theme.error(`\u26A0 ${name} error: `) + theme.dim(content.slice(0, 300))
+      );
+    } else {
+      const lines = content.split("\n");
+      const maxLines = name === "run_interactive" ? 40 : 8;
+      const preview = lines.slice(0, maxLines);
+      const prefixedPreview = preview.map((l) => PREFIX + "  " + theme.dim(l)).join("\n");
+      const moreLines = lines.length > maxLines ? "\n" + PREFIX + theme.dim(`  ... (${lines.length - maxLines} more lines)`) : "";
+      const truncNote = wasTruncated ? "\n" + PREFIX + theme.warning(`  \u26A1 Output truncated`) : "";
+      console.log(PREFIX + theme.success("\u2713 Result:"));
+      console.log(prefixedPreview + moreLines + truncNote);
+    }
+  }
+};
+function buildSubAgentSystemPrompt(task, parentSystemPrompt) {
+  const parts = [];
+  if (parentSystemPrompt) {
+    parts.push(parentSystemPrompt);
+  }
+  parts.push(
+    `# Sub-Agent Mode
+
+You are a focused sub-agent delegated by the main agent to complete a specific task.
+
+**Your Task**:
+${task}
+
+**Rules**:
+1. Stay focused on your task, do not deviate
+2. When done, output a concise summary: what was done, which files were modified, and the result
+3. You cannot interact with the user (no ask_user tool), work independently using the task description
+4. You cannot create sub-agents (no spawn_agent tool)
+5. Destructive operations (rm -rf etc.) will be automatically blocked
+6. Be efficient, minimize unnecessary tool call rounds`
+  );
+  return parts.join("\n\n---\n\n");
+}
+function printSubAgentHeader(task, maxRounds) {
+  console.log();
+  console.log(theme.dim("  \u250F\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log(PREFIX + theme.toolCall("\u{1F916} Sub-Agent Spawned"));
+  console.log(
+    PREFIX + theme.dim("Task: ") + (task.slice(0, 120) + (task.length > 120 ? "..." : ""))
+  );
+  console.log(PREFIX + theme.dim(`Max rounds: ${maxRounds}`));
+  console.log(theme.dim("  \u2503"));
+}
+function printSubAgentFooter(usage) {
+  console.log(PREFIX);
+  console.log(PREFIX + theme.toolCall("Sub-Agent Complete"));
+  if (usage.inputTokens > 0 || usage.outputTokens > 0) {
+    console.log(
+      PREFIX + theme.dim(
+        `Tokens: ${usage.inputTokens} in / ${usage.outputTokens} out`
+      )
+    );
+  }
+  console.log(theme.dim("  \u2517\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log();
+}
+var spawnAgentTool = {
+  definition: {
+    name: "spawn_agent",
+    description: "Delegate a specific subtask to an independent sub-agent. The sub-agent has its own conversation context and agentic tool-call loop, with access to bash, file read/write, edit, search, etc., but cannot interact with the user or spawn more sub-agents. Suitable for independently completable subtasks like: refactoring a module, writing tests, researching a technical approach, or implementing a specific feature. Returns a summary of the sub-agent execution result.",
+    parameters: {
+      task: {
+        type: "string",
+        description: "Task description for the sub-agent. Must include all necessary context: file paths, requirements, constraints, expected output. The sub-agent cannot access the parent conversation history; all info must be in this parameter.",
+        required: true
+      },
+      max_rounds: {
+        type: "number",
+        description: "Max tool-call rounds for the sub-agent (1-15, default 10). Use fewer for simple tasks, more for complex ones.",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const task = String(args["task"] ?? "").trim();
+    if (!task) throw new Error("task parameter is required");
+    const rawMaxRounds = Number(args["max_rounds"] ?? SUBAGENT_DEFAULT_MAX_ROUNDS);
+    const maxRounds = Math.min(
+      Math.max(Math.round(rawMaxRounds), 1),
+      SUBAGENT_MAX_ROUNDS_LIMIT
+    );
+    const ctx = spawnAgentContext;
+    if (!ctx.provider) {
+      throw new Error("spawn_agent: provider not initialized (context not injected)");
+    }
+    const subRegistry = new ToolRegistry();
+    for (const tool of subRegistry.listAll()) {
+      if (!SUBAGENT_ALLOWED_TOOLS.has(tool.definition.name)) {
+        subRegistry.unregister(tool.definition.name);
+      }
+    }
+    const subExecutor = new SubAgentExecutor(subRegistry);
+    const subMessages = [
+      { role: "user", content: task, timestamp: /* @__PURE__ */ new Date() }
+    ];
+    const subSystemPrompt = buildSubAgentSystemPrompt(task, ctx.systemPrompt);
+    const toolDefs = subRegistry.getDefinitions();
+    const extraMessages = [];
+    const totalUsage = { inputTokens: 0, outputTokens: 0 };
+    let finalContent = "";
+    printSubAgentHeader(task, maxRounds);
+    try {
+      for (let round = 0; round < maxRounds; round++) {
+        subExecutor.setRoundInfo(round + 1, maxRounds);
+        const result = await ctx.provider.chatWithTools(
+          {
+            messages: subMessages,
+            model: ctx.model,
+            systemPrompt: subSystemPrompt,
+            stream: false,
+            temperature: ctx.modelParams.temperature,
+            maxTokens: ctx.modelParams.maxTokens,
+            timeout: ctx.modelParams.timeout,
+            thinking: ctx.modelParams.thinking,
+            ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+          },
+          toolDefs
+        );
+        if (result.usage) {
+          totalUsage.inputTokens += result.usage.inputTokens;
+          totalUsage.outputTokens += result.usage.outputTokens;
+        }
+        if ("content" in result) {
+          finalContent = result.content;
+          break;
+        }
+        if (ctx.configManager) {
+          googleSearchContext.configManager = ctx.configManager;
+        }
+        const toolResults = await subExecutor.executeAll(result.toolCalls);
+        const reasoningContent = "reasoningContent" in result ? result.reasoningContent : void 0;
+        const newMsgs = ctx.provider.buildToolResultMessages(
+          result.toolCalls,
+          toolResults,
+          reasoningContent
+        );
+        extraMessages.push(...newMsgs);
+      }
+      if (!finalContent) {
+        finalContent = `(Sub-agent reached maximum rounds (${maxRounds}) without producing a final response)`;
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      finalContent = `(Sub-agent error: ${errMsg})`;
+      process.stderr.write(
+        `
+[spawn_agent] Error in sub-agent loop: ${errMsg}
+`
+      );
+    }
+    printSubAgentFooter(totalUsage);
+    const lines = [
+      "## Sub-Agent Result",
+      "",
+      finalContent,
+      "",
+      "---",
+      `Token usage: ${totalUsage.inputTokens} input, ${totalUsage.outputTokens} output`
+    ];
+    return lines.join("\n");
+  }
+};
+
+// src/tools/registry.ts
+import { pathToFileURL } from "url";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync6 } from "fs";
+import { join as join5 } from "path";
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  pluginToolNames = /* @__PURE__ */ new Set();
+  mcpToolNames = /* @__PURE__ */ new Set();
+  constructor() {
+    this.register(bashTool);
+    this.register(readFileTool);
+    this.register(writeFileTool);
+    this.register(editFileTool);
+    this.register(listDirTool);
+    this.register(grepFilesTool);
+    this.register(globFilesTool);
+    this.register(runInteractiveTool);
+    this.register(webFetchTool);
+    this.register(saveLastResponseTool);
+    this.register(saveMemoryTool);
+    this.register(askUserTool);
+    this.register(writeTodosTool);
+    this.register(googleSearchTool);
+    this.register(spawnAgentTool);
+    this.register(runTestsTool);
+  }
+  register(tool) {
+    this.tools.set(tool.definition.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** 注销指定工具（子代理创建过滤后的工具集时使用） */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /** 返回所有工具的 schema，用于发送给 AI */
+  getDefinitions() {
+    return [...this.tools.values()].map((t) => t.definition);
+  }
+  listAll() {
+    return [...this.tools.values()];
+  }
+  /** Returns only tools loaded from plugins (not built-in). */
+  listPluginTools() {
+    return [...this.tools.values()].filter((t) => this.pluginToolNames.has(t.definition.name));
+  }
+  /** 注册一个 MCP 工具（名称以 mcp__ 开头） */
+  registerMcpTool(tool) {
+    this.tools.set(tool.definition.name, tool);
+    this.mcpToolNames.add(tool.definition.name);
+  }
+  /** 返回所有 MCP 工具 */
+  listMcpTools() {
+    return [...this.tools.values()].filter((t) => this.mcpToolNames.has(t.definition.name));
+  }
+  /** 清除所有已注册的 MCP 工具（重连时先清除再重新注册） */
+  unregisterMcpTools() {
+    for (const name of this.mcpToolNames) {
+      this.tools.delete(name);
+    }
+    this.mcpToolNames.clear();
+  }
+  /**
+   * Dynamically loads .js plugin files from pluginsDir.
+   *
+   * Security notes:
+   *   - Only loads when allowPlugins=true (must be explicitly enabled in config).
+   *   - Plugins run with FULL Node.js privileges in the main process.
+   *   - Prints a prominent warning listing every file before loading.
+   *   - Built-in tool names cannot be overridden by plugins.
+   *
+   * Creates the dir if missing. Skips invalid plugins with a warning.
+   * Returns the number of successfully loaded plugins.
+   */
+  async loadPlugins(pluginsDir, allowPlugins = false) {
+    if (!existsSync9(pluginsDir)) {
+      try {
+        mkdirSync4(pluginsDir, { recursive: true });
+      } catch {
+      }
+      return 0;
+    }
+    let files;
+    try {
+      files = readdirSync6(pluginsDir).filter((f) => f.endsWith(".js"));
+    } catch {
+      return 0;
+    }
+    if (files.length === 0) return 0;
+    if (!allowPlugins) {
+      process.stderr.write(
+        `[plugins] Found ${files.length} plugin(s) in ${pluginsDir} but loading is disabled.
+  To enable, set "allowPlugins": true in ~/.aicli/config.json (or via /config).
+  \u26A0 Plugins run with full system privileges. Only enable for trusted sources.
+`
+      );
+      return 0;
+    }
+    process.stderr.write(
+      `
+[plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
+` + files.map((f) => `  + ${join5(pluginsDir, f)}`).join("\n") + "\n\n"
+    );
+    let loaded = 0;
+    for (const file of files) {
+      try {
+        const fileUrl = pathToFileURL(join5(pluginsDir, file)).href;
+        const mod = await import(fileUrl);
+        const tool = mod.tool ?? mod.default?.tool ?? mod.default;
+        if (!tool || typeof tool.execute !== "function" || !tool.definition?.name) {
+          process.stderr.write(`[plugins] Skipping ${file}: missing or invalid 'tool' export
+`);
+          continue;
+        }
+        if (this.tools.has(tool.definition.name) && !this.pluginToolNames.has(tool.definition.name)) {
+          process.stderr.write(`[plugins] Skipping ${file}: name '${tool.definition.name}' conflicts with built-in tool
+`);
+          continue;
+        }
+        this.register(tool);
+        this.pluginToolNames.add(tool.definition.name);
+        loaded++;
+        process.stderr.write(`[plugins] Loaded: ${tool.definition.name} (${file})
+`);
+      } catch (err) {
+        process.stderr.write(`[plugins] Failed to load ${file}: ${err.message}
+`);
+      }
+    }
+    return loaded;
+  }
+};
+
+export {
+  EnvLoader,
+  isFileWriteTool,
+  getDangerLevel,
+  schemaToJsonSchema,
+  initTheme,
+  theme,
+  undoStack,
+  lastResponseStore,
+  askUserContext,
+  googleSearchContext,
+  setContextWindow,
+  getActiveMaxChars,
+  truncateOutput,
+  spawnAgentContext,
+  ToolRegistry
+};