minimal-agent 0.1.0

package/dist/main.js

@@ -0,0 +1,4140 @@
+#!/usr/bin/env node
+
+// src/main.tsx
+import { render } from "ink";
+import { createRequire } from "module";
+
+// src/config/configFile.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function getConfigFilePath() {
+  return process.env.MINIMAL_AGENT_CONFIG_FILE ?? join(homedir(), ".minimal-agent", "config.json");
+}
+async function readSavedConfig() {
+  const file = getConfigFilePath();
+  try {
+    const raw = await readFile(file, "utf8");
+    const data = JSON.parse(raw);
+    if (typeof data.baseURL !== "string" || typeof data.apiKey !== "string" || typeof data.model !== "string" || data.baseURL.length === 0 || data.apiKey.length === 0 || data.model.length === 0) {
+      return null;
+    }
+    return {
+      baseURL: data.baseURL,
+      apiKey: data.apiKey,
+      model: data.model,
+      provider: typeof data.provider === "string" ? data.provider : void 0,
+      contextWindow: typeof data.contextWindow === "number" && data.contextWindow > 0 ? data.contextWindow : void 0,
+      savedAt: typeof data.savedAt === "number" ? data.savedAt : 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(cfg) {
+  const file = getConfigFilePath();
+  await mkdir(dirname(file), { recursive: true });
+  const data = { ...cfg, savedAt: Date.now() };
+  await writeFile(file, JSON.stringify(data, null, 2), "utf8");
+  try {
+    await chmod(file, 384);
+  } catch {
+  }
+}
+
+// src/config.ts
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+async function loadProvider() {
+  const baseURL = process.env.MINIMAL_AGENT_BASE_URL;
+  const apiKey = process.env.MINIMAL_AGENT_API_KEY;
+  const model = process.env.MINIMAL_AGENT_MODEL;
+  if (!baseURL || !apiKey || !model) {
+    const missing = [];
+    if (!baseURL) missing.push("MINIMAL_AGENT_BASE_URL");
+    if (!apiKey) missing.push("MINIMAL_AGENT_API_KEY");
+    if (!model) missing.push("MINIMAL_AGENT_MODEL");
+    throw new Error(
+      `\u7F3A\u5C11\u5FC5\u9700\u7684\u73AF\u5883\u53D8\u91CF\uFF1A${missing.join(", ")}
+
+\u8BF7\u5728 .env \u4E2D\u914D\u7F6E\uFF1A
+  MINIMAL_AGENT_BASE_URL=https://api.example.com/v1
+  MINIMAL_AGENT_API_KEY=your-api-key
+  MINIMAL_AGENT_MODEL=your-model
+
+\u53C2\u8003 .env.example`
+    );
+  }
+  const contextWindowRaw = process.env.MINIMAL_AGENT_CONTEXT_WINDOW;
+  let contextWindow = DEFAULT_CONTEXT_WINDOW;
+  if (contextWindowRaw) {
+    const n = parseInt(contextWindowRaw, 10);
+    if (!Number.isNaN(n) && n > 0) {
+      contextWindow = n;
+    }
+  }
+  return {
+    name: process.env.MINIMAL_AGENT_PROVIDER ?? "env",
+    baseURL,
+    apiKey,
+    model,
+    contextWindow
+  };
+}
+async function loadProviderLayered() {
+  const envBaseURL = process.env.MINIMAL_AGENT_BASE_URL;
+  const envApiKey = process.env.MINIMAL_AGENT_API_KEY;
+  const envModel = process.env.MINIMAL_AGENT_MODEL;
+  const envName = process.env.MINIMAL_AGENT_PROVIDER;
+  const envContextRaw = process.env.MINIMAL_AGENT_CONTEXT_WINDOW;
+  let saved = null;
+  if (!envBaseURL || !envApiKey || !envModel) {
+    saved = await readSavedConfig();
+  }
+  const baseURL = envBaseURL ?? saved?.baseURL;
+  const apiKey = envApiKey ?? saved?.apiKey;
+  const model = envModel ?? saved?.model;
+  if (!baseURL || !apiKey || !model) return null;
+  let contextWindow = DEFAULT_CONTEXT_WINDOW;
+  if (envContextRaw) {
+    const n = parseInt(envContextRaw, 10);
+    if (!Number.isNaN(n) && n > 0) contextWindow = n;
+  } else if (saved?.contextWindow) {
+    contextWindow = saved.contextWindow;
+  }
+  return {
+    name: envName ?? saved?.provider ?? "env",
+    baseURL,
+    apiKey,
+    model,
+    contextWindow
+  };
+}
+
+// src/context/persistContext.ts
+import { mkdir as mkdir2, readFile as readFile2, unlink, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+function getContextPath() {
+  return process.env.MINIMAL_AGENT_CONTEXT_FILE ?? join2(homedir2(), ".minimal-agent", "last-context.json");
+}
+async function loadContext() {
+  const file = getContextPath();
+  try {
+    const raw = await readFile2(file, "utf8");
+    const data = JSON.parse(raw);
+    if (!Array.isArray(data.messages)) return null;
+    return data.messages;
+  } catch {
+    return null;
+  }
+}
+async function saveContext(messages) {
+  const file = getContextPath();
+  try {
+    await mkdir2(dirname2(file), { recursive: true });
+    const data = { updatedAt: Date.now(), messages };
+    await writeFile2(file, JSON.stringify(data), "utf8");
+  } catch {
+  }
+}
+async function clearContext() {
+  const file = getContextPath();
+  try {
+    await unlink(file);
+  } catch {
+  }
+}
+
+// src/prompts/system.ts
+import { homedir as homedir3 } from "os";
+
+// src/prompts/projectInstructions.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+var FILENAME = "minimal-agent.md";
+async function loadProjectInstructions(cwd) {
+  const filePath = join3(cwd, FILENAME);
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    const trimmed = content.trim();
+    if (trimmed.length === 0) return null;
+    return trimmed;
+  } catch (e) {
+    const code = e.code;
+    if (code !== "ENOENT") {
+      process.stderr.write(
+        `[minimal-agent] \u8DF3\u8FC7\u9879\u76EE\u6307\u4EE4 ${filePath}\uFF1A${code ?? e.message}
+`
+      );
+    }
+    return null;
+  }
+}
+
+// src/prompts/skillList.ts
+import { readFile as readFile4, readdir } from "fs/promises";
+import { join as join4, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var PROJECT_ROOT = join4(__dirname, "..", "..");
+var SKILLS_DIR = join4(PROJECT_ROOT, "skills");
+function stripQuotes(s) {
+  const trimmed = s.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const frontmatter = match[1];
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+  const typeMatch = frontmatter.match(/^type:\s*(.+)$/m);
+  const triggersMatch = frontmatter.match(/^triggers:\s*(.+)$/m);
+  if (!nameMatch || !descMatch) return null;
+  return {
+    name: stripQuotes(nameMatch[1]),
+    description: stripQuotes(descMatch[1]),
+    type: typeMatch ? stripQuotes(typeMatch[1]) : void 0,
+    triggers: triggersMatch ? stripQuotes(triggersMatch[1]) : void 0
+  };
+}
+async function getSkillList() {
+  const skills = [];
+  try {
+    const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = join4(SKILLS_DIR, entry.name, "SKILL.md");
+      try {
+        const content = await readFile4(skillPath, "utf8");
+        const meta = parseFrontmatter(content);
+        if (meta) {
+          skills.push(meta);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+function formatSkillHint(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("# \u53EF\u7528\u6280\u80FD\uFF08/\u547D\u4EE4\uFF09");
+  lines.push("");
+  lines.push(
+    "\u4EE5\u4E0B\u662F\u5F53\u524D\u53EF\u7528\u7684\u6280\u80FD\u3002**\u5F53\u7528\u6237\u610F\u56FE\u5339\u914D\u67D0\u4E2A\u6280\u80FD\u7684\u89E6\u53D1\u65F6\u673A\u65F6\uFF0C\u4F60\u5E94\u8BE5\u4E3B\u52A8\u4F7F\u7528\u5B83**\u3002"
+  );
+  lines.push("\u5728\u4F7F\u7528\u524D\uFF0C\u5148\u7528 Read \u5DE5\u5177\u8BFB\u53D6 `skills/{name}/SKILL.md` \u4E86\u89E3\u5B8C\u6574\u6D41\u7A0B\u3002");
+  lines.push("");
+  for (const skill of skills) {
+    const type = skill.type ?? "prompt\uFF08\u5C55\u5F00\u4E3A\u7CFB\u7EDF\u63D0\u793A\u8BCD\uFF0C\u6307\u5BFC\u6A21\u578B\u6267\u884C\u590D\u6742\u4EFB\u52A1\uFF09";
+    const triggers = skill.triggers ?? "\uFF08\u8BE6\u89C1 SKILL.md\uFF09";
+    lines.push(`## ${skill.name}`);
+    lines.push(`- **\u89E6\u53D1\u65F6\u673A**: ${triggers}`);
+    lines.push(`- **\u529F\u80FD**: ${skill.description}`);
+    lines.push(`- **\u7C7B\u578B**: ${type}`);
+    lines.push("");
+  }
+  lines.push("## \u6280\u80FD\u8C03\u7528\u6D41\u7A0B");
+  lines.push("");
+  lines.push("```");
+  lines.push("1. \u5728 T \u9636\u6BB5\u5224\u65AD\u7528\u6237\u610F\u56FE\u662F\u5426\u5339\u914D\u67D0\u4E2A\u6280\u80FD\u7684\u89E6\u53D1\u65F6\u673A");
+  lines.push("2. \u5339\u914D \u2192 \u5728 A \u9636\u6BB5\u7528 Read \u5DE5\u5177\u8BFB\u53D6 skills/{name}/SKILL.md");
+  lines.push("3. \u6309\u7167 SKILL.md \u7684 Quick Reference \u548C\u6D41\u7A0B\u6267\u884C");
+  lines.push("4. \u5982\u679C\u6280\u80FD\u7C7B\u578B\u662F prompt\uFF0C\u5C06\u5176\u5185\u5BB9\u4F5C\u4E3A\u989D\u5916\u4E0A\u4E0B\u6587\u6307\u5BFC\u540E\u7EED\u64CD\u4F5C");
+  lines.push("```");
+  lines.push("");
+  lines.push("> \u{1F4A1} \u6280\u80FD\u662F\u5DE5\u5177\u7684\u7EC4\u5408\u62F3\u3002\u5355\u4E2A\u5DE5\u5177\u662F\u57FA\u7840\u64CD\u4F5C\uFF1B\u6280\u80FD\u662F\u9488\u5BF9\u7279\u5B9A\u573A\u666F\u7684\u6807\u51C6\u5316\u5DE5\u4F5C\u6D41\u3002");
+  return lines.join("\n");
+}
+
+// src/prompts/system.ts
+async function getSystemPrompt(cwd, tools) {
+  const toolList = tools.map((t) => `  - ${t.name}`).join("\n");
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const skills = await getSkillList();
+  const skillHint = formatSkillHint(skills);
+  return `\u4F60\u662F minimal-agent\uFF0C\u4E00\u4E2A\u6700\u5C0F\u5316\u7684 AI \u7F16\u7A0B\u52A9\u624B\u3002
+\u4F60\u8FD0\u884C\u5728\u7528\u6237\u7684\u672C\u5730\u7EC8\u7AEF\u91CC\uFF0C\u53EF\u4EE5\u8BFB\u53D6\u3001\u4FEE\u6539\u3001\u521B\u5EFA\u6587\u4EF6\uFF0C\u53EF\u4EE5\u641C\u7D22\u6587\u4EF6\u540D\u548C\u6587\u4EF6\u5185\u5BB9\uFF0C\u53EF\u4EE5\u8054\u7F51\u641C\u7D22\u6700\u65B0\u4FE1\u606F\u3002
+
+# \u5DE5\u4F5C\u73AF\u5883
+- \u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55: ${cwd}
+- \u7528\u6237\u4E3B\u76EE\u5F55: ${homedir3()}
+- \u5E73\u53F0: ${process.platform}
+- \u5F53\u524D\u65E5\u671F: ${today}
+
+# \u65F6\u95F4\u611F\u77E5\u89C4\u5219\uFF08\u91CD\u8981\uFF01\u641C\u7D22\u524D\u5FC5\u8BFB\uFF09
+- **\u6BCF\u6B21\u6267\u884C WebSearch \u524D\uFF0C\u5FC5\u987B\u5148\u786E\u8BA4\u5F53\u524D\u65E5\u671F**
+- \u5F53\u524D\u65E5\u671F\uFF1A${today}
+- \u641C\u7D22\u65F6\u5FC5\u987B\u5728 query \u672B\u5C3E\u9644\u5E26\u65E5\u671F\u9650\u5236\uFF0C\u5982 "... as of [\u65E5\u671F]" \u6216 "... ${today}"
+- \u4F8B\u5982\u641C\u7D22\u65E5\u672C\u653F\u7B56\u65F6\u5199\uFF1A"\u65E5\u672C\u5165\u5883\u653F\u7B56 ${today}"
+- \u7981\u6B62\u4F7F\u7528 "\u73B0\u5728"\u3001"\u6700\u8FD1"\u3001"\u6700\u65B0" \u7B49\u6A21\u7CCA\u65F6\u95F4\u8BCD\u2014\u2014\u5FC5\u987B\u7528\u5177\u4F53\u65E5\u671F
+
+# \u53EF\u7528\u5DE5\u5177
+${toolList}
+
+# \u5DE5\u5177\u4F7F\u7528\u89C4\u8303
+- \u4FEE\u6539\u65E2\u6709\u6587\u4EF6\u4E4B\u524D\uFF0C\u5FC5\u987B\u7528 Read \u5DE5\u5177\u8BFB\u53D6\u76F8\u5173\u4EE3\u7801\u7684\u6700\u65B0\u5185\u5BB9\u3002
+  "\u6211\u8BB0\u5F97"\u3001"\u6211\u4E4B\u524D\u770B\u8FC7"\u3001"\u5E94\u8BE5\u5DEE\u4E0D\u591A"\u90FD\u4E0D\u7B97\u8BFB\u8FC7\u2014\u2014\u5FC5\u987B\u5728\u672C\u8F6E\u4EFB\u52A1\u4E2D\u5B9E\u9645\u8C03\u7528 Read\u3002
+  \u5C24\u5176\u5F53\u4F60\u8981\u53C2\u8003\u67D0\u4E2A\u6587\u4EF6\u7684\u5199\u6CD5\u6765\u5B9E\u73B0\u7C7B\u4F3C\u529F\u80FD\u65F6\uFF0C\u5FC5\u987B\u5148\u91CD\u8BFB\u8BE5\u6587\u4EF6\u7684\u5173\u952E\u90E8\u5206\uFF08\u51FD\u6570\u5B9E\u73B0\u3001\u5224\u65AD\u903B\u8F91\u3001\u6570\u636E\u6D41\uFF09\uFF0C\u7406\u89E3\u6E05\u695A\u540E\u518D\u52A8\u624B\u3002
+- Edit \u5DE5\u5177\u7684 old_string \u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF1B\u4E0D\u552F\u4E00\u65F6\u8BF7\u6269\u5927\u4E0A\u4E0B\u6587\u6216\u663E\u5F0F replace_all=true\u3002
+- \u521B\u5EFA\u65B0\u6587\u4EF6\u7528 Write\uFF0C\u6216 Edit \u65F6 old_string \u4F20\u7A7A\u5B57\u7B26\u4E32\u3002
+- \u627E\u6587\u4EF6\u7528 Glob\uFF08"**/*.ts"\uFF09\uFF0C\u627E\u6587\u4EF6\u5185\u5BB9\u7528 Grep\uFF08\u57FA\u4E8E ripgrep\uFF09\u3002
+- \u5F53\u7528\u6237\u95EE\u5230\u8BAD\u7EC3\u622A\u6B62\u540E\u624D\u51FA\u73B0\u7684\u4FE1\u606F\uFF08\u6700\u65B0\u7248\u672C\u53F7\u3001\u8FD1\u671F\u65B0\u95FB\u3001\u7B2C\u4E09\u65B9 API \u6587\u6863\uFF09\u65F6\u7528 WebSearch\uFF1B\u4F18\u5148\u7CBE\u786E\u7684\u81EA\u7136\u8BED\u8A00\u67E5\u8BE2\u3002
+- \u5F53\u9700\u8981\u6267\u884C\u7EC8\u7AEF\u547D\u4EE4\uFF08\u5B89\u88C5\u4F9D\u8D56\u3001\u8FD0\u884C\u6D4B\u8BD5/\u6784\u5EFA/lint\u3001git \u64CD\u4F5C\u3001\u6587\u4EF6\u7CFB\u7EDF\u64CD\u4F5C\u7B49\uFF09\u65F6\u7528 Bash\u3002
+  \u26A0\uFE0F **Bash \u662F\u4E07\u80FD\u5DE5\u5177\uFF0C\u4F46\u5FC5\u987B\u4F5C\u4E3A\u6700\u540E\u624B\u6BB5**\uFF1A\u5F53 Read/Edit/Write/Glob/Grep \u7B49\u4E13\u7528\u5DE5\u5177\u65E0\u6CD5\u5B8C\u6210\u4EFB\u52A1\u65F6\uFF0C\u624D\u8003\u8651\u7528 Bash\u3002
+  \u4E0D\u8981\u7528 Bash \u6267\u884C find/grep/cat/head/tail/sed/awk/echo \u7B49\u547D\u4EE4\u6765\u66FF\u4EE3\u4E13\u7528\u5DE5\u5177\u2014\u2014\u4E13\u7528\u5DE5\u5177\u63D0\u4F9B\u66F4\u597D\u7684\u7528\u6237\u4F53\u9A8C\u548C\u53EF\u5BA1\u8BA1\u6027\u3002
+  Bash \u6709\u5B89\u5168\u9ED1\u540D\u5355\uFF08rm -rf /\u3001mkfs\u3001shutdown \u7B49\u5371\u9669\u547D\u4EE4\u4F1A\u88AB\u62E6\u622A\uFF09\uFF0C\u4F46\u4ECD\u9700\u8C28\u614E\uFF1A
+  \u5148\u786E\u8BA4\u547D\u4EE4\u65E0\u5BB3\u518D\u6267\u884C\uFF0C\u907F\u514D\u4E0D\u53EF\u9006\u64CD\u4F5C\uFF08\u5982 git push --force\u3001git reset --hard\uFF09\u3002
+  \u957F\u65F6\u95F4\u8FD0\u884C\u7684\u547D\u4EE4\uFF08npm install\u3001bun test\uFF09\u6CE8\u610F\u8D85\u65F6\u8BBE\u7F6E\uFF1B\u9700\u8981\u4EA4\u4E92\u8F93\u5165\u7684\u547D\u4EE4\u4E0D\u8981\u7528 Bash\uFF08\u7528 Write \u5199\u811A\u672C\u4EE3\u66FF\uFF09\u3002
+- \u5F53\u9700\u8981\u83B7\u53D6\u7F51\u9875\u9759\u6001\u6587\u672C\u5185\u5BB9\uFF08\u6293\u53D6\u6587\u6863\u3001\u8BFB\u53D6\u6587\u7AE0\uFF09\u65F6\u7528 WebFetch\u3002
+  WebBrowser \u4F9D\u8D56\u53EF\u9009\u5305\uFF08playwright-core + chromium\uFF09\u2014\u2014 **\u9ED8\u8BA4\u5047\u5B9A\u672A\u5B89\u88C5**\uFF0C
+  \u4EC5\u5728 WebFetch \u660E\u786E\u65E0\u6CD5\u6EE1\u8DB3\uFF08\u5982\u9700\u8981 JS \u6E32\u67D3\u540E\u7684\u5185\u5BB9\u3001\u70B9\u51FB\u6309\u94AE\u3001\u586B\u8868\u5355\u3001\u622A\u56FE\uFF09\u65F6\u518D\u5C1D\u8BD5\u3002
+  \u5982\u679C WebBrowser \u62A5"\u65E0\u6CD5\u542F\u52A8\u6D4F\u89C8\u5668/\u7F3A\u5C11\u4F9D\u8D56"\uFF0C\u4E0D\u8981\u91CD\u8BD5\uFF0C\u6539\u56DE WebFetch \u6216\u544A\u77E5\u7528\u6237\u5B89\u88C5\u4F9D\u8D56\u3002
+- \u4E00\u6B21\u56DE\u7B54\u91CC\u53EF\u4EE5\u5E76\u884C\u8C03\u7528\u591A\u4E2A\u53EA\u8BFB\u5DE5\u5177\uFF08Read/Glob/Grep/WebSearch/WebFetch\uFF09\uFF0C\u5199\u5DE5\u5177\uFF08Edit/Write/Bash\uFF09\u8BF7\u9010\u4E2A\u6267\u884C\u3002
+
+# \u6280\u80FD\u7CFB\u7EDF\uFF08\u79EF\u6781\u4F7F\u7528\uFF09
+${skillHint}
+
+# \u6587\u4EF6\u8BFB\u53D6\u89C4\u8303\uFF08\u91CD\u8981\uFF01\u9632\u6B62\u4E0A\u4E0B\u6587\u6C61\u67D3\uFF09
+## \u8BFB\u53D6\u7B56\u7565\uFF08\u6309\u573A\u666F\u9009\u62E9\uFF09
+### \u573A\u666F 1\uFF1A\u4E0D\u786E\u5B9A\u6587\u4EF6\u5185\u5BB9
+\u2192 \u5148 Grep("\u5173\u952E\u5B57", path="\u6587\u4EF6\u8DEF\u5F84") \u5B9A\u4F4D
+\u2192 \u518D Read(file_path, offset=X, limit=Y) \u8BFB\u6307\u5B9A\u533A\u57DF
+
+### \u573A\u666F 2\uFF1A\u77E5\u9053\u8981\u6539\u54EA\u4E2A\u51FD\u6570
+\u2192 \u76F4\u63A5 Read(file_path, offset=1, limit=400) \u5148\u8BFB\u524D 400 \u884C
+\u2192 \u6216\u8005\u7528 Grep \u627E\u5230\u884C\u53F7\u540E Read(file_path, offset=\u884C\u53F7, limit=200)
+
+### \u573A\u666F 3\uFF1A\u5927\u6587\u4EF6\uFF08>256KB\uFF09
+\u2192 \u4E0D\u8981\u4E00\u6B21\u6027\u8BFB\uFF0C\u7528 Grep \u5B9A\u4F4D\u5173\u952E\u90E8\u5206
+\u2192 \u5206\u591A\u6B21\u5C0F\u8303\u56F4 Read\uFF0C\u6BCF\u6B21\u4E0D\u8D85\u8FC7 200 \u884C
+\u2192 \u4F8B\u5982\uFF1ARead(file, offset=1, limit=100) \u2192 Read(file, offset=101, limit=100)
+
+### \u573A\u666F 4\uFF1A\u9700\u8981\u770B imports/exports
+\u2192 Read(file, offset=1, limit=50) \u53EA\u8BFB\u6587\u4EF6\u5934\u90E8
+
+## \u8B66\u60D5\u4FE1\u53F7
+- \u9047\u5230 "\u6587\u4EF6\u8FC7\u5927" \u9519\u8BEF \u2192 \u8BF4\u660E\u4F60\u8BFB\u4E86\u4E0D\u8BE5\u8BFB\u7684\u5927\u6587\u4EF6\uFF0C\u6539\u7528\u5206\u6BB5\u8BFB
+- \u9047\u5230 "\u8F93\u51FA\u8D85\u8FC7 30000 \u5B57\u7B26" \u2192 \u8BF4\u660E\u5355\u6B21\u8BFB\u592A\u591A\uFF0C\u6539\u5C0F limit
+
+# \u8F93\u51FA\u98CE\u683C
+- \u7528\u4E2D\u6587\u56DE\u7B54\u7528\u6237\u3002
+- \u7B80\u660E\u627C\u8981\uFF0C\u907F\u514D\u91CD\u590D\u89E3\u91CA\u4EE3\u7801\u505A\u4E86\u4EC0\u4E48 \u2014\u2014 \u8BA9\u4EE3\u7801\u81EA\u8EAB\u8BF4\u8BDD\u3002
+- \u62A5\u9519\u65F6\u7ED9\u51FA\u6839\u56E0\uFF0C\u4E0D\u8981\u53EA\u590D\u8FF0\u9519\u8BEF\u6D88\u606F\u3002
+- \u4E0D\u4E3B\u52A8\u8DD1\u6D4B\u8BD5\u6216 typecheck\uFF0C\u9664\u975E\u7528\u6237\u8981\u6C42\u3002
+
+# \u884C\u4E3A\u7EA6\u675F
+- \u6CA1\u6709\u7528\u6237\u8BB8\u53EF\u4E0D\u8981\u6267\u884C\u7834\u574F\u6027\u64CD\u4F5C\uFF08rm -rf / git reset --hard / git push --force \u7B49\uFF09\u3002
+- \u5982\u679C\u7528\u6237\u7684\u8BF7\u6C42\u4E0D\u6E05\u6670\uFF0C\u5148\u7528\u4E00\u53E5\u8BDD\u6F84\u6E05\u518D\u52A8\u624B\u3002
+- \u4EFB\u52A1\u5B8C\u6210\u540E\u7528\u4E00\u4E24\u53E5\u8BDD\u603B\u7ED3\u6539\u4E86\u4EC0\u4E48\uFF0C\u4E0D\u8981\u957F\u7BC7\u5927\u8BBA\u3002
+
+# \u4E2D\u65AD\u652F\u6301
+- \u7528\u6237\u53EF\u4EE5\u968F\u65F6\u6309 ESC \u6216 Ctrl+C \u4E2D\u65AD\u4F60\u7684\u5DE5\u4F5C\u3002
+- \u4E2D\u65AD\u540E\u7B49\u5F85\u7528\u6237\u8F93\u5165\u65B0\u4EFB\u52A1\uFF0C\u4E0D\u8981\u81EA\u884C\u7EE7\u7EED\u6267\u884C\u88AB\u4E2D\u65AD\u7684\u64CD\u4F5C\u3002
+- \u5982\u679C\u7528\u6237\u8F93\u5165\u4E86\u65B0\u4EFB\u52A1\uFF0C\u76F4\u63A5\u54CD\u5E94\u65B0\u4EFB\u52A1\uFF0C\u4E0D\u5FC5\u63D0\u53CA\u4E4B\u524D\u88AB\u4E2D\u65AD\u7684\u64CD\u4F5C\u3002
+
+# \u4EFB\u52A1\u8BC6\u522B
+- \u7528\u6237\u5F00\u59CB\u65B0\u4EFB\u52A1\u65F6\uFF08"\u5E2E\u6211\u505A X"\u3001"\u8FD9\u6B21\u505A YYY"\uFF09\uFF0C\u4E0D\u8981\u7EE7\u7EED\u4E4B\u524D\u672A\u5B8C\u6210\u7684\u65E7\u4EFB\u52A1
+- \u7528\u6237\u8BF4"\u7EE7\u7EED"\u3001"\u63A5\u7740\u505A"\u3001"\u518D\u52A0\u4E00\u4E2A"\u65F6\uFF0C\u4FDD\u6301\u5F53\u524D\u4EFB\u52A1\u4E0A\u4E0B\u6587
+- \u7528\u6237\u8BF4"\u91CD\u65B0\u5F00\u59CB"\u3001"\u4E0D\u7B97\u4E86\uFF0C\u505A X"\u65F6\uFF0C\u7ACB\u5373\u653E\u4E0B\u65E7\u4EFB\u52A1
+- \u610F\u56FE\u6A21\u7CCA\u65F6\uFF0C\u5148\u7528\u4E00\u53E5\u8BDD\u6F84\u6E05\uFF1A"\u4F60\u662F\u7EE7\u7EED\u521A\u624D\u7684\uFF0C\u8FD8\u662F\u5F00\u59CB\u65B0\u7684\uFF1F"`;
+}
+async function buildFullSystemPrompt(cwd, tools) {
+  let content = await getSystemPrompt(cwd, tools);
+  const projectInstructions = await loadProjectInstructions(cwd);
+  if (projectInstructions) {
+    content += [
+      "",
+      "--- \u9879\u76EE\u6307\u4EE4\uFF08minimal-agent.md\uFF09 ---",
+      "",
+      "\u26A0\uFE0F \u65F6\u6548\u6027\u58F0\u660E\uFF1A",
+      "- \u4EE5\u4E0B\u5185\u5BB9\u6765\u6E90\u4E8E\u9879\u76EE\u6839\u76EE\u5F55\u7684 `minimal-agent.md` \u6587\u4EF6\uFF0C\u5177\u6709\u65F6\u6548\u6027\uFF0C\u53EF\u80FD\u5DF2\u8FC7\u65F6\u3002",
+      "- \u5B83\u662F\u53C2\u8003\u7EBF\u7D22\uFF0C\u4E0D\u662F\u7EDD\u5BF9\u771F\u7406\u3002\u5F53\u5B83\u4E0E\u5B9E\u9645\u4EE3\u7801\u6216\u6587\u4EF6\u5185\u5BB9\u51B2\u7A81\u65F6\uFF0C\u4EE5\u4EE3\u7801\u4E3A\u51C6\u3002",
+      "- \u6D89\u53CA\u4EE3\u7801\u548C\u9879\u76EE\u6587\u4EF6\u7684\u4EFB\u4F55\u64CD\u4F5C\u524D\uFF0C\u5FC5\u987B\u5148\u7528 Read / Grep \u5DE5\u5177\u786E\u8BA4\u5F53\u524D\u4EE3\u7801\u7684\u5B9E\u9645\u72B6\u6001\uFF0C\u518D\u57FA\u4E8E\u6700\u65B0\u4FE1\u606F\u505A\u51B3\u7B56\uFF0C\u4E0D\u8981\u4EC5\u51ED\u6B64\u6587\u6863\u7684\u63CF\u8FF0\u64CD\u4F5C\u3002",
+      "- \u5982\u679C\u4F60\u53D1\u73B0 `minimal-agent.md` \u7684\u63CF\u8FF0\u4E0E\u5F53\u524D\u4EE3\u7801\u4E0D\u4E00\u81F4\uFF0C\u5E94\u4E3B\u52A8\u7528 Write \u5DE5\u5177\u66F4\u65B0 `minimal-agent.md` \u4F7F\u5176\u4E0E\u4EE3\u7801\u4FDD\u6301\u540C\u6B65\u3002",
+      "",
+      projectInstructions
+    ].join("\n");
+  }
+  return content;
+}
+
+// src/tools/bash/bash.ts
+import { spawn } from "child_process";
+import { z } from "zod";
+
+// src/tools/types.ts
+var DEFAULT_MAX_RESULT_SIZE_CHARS = 3e4;
+var MAX_LINES_TO_READ = 2e3;
+var MAX_FILE_SIZE_BYTES = 256 * 1024;
+
+// src/utils/zodToJson.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+function toToolParameters(schema) {
+  const json = zodToJsonSchema(schema, {
+    target: "openApi3",
+    $refStrategy: "none"
+  });
+  const { $schema, ...rest } = json;
+  return rest;
+}
+
+// src/tools/bash/bash.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_TIMEOUT_MS = 6e5;
+var FORBIDDEN_PATTERNS = [
+  // ---- rm -rf / 及变体 ----
+  // 经典："rm -rf /"、"rm -rf /*"、"rm -fr /usr"、"rm -rf $HOME"、"rm -rf ~"
+  // 也覆盖 sudo rm -rf /
+  {
+    pattern: /\brm\s+(?:-[a-zA-Z]*[rRf][a-zA-Z]*\s+)+(?:\/+\*?|\$HOME|~)(?:\s|$)/,
+    reason: "\u7981\u6B62\u9012\u5F52\u5220\u9664\u6839\u76EE\u5F55\u6216\u5BB6\u76EE\u5F55\uFF08rm -rf / \u7C7B\uFF09"
+  },
+  // 拦截 "rm -rf <绝对路径>" 中目标是关键系统目录的情况（防误伤其它正常 rm -rf ./tmp）
+  {
+    pattern: /\brm\s+(?:-[a-zA-Z]*[rRf][a-zA-Z]*\s+)+(?:\/etc|\/usr|\/bin|\/sbin|\/var|\/boot|\/lib|\/System|\/Windows|\/Users|\/home)(?:\/|\s|$)/,
+    reason: "\u7981\u6B62\u9012\u5F52\u5220\u9664\u7CFB\u7EDF\u5173\u952E\u76EE\u5F55"
+  },
+  // ---- 格盘 / 改写裸设备 ----
+  {
+    pattern: /\bmkfs(?:\.[a-z0-9]+)?\b/i,
+    reason: "\u7981\u6B62\u683C\u5F0F\u5316\u6587\u4EF6\u7CFB\u7EDF\uFF08mkfs\uFF09"
+  },
+  {
+    // 末尾不能用 \b：盘符 "C:" 后是非 word char，\b 匹配不到。
+    // 改成"盘符后跟空白/反斜杠/结尾"。
+    pattern: /\bformat\s+[A-Za-z]:(?=\s|\\|$)/i,
+    reason: "\u7981\u6B62 Windows \u683C\u76D8\u547D\u4EE4\uFF08format X:\uFF09"
+  },
+  {
+    pattern: /\bdd\s+[^|;&]*\bof=\/dev\/(?:sd[a-z]|nvme|disk|hd[a-z]|mmcblk)/i,
+    reason: "\u7981\u6B62 dd \u5199\u5165\u88F8\u78C1\u76D8\u8BBE\u5907"
+  },
+  {
+    pattern: />\s*\/dev\/(?:sd[a-z]|nvme|disk|hd[a-z]|mmcblk)/i,
+    reason: "\u7981\u6B62\u91CD\u5B9A\u5411\u5230\u88F8\u78C1\u76D8\u8BBE\u5907"
+  },
+  // ---- 关机 / 重启 ----
+  {
+    pattern: /\b(?:shutdown|reboot|halt|poweroff)\b/i,
+    reason: "\u7981\u6B62\u5173\u673A/\u91CD\u542F\u547D\u4EE4"
+  },
+  {
+    pattern: /\binit\s+[06]\b/,
+    reason: "\u7981\u6B62 init 0/6\uFF08\u5173\u673A/\u91CD\u542F\uFF09"
+  },
+  // ---- Fork bomb ----
+  {
+    pattern: /:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/,
+    reason: "\u7981\u6B62 fork bomb"
+  },
+  // ---- 管道到 shell（典型恶意安装脚本模式） ----
+  // curl ... | sh / wget ... | bash / curl ... | python
+  {
+    pattern: /\b(?:curl|wget|fetch)\b[^|;&]*\|\s*(?:sh|bash|zsh|dash|python|perl|ruby|node)\b/i,
+    reason: "\u7981\u6B62\u4ECE\u7F51\u7EDC\u7BA1\u9053\u5230 shell \u89E3\u91CA\u5668\uFF08curl ... | sh \u6A21\u5F0F\uFF09"
+  },
+  // ---- chmod 整盘 777 ----
+  {
+    pattern: /\bchmod\s+(?:-R\s+)?[0-7]*7[0-7]*\s+\/(?:\s|$)/,
+    reason: "\u7981\u6B62\u5BF9\u6839\u76EE\u5F55 chmod 777"
+  },
+  // ---- Windows 系统级删除 ----
+  {
+    pattern: /\b(?:del|erase)\s+\/[sS][^|;&]*[A-Za-z]:\\?\s*$/,
+    reason: "\u7981\u6B62 Windows \u5168\u76D8\u5220\u9664\uFF08del /s \u6839\u76EE\u5F55\uFF09"
+  },
+  {
+    pattern: /\brmdir\s+\/[sS][^|;&]*[A-Za-z]:\\?\s*$/,
+    reason: "\u7981\u6B62 Windows \u5168\u76D8 rmdir"
+  },
+  {
+    pattern: /\bdiskpart\b/i,
+    reason: "\u7981\u6B62 diskpart"
+  }
+];
+function checkForbidden(command) {
+  for (const { pattern, reason } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(command)) return reason;
+  }
+  return null;
+}
+var inputSchema = z.object({
+  command: z.string().min(1, "\u5FC5\u987B\u63D0\u4F9B command").describe("\u8981\u6267\u884C\u7684 shell \u547D\u4EE4\uFF08\u5047\u5B9A bash \u8BED\u6CD5\uFF09"),
+  timeout: z.number().int().positive().max(MAX_TIMEOUT_MS).optional().describe(`\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09\uFF0C\u6700\u591A ${MAX_TIMEOUT_MS}\uFF08${MAX_TIMEOUT_MS / 6e4} \u5206\u949F\uFF09\uFF1B\u4E0D\u586B\u9ED8\u8BA4 ${DEFAULT_TIMEOUT_MS}`),
+  description: z.string().optional().describe('\u7528\u4E00\u53E5\u8BDD\u4E3B\u52A8\u8BED\u6001\u63CF\u8FF0\u547D\u4EE4\u505A\u4EC0\u4E48\uFF085-10 \u8BCD\uFF09\uFF0C\u5982 "List files in current directory"')
+});
+var parameters = toToolParameters(inputSchema);
+var description = `Executes a given bash command and returns its output.
+
+The working directory persists between commands, but shell state does not. The shell environment is initialized from the user's profile.
+
+IMPORTANT: Avoid using this tool to run \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool as this will provide a much better experience for the user:
+
+ - File search: Use Glob (NOT find or ls)
+ - Content search: Use Grep (NOT grep or rg)
+ - Read files: Use Read (NOT cat/head/tail)
+ - Edit files: Use Edit (NOT sed/awk)
+ - Write files: Use Write (NOT echo >/cat <<EOF)
+ - Communication: Output text directly (NOT echo/printf)
+While the Bash tool can do similar things, it's better to use the built-in tools as they provide a better user experience and make it easier to review tool calls and give permission.
+
+# Instructions
+ - If your command will create new directories or files, first use this tool to run \`ls\` to verify the parent directory exists and is the correct location.
+ - Always quote file paths that contain spaces with double quotes in your command (e.g., cd "path with spaces/file.txt").
+ - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.
+ - You may specify an optional timeout in milliseconds (up to ${MAX_TIMEOUT_MS}ms / ${MAX_TIMEOUT_MS / 6e4} minutes). By default, your command will timeout after ${DEFAULT_TIMEOUT_MS}ms (${DEFAULT_TIMEOUT_MS / 6e4} minutes).
+ - When issuing multiple commands:
+  - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message.
+  - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them.
+  - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail.
+  - DO NOT use newlines to separate commands (newlines are ok in quoted strings and here-strings).
+ - For git commands:
+  - Prefer to create a new commit rather than amending an existing commit.
+  - Before running destructive operations (e.g., git reset --hard, git push --force, git checkout --), consider whether there is a safer alternative that achieves the same goal. Only use destructive operations when they are truly the best approach.
+  - Never skip hooks (--no-verify) or bypass signing (--no-gpg-sign, -c commit.gpgsign=false) unless the user has explicitly asked for it. If a hook fails, investigate and fix the underlying issue.
+ - Avoid unnecessary \`sleep\` commands; do not retry failing commands in a sleep loop \u2014 diagnose the root cause.
+
+# Safety
+The following command patterns are blocked at the tool level and will fail before execution (no need to try them):
+ - \`rm -rf /\` and variants targeting root, $HOME, ~, or system directories (/etc, /usr, /bin, /Windows, /Users, /home, ...)
+ - Filesystem destruction: \`mkfs\`, \`format X:\`, \`dd of=/dev/sdX\`, redirects to raw block devices
+ - Power management: \`shutdown\`, \`reboot\`, \`halt\`, \`poweroff\`, \`init 0/6\`
+ - Fork bombs
+ - Pipe-to-shell from network: \`curl ... | sh\`, \`wget ... | bash\`, etc.
+ - \`chmod 777 /\`, Windows full-disk \`del /s\` / \`rmdir /s\`, \`diskpart\`
+
+If you have a legitimate use case that requires one of the above patterns, ask the user to run the command themselves in their terminal \u2014 do not try to bypass the check.`;
+async function call(input, signal) {
+  const command = input.command;
+  const timeoutMs = Math.min(input.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+  const forbiddenReason = checkForbidden(command);
+  if (forbiddenReason) {
+    return {
+      ok: false,
+      error: `\u5B89\u5168\u68C0\u67E5\u62D2\u7EDD\u6267\u884C\uFF1A${forbiddenReason}
+\u547D\u4EE4\uFF1A${command}`
+    };
+  }
+  let stdout = "";
+  let stderr = "";
+  let exitCode = null;
+  let timedOut = false;
+  let killedBySignal = false;
+  const ac = new AbortController();
+  const onAbort = () => ac.abort();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    ac.abort();
+  }, timeoutMs);
+  try {
+    await new Promise((resolveP, rejectP) => {
+      const child = spawn(command, {
+        shell: true,
+        cwd: process.cwd(),
+        signal: ac.signal,
+        env: process.env,
+        windowsHide: true
+      });
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.on("error", (e) => {
+        if (e.code === "ABORT_ERR") {
+          killedBySignal = true;
+          resolveP();
+        } else {
+          rejectP(e);
+        }
+      });
+      child.on("close", (code, sig) => {
+        exitCode = code;
+        if (sig) killedBySignal = true;
+        resolveP();
+      });
+    });
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u6267\u884C\u547D\u4EE4\u5931\u8D25\uFF1A${e.message}
+\u547D\u4EE4\uFF1A${command}`
+    };
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+  const parts = [];
+  if (stdout) parts.push(`<stdout>
+${stdout.replace(/\s+$/, "")}
+</stdout>`);
+  if (stderr) parts.push(`<stderr>
+${stderr.replace(/\s+$/, "")}
+</stderr>`);
+  if (parts.length === 0) parts.push("<no output>");
+  if (timedOut) {
+    parts.push(`
+[\u8D85\u65F6 ${timeoutMs}ms \u540E\u88AB\u4E2D\u65AD]`);
+  } else if (killedBySignal && !timedOut) {
+    parts.push(`
+[\u88AB\u4FE1\u53F7\u4E2D\u65AD]`);
+  }
+  parts.push(`
+[exit code: ${exitCode === null ? "killed" : exitCode}]`);
+  let content = parts.join("\n");
+  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
+  }
+  if (timedOut || exitCode !== null && exitCode !== 0 || killedBySignal) {
+    return { ok: false, error: content };
+  }
+  return { ok: true, content };
+}
+var bashTool = {
+  name: "Bash",
+  description,
+  inputSchema,
+  parameters,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  // 默认按"会改状态"算；保守不并发
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call
+};
+
+// src/tools/edit/edit.ts
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname as dirname4, resolve } from "path";
+import { z as z2 } from "zod";
+var MAX_EDIT_FILE_SIZE_BYTES = 1024 * 1024 * 1024;
+var inputSchema2 = z2.object({
+  file_path: z2.string().min(1).describe("\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84"),
+  old_string: z2.string().describe(
+    "\u8981\u66FF\u6362\u7684\u539F\u6587\u672C\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u9664\u975E replace_all=true\uFF09\uFF1B\u4E3A\u7A7A\u5B57\u7B26\u4E32\u4E14\u6587\u4EF6\u4E0D\u5B58\u5728\u65F6\u521B\u5EFA\u65B0\u6587\u4EF6"
+  ),
+  new_string: z2.string().describe("\u66FF\u6362\u4E3A\u7684\u65B0\u6587\u672C\uFF08\u4E0E old_string \u5FC5\u987B\u4E0D\u540C\uFF09"),
+  replace_all: z2.boolean().optional().describe("\u662F\u5426\u66FF\u6362\u6240\u6709\u51FA\u73B0\u4F4D\u7F6E\uFF08\u9ED8\u8BA4 false\uFF09")
+});
+var parameters2 = toToolParameters(inputSchema2);
+var description2 = `Performs exact string replacements in files.
+
+Usage:
+- You MUST use your \`Read\` tool to read the current content of the file BEFORE calling Edit.
+  Memory is unreliable \u2014 if you think you "remember" how the code looks, you are probably wrong.
+  Re-read the relevant sections (function, module, or area you plan to change) every time.
+- To create a new file, pass an empty \`old_string\` and the desired contents as \`new_string\`.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+- Preserve exact indentation (tabs/spaces).`;
+function validatePath(filePath) {
+  if (filePath.includes("\0")) {
+    return { ok: false, error: "\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26\uFF08null byte\uFF09" };
+  }
+  if (process.platform === "win32" && filePath.includes("\\\\")) {
+    return { ok: false, error: "\u4E0D\u652F\u6301 UNC \u8DEF\u5F84\uFF08\\\\server\\share \u683C\u5F0F\uFF09\uFF0C\u8BF7\u4F7F\u7528\u672C\u5730\u8DEF\u5F84" };
+  }
+  return { ok: true };
+}
+async function call2(input) {
+  const filePath = resolve(input.file_path);
+  const { old_string, new_string } = input;
+  const replaceAll = input.replace_all ?? false;
+  const pathCheck = validatePath(filePath);
+  if (!pathCheck.ok) return pathCheck;
+  if (old_string === new_string) {
+    return { ok: false, error: "old_string \u4E0E new_string \u5B8C\u5168\u76F8\u540C\uFF0C\u6CA1\u6709\u53EF\u6539\u7684\u5185\u5BB9\u3002" };
+  }
+  if (old_string === "" && !existsSync(filePath)) {
+    try {
+      await mkdir3(dirname4(filePath), { recursive: true });
+      await writeFile3(filePath, new_string, "utf8");
+      return {
+        ok: true,
+        content: `\u5DF2\u521B\u5EFA\u65B0\u6587\u4EF6\uFF1A${filePath}\uFF08${new_string.length} \u5B57\u7B26\uFF09`
+      };
+    } catch (e) {
+      return { ok: false, error: `\u521B\u5EFA\u6587\u4EF6\u5931\u8D25\uFF1A${e.message}` };
+    }
+  }
+  if (!existsSync(filePath)) {
+    return {
+      ok: false,
+      error: `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${filePath}
+\uFF08\u8981\u521B\u5EFA\u65B0\u6587\u4EF6\uFF0C\u8BF7\u628A old_string \u8BBE\u4E3A\u7A7A\u5B57\u7B26\u4E32\uFF09`
+    };
+  }
+  let original;
+  try {
+    original = await readFile5(filePath, "utf8");
+  } catch (e) {
+    return { ok: false, error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` };
+  }
+  const fileSize = Buffer.byteLength(original, "utf8");
+  if (fileSize > MAX_EDIT_FILE_SIZE_BYTES) {
+    return {
+      ok: false,
+      error: `\u6587\u4EF6\u8FC7\u5927\uFF08${fileSize} \u5B57\u8282 > ${MAX_EDIT_FILE_SIZE_BYTES} \u5B57\u8282 \u2248 1GB\uFF09\u3002Edit \u4E0D\u9002\u5408\u64CD\u4F5C\u8D85\u5927\u6587\u4EF6\uFF0C\u8BF7\u7528 Write \u5DE5\u5177\u3002`
+    };
+  }
+  if (old_string === "") {
+    return {
+      ok: false,
+      error: "old_string \u4E3A\u7A7A\u4F46\u6587\u4EF6\u5DF2\u5B58\u5728 \u2014\u2014 \u8FD9\u901A\u5E38\u662F\u9519\u8BEF\u7684\u3002\u8981\u66FF\u6362\u5168\u6587\u8BF7\u7528 Write \u5DE5\u5177\u3002"
+    };
+  }
+  const occurrences = countOccurrences(original, old_string);
+  if (occurrences === 0) {
+    const hint = findFuzzyMatchHint(original, old_string);
+    const extraMsg = hint ? `
+
+\u{1F4A1} \u63D0\u793A\uFF1A${hint}` : "";
+    return {
+      ok: false,
+      error: `\u5728 ${filePath} \u4E2D\u627E\u4E0D\u5230 old_string\u3002\u8BF7\u5148\u7528 Read \u5DE5\u5177\u6838\u5BF9\u5185\u5BB9\uFF08\u6CE8\u610F\u7A7A\u683C/\u7F29\u8FDB/\u6362\u884C\uFF09\u3002${extraMsg}`
+    };
+  }
+  if (occurrences > 1 && !replaceAll) {
+    return {
+      ok: false,
+      error: `old_string \u5728\u6587\u4EF6\u4E2D\u51FA\u73B0\u4E86 ${occurrences} \u6B21\uFF0C\u4E0D\u552F\u4E00\u3002
+\u8BF7\u6269\u5927 old_string \u5305\u542B\u66F4\u591A\u4E0A\u4E0B\u6587\uFF0C\u6216\u663E\u5F0F\u4F20 replace_all=true\u3002`
+    };
+  }
+  const replaced = replaceAll ? splitReplaceAll(original, old_string, new_string) : original.replace(old_string, new_string);
+  try {
+    await writeFile3(filePath, replaced, "utf8");
+  } catch (e) {
+    return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
+  }
+  const linesBefore = original.split("\n").length;
+  const linesAfter = replaced.split("\n").length;
+  return {
+    ok: true,
+    content: `\u5DF2\u7F16\u8F91 ${filePath}
+\u66FF\u6362\u6B21\u6570\uFF1A${replaceAll ? occurrences : 1}
+\u884C\u6570\uFF1A${linesBefore} \u2192 ${linesAfter}`
+  };
+}
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function splitReplaceAll(haystack, needle, replacement) {
+  return haystack.split(needle).join(replacement);
+}
+function findFuzzyMatchHint(fileContent, target) {
+  const MIN_OVERLAP_RATIO = 0.5;
+  const MAX_HINTS = 3;
+  const targetTrimmed = target.trim();
+  if (targetTrimmed.length < 5) return null;
+  const lines = fileContent.split("\n");
+  const candidates = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmedLine = line.trim();
+    if (trimmedLine.length < 5) continue;
+    const ratio = lcsRatio(targetTrimmed, trimmedLine);
+    if (ratio >= MIN_OVERLAP_RATIO) {
+      candidates.push({ lineNum: i + 1, text: trimmedLine, ratio });
+    }
+  }
+  if (target.includes("\n") && candidates.length < MAX_HINTS) {
+    const targetLines = target.split("\n").filter((l) => l.trim().length > 0);
+    if (targetLines.length >= 2) {
+      for (let start = 0; start <= lines.length - targetLines.length; start++) {
+        const window = lines.slice(start, start + targetLines.length).map((l) => l.trim()).join("\n");
+        const ratio = lcsRatio(target.trim(), window);
+        if (ratio >= MIN_OVERLAP_RATIO) {
+          candidates.push({ lineNum: start + 1, text: window.slice(0, 80) + (window.length > 80 ? "..." : ""), ratio });
+        }
+      }
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => b.ratio - a.ratio);
+  const top = candidates.slice(0, MAX_HINTS);
+  const hints = top.map(
+    (c) => `\u7B2C ${c.lineNum} \u884C\u9644\u8FD1\u6709\u76F8\u4F3C\u5185\u5BB9\uFF08\u76F8\u4F3C\u5EA6 ${(c.ratio * 100).toFixed(0)}%\uFF09:
+      "${c.text.slice(0, 100)}${c.text.length > 100 ? "\u2026" : ""}"`
+  );
+  return `\u53EF\u80FD\u4F60\u60F3\u8981\u4FEE\u6539\u4EE5\u4E0B\u4F4D\u7F6E\u4E4B\u4E00\uFF1F
+  ${hints.join("\n  ")}`;
+}
+function lcsRatio(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const MAX_LEN = 500;
+  const aa = m > MAX_LEN ? a.slice(0, MAX_LEN) : a;
+  const bb = n > MAX_LEN ? b.slice(0, MAX_LEN) : b;
+  const mm = aa.length;
+  const nn = bb.length;
+  const dp = new Array(nn + 1).fill(0);
+  for (let i = 1; i <= mm; i++) {
+    let prev = 0;
+    for (let j = 1; j <= nn; j++) {
+      const temp = dp[j];
+      if (aa[i - 1] === bb[j - 1]) {
+        dp[j] = prev + 1;
+      } else {
+        dp[j] = Math.max(dp[j], dp[j - 1]);
+      }
+      prev = temp;
+    }
+  }
+  return dp[nn] / Math.max(mm, nn);
+}
+var editTool = {
+  name: "Edit",
+  description: description2,
+  inputSchema: inputSchema2,
+  parameters: parameters2,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call2
+};
+
+// src/tools/glob/glob.ts
+import { stat } from "fs/promises";
+import { isAbsolute, resolve as resolve2 } from "path";
+import fg from "fast-glob";
+import { z as z3 } from "zod";
+var inputSchema3 = z3.object({
+  pattern: z3.string().min(1).describe('glob \u6A21\u5F0F\uFF0C\u4F8B\u5982 "**/*.ts" \u6216 "src/components/**/*.tsx"'),
+  path: z3.string().optional().describe('\u641C\u7D22\u7684\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09\uFF1B\u7701\u7565\u65F6\u4E0D\u8981\u4F20 "undefined" \u5B57\u7B26\u4E32')
+});
+var parameters3 = toToolParameters(inputSchema3);
+var description3 = `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time (oldest first)
+- Use this tool when you need to find files by name patterns
+- When you need to do an open ended search that may require multiple rounds, prefer the Grep tool for content search`;
+async function call3(input) {
+  const cwd = input.path ? resolve2(input.path) : process.cwd();
+  const pattern = input.pattern.replace(/\\/g, "/");
+  let matches;
+  try {
+    matches = await fg(pattern, {
+      cwd,
+      dot: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      // 默认排除一些噪音目录；如果用户的 pattern 显式指了它们，这里也不会盖
+      ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+      absolute: false
+    });
+  } catch (e) {
+    return { ok: false, error: `glob \u5931\u8D25\uFF1A${e.message}` };
+  }
+  if (matches.length === 0) {
+    return { ok: true, content: `(no files matched pattern "${pattern}" in ${cwd})` };
+  }
+  const withMtime = await Promise.all(
+    matches.map(async (rel) => {
+      const abs = isAbsolute(rel) ? rel : resolve2(cwd, rel);
+      try {
+        const st = await stat(abs);
+        return { path: rel, mtime: st.mtimeMs };
+      } catch {
+        return { path: rel, mtime: 0 };
+      }
+    })
+  );
+  withMtime.sort((a, b) => a.mtime - b.mtime);
+  let content = withMtime.map((m) => m.path).join("\n");
+  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u5171 ${withMtime.length} \u4E2A\u6587\u4EF6\uFF0C\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD\u5C3E\u90E8\u65B0\u6587\u4EF6)`;
+  }
+  return {
+    ok: true,
+    content: `${content}
+
+(\u5171 ${withMtime.length} \u4E2A\u6587\u4EF6\uFF0C\u6309\u4FEE\u6539\u65F6\u95F4\u5347\u5E8F/\u65E7\u5728\u524D)`
+  };
+}
+var globTool = {
+  name: "Glob",
+  description: description3,
+  inputSchema: inputSchema3,
+  parameters: parameters3,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call3
+};
+
+// src/tools/grep/grep.ts
+import { spawn as spawn3 } from "child_process";
+import { resolve as resolve4 } from "path";
+import { z as z4 } from "zod";
+
+// src/tools/grep/rgPath.ts
+import { spawn as spawn2 } from "child_process";
+import { chmodSync, existsSync as existsSync2 } from "fs";
+import { dirname as dirname5, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cached;
+async function resolveRgPath() {
+  if (cached !== void 0) return cached;
+  cached = await detect();
+  return cached;
+}
+async function detect() {
+  const fromEnv = process.env.MINIMAL_AGENT_RIPGREP_PATH;
+  if (fromEnv && existsSync2(fromEnv)) return fromEnv;
+  const vendored = vendoredRgPath();
+  if (vendored && existsSync2(vendored)) {
+    ensureExecutable(vendored);
+    return vendored;
+  }
+  if (await trySpawn("rg")) return "rg";
+  for (const candidate of claudeCodeCandidates()) {
+    if (existsSync2(candidate)) {
+      ensureExecutable(candidate);
+      return candidate;
+    }
+  }
+  return null;
+}
+function vendoredRgPath() {
+  try {
+    const here = dirname5(fileURLToPath2(import.meta.url));
+    const projectRoot = resolve3(here, "..", "..");
+    return resolve3(projectRoot, "vendor", "ripgrep", subdir(), exeName());
+  } catch {
+    return null;
+  }
+}
+function subdir() {
+  return `${process.arch}-${process.platform}`;
+}
+function exeName() {
+  return process.platform === "win32" ? "rg.exe" : "rg";
+}
+function ensureExecutable(path2) {
+  if (process.platform === "win32") return;
+  try {
+    chmodSync(path2, 493);
+  } catch {
+  }
+}
+function trySpawn(cmd) {
+  return new Promise((resolveP) => {
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolveP(ok);
+    };
+    try {
+      const child = spawn2(cmd, ["--version"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      });
+      let stdout = "";
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (c) => stdout += c);
+      child.on("error", () => done(false));
+      child.on(
+        "close",
+        (code) => done(code === 0 && stdout.startsWith("ripgrep "))
+      );
+      setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+        }
+        done(false);
+      }, 5e3);
+    } catch {
+      done(false);
+    }
+  });
+}
+function claudeCodeCandidates() {
+  const arch = process.arch;
+  const platform = process.platform;
+  const subdir2 = `${arch}-${platform}`;
+  const exe = platform === "win32" ? "rg.exe" : "rg";
+  const npmRoots = [];
+  if (platform === "win32") {
+    if (process.env.APPDATA) {
+      npmRoots.push(resolve3(process.env.APPDATA, "npm", "node_modules"));
+    }
+    if (process.env.USERPROFILE) {
+      npmRoots.push(
+        resolve3(process.env.USERPROFILE, "AppData", "Roaming", "npm", "node_modules")
+      );
+    }
+  } else {
+    const home = process.env.HOME ?? "";
+    if (home) {
+      npmRoots.push(resolve3(home, ".npm-global", "lib", "node_modules"));
+      npmRoots.push(resolve3(home, ".npm", "lib", "node_modules"));
+      npmRoots.push(resolve3(home, "node_modules"));
+    }
+    npmRoots.push("/usr/local/lib/node_modules");
+    npmRoots.push("/usr/lib/node_modules");
+    npmRoots.push("/opt/homebrew/lib/node_modules");
+  }
+  return npmRoots.map(
+    (root) => resolve3(root, "@anthropic-ai", "claude-code", "vendor", "ripgrep", subdir2, exe)
+  );
+}
+
+// src/tools/grep/grep.ts
+var inputSchema4 = z4.object({
+  pattern: z4.string().min(1).describe("\u6B63\u5219\u8868\u8FBE\u5F0F\uFF08ripgrep \u517C\u5BB9\u8BED\u6CD5\uFF09"),
+  path: z4.string().optional().describe("\u641C\u7D22\u7684\u6839\u76EE\u5F55\u6216\u6587\u4EF6\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"),
+  glob: z4.string().optional().describe('\u6587\u4EF6\u540D glob \u8FC7\u6EE4\uFF0C\u5982 "*.ts"'),
+  type: z4.string().optional().describe('rg \u7684\u6587\u4EF6\u7C7B\u578B\u5FEB\u6377\u540D\uFF0C\u5982 "py"\u3001"rust"\u3001"js"'),
+  output_mode: z4.enum(["content", "files_with_matches", "count"]).optional().describe("\u8F93\u51FA\u6A21\u5F0F\uFF1Acontent=\u5339\u914D\u884C\uFF1Bfiles_with_matches=\u53EA\u5217\u6587\u4EF6\uFF1Bcount=\u6BCF\u6587\u4EF6\u8BA1\u6570"),
+  "-i": z4.boolean().optional().describe("\u5FFD\u7565\u5927\u5C0F\u5199"),
+  "-n": z4.boolean().optional().describe("\u663E\u793A\u884C\u53F7\uFF08\u4EC5 content \u6A21\u5F0F\uFF09"),
+  "-A": z4.number().int().min(0).optional().describe("\u5339\u914D\u540E\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-B": z4.number().int().min(0).optional().describe("\u5339\u914D\u524D\u5C55\u793A\u51E0\u884C\u4E0A\u4E0B\u6587"),
+  "-C": z4.number().int().min(0).optional().describe("\u5339\u914D\u524D\u540E\u5404\u5C55\u793A\u51E0\u884C\uFF08\u8986\u76D6 -A/-B\uFF09"),
+  head_limit: z4.number().int().positive().optional().describe("\u8F93\u51FA\u6700\u591A\u4FDD\u7559\u524D N \u884C\uFF08\u9632\u6B62\u7ED3\u679C\u8FC7\u5927\uFF09")
+});
+var parameters4 = toToolParameters(inputSchema4);
+var description4 = `A powerful search tool built on ripgrep.
+
+Usage:
+- ALWAYS use Grep for content search tasks. Do NOT invoke \`grep\` or \`rg\` directly via Bash.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+- Pattern syntax: Uses ripgrep (not classic grep)`;
+async function call4(input, signal) {
+  const args = [];
+  const mode = input.output_mode ?? "files_with_matches";
+  if (mode === "files_with_matches") args.push("-l");
+  else if (mode === "count") args.push("--count-matches");
+  if (input["-i"]) args.push("-i");
+  if (mode === "content" && input["-n"]) args.push("-n");
+  if (typeof input["-C"] === "number") {
+    args.push("-C", String(input["-C"]));
+  } else {
+    if (typeof input["-A"] === "number") args.push("-A", String(input["-A"]));
+    if (typeof input["-B"] === "number") args.push("-B", String(input["-B"]));
+  }
+  if (input.glob) args.push("--glob", input.glob);
+  if (input.type) args.push("--type", input.type);
+  args.push("--max-columns", "500");
+  args.push("--max-columns-preview");
+  args.push("--sort", "modified");
+  args.push("-e", input.pattern);
+  args.push(input.path ? resolve4(input.path) : ".");
+  const rgPath = await resolveRgPath();
+  if (!rgPath) {
+    return {
+      ok: false,
+      error: "\u627E\u4E0D\u5230 ripgrep\uFF08rg\uFF09\u3002\u53EF\u4EE5\u4E09\u9009\u4E00\uFF1A\n  \u2460 \u88C5 Claude Code\uFF08\u81EA\u5E26 rg\uFF09\uFF1Anpm i -g @anthropic-ai/claude-code\n  \u2461 \u7CFB\u7EDF\u88C5 ripgrep\uFF1A\n     macOS:   brew install ripgrep\n     Windows: scoop install ripgrep\n     Ubuntu:  sudo apt install ripgrep\n  \u2462 \u5728 .env \u8BBE\u7F6E MINIMAL_AGENT_RIPGREP_PATH=/\u7EDD\u5BF9/\u8DEF\u5F84/\u5230/rg"
+    };
+  }
+  let stdout = "";
+  let stderr = "";
+  let exitCode = null;
+  try {
+    await new Promise((resolveP, rejectP) => {
+      const child = spawn3(rgPath, args, {
+        cwd: process.cwd(),
+        signal,
+        windowsHide: true
+      });
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => stdout += chunk);
+      child.stderr.on("data", (chunk) => stderr += chunk);
+      child.on("error", (e) => rejectP(e));
+      child.on("close", (code) => {
+        exitCode = code;
+        resolveP();
+      });
+    });
+  } catch (e) {
+    const err = e;
+    return { ok: false, error: `\u6267\u884C rg \u5931\u8D25\uFF08${rgPath}\uFF09\uFF1A${err.message}` };
+  }
+  if (exitCode === 1) {
+    return { ok: true, content: `(no matches for pattern: ${input.pattern})` };
+  }
+  if (exitCode !== 0) {
+    return {
+      ok: false,
+      error: `rg \u9000\u51FA\u7801 ${exitCode}\uFF1A${stderr.slice(0, 500) || "(\u65E0 stderr)"}`
+    };
+  }
+  let content = stdout;
+  if (input.head_limit && input.head_limit > 0) {
+    const lines = content.split("\n");
+    if (lines.length > input.head_limit) {
+      content = lines.slice(0, input.head_limit).join("\n") + `
+... (\u5DF2\u622A\u65AD\u5230 ${input.head_limit} \u884C / \u5171 ${lines.length} \u884C\uFF0C\u4FDD\u7559\u6700\u65B0\u5339\u914D)`;
+    }
+  }
+  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD\u5C3E\u90E8\u65E7\u7ED3\u679C)`;
+  }
+  return { ok: true, content };
+}
+var grepTool = {
+  name: "Grep",
+  description: description4,
+  inputSchema: inputSchema4,
+  parameters: parameters4,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call4
+};
+
+// src/tools/read/read.ts
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { z as z5 } from "zod";
+var inputSchema5 = z5.object({
+  file_path: z5.string().min(1, "\u5FC5\u987B\u63D0\u4F9B file_path").describe("\u8981\u8BFB\u53D6\u7684\u6587\u4EF6\u8DEF\u5F84\uFF0C\u7EDD\u5BF9\u8DEF\u5F84\u4F18\u5148"),
+  offset: z5.number().int().positive().optional().describe("\u8D77\u59CB\u884C\u53F7\uFF081-indexed\uFF09\uFF1B\u4E0D\u586B\u5219\u4ECE\u6587\u4EF6\u5F00\u5934\u8BFB"),
+  limit: z5.number().int().positive().optional().describe(`\u6700\u591A\u8BFB\u591A\u5C11\u884C\uFF1B\u4E0D\u586B\u5219\u7528\u9ED8\u8BA4\u503C ${MAX_LINES_TO_READ}`)
+});
+var parameters5 = toToolParameters(inputSchema5);
+var description5 = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files)
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool can only read text files, not directories. To read a directory, use the Glob tool.
+- If you read a file that exists but has empty contents you will receive a warning in place of file contents.`;
+async function call5(input) {
+  const filePath = resolve5(input.file_path);
+  const offset = input.offset ?? 1;
+  const limit = input.limit ?? MAX_LINES_TO_READ;
+  let st;
+  try {
+    st = await stat2(filePath);
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${filePath} \u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u8BBF\u95EE\uFF08${e.message}\uFF09`
+    };
+  }
+  if (!st.isFile()) {
+    return { ok: false, error: `${filePath} \u4E0D\u662F\u6587\u4EF6\uFF08\u53EF\u80FD\u662F\u76EE\u5F55\uFF09\u3002\u8981\u5217\u76EE\u5F55\u7528 Glob \u5DE5\u5177\u3002` };
+  }
+  if (st.size > MAX_FILE_SIZE_BYTES) {
+    return {
+      ok: false,
+      error: `\u6587\u4EF6\u8FC7\u5927\uFF08${st.size} \u5B57\u8282 > ${MAX_FILE_SIZE_BYTES}\uFF09\u3002\u8BF7\u7528 offset/limit \u5206\u6BB5\u8BFB\u3002`
+    };
+  }
+  let raw;
+  try {
+    raw = await readFile6(filePath, "utf8");
+  } catch (e) {
+    return { ok: false, error: `\u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` };
+  }
+  if (raw.length === 0) {
+    return { ok: true, content: "<file is empty>" };
+  }
+  const allLines = raw.split("\n");
+  const totalLines = allLines.length;
+  const startIdx = Math.max(0, offset - 1);
+  const endIdx = Math.min(totalLines, startIdx + limit);
+  const slice = allLines.slice(startIdx, endIdx);
+  const numbered = slice.map((line, i) => `${(startIdx + i + 1).toString()}	${line}`).join("\n");
+  let content = numbered;
+  const contentLength = content.length;
+  if (contentLength > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
+  }
+  if (endIdx < totalLines) {
+    const nextOffset = endIdx + 1;
+    content += `
+
+... (\u672C\u6B21\u8FD4\u56DE ${slice.length} \u884C / \u6587\u4EF6\u5171 ${totalLines} \u884C\uFF1B\u7528 offset=${nextOffset} \u7EE7\u7EED\u8BFB)`;
+  }
+  if (st.size > 100 * 1024 && offset === 1) {
+    content += `
+
+\u26A0\uFE0F \u6CE8\u610F\uFF1A\u8FD9\u662F\u4E00\u4E2A\u5927\u6587\u4EF6\uFF08${(st.size / 1024).toFixed(1)} KB\uFF09\u3002\u5EFA\u8BAE\u7528 offset/limit \u5206\u6BB5\u8BFB\u53D6\uFF0C\u4F8B\u5982\u5148\u8BFB\u5173\u952E\u90E8\u5206\uFF08imports\u3001exports\u3001\u51FD\u6570\u7B7E\u540D\uFF09\u3002`;
+  }
+  return { ok: true, content };
+}
+var readTool = {
+  name: "Read",
+  description: description5,
+  inputSchema: inputSchema5,
+  parameters: parameters5,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call5
+};
+
+// src/tools/webfetch/webfetch.ts
+import { z as z6 } from "zod";
+
+// src/tools/webfetch/preapproved.ts
+var PREAPPROVED_HOSTS = /* @__PURE__ */ new Set([
+  // GitHub
+  "github.com",
+  "gist.github.com",
+  // 开发文档
+  "docs.github.com",
+  "developer.github.com",
+  "help.github.com",
+  // NPM
+  "npmjs.com",
+  "www.npmjs.com",
+  // 包注册表
+  "pypi.org",
+  "www.pypi.org",
+  "crates.io",
+  "pub.dev",
+  "packagist.org",
+  "rubygems.org",
+  // 开发平台
+  "stackoverflow.com",
+  "www.stackoverflow.com",
+  "serverfault.com",
+  "superuser.com",
+  "askubuntu.com",
+  // 文档与 wiki
+  "readthedocs.io",
+  "www.readthedocs.io",
+  "readthedocs.org",
+  "wiki.python.org",
+  "en.wikipedia.org",
+  "zh.wikipedia.org",
+  // 官方文档
+  "nodejs.org",
+  "www.nodejs.org",
+  "deno.land",
+  "www.deno.land",
+  "bun.sh",
+  "www.bun.sh",
+  // Rust
+  "doc.rust-lang.org",
+  "www.rust-lang.org",
+  "rust-lang.org",
+  // 云平台
+  "aws.amazon.com",
+  "docs.aws.amazon.com",
+  "cloud.google.com",
+  "docs.microsoft.com",
+  "azure.microsoft.com",
+  "developer.microsoft.com",
+  // AI/LLM
+  "openai.com",
+  "platform.openai.com",
+  "docs.anthropic.com",
+  "anthropic.com",
+  "claude.ai",
+  "docs.cohere.com",
+  "cohere.com",
+  // AI 模型文档
+  "ai.google.dev",
+  "ai.google.com",
+  "developers.google.com",
+  "learn.deepmind.com",
+  // AI 开发框架
+  "python.langchain.com",
+  "js.langchain.com",
+  "docs.litellm.ai",
+  "litellm.ai",
+  // 前端框架
+  "react.dev",
+  "reactjs.org",
+  "www.reactjs.org",
+  "nextjs.org",
+  "www.nextjs.org",
+  "vuejs.org",
+  "www.vuejs.org",
+  "svelte.dev",
+  "svelte.org",
+  "angular.io",
+  "www.angular.io",
+  // 构建工具
+  "vitejs.dev",
+  "vite.dev",
+  "webpack.js.org",
+  "esbuild.github.io",
+  "rollupjs.org",
+  "esbuild.github.io",
+  // CSS
+  "tailwindcss.com",
+  "www.tailwindcss.com",
+  "postcss.org",
+  // 数据库
+  "redis.io",
+  "www.redis.io",
+  "postgresql.org",
+  "www.postgresql.org",
+  "www.mysql.com",
+  "dev.mysql.com",
+  "docs.mongodb.com",
+  "www.mongodb.com",
+  "sqlite.org",
+  "www.sqlite.org",
+  // 工具类
+  "regex101.com",
+  "ihateregex.io",
+  "explainshell.com",
+  "tldr.sh",
+  // 代码分享
+  "replit.com",
+  "www.replit.com",
+  "codesandbox.io",
+  "www.codesandbox.io",
+  "codepen.io",
+  "www.codepen.io",
+  "jsfiddle.net",
+  "www.jsfiddle.net",
+  // CI/CD
+  "docs.github.com/en/actions",
+  "circleci.com",
+  "docs.circleci.com",
+  "travis-ci.org",
+  "www.travis-ci.com",
+  "jenkins.io",
+  "www.jenkins.io",
+  // 容器/云原生
+  "kubernetes.io",
+  "www.kubernetes.io",
+  "docker.com",
+  "www.docker.com",
+  "docs.docker.com",
+  // 测试
+  "jestjs.io",
+  "www.jestjs.io",
+  "vitest.dev",
+  "testing-library.com",
+  "www.testing-library.com",
+  "playwright.dev",
+  "www.playwright.dev",
+  "webdriver.io",
+  "webdriver.io",
+  // API 文档
+  "httpbin.org",
+  "restfulapi.net",
+  "swagger.io",
+  "www.swagger.io",
+  "openapi.net",
+  // 安全
+  "owasp.org",
+  "www.owasp.org",
+  "cve.mitre.org",
+  // 证书
+  "letsencrypt.org",
+  "www.letsencrypt.org",
+  "acmev2.pki.duckdns.org",
+  // 博客与技术文章
+  "medium.com",
+  "www.medium.com",
+  "dev.to",
+  "www.dev.to",
+  "hashnode.com",
+  "www.hashnode.com",
+  "devblogs.microsoft.com",
+  // 浏览器
+  "caniuse.com",
+  "developer.mozilla.org",
+  "web.dev",
+  "www.w3.org",
+  // 开源项目
+  "apache.org",
+  "www.apache.org",
+  "gnu.org",
+  "www.gnu.org",
+  "fsf.org",
+  "www.fsf.org",
+  "opensource.org",
+  "www.opensource.org",
+  // 技术社区
+  "reddit.com",
+  "www.reddit.com",
+  "news.ycombinator.com",
+  "lobste.rs",
+  // 文件格式
+  "json.org",
+  "yaml.org",
+  "www.yaml.org",
+  "toml.io",
+  "www.toml.io",
+  // 版本控制
+  "git-scm.com",
+  "www.git-scm.com",
+  "github.blog",
+  "githubstatus.com",
+  // AI 搜索
+  "tavily.com",
+  "www.tavily.com",
+  "perplexity.ai",
+  "www.perplexity.ai",
+  // AI 图片
+  "midjourney.com",
+  "www.midjourney.com",
+  "stability.ai",
+  "www.stability.ai",
+  // Embeddings / 向量
+  "qdrant.tech",
+  "www.qdrant.tech",
+  "weaviate.io",
+  "www.weaviate.io",
+  "pinecone.io",
+  "www.pinecone.io",
+  // API 平台
+  "ngrok.com",
+  "www.ngrok.com",
+  "requestly.io",
+  "www.requestly.io",
+  // MCP
+  "modelcontextprotocol.io",
+  "www.modelcontextprotocol.io",
+  "github.com/modelcontextprotocol"
+]);
+var PREAPPROVED_SUFFIXES = [
+  ".github.io",
+  ".readthedocs.io",
+  ".vercel.app",
+  ".vercel.dev",
+  ".netlify.app",
+  ".netlify.com",
+  ".cloudflare-pages.com",
+  ".pages.dev",
+  ".surge.sh",
+  ".herokuapp.com",
+  ".railway.app",
+  ".fly.dev",
+  ".repl.co",
+  ".workers.dev",
+  ".pages.plus",
+  ".coded.app",
+  ".preview.app",
+  ".staging.app"
+];
+function isPreapprovedHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (PREAPPROVED_HOSTS.has(normalized)) {
+    return true;
+  }
+  for (const suffix of PREAPPROVED_SUFFIXES) {
+    if (normalized.endsWith(suffix)) {
+      return true;
+    }
+  }
+  return false;
+}
+var isPreapprovedDomain = isPreapprovedHost;
+
+// src/tools/webfetch/webfetch.ts
+var MAX_URL_LENGTH = 2e3;
+var FETCH_TIMEOUT_MS = 6e4;
+var MAX_HTTP_CONTENT_LENGTH = 10 * 1024 * 1024;
+var MAX_REDIRECTS = 10;
+var URL_CACHE = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 15 * 60 * 1e3;
+var MAX_CACHE_SIZE_BYTES = 50 * 1024 * 1024;
+function cleanCache() {
+  const now = Date.now();
+  let totalSize = 0;
+  const entries = [];
+  for (const [url, entry] of URL_CACHE) {
+    if (now - entry.fetchedAt > CACHE_TTL_MS) {
+      URL_CACHE.delete(url);
+      continue;
+    }
+    const size = entry.bytes;
+    totalSize += size;
+    entries.push({ url, entry, size });
+  }
+  if (totalSize > MAX_CACHE_SIZE_BYTES) {
+    entries.sort((a, b) => a.entry.fetchedAt - b.entry.fetchedAt);
+    for (const { url, size } of entries) {
+      URL_CACHE.delete(url);
+      totalSize -= size;
+      if (totalSize <= MAX_CACHE_SIZE_BYTES * 0.8) break;
+    }
+  }
+}
+var inputSchema6 = z6.object({
+  url: z6.string().describe("\u8981\u83B7\u53D6\u5185\u5BB9\u7684 URL"),
+  prompt: z6.string().describe("\u5BF9\u5185\u5BB9\u8FDB\u884C\u5904\u7406\u7684\u6307\u4EE4\uFF0C\u63CF\u8FF0\u4F60\u60F3\u4ECE\u9875\u9762\u63D0\u53D6\u4EC0\u4E48\u4FE1\u606F")
+});
+var parameters6 = toToolParameters(inputSchema6);
+var description6 = `- Fetches content from a specified URL and processes it using an AI model.
+- Takes a URL and a prompt as input.
+- Fetches the URL content, converts HTML to markdown.
+- Processes the content with the prompt (e.g., extract summary, find specific info).
+- Returns the processed result.
+- HTTP URLs are automatically upgraded to HTTPS.
+- When a URL redirects to a different host, returns a warning with the redirect URL.
+- This tool is read-only and does not modify any files.
+- Results may be summarized if the content is very large.
+- \u26A0\uFE0F IMPORTANT: This tool WILL FAIL for authenticated or private URLs.
+  Before using this tool, check if the URL points to an authenticated service
+  (e.g. Google Docs, Confluence, Jira, GitHub private repos). If so, look for
+  a specialized MCP tool that provides authenticated access.
+- \u{1F4A1} For GitHub URLs (repos, issues, PRs), prefer using the \`gh\` CLI via Bash
+  instead (e.g. \`gh pr view <pr-number>\`, \`gh issue view <number>\`, \`gh api <endpoint>\`).
+- \u26A1 If an MCP-provided web fetch tool is available, prefer using that tool instead,
+  as it may have fewer restrictions and better performance.
+- \u{1F512} Domain preapproved list includes common documentation sites (MDN, TypeScript,
+  React, Vue, Angular, Node.js, Bun, Rust, Go, Python, etc.). Other domains
+  will work but results may be less reliable.
+- \u{1F4DD} This tool includes a self-cleaning 15-minute cache for faster repeated access
+  to the same URL.
+- \u26A0\uFE0F For PDF files, the tool will attempt to extract readable text but results may
+  be limited. Binary images cannot be processed.`;
+function validateURL(url) {
+  if (url.length > MAX_URL_LENGTH) {
+    return { ok: false, error: `URL \u592A\u957F\uFF08\u6700\u5927 ${MAX_URL_LENGTH} \u5B57\u7B26\uFF09` };
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { ok: false, error: `\u65E0\u6548\u7684 URL \u683C\u5F0F` };
+  }
+  if (parsed.username || parsed.password) {
+    return { ok: false, error: `URL \u4E0D\u80FD\u5305\u542B\u7528\u6237\u540D\u6216\u5BC6\u7801` };
+  }
+  return { ok: true, parsed };
+}
+async function fetchURL(url, signal, depth = 0) {
+  const validated = validateURL(url);
+  if (!validated.ok) return { type: "error", error: validated.error };
+  let targetUrl = url;
+  const parsed = validated.parsed;
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "https:";
+    targetUrl = parsed.toString();
+  }
+  let response;
+  try {
+    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    const controller = new AbortController();
+    const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    response = await fetch(targetUrl, {
+      signal: combinedSignal,
+      headers: {
+        Accept: "text/markdown, text/html, */*",
+        "User-Agent": "minimal-agent/1.0"
+      }
+    });
+  } catch (e) {
+    if (signal?.aborted) return { type: "error", error: "\u8BF7\u6C42\u88AB\u4E2D\u65AD" };
+    return { type: "error", error: `\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${e.message}` };
+  }
+  const code = response.status;
+  const codeText = response.statusText;
+  const contentType = response.headers.get("content-type") ?? "";
+  const location = response.headers.get("location");
+  if (location && [301, 302, 307, 308].includes(code)) {
+    const redirectUrl = new URL(location, targetUrl).toString();
+    const originalHost = new URL(url).hostname;
+    const redirectHost = new URL(redirectUrl).hostname;
+    const stripWww = (h) => h.replace(/^www\./, "");
+    if (stripWww(originalHost) !== stripWww(redirectHost)) {
+      return {
+        type: "redirect",
+        originalUrl: url,
+        redirectUrl,
+        statusCode: code
+      };
+    }
+    if (depth >= MAX_REDIRECTS) {
+      return { type: "error", error: `\u91CD\u5B9A\u5411\u5FAA\u73AF\u8D85\u8FC7\u9650\u5236\uFF08\u6700\u591A ${MAX_REDIRECTS} \u6B21\uFF09` };
+    }
+    return fetchURL(redirectUrl, signal, depth + 1);
+  }
+  let rawBuffer;
+  try {
+    rawBuffer = await response.arrayBuffer();
+  } catch (e) {
+    return { type: "error", error: `\u8BFB\u53D6\u54CD\u5E94\u4F53\u5931\u8D25\uFF1A${e.message}` };
+  }
+  if (rawBuffer.byteLength > MAX_HTTP_CONTENT_LENGTH) {
+    return { type: "error", error: `\u5185\u5BB9\u592A\u5927\uFF08${rawBuffer.byteLength} bytes\uFF0C\u8D85\u8FC7 ${MAX_HTTP_CONTENT_LENGTH}\uFF09` };
+  }
+  let content;
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: false });
+    content = decoder.decode(rawBuffer);
+  } catch (e) {
+    return { type: "error", error: `\u89E3\u7801\u5931\u8D25\uFF1A${e.message}` };
+  }
+  return { type: "success", content, bytes: rawBuffer.byteLength, code, codeText, contentType };
+}
+async function htmlToMarkdown(html) {
+  const TurndownService = (await import("turndown")).default;
+  const td = new TurndownService();
+  return td.turndown(html);
+}
+async function call6(input, signal) {
+  const { url } = input;
+  const start = Date.now();
+  const cacheKey = url;
+  let targetHostname;
+  try {
+    targetHostname = new URL(url).hostname;
+  } catch {
+    targetHostname = "";
+  }
+  const preapproved = isPreapprovedDomain(targetHostname);
+  const cached2 = URL_CACHE.get(cacheKey);
+  if (cached2 && Date.now() - cached2.fetchedAt <= CACHE_TTL_MS) {
+    let content2 = cached2.content;
+    const contentType2 = cached2.contentType;
+    if (contentType2.includes("text/html")) {
+      try {
+        content2 = await htmlToMarkdown(content2);
+      } catch (e) {
+        console.warn(`turndown \u5931\u8D25: ${e.message}`);
+      }
+    }
+    const formattedSize2 = cached2.bytes < 1024 ? `${cached2.bytes} B` : cached2.bytes < 1024 * 1024 ? `${(cached2.bytes / 1024).toFixed(1)} KB` : `${(cached2.bytes / 1024 / 1024).toFixed(1)} MB`;
+    const domainNote2 = preapproved ? "[\u{1F512} \u9884\u6279\u51C6\u57DF\u540D\uFF0C\u5185\u5BB9\u53EF\u4FE1]" : "[\u26A0\uFE0F \u975E\u9884\u6279\u51C6\u57DF\u540D\uFF0C\u5185\u5BB9\u53EF\u80FD\u4E0D\u51C6\u786E]";
+    const output2 = `\u3010WebFetch \u7ED3\u679C\u3011
+URL: ${url}
+\u72B6\u6001: ${cached2.code} ${cached2.codeText}
+\u5927\u5C0F: ${formattedSize2}
+\u8017\u65F6: 0.00s (\u7F13\u5B58\u547D\u4E2D)
+${domainNote2}
+[\u{1F4E6} \u6765\u81EA\u7F13\u5B58\uFF0815\u5206\u949F TTL\uFF09]
+
+--- \u5185\u5BB9 ---
+${content2}`;
+    let final2 = output2;
+    if (final2.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+      final2 = final2.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
+    }
+    return { ok: true, content: final2 };
+  }
+  const fetched = await fetchURL(url, signal ?? new AbortController().signal);
+  const durationMs = Date.now() - start;
+  if (fetched.type === "redirect") {
+    const statusText = fetched.statusCode === 301 ? "Moved Permanently" : fetched.statusCode === 308 ? "Permanent Redirect" : fetched.statusCode === 307 ? "Temporary Redirect" : "Found";
+    return {
+      ok: true,
+      content: `\u3010\u91CD\u5B9A\u5411\u68C0\u6D4B\u3011
+
+\u539F\u59CB URL: ${fetched.originalUrl}
+\u91CD\u5B9A\u5411\u5230: ${fetched.redirectUrl}
+\u72B6\u6001: ${fetched.statusCode} ${statusText}
+
+\u8BF7\u4F7F\u7528\u91CD\u5B9A\u5411\u540E\u7684 URL \u518D\u6B21\u8C03\u7528 WebFetch \u5DE5\u5177\u3002`
+    };
+  }
+  if (fetched.type === "error") {
+    return { ok: false, error: fetched.error };
+  }
+  let { content, bytes, code, codeText, contentType } = fetched;
+  URL_CACHE.set(cacheKey, {
+    bytes,
+    code,
+    codeText,
+    content,
+    contentType,
+    fetchedAt: Date.now()
+  });
+  cleanCache();
+  if (contentType.includes("text/html")) {
+    try {
+      content = await htmlToMarkdown(content);
+    } catch (e) {
+      console.warn(`turndown \u5931\u8D25: ${e.message}`);
+    }
+  }
+  const formattedSize = bytes < 1024 ? `${bytes} B` : bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  const domainNote = preapproved ? "[\u{1F512} \u9884\u6279\u51C6\u57DF\u540D\uFF0C\u5185\u5BB9\u53EF\u4FE1]" : "[\u26A0\uFE0F \u975E\u9884\u6279\u51C6\u57DF\u540D\uFF0C\u5185\u5BB9\u53EF\u80FD\u4E0D\u51C6\u786E]";
+  const output = `\u3010WebFetch \u7ED3\u679C\u3011
+URL: ${url}
+\u72B6\u6001: ${code} ${codeText}
+\u5927\u5C0F: ${formattedSize}
+\u8017\u65F6: ${(durationMs / 1e3).toFixed(2)}s
+${domainNote}
+
+--- \u5185\u5BB9 ---
+${content}`;
+  let final = output;
+  if (final.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    final = final.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
+  }
+  return { ok: true, content: final };
+}
+var webfetchTool = {
+  name: "WebFetch",
+  description: description6,
+  inputSchema: inputSchema6,
+  parameters: parameters6,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call6
+};
+
+// src/tools/webbrowser/webbrowser.ts
+import { z as z7 } from "zod";
+
+// src/tools/webbrowser/browser.ts
+import os from "os";
+import path from "path";
+var browserInstance = null;
+var pageInstance = null;
+async function getBrowserPage() {
+  if (!browserInstance) {
+    const { chromium } = await import("playwright-core");
+    try {
+      browserInstance = await chromium.launch({
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new Error(
+        `Failed to launch browser: ${message}
+\u8BF7\u5148\u5B89\u88C5 playwright \u53CA\u6D4F\u89C8\u5668\uFF1A
+  npm install playwright-core
+  npx playwright install chromium`
+      );
+    }
+  }
+  if (!pageInstance) {
+    pageInstance = await browserInstance.newPage();
+    await pageInstance.setViewportSize({ width: 1280, height: 720 });
+  }
+  return pageInstance;
+}
+function screenshotPath(prefix = "browser") {
+  return path.join(os.tmpdir(), `${prefix}-${Date.now()}.png`);
+}
+
+// src/tools/webbrowser/webbrowser.ts
+var inputSchema7 = z7.object({
+  action: z7.enum(["navigate", "screenshot", "getContent", "click", "fill", "submit"]).describe("Browser action to perform"),
+  url: z7.string().url().optional().describe("URL to navigate to (required for navigate action)"),
+  selector: z7.string().optional().describe("CSS selector for click/fill/submit actions"),
+  value: z7.string().optional().describe("Value to fill in input fields"),
+  timeout: z7.number().int().positive().optional().describe("Timeout in milliseconds (default: 30000)")
+});
+var parameters7 = toToolParameters(inputSchema7);
+var description7 = `Control a headless web browser. Navigate to URLs, take screenshots, and interact with web pages.
+
+When to use WebBrowser vs WebSearch:
+- WebSearch: When you need to find information or discover URLs through search
+- WebBrowser: When you need to interact with a specific web page (navigate, click, fill forms, get content, take screenshots)
+
+Input parameters:
+  - action (required): The browser action. One of:
+    - navigate: Go to a URL (requires url parameter)
+    - screenshot: Take a screenshot of the current page
+    - getContent: Extract text content from the current page
+    - click: Click an element (requires selector parameter)
+    - fill: Fill an input field (requires selector and value parameters)
+    - submit: Submit a form (requires selector parameter)
+  - url (optional): URL to navigate to (required for navigate action, must be a valid URL)
+  - selector (optional): CSS selector for click/fill/submit actions
+  - value (optional): Value to fill in input fields
+  - timeout (optional): Timeout in milliseconds for actions (default: 30000)
+
+Usage notes:
+  - The browser runs headless (no visible window)
+  - Screenshots are saved to temporary files (/tmp/browser-*.png)
+  - Content is truncated to 50000 characters max
+  - Only one browser instance is maintained per session
+  - Requires: npm install playwright-core && npx playwright install chromium
+
+Example actions:
+  - Navigate and get content: { action: "navigate", url: "https://example.com" }
+  - Take screenshot: { action: "screenshot" }
+  - Click element: { action: "click", selector: "#submit-btn" }
+  - Fill form field: { action: "fill", selector: "input[name='email']", value: "user@example.com" }`;
+async function call7(input, signal) {
+  const { action, url, selector, value, timeout = 3e4 } = input;
+  let page;
+  try {
+    page = await getBrowserPage();
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u65E0\u6CD5\u542F\u52A8\u6D4F\u89C8\u5668\uFF1A${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+  try {
+    switch (action) {
+      case "navigate": {
+        if (!url) {
+          return { ok: false, error: "navigate action requires url parameter" };
+        }
+        await page.goto(url, { timeout, waitUntil: "domcontentloaded" });
+        const content = await page.evaluate(() => document.body.innerText);
+        const screenshot = screenshotPath("browser-nav");
+        await page.screenshot({ path: screenshot });
+        const truncatedContent = content.substring(0, 5e4);
+        return {
+          ok: true,
+          content: [
+            `[Navigate] ${page.url()}`,
+            `Screenshot: ${screenshot}`,
+            "",
+            "--- Page Content (first 50000 chars) ---",
+            truncatedContent,
+            content.length > 5e4 ? "\n... (truncated)" : ""
+          ].join("\n")
+        };
+      }
+      case "screenshot": {
+        const screenshot = screenshotPath("browser-screenshot");
+        await page.screenshot({ path: screenshot });
+        return {
+          ok: true,
+          content: `[Screenshot] ${page.url()}
+Saved: ${screenshot}`
+        };
+      }
+      case "getContent": {
+        const content = await page.evaluate(() => document.body.innerText);
+        const truncated = content.substring(0, 5e4);
+        return {
+          ok: true,
+          content: [
+            `[Page Content] ${page.url()}`,
+            "",
+            truncated,
+            content.length > 5e4 ? "\n... (truncated at 50000 chars)" : ""
+          ].join("\n")
+        };
+      }
+      case "click": {
+        if (!selector) {
+          return { ok: false, error: "click action requires selector parameter" };
+        }
+        await page.click(selector, { timeout });
+        return {
+          ok: true,
+          content: `[Click] ${selector}
+Current URL: ${page.url()}`
+        };
+      }
+      case "fill": {
+        if (!selector || value === void 0) {
+          return { ok: false, error: "fill action requires selector and value parameters" };
+        }
+        await page.fill(selector, value);
+        return {
+          ok: true,
+          content: `[Fill] ${selector} = "${value}"
+Current URL: ${page.url()}`
+        };
+      }
+      case "submit": {
+        if (!selector) {
+          return { ok: false, error: "submit action requires selector parameter" };
+        }
+        await Promise.all([
+          page.waitForNavigation({ timeout }).catch(() => {
+          }),
+          page.click(selector, { timeout })
+        ]);
+        return {
+          ok: true,
+          content: `[Submit] ${selector}
+Current URL: ${page.url()}`
+        };
+      }
+      default:
+        return { ok: false, error: `Unknown action: ${action}` };
+    }
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    const truncated = message.length > DEFAULT_MAX_RESULT_SIZE_CHARS ? message.substring(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + "\n... (truncated)" : message;
+    return { ok: false, error: `[${action}] Error: ${truncated}` };
+  }
+}
+var webbrowserTool = {
+  name: "WebBrowser",
+  description: description7,
+  inputSchema: inputSchema7,
+  parameters: parameters7,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call7
+};
+
+// src/tools/websearch/websearch.ts
+import { z as z8 } from "zod";
+var inputSchema8 = z8.object({
+  query: z8.string().min(1, "\u5FC5\u987B\u63D0\u4F9B\u641C\u7D22\u5173\u952E\u8BCD").max(400, "\u641C\u7D22\u5173\u952E\u8BCD\u592A\u957F\uFF08>400 \u5B57\uFF09").describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF0C\u5EFA\u8BAE\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\u9700\u8981\u67E5\u7684\u4FE1\u606F"),
+  max_results: z8.number().int().min(1).max(20).optional().describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF0C1-20\uFF0C\u9ED8\u8BA4 5"),
+  search_depth: z8.enum(["basic", "advanced"]).optional().describe("basic \u5FEB\u4F46\u6D45\uFF1Badvanced \u6162\u4F46\u6DF1\uFF08\u542B answer \u6458\u8981\uFF09\uFF0C\u9ED8\u8BA4 basic"),
+  topic: z8.enum(["general", "news"]).optional().describe("general=\u901A\u7528\u7F51\u9875\uFF1Bnews=\u504F\u65B0\u95FB\u6E90\uFF1B\u9ED8\u8BA4 general")
+});
+var parameters8 = toToolParameters(inputSchema8);
+var description8 = `- Searches the public web via the Tavily Search API and returns structured results.
+- Use this when you need up-to-date information that is not in your training data, or when the user asks for recent news / docs / API references.
+- Returns the top N results, each with a title, URL, and content snippet. With \`search_depth: "advanced"\` Tavily also returns a synthesized answer at the top.
+- Prefer specific natural-language queries over keyword soup (e.g. "how does Bun handle .env files in version 1.1").
+- Requires the TAVILY_API_KEY environment variable to be set; if missing the tool returns a friendly error.`;
+async function call8(input, signal) {
+  const apiKey = process.env.TAVILY_API_KEY;
+  if (!apiKey) {
+    return {
+      ok: false,
+      error: "WebSearch \u4E0D\u53EF\u7528\uFF1A\u73AF\u5883\u53D8\u91CF TAVILY_API_KEY \u672A\u8BBE\u7F6E\u3002\n\u8BF7\u5728\u9879\u76EE\u6839 .env \u91CC\u52A0\uFF1A\n  TAVILY_API_KEY=tvly-\u4F60\u7684key\n\u514D\u8D39 key \u7533\u8BF7\uFF1Ahttps://tavily.com/"
+    };
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const queryWithDate = input.query.includes(today) ? input.query : `${input.query} (as of ${today})`;
+  const body = {
+    api_key: apiKey,
+    query: queryWithDate,
+    max_results: input.max_results ?? 5,
+    search_depth: input.search_depth ?? "basic",
+    topic: input.topic ?? "general",
+    // 让 advanced 模式自动给 answer；basic 不会有
+    include_answer: input.search_depth === "advanced"
+  };
+  let res;
+  try {
+    res = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal
+    });
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u8C03\u7528 Tavily \u5931\u8D25\uFF08\u7F51\u7EDC\uFF09\uFF1A${e.message}`
+    };
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    return {
+      ok: false,
+      error: `Tavily HTTP ${res.status}\uFF1A${text.slice(0, 500)}`
+    };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch (e) {
+    return {
+      ok: false,
+      error: `Tavily \u54CD\u5E94\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${e.message}`
+    };
+  }
+  const results = data.results ?? [];
+  if (results.length === 0) {
+    return {
+      ok: true,
+      content: `(no results for "${input.query}")`
+    };
+  }
+  const parts = [];
+  if (data.answer) {
+    parts.push(`\u3010\u7EFC\u5408\u56DE\u7B54\u3011
+${data.answer}
+`);
+  }
+  parts.push(`\u3010\u5171 ${results.length} \u6761\u7ED3\u679C\u3011`);
+  results.forEach((r, i) => {
+    const date = r.published_date ? `\uFF08${r.published_date}\uFF09` : "";
+    parts.push(
+      `
+[${i + 1}] ${r.title}${date}
+URL: ${r.url}
+${(r.content ?? "").trim()}`
+    );
+  });
+  let content = parts.join("\n");
+  if (content.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+    content = content.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS) + `
+
+... (\u8F93\u51FA\u8D85\u8FC7 ${DEFAULT_MAX_RESULT_SIZE_CHARS} \u5B57\u7B26\uFF0C\u5DF2\u622A\u65AD)`;
+  }
+  return { ok: true, content };
+}
+var webSearchTool = {
+  name: "WebSearch",
+  description: description8,
+  inputSchema: inputSchema8,
+  parameters: parameters8,
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call8
+};
+
+// src/tools/write/write.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname6, resolve as resolve6 } from "path";
+import { z as z9 } from "zod";
+var MAX_WRITE_SIZE_BYTES = 1024 * 1024 * 1024;
+var inputSchema9 = z9.object({
+  file_path: z9.string().min(1).describe("\u8981\u5199\u5165\u7684\u6587\u4EF6\u8DEF\u5F84"),
+  content: z9.string().describe("\u6587\u4EF6\u5B8C\u6574\u5185\u5BB9\uFF08\u4F1A\u8986\u76D6\u65E2\u6709\u5185\u5BB9\uFF09")
+});
+var parameters9 = toToolParameters(inputSchema9);
+var description9 = `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If the parent directory does not exist, it will be created recursively.
+- ALWAYS prefer editing existing files in the codebase via the Edit tool. NEVER write new files unless explicitly required.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.`;
+function validatePath2(filePath) {
+  if (filePath.includes("\0")) {
+    return { ok: false, error: "\u8DEF\u5F84\u5305\u542B\u975E\u6CD5\u5B57\u7B26\uFF08null byte\uFF09" };
+  }
+  if (process.platform === "win32" && filePath.includes("\\\\")) {
+    return { ok: false, error: "\u4E0D\u652F\u6301 UNC \u8DEF\u5F84\uFF08\\\\server\\share \u683C\u5F0F\uFF09\uFF0C\u8BF7\u4F7F\u7528\u672C\u5730\u8DEF\u5F84" };
+  }
+  return { ok: true };
+}
+async function call9(input) {
+  const filePath = resolve6(input.file_path);
+  const pathCheck = validatePath2(filePath);
+  if (!pathCheck.ok) return pathCheck;
+  const contentSize = Buffer.byteLength(input.content, "utf8");
+  if (contentSize > MAX_WRITE_SIZE_BYTES) {
+    return {
+      ok: false,
+      error: `\u5199\u5165\u5185\u5BB9\u8FC7\u5927\uFF08${contentSize} \u5B57\u8282 > ${MAX_WRITE_SIZE_BYTES} \u5B57\u8282 \u2248 1GB\uFF09\u3002\u8BF7\u62C6\u5206\u5185\u5BB9\u6216\u4F7F\u7528 Edit \u5DE5\u5177\u5206\u5757\u4FEE\u6539\u3002`
+    };
+  }
+  try {
+    await mkdir4(dirname6(filePath), { recursive: true });
+    let originalSize = 0;
+    const fileExisted = existsSync3(filePath);
+    if (fileExisted) {
+      try {
+        const st = await stat3(filePath);
+        originalSize = st.size;
+      } catch {
+      }
+    }
+    await writeFile4(filePath, input.content, "utf8");
+    const action = fileExisted ? "\u5DF2\u8986\u76D6" : "\u5DF2\u521B\u5EFA\u65B0\u6587\u4EF6";
+    const sizeInfo = fileExisted ? `\uFF08\u539F\u6587\u4EF6 ${originalSize} \u5B57\u7B26 \u2192 \u65B0\u5185\u5BB9 ${input.content.length} \u5B57\u7B26\uFF09` : `\uFF08${input.content.length} \u5B57\u7B26\uFF09`;
+    return {
+      ok: true,
+      content: `${action} ${filePath}${sizeInfo}`
+    };
+  } catch (e) {
+    return { ok: false, error: `\u5199\u5165\u5931\u8D25\uFF1A${e.message}` };
+  }
+}
+var writeTool = {
+  name: "Write",
+  description: description9,
+  inputSchema: inputSchema9,
+  parameters: parameters9,
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  call: call9
+};
+
+// src/tools/index.ts
+var ALL_TOOLS = [
+  readTool,
+  editTool,
+  writeTool,
+  globTool,
+  grepTool,
+  webSearchTool,
+  webfetchTool,
+  webbrowserTool,
+  bashTool
+];
+function getToolByName(name) {
+  return ALL_TOOLS.find((t) => t.name === name);
+}
+async function executeTool(name, rawArguments, signal) {
+  const tool = getToolByName(name);
+  if (!tool) {
+    const available = ALL_TOOLS.map((t) => t.name).join(", ");
+    return { ok: false, error: `\u672A\u77E5\u5DE5\u5177 "${name}"\u3002\u53EF\u7528\u5DE5\u5177\uFF1A${available}` };
+  }
+  let parsedJson;
+  try {
+    parsedJson = rawArguments.length === 0 ? {} : JSON.parse(rawArguments);
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u5DE5\u5177\u53C2\u6570\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${e.message}
+\u6536\u5230\u7684\u5B57\u7B26\u4E32\uFF1A${rawArguments.slice(0, 200)}`
+    };
+  }
+  const checked = tool.inputSchema.safeParse(parsedJson);
+  if (!checked.success) {
+    const issues = checked.error.issues.map((i) => `  - ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+    return {
+      ok: false,
+      error: `\u53C2\u6570\u6821\u9A8C\u5931\u8D25\uFF08\u8BF7\u68C0\u67E5\u53C2\u6570\u540D/\u7C7B\u578B\uFF09\uFF1A
+${issues}`
+    };
+  }
+  try {
+    return await tool.call(checked.data, signal);
+  } catch (e) {
+    return {
+      ok: false,
+      error: `\u5DE5\u5177\u6267\u884C\u629B\u51FA\u5F02\u5E38\uFF1A${e.message}`
+    };
+  }
+}
+
+// src/ui/Root.tsx
+import { useEffect as useEffect2, useState as useState6 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+
+// src/cli/configWizard.tsx
+import { useCallback, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_CONTEXT_WINDOW2 = 128e3;
+var PRESETS = [
+  {
+    name: "minimax",
+    label: "MiniMax (\u6D77\u87BA)",
+    baseURL: "https://api.minimax.chat/v1",
+    models: ["MiniMax-M2.7", "MiniMax-M1", "abab6.5s-chat"]
+  },
+  {
+    name: "deepseek",
+    label: "DeepSeek",
+    baseURL: "https://api.deepseek.com/v1",
+    models: ["deepseek-chat", "deepseek-reasoner"]
+  },
+  {
+    name: "openai",
+    label: "OpenAI",
+    baseURL: "https://api.openai.com/v1",
+    models: ["gpt-4o", "gpt-4o-mini"]
+  },
+  {
+    name: "moonshot",
+    label: "Moonshot (Kimi)",
+    baseURL: "https://api.moonshot.cn/v1",
+    models: ["moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]
+  },
+  {
+    name: "custom",
+    label: "\u81EA\u5B9A\u4E49\uFF08\u624B\u52A8\u586B baseURL\uFF09",
+    baseURL: "",
+    models: []
+  }
+];
+function ConfigWizard({ onSuccess }) {
+  const { exit } = useApp();
+  const [step, setStep] = useState("preset");
+  const [presetIndex, setPresetIndex] = useState(0);
+  const [baseURL, setBaseURL] = useState("");
+  const [apiKey, setApiKey] = useState("");
+  const [model, setModel] = useState("");
+  const [modelIndex, setModelIndex] = useState(0);
+  const [draft, setDraft] = useState("");
+  const [errorMsg, setErrorMsg] = useState(null);
+  const preset = PRESETS[presetIndex];
+  const enterStep = useCallback(
+    (next) => {
+      setErrorMsg(null);
+      if (next === "baseURL") setDraft(baseURL || preset.baseURL);
+      if (next === "apiKey") setDraft("");
+      if (next === "model") {
+        if (preset.models.length > 0) {
+          setDraft(model || preset.models[0]);
+          setModelIndex(0);
+        } else {
+          setDraft(model);
+        }
+      }
+      setStep(next);
+    },
+    [baseURL, model, preset]
+  );
+  const handleTest = useCallback(async () => {
+    setStep("testing");
+    setErrorMsg(null);
+    try {
+      const url = `${baseURL.replace(/\/$/, "")}/chat/completions`;
+      const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: "ping" }],
+          max_tokens: 5,
+          stream: false
+        })
+      });
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        throw new Error(`HTTP ${resp.status}: ${body.slice(0, 200) || resp.statusText}`);
+      }
+      const data = await resp.json();
+      if (!Array.isArray(data.choices)) {
+        throw new Error("\u54CD\u5E94\u4E2D\u6CA1\u6709 choices \u5B57\u6BB5\uFF0C\u53EF\u80FD\u4E0D\u662F OpenAI \u517C\u5BB9\u534F\u8BAE");
+      }
+      await saveConfig({
+        baseURL,
+        apiKey,
+        model,
+        provider: preset.name,
+        contextWindow: DEFAULT_CONTEXT_WINDOW2
+      });
+      onSuccess({
+        name: preset.name,
+        baseURL,
+        apiKey,
+        model,
+        contextWindow: DEFAULT_CONTEXT_WINDOW2
+      });
+    } catch (e) {
+      setErrorMsg(e.message || "\u8FDE\u63A5\u5931\u8D25");
+      setStep("error");
+    }
+  }, [apiKey, baseURL, model, onSuccess, preset.name]);
+  useInput((input, key) => {
+    if (key.escape || key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (step === "preset") {
+      if (key.upArrow) {
+        setPresetIndex((i) => (i - 1 + PRESETS.length) % PRESETS.length);
+      } else if (key.downArrow) {
+        setPresetIndex((i) => (i + 1) % PRESETS.length);
+      } else if (key.return) {
+        enterStep("baseURL");
+      }
+      return;
+    }
+    if (step === "baseURL") {
+      if (key.return) {
+        if (draft.trim().length === 0) return;
+        setBaseURL(draft.trim());
+        enterStep("apiKey");
+      } else if (key.backspace || key.delete) {
+        setDraft((s) => s.slice(0, -1));
+      } else if (input && !key.meta && !key.ctrl) {
+        setDraft((s) => s + input);
+      }
+      return;
+    }
+    if (step === "apiKey") {
+      if (key.return) {
+        if (draft.length === 0) return;
+        setApiKey(draft);
+        enterStep("model");
+      } else if (key.backspace || key.delete) {
+        setDraft((s) => s.slice(0, -1));
+      } else if (input && !key.meta && !key.ctrl) {
+        setDraft((s) => s + input);
+      }
+      return;
+    }
+    if (step === "model") {
+      if (preset.models.length > 0) {
+        if (key.upArrow) {
+          const ni = (modelIndex - 1 + preset.models.length) % preset.models.length;
+          setModelIndex(ni);
+          setDraft(preset.models[ni]);
+        } else if (key.downArrow) {
+          const ni = (modelIndex + 1) % preset.models.length;
+          setModelIndex(ni);
+          setDraft(preset.models[ni]);
+        } else if (key.tab) {
+          setDraft((s) => s + "");
+        }
+      }
+      if (key.return) {
+        if (draft.trim().length === 0) return;
+        setModel(draft.trim());
+        void handleTest();
+      } else if (key.backspace || key.delete) {
+        setDraft((s) => s.slice(0, -1));
+      } else if (input && !key.meta && !key.ctrl && !key.upArrow && !key.downArrow) {
+        setDraft((s) => s + input);
+      }
+      return;
+    }
+    if (step === "error") {
+      if (key.return) {
+        enterStep("preset");
+      }
+      return;
+    }
+  });
+  const maskedApiKey = useMemo(() => "*".repeat(Math.min(draft.length, 32)), [draft]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "minimal-agent \xB7 \u9996\u6B21\u914D\u7F6E\u5411\u5BFC" }) }),
+    /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u6309 ESC \u6216 Ctrl+C \u9000\u51FA\uFF08\u4E0D\u5199\u914D\u7F6E\uFF0C\u4E0B\u6B21\u542F\u52A8\u7EE7\u7EED\u5411\u5BFC\uFF09" }) }),
+    step === "preset" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { children: "Step 1/4 \xB7 \u9009\u62E9 provider \u9884\u8BBE\uFF08\u2191\u2193 \u79FB\u52A8\uFF0CEnter \u786E\u8BA4\uFF09" }),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: PRESETS.map((p, i) => /* @__PURE__ */ jsxs(Text, { color: i === presetIndex ? "cyan" : void 0, children: [
+        i === presetIndex ? "> " : "  ",
+        p.label,
+        p.baseURL ? `  (${p.baseURL})` : ""
+      ] }, p.name)) })
+    ] }),
+    step === "baseURL" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { children: "Step 2/4 \xB7 \u8F93\u5165 API base URL\uFF08\u9ED8\u8BA4\u4E3A\u9884\u8BBE\u503C\uFF0C\u53EF\u6539\uFF09" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: draft || " " }) }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter \u786E\u8BA4 \xB7 Backspace \u5220\u9664" })
+    ] }),
+    step === "apiKey" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { children: "Step 3/4 \xB7 \u8F93\u5165 API key\uFF08\u8F93\u5165\u5185\u5BB9\u4E0D\u4F1A\u663E\u793A\uFF09" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: maskedApiKey || " " }) }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "Enter \u786E\u8BA4 \xB7 Backspace \u5220\u9664\uFF08\u5DF2\u8F93\u5165 ",
+        draft.length,
+        " \u5B57\u7B26\uFF09"
+      ] })
+    ] }),
+    step === "model" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Step 4/4 \xB7 \u8F93\u5165\u6216\u9009\u62E9 model",
+        preset.models.length > 0 ? "\uFF08\u2191\u2193 \u5207\u6362\u9884\u8BBE\uFF0C\u6216\u76F4\u63A5\u7F16\u8F91\uFF09" : ""
+      ] }),
+      preset.models.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: preset.models.map((m, i) => /* @__PURE__ */ jsxs(Text, { color: i === modelIndex ? "cyan" : "gray", children: [
+        i === modelIndex ? "> " : "  ",
+        m
+      ] }, m)) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: /* @__PURE__ */ jsx(Text, { children: draft || " " }) }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter \u63D0\u4EA4\u5E76\u6D4B\u8BD5\u8FDE\u63A5" })
+    ] }),
+    step === "testing" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "\u23F3 \u6B63\u5728\u6D4B\u8BD5\u8FDE\u63A5 ",
+        baseURL,
+        " ..."
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "model = ",
+        model
+      ] })
+    ] }),
+    step === "error" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "red", children: "\u2717 \u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "red", children: errorMsg ?? "\u672A\u77E5\u9519\u8BEF" }) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u5DF2\u8F93\u5165\uFF1A" }) }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "  provider = ",
+        preset.name
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "  baseURL  = ",
+        baseURL
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "  model    = ",
+        model
+      ] }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u6309 Enter \u56DE\u5230 Step 1 \u91CD\u8BD5 \xB7 ESC \u9000\u51FA" }) })
+    ] })
+  ] });
+}
+
+// src/ui/App.tsx
+import React3 from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/ui/InputBox.tsx
+import { useRef as useRef2, useState as useState4, useCallback as useCallback4 } from "react";
+import { Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2 } from "ink";
+
+// src/ui/hooks/useTextBuffer.ts
+import { useCallback as useCallback2, useMemo as useMemo2, useState as useState2 } from "react";
+
+// src/ui/textBuffer.ts
+var EMPTY_BUFFER = { text: "", cursor: 0 };
+function toCps(s) {
+  return Array.from(s);
+}
+function fromCps(cps) {
+  return cps.join("");
+}
+function isWordChar(c) {
+  if (!c) return false;
+  return /[A-Za-z0-9_]/.test(c);
+}
+function findLineStart(cps, idx) {
+  let i = idx;
+  while (i > 0 && cps[i - 1] !== "\n") i--;
+  return i;
+}
+function findLineEnd(cps, idx) {
+  let i = idx;
+  while (i < cps.length && cps[i] !== "\n") i++;
+  return i;
+}
+function clamp(cps, idx) {
+  return Math.max(0, Math.min(cps.length, idx));
+}
+function bufInsert(s, content) {
+  if (content.length === 0) return s;
+  const cps = toCps(s.text);
+  const ins = toCps(content);
+  cps.splice(s.cursor, 0, ...ins);
+  return { text: fromCps(cps), cursor: s.cursor + ins.length };
+}
+function bufSetText(text) {
+  return { text, cursor: toCps(text).length };
+}
+function bufClear() {
+  return EMPTY_BUFFER;
+}
+function bufDeleteBefore(s) {
+  if (s.cursor === 0) return s;
+  const cps = toCps(s.text);
+  cps.splice(s.cursor - 1, 1);
+  return { text: fromCps(cps), cursor: s.cursor - 1 };
+}
+function bufDeleteAt(s) {
+  const cps = toCps(s.text);
+  if (s.cursor >= cps.length) return s;
+  cps.splice(s.cursor, 1);
+  return { text: fromCps(cps), cursor: s.cursor };
+}
+function bufDeleteWordBefore(s) {
+  if (s.cursor === 0) return s;
+  const cps = toCps(s.text);
+  let i = s.cursor;
+  while (i > 0 && !isWordChar(cps[i - 1])) i--;
+  while (i > 0 && isWordChar(cps[i - 1])) i--;
+  cps.splice(i, s.cursor - i);
+  return { text: fromCps(cps), cursor: i };
+}
+function bufKillToLineStart(s) {
+  const cps = toCps(s.text);
+  const lineStart = findLineStart(cps, s.cursor);
+  if (lineStart === s.cursor) return s;
+  cps.splice(lineStart, s.cursor - lineStart);
+  return { text: fromCps(cps), cursor: lineStart };
+}
+function bufKillToLineEnd(s) {
+  const cps = toCps(s.text);
+  const lineEnd = findLineEnd(cps, s.cursor);
+  if (lineEnd === s.cursor) return s;
+  cps.splice(s.cursor, lineEnd - s.cursor);
+  return { text: fromCps(cps), cursor: s.cursor };
+}
+function bufMoveLeft(s) {
+  return { text: s.text, cursor: Math.max(0, s.cursor - 1) };
+}
+function bufMoveRight(s) {
+  const len = toCps(s.text).length;
+  return { text: s.text, cursor: Math.min(len, s.cursor + 1) };
+}
+function bufMoveWordLeft(s) {
+  const cps = toCps(s.text);
+  let i = s.cursor;
+  while (i > 0 && !isWordChar(cps[i - 1])) i--;
+  while (i > 0 && isWordChar(cps[i - 1])) i--;
+  return { text: s.text, cursor: i };
+}
+function bufMoveWordRight(s) {
+  const cps = toCps(s.text);
+  let i = s.cursor;
+  while (i < cps.length && !isWordChar(cps[i])) i++;
+  while (i < cps.length && isWordChar(cps[i])) i++;
+  return { text: s.text, cursor: i };
+}
+function bufMoveLineStart(s) {
+  const cps = toCps(s.text);
+  return { text: s.text, cursor: findLineStart(cps, s.cursor) };
+}
+function bufMoveLineEnd(s) {
+  const cps = toCps(s.text);
+  return { text: s.text, cursor: findLineEnd(cps, s.cursor) };
+}
+function bufMoveBufferStart(s) {
+  return { text: s.text, cursor: 0 };
+}
+function bufMoveBufferEnd(s) {
+  return { text: s.text, cursor: toCps(s.text).length };
+}
+function bufMoveUp(s) {
+  const cps = toCps(s.text);
+  const lineStart = findLineStart(cps, s.cursor);
+  if (lineStart === 0) return s;
+  const prevLineEnd = lineStart - 1;
+  const prevLineStart = findLineStart(cps, prevLineEnd);
+  const col = s.cursor - lineStart;
+  const prevLineLen = prevLineEnd - prevLineStart;
+  return { text: s.text, cursor: prevLineStart + Math.min(col, prevLineLen) };
+}
+function bufMoveDown(s) {
+  const cps = toCps(s.text);
+  const lineStart = findLineStart(cps, s.cursor);
+  const lineEnd = findLineEnd(cps, s.cursor);
+  if (lineEnd === cps.length) return s;
+  const nextLineStart = lineEnd + 1;
+  const nextLineEnd = findLineEnd(cps, nextLineStart);
+  const col = s.cursor - lineStart;
+  const nextLineLen = nextLineEnd - nextLineStart;
+  return { text: s.text, cursor: nextLineStart + Math.min(col, nextLineLen) };
+}
+function layoutBuffer(s) {
+  const cps = toCps(s.text);
+  const cursor = clamp(cps, s.cursor);
+  const lineStart = findLineStart(cps, cursor);
+  const lines = [];
+  let buf = [];
+  let cursorRow = 0;
+  let charCount = 0;
+  for (const ch of cps) {
+    if (ch === "\n") {
+      lines.push(fromCps(buf));
+      buf = [];
+      if (charCount < lineStart) cursorRow++;
+    } else {
+      buf.push(ch);
+    }
+    charCount++;
+  }
+  lines.push(fromCps(buf));
+  const cursorCol = cursor - lineStart;
+  return { lines, cursorRow, cursorCol };
+}
+
+// src/ui/hooks/useTextBuffer.ts
+function useTextBuffer() {
+  const [state, setState] = useState2(EMPTY_BUFFER);
+  const insert = useCallback2((s) => setState((p) => bufInsert(p, s)), []);
+  const setText = useCallback2((s) => setState(bufSetText(s)), []);
+  const clear = useCallback2(() => setState(bufClear()), []);
+  const deleteBefore = useCallback2(() => setState(bufDeleteBefore), []);
+  const deleteAt = useCallback2(() => setState(bufDeleteAt), []);
+  const deleteWordBefore = useCallback2(() => setState(bufDeleteWordBefore), []);
+  const killToLineStart = useCallback2(() => setState(bufKillToLineStart), []);
+  const killToLineEnd = useCallback2(() => setState(bufKillToLineEnd), []);
+  const moveLeft = useCallback2(() => setState(bufMoveLeft), []);
+  const moveRight = useCallback2(() => setState(bufMoveRight), []);
+  const moveWordLeft = useCallback2(() => setState(bufMoveWordLeft), []);
+  const moveWordRight = useCallback2(() => setState(bufMoveWordRight), []);
+  const moveLineStart = useCallback2(() => setState(bufMoveLineStart), []);
+  const moveLineEnd = useCallback2(() => setState(bufMoveLineEnd), []);
+  const moveBufferStart = useCallback2(() => setState(bufMoveBufferStart), []);
+  const moveBufferEnd = useCallback2(() => setState(bufMoveBufferEnd), []);
+  const moveUp = useCallback2(() => setState(bufMoveUp), []);
+  const moveDown = useCallback2(() => setState(bufMoveDown), []);
+  const layout = useMemo2(() => layoutBuffer(state), [state]);
+  return {
+    state,
+    layout,
+    insert,
+    setText,
+    clear,
+    deleteBefore,
+    deleteAt,
+    deleteWordBefore,
+    killToLineStart,
+    killToLineEnd,
+    moveLeft,
+    moveRight,
+    moveWordLeft,
+    moveWordRight,
+    moveLineStart,
+    moveLineEnd,
+    moveBufferStart,
+    moveBufferEnd,
+    moveUp,
+    moveDown
+  };
+}
+
+// src/ui/hooks/usePasteHandler.ts
+import { useCallback as useCallback3, useRef, useState as useState3 } from "react";
+var PASTE_THRESHOLD = 20;
+var PASTE_TIMEOUT_MS = 100;
+function usePasteHandler({
+  onPasteComplete,
+  multiline = false
+}) {
+  const [isPasting, setIsPasting] = useState3(false);
+  const pasteStateRef = useRef({
+    chunks: [],
+    timeoutId: null
+  });
+  const onPasteCompleteRef = useRef(onPasteComplete);
+  onPasteCompleteRef.current = onPasteComplete;
+  const setIsPastingRef = useRef(setIsPasting);
+  setIsPastingRef.current = setIsPasting;
+  const flushPaste = useCallback3(() => {
+    const { chunks } = pasteStateRef.current;
+    if (chunks.length === 0) return;
+    const rawText = chunks.join("");
+    const cleanedText = rawText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n");
+    pasteStateRef.current = { chunks: [], timeoutId: null };
+    setIsPastingRef.current(false);
+    onPasteCompleteRef.current(cleanedText);
+  }, []);
+  const handleInput = useCallback3(
+    (input, key) => {
+      if (isPasting && key.return) {
+        return "enter-in-paste";
+      }
+      if (multiline && key.return && key.meta && !key.ctrl) {
+        return "enter-newline";
+      }
+      if (key.return) {
+        return "continue";
+      }
+      const isLongInput = input.length > PASTE_THRESHOLD;
+      if (isLongInput || isPasting) {
+        setIsPasting(true);
+        if (pasteStateRef.current.timeoutId) {
+          clearTimeout(pasteStateRef.current.timeoutId);
+        }
+        pasteStateRef.current.chunks.push(input);
+        pasteStateRef.current.timeoutId = setTimeout(() => {
+          flushPaste();
+        }, PASTE_TIMEOUT_MS);
+        return "paste";
+      }
+      return "continue";
+    },
+    [isPasting, multiline, flushPaste]
+  );
+  return {
+    handleInput,
+    isPasting
+  };
+}
+
+// src/ui/InputBox.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function InputBox({ onSubmit, disabled, onAbort, onClear, onCompact }) {
+  const buf = useTextBuffer();
+  const ctrlCCountRef = useRef2(0);
+  const ctrlCTimerRef = useRef2(null);
+  const { exit } = useApp2();
+  const [refreshCounter, setRefreshCounter] = useState4(0);
+  const lastDeleteTime = useRef2(0);
+  const DELETE_DEBOUNCE_MS = 20;
+  const forceRefresh = useCallback4(() => {
+    setRefreshCounter((c) => c + 1);
+  }, []);
+  const { handleInput: handlePasteInput } = usePasteHandler({
+    onPasteComplete: (text) => {
+      buf.insert(text);
+      forceRefresh();
+    },
+    multiline: true
+  });
+  useInput2((input, key) => {
+    const pasteResult = handlePasteInput(input, key);
+    if (pasteResult === "paste") {
+      return;
+    }
+    if (pasteResult === "enter-in-paste") {
+      return;
+    }
+    if (pasteResult === "enter-newline") {
+      buf.insert("\n");
+      forceRefresh();
+      return;
+    }
+    if (key.escape) {
+      if (disabled) onAbort();
+      return;
+    }
+    if (key.ctrl && input === "c") {
+      if (buf.state.text.length > 0) {
+        buf.clear();
+        forceRefresh();
+        return;
+      }
+      if (disabled) {
+        onAbort();
+        return;
+      }
+      ctrlCCountRef.current++;
+      if (ctrlCCountRef.current >= 2) exit();
+      if (ctrlCTimerRef.current) clearTimeout(ctrlCTimerRef.current);
+      ctrlCTimerRef.current = setTimeout(() => {
+        ctrlCCountRef.current = 0;
+      }, 1e3);
+      return;
+    }
+    if (key.return) {
+      const text = buf.state.text.trim();
+      if (text.length === 0) return;
+      if (text === "/exit" || text === "/quit") exit();
+      else if (text === "/new" || text === "/clear") {
+        buf.clear();
+        forceRefresh();
+        onClear();
+      } else if (text === "/compact") {
+        buf.clear();
+        forceRefresh();
+        onCompact();
+      } else {
+        buf.clear();
+        forceRefresh();
+        onSubmit(text);
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      if (key.ctrl || key.meta) buf.moveWordLeft();
+      else buf.moveLeft();
+      forceRefresh();
+      return;
+    }
+    if (key.rightArrow) {
+      if (key.ctrl || key.meta) buf.moveWordRight();
+      else buf.moveRight();
+      forceRefresh();
+      return;
+    }
+    if (key.upArrow) {
+      buf.moveUp();
+      forceRefresh();
+      return;
+    }
+    if (key.downArrow) {
+      buf.moveDown();
+      forceRefresh();
+      return;
+    }
+    if (key.backspace) {
+      buf.deleteBefore();
+      forceRefresh();
+      return;
+    }
+    if (key.delete) {
+      const now = Date.now();
+      if (now - lastDeleteTime.current < DELETE_DEBOUNCE_MS) {
+        return;
+      }
+      lastDeleteTime.current = now;
+      buf.deleteBefore();
+      forceRefresh();
+      return;
+    }
+    if (key.ctrl && !key.meta) {
+      switch (input) {
+        case "a":
+          buf.moveLineStart();
+          break;
+        case "e":
+          buf.moveLineEnd();
+          break;
+        case "b":
+          buf.moveLeft();
+          break;
+        case "f":
+          buf.moveRight();
+          break;
+        case "u":
+          buf.killToLineStart();
+          break;
+        case "k":
+          buf.killToLineEnd();
+          break;
+        case "w":
+          buf.deleteWordBefore();
+          break;
+        case "h":
+          buf.deleteBefore();
+          break;
+        // Ctrl+H = Backspace
+        default:
+          return;
+      }
+      forceRefresh();
+      return;
+    }
+    if (key.meta && input === "<") {
+      buf.moveBufferStart();
+      forceRefresh();
+      return;
+    }
+    if (key.meta && input === ">") {
+      buf.moveBufferEnd();
+      forceRefresh();
+      return;
+    }
+    if (input && !key.meta) {
+      const normalized = input.replace(/\r\n?/g, "\n");
+      buf.insert(normalized);
+      forceRefresh();
+    }
+  });
+  return /* @__PURE__ */ jsx2(
+    BufferView,
+    {
+      buf,
+      disabled,
+      refreshCounter
+    }
+  );
+}
+function BufferView({ buf, disabled, refreshCounter }) {
+  const { lines, cursorRow, cursorCol } = buf.layout;
+  const promptColor = disabled ? "gray" : "cyan";
+  const prompt = disabled ? "\u23F3 " : "> ";
+  return /* @__PURE__ */ jsx2(Box2, { borderStyle: "round", borderColor: promptColor, paddingX: 1, flexDirection: "column", children: lines.map((line, row) => {
+    const isFirst = row === 0;
+    const isCursorRow = row === cursorRow && !disabled;
+    return /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: promptColor, bold: true, children: isFirst ? prompt : "  " }),
+      isCursorRow ? /* @__PURE__ */ jsx2(CursorLine, { line, col: cursorCol }) : /* @__PURE__ */ jsx2(Text2, { children: line || " " })
+    ] }, row);
+  }) });
+}
+function CursorLine({ line, col }) {
+  const cps = Array.from(line);
+  const before = cps.slice(0, col).join("");
+  const cursorChar = cps[col] ?? " ";
+  const after = cps.slice(col + 1).join("");
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    before,
+    /* @__PURE__ */ jsx2(Text2, { inverse: true, children: cursorChar }),
+    after
+  ] });
+}
+
+// src/ui/MessageList.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_TOOL_PREVIEW_LINES = 3;
+function MessageList({ history, streamingText }) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    history.map((m, i) => /* @__PURE__ */ jsx3(MessageRow, { message: m }, i)),
+    streamingText.length > 0 && /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: streamingText }),
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", children: " \u258D" })
+    ] })
+  ] });
+}
+function MessageRow({ message }) {
+  switch (message.role) {
+    case "system":
+      return null;
+    // 不展示系统提示词
+    case "user":
+      return /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", bold: true, children: "> " }),
+        /* @__PURE__ */ jsx3(Text3, { children: message.content })
+      ] });
+    case "assistant": {
+      const text = message.content ?? "";
+      const tcCount = message.tool_calls?.length ?? 0;
+      return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        text.length > 0 && /* @__PURE__ */ jsx3(Text3, { children: text }),
+        tcCount > 0 && /* @__PURE__ */ jsx3(Text3, { color: "yellow", dimColor: true, children: `  \u2514\u2500 \u8C03\u7528\u4E86 ${tcCount} \u4E2A\u5DE5\u5177\uFF1A${(message.tool_calls ?? []).map((tc) => tc.function.name).join(", ")}` })
+      ] });
+    }
+    case "tool": {
+      const lines = message.content.split("\n");
+      const preview = lines.slice(0, MAX_TOOL_PREVIEW_LINES).join("\n");
+      const hidden = Math.max(0, lines.length - MAX_TOOL_PREVIEW_LINES);
+      return /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, paddingLeft: 2, children: /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "[tool result]" }),
+        /* @__PURE__ */ jsx3(Text3, { color: "gray", children: preview }),
+        hidden > 0 && /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: `... (\u7701\u7565 ${hidden} \u884C)` })
+      ] }) });
+    }
+  }
+}
+
+// src/ui/StatusLine.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/llm/client.ts
+async function* chat(args) {
+  const { provider, messages, tools, signal } = args;
+  const openaiTools = tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: typeof t.description === "function" ? t.description() : t.description,
+      parameters: t.parameters
+    }
+  }));
+  const body = {
+    model: provider.model,
+    messages,
+    tools: openaiTools.length > 0 ? openaiTools : void 0,
+    stream: true,
+    // tool_choice: 'auto' 是默认值，可不写；某些 provider 必须显式
+    tool_choice: openaiTools.length > 0 ? "auto" : void 0
+  };
+  const url = `${provider.baseURL.replace(/\/$/, "")}/chat/completions`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${provider.apiKey}`
+    },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!resp.ok) {
+    const errText = await resp.text().catch(() => "");
+    throw new Error(
+      `LLM \u8BF7\u6C42\u5931\u8D25 [${resp.status} ${resp.statusText}]\uFF1A${errText.slice(0, 500)}`
+    );
+  }
+  if (!resp.body) {
+    throw new Error("LLM \u54CD\u5E94\u6CA1\u6709 body\uFF08provider \u53EF\u80FD\u4E0D\u652F\u6301\u6D41\u5F0F\uFF1F\uFF09");
+  }
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let stopReason = "unknown";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        yield { type: "done", stopReason: "aborted" };
+        return;
+      }
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (signal?.aborted) {
+        yield { type: "done", stopReason: "aborted" };
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let lineEnd;
+      while ((lineEnd = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line || !line.startsWith("data:")) continue;
+        const dataStr = line.slice(5).trim();
+        if (dataStr === "[DONE]") {
+          yield { type: "done", stopReason };
+          return;
+        }
+        let chunk;
+        try {
+          chunk = JSON.parse(dataStr);
+        } catch {
+          continue;
+        }
+        const delta = chunk.choices?.[0]?.delta;
+        const finish = chunk.choices?.[0]?.finish_reason;
+        if (finish) {
+          stopReason = finish === "stop" || finish === "tool_calls" || finish === "length" ? finish : "unknown";
+        }
+        if (!delta) continue;
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+          yield { type: "text_delta", delta: delta.content };
+        }
+        if (Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            yield {
+              type: "tool_call_delta",
+              index: tc.index ?? 0,
+              id: tc.id,
+              name: tc.function?.name,
+              argumentsDelta: tc.function?.arguments
+            };
+          }
+        }
+        if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+          yield {
+            type: "reasoning_delta",
+            field: "reasoning_content",
+            delta: delta.reasoning_content
+          };
+        }
+        if (typeof delta.reasoning === "string" && delta.reasoning.length > 0) {
+          yield {
+            type: "reasoning_delta",
+            field: "reasoning",
+            delta: delta.reasoning
+          };
+        }
+        if (Array.isArray(delta.reasoning_details) && delta.reasoning_details.length > 0) {
+          yield {
+            type: "reasoning_delta",
+            field: "reasoning_details",
+            items: delta.reasoning_details
+          };
+        }
+      }
+    }
+    yield { type: "done", stopReason };
+  } finally {
+    reader.releaseLock?.();
+  }
+}
+
+// src/context/tokenCounter.ts
+function countTextTokens(text) {
+  if (!text) return 0;
+  let asciiChars = 0;
+  let nonAsciiChars = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code < 128) asciiChars++;
+    else nonAsciiChars++;
+  }
+  return Math.ceil(asciiChars / 4) + nonAsciiChars;
+}
+function countMessagesTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    total += 4;
+    if (typeof m.content === "string") {
+      total += countTextTokens(m.content);
+    } else if (m.content === null) {
+    }
+    if (m.role === "assistant" && m.tool_calls) {
+      for (const tc of m.tool_calls) {
+        total += 8;
+        total += countTextTokens(tc.function.name);
+        total += countTextTokens(tc.function.arguments);
+      }
+    }
+    if (m.role === "tool") {
+      total += countTextTokens(m.tool_call_id);
+    }
+  }
+  return total;
+}
+
+// src/context/compact.ts
+var NO_TOOLS_PREAMBLE = `CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.
+
+- Do NOT use Read, Bash, Grep, Glob, Edit, Write, or ANY other tool.
+- You already have all the context you need in the conversation above.
+- Tool calls will be REJECTED and will waste your only turn \u2014 you will fail the task.
+- Your entire response must be plain text: an <analysis> block followed by a <summary> block.
+
+`;
+var NO_TOOLS_TRAILER = "\n\nREMINDER: Do NOT call any tools. Respond with plain text only \u2014 an <analysis> block followed by a <summary> block. Tool calls will be rejected and you will fail the task.";
+var COMPACT_PROMPT_BODY = `Your task is to create a detailed summary of this conversation. This summary will be placed at the start of a continuing session; newer messages that build on this context will follow after your summary. Summarize thoroughly so that someone reading only your summary and then the newer messages can fully understand what happened and continue the work.
+
+Before providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:
+
+1. Chronologically analyze each message and section of the conversation. For each section thoroughly identify:
+   - The user's explicit requests and intents
+   - Your approach to addressing the user's requests
+   - Key decisions, technical concepts and code patterns
+   - Specific details like file names, full code snippets, function signatures, file edits
+   - Errors that you ran into and how you fixed them
+   - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+2. Double-check for technical accuracy and completeness, addressing each required element thoroughly.
+
+Your summary should include the following sections:
+
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Include FULL code snippets where applicable and include a summary of why this file read or edit is important. (Code snippets are NOT compressed \u2014 preserve them verbatim.)
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent. (User messages are NOT compressed \u2014 preserve them verbatim.)
+7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+8. Work Completed: Describe what was accomplished by the end of this portion.
+9. Context for Continuing Work: Summarize any context, decisions, or state that would be needed to understand and continue the work in subsequent messages. Include direct quotes from the most recent conversation showing exactly where work was left off \u2014 this should be verbatim to ensure there's no drift.
+
+Here's an example of how your output should be structured:
+
+<example>
+<analysis>
+[Your thought process, ensuring all points are covered thoroughly and accurately]
+</analysis>
+
+<summary>
+1. Primary Request and Intent:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [...]
+
+3. Files and Code Sections:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Important Code Snippet]
+   - [...]
+
+4. Errors and fixes:
+    - [Detailed description of error 1]:
+      - [How you fixed the error]
+      - [User feedback on the error if any]
+    - [...]
+
+5. Problem Solving:
+  [Description of solved problems and ongoing troubleshooting]
+
+6. All user messages:
+    - [Detailed non tool use user message]
+    - [...]
+
+7. Pending Tasks:
+   - [Task 1]
+   - [...]
+
+8. Work Completed:
+  [What was accomplished]
+
+9. Context for Continuing Work:
+  [Key context, decisions, or state needed to continue]
+
+</summary>
+</example>
+
+Please provide your summary following this structure, ensuring precision and thoroughness in your response.`;
+function buildCompactPrompt(customInstructions) {
+  let prompt = NO_TOOLS_PREAMBLE + COMPACT_PROMPT_BODY;
+  if (customInstructions && customInstructions.trim() !== "") {
+    prompt += `
+
+Additional Instructions:
+${customInstructions.trim()}`;
+  }
+  prompt += NO_TOOLS_TRAILER;
+  return prompt;
+}
+var BASE_COMPACT_PROMPT = buildCompactPrompt();
+function buildContinuationUserMessage(args) {
+  const { summary, recentMessagesPreserved } = args;
+  let msg = `This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.
+
+${summary}`;
+  if (recentMessagesPreserved) {
+    msg += `
+
+Recent messages are preserved verbatim.`;
+  }
+  msg += `
+
+Continue the conversation from where it left off without asking the user any further questions. Resume directly \u2014 do not acknowledge the summary, do not recap what was happening, do not preface with "I'll continue" or similar. Pick up the last task as if the break never happened.`;
+  return msg;
+}
+function formatCompactSummary(rawResponse) {
+  const match = rawResponse.match(/<summary>([\s\S]*?)<\/summary>/);
+  if (match) return match[1].trim();
+  const stripped = rawResponse.replace(/<analysis>[\s\S]*?<\/analysis>/g, "").trim();
+  return stripped || rawResponse.trim();
+}
+var AUTOCOMPACT_BUFFER_TOKENS = 25e3;
+var MIN_KEEP_RECENT_MESSAGES = 4;
+function getCompactThreshold(provider) {
+  return Math.max(1e3, provider.contextWindow - AUTOCOMPACT_BUFFER_TOKENS);
+}
+function findTailWithCompleteToolChains(messages, minKeep = MIN_KEEP_RECENT_MESSAGES) {
+  if (messages.length <= minKeep) return [...messages];
+  const tailEnd = messages.length;
+  let tailStart = tailEnd - minKeep;
+  const knownToolCallIds = /* @__PURE__ */ new Set();
+  for (let i = tailStart; i < tailEnd; i++) {
+    const msg = messages[i];
+    if (msg.role === "assistant" && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        knownToolCallIds.add(tc.id);
+      }
+    }
+  }
+  let needsExpansion = true;
+  while (needsExpansion && tailStart > 0) {
+    needsExpansion = false;
+    for (let i = tailStart; i < tailEnd; i++) {
+      const msg = messages[i];
+      if (msg.role === "tool" && msg.tool_call_id) {
+        if (!knownToolCallIds.has(msg.tool_call_id)) {
+          needsExpansion = true;
+          tailStart--;
+          const newMsg = messages[tailStart];
+          if (newMsg.role === "assistant" && newMsg.tool_calls) {
+            for (const tc of newMsg.tool_calls) {
+              knownToolCallIds.add(tc.id);
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  return messages.slice(tailStart);
+}
+async function autoCompactIfNeeded(messages, provider) {
+  const before = countMessagesTokens(messages);
+  const threshold = getCompactThreshold(provider);
+  if (before < threshold) {
+    return { messages, compacted: false, before, after: before };
+  }
+  const compactedMessages = await runCompaction(messages, provider);
+  const after = countMessagesTokens(compactedMessages);
+  return { messages: compactedMessages, compacted: true, before, after };
+}
+async function forceCompact(messages, provider) {
+  const before = countMessagesTokens(messages);
+  const compactedMessages = await runCompaction(messages, provider);
+  const after = countMessagesTokens(compactedMessages);
+  return { messages: compactedMessages, before, after };
+}
+async function runCompaction(messages, provider) {
+  const systemMsg = messages.find((m) => m.role === "system");
+  const nonSystem = messages.filter((m) => m.role !== "system");
+  const compactRequest = [
+    ...systemMsg ? [systemMsg] : [],
+    ...nonSystem,
+    {
+      role: "user",
+      content: buildCompactPrompt()
+    }
+  ];
+  let summary = "";
+  try {
+    for await (const ev of chat({
+      provider,
+      messages: compactRequest,
+      tools: []
+    })) {
+      if (ev.type === "text_delta") summary += ev.delta;
+    }
+  } catch (e) {
+    return [
+      ...systemMsg ? [systemMsg] : [],
+      {
+        role: "user",
+        content: `(\u81EA\u52A8\u538B\u7F29\u5931\u8D25\uFF1A${e.message}\uFF0C\u5DF2\u76F4\u63A5\u622A\u65AD\u65E7\u5386\u53F2)`
+      },
+      ...findTailWithCompleteToolChains(nonSystem)
+    ];
+  }
+  const cleanSummary = formatCompactSummary(summary);
+  const recentTail = findTailWithCompleteToolChains(nonSystem);
+  return [
+    ...systemMsg ? [systemMsg] : [],
+    {
+      role: "user",
+      content: buildContinuationUserMessage({
+        summary: cleanSummary,
+        recentMessagesPreserved: recentTail.length > 0
+      })
+    },
+    ...recentTail
+  ];
+}
+
+// src/ui/hooks/useTokenUsage.ts
+function useTokenUsage(messages, provider) {
+  const tokens = countMessagesTokens(messages);
+  const threshold = Math.max(1e3, provider.contextWindow - AUTOCOMPACT_BUFFER_TOKENS);
+  return {
+    tokens,
+    threshold,
+    contextWindow: provider.contextWindow,
+    percentageOfWindow: tokens / provider.contextWindow,
+    toThreshold: threshold - tokens
+  };
+}
+
+// src/ui/StatusLine.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function StatusLine({ provider, history }) {
+  const usage = useTokenUsage(history, provider);
+  const ratio = usage.tokens / usage.threshold;
+  const color = ratio >= 1 ? "red" : ratio >= 0.7 ? "yellow" : "green";
+  return /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+      provider.name,
+      "/",
+      provider.model
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " \xB7 " }),
+    /* @__PURE__ */ jsxs4(Text4, { color, children: [
+      "tokens ",
+      fmt(usage.tokens),
+      " / ",
+      fmt(usage.contextWindow)
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: " \xB7 " }),
+    /* @__PURE__ */ jsx4(Text4, { color, children: usage.toThreshold > 0 ? `\u8DDD\u538B\u7F29 ${fmt(usage.toThreshold)}` : `\u5DF2\u8D85\u9608\u503C\uFF08\u4E0B\u8F6E\u538B\u7F29\uFF09` })
+  ] });
+}
+function fmt(n) {
+  if (n < 1e3) return `${n}`;
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}K`;
+  return `${(n / 1e6).toFixed(2)}M`;
+}
+
+// src/ui/ToolStatus.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ToolStatus({ status, compacting }) {
+  if (compacting) {
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { color: "magenta", bold: true, children: "\u{1F5DC}  \u6B63\u5728\u538B\u7F29\u5BF9\u8BDD\u5386\u53F2..." }) });
+  }
+  if (status) {
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      "\u23F3 ",
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: status.toolName }),
+      `(${status.argsPreview})`
+    ] }) });
+  }
+  return null;
+}
+
+// src/ui/hooks/useChat.ts
+import { useCallback as useCallback5, useEffect, useMemo as useMemo3, useRef as useRef3, useState as useState5 } from "react";
+
+// src/context/snipCompact.ts
+var DEFAULT_SNIP_PERCENT = 0.2;
+var DEFAULT_MIN_KEEP = 5;
+var DEFAULT_MAX_SNIP = 50;
+var DEFAULT_THRESHOLD = 10;
+function snipCompactIfNeeded(messages, options = {}) {
+  const force = options.force ?? false;
+  const snipPercent = options.snipPercent ?? DEFAULT_SNIP_PERCENT;
+  const minKeep = options.minMessagesToKeep ?? DEFAULT_MIN_KEEP;
+  const maxSnip = options.maxMessagesToSnip ?? DEFAULT_MAX_SNIP;
+  if (messages.length === 0) {
+    return { messages: [], messagesRemoved: 0, tokensFreed: 0 };
+  }
+  const systemMsg = messages[0].role === "system" ? messages[0] : null;
+  const rest = systemMsg ? messages.slice(1) : messages.slice();
+  if (!force && rest.length < DEFAULT_THRESHOLD) {
+    return { messages: messages.slice(), messagesRemoved: 0, tokensFreed: 0 };
+  }
+  const byPercent = Math.floor(rest.length * snipPercent);
+  const proposedSnipCount = Math.min(
+    byPercent,
+    maxSnip,
+    Math.max(0, rest.length - minKeep)
+  );
+  if (proposedSnipCount <= 0) {
+    return { messages: messages.slice(), messagesRemoved: 0, tokensFreed: 0 };
+  }
+  const actualCut = findHeadCutpoint(rest, proposedSnipCount);
+  if (actualCut === 0 || actualCut >= rest.length) {
+    return { messages: messages.slice(), messagesRemoved: 0, tokensFreed: 0 };
+  }
+  const snipped = rest.slice(0, actualCut);
+  const remaining = rest.slice(actualCut);
+  const tokensFreed = countMessagesTokens(snipped);
+  const marker = {
+    role: "user",
+    content: `[\u5DF2\u81EA\u52A8\u5220\u9664\u6700\u65E9\u7684 ${actualCut} \u6761\u5BF9\u8BDD\u4EE5\u8282\u7701 token\uFF08\u7EA6\u91CA\u653E ${tokensFreed.toLocaleString()} tokens\uFF09\u3002\u5982\u9700\u5B8C\u6574\u5386\u53F2\u8BF7\u7528 /new \u91CD\u542F\u4F1A\u8BDD\u6216 /compact \u89E6\u53D1 LLM \u6458\u8981\u538B\u7F29\u3002]`
+  };
+  return {
+    messages: [...systemMsg ? [systemMsg] : [], marker, ...remaining],
+    messagesRemoved: actualCut,
+    tokensFreed
+  };
+}
+function findHeadCutpoint(messages, proposedCut) {
+  let cut = Math.max(0, Math.min(proposedCut, messages.length));
+  while (cut < messages.length) {
+    const knownIds = /* @__PURE__ */ new Set();
+    let foundOrphan = false;
+    for (let i = cut; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) knownIds.add(tc.id);
+      } else if (msg.role === "tool" && !knownIds.has(msg.tool_call_id)) {
+        foundOrphan = true;
+        break;
+      }
+    }
+    if (!foundOrphan) return cut;
+    cut++;
+  }
+  return cut;
+}
+
+// src/context/reactiveCompact.ts
+var attemptedThisSession = false;
+function resetReactiveCompactState() {
+  attemptedThisSession = false;
+}
+function isPromptTooLongError(error) {
+  const msg = errorMessage(error).toLowerCase();
+  if (!msg) return false;
+  const hasSubject = /prompt|context|token|input length/.test(msg);
+  const hasIssue = /too long|exceed|limit|maximum|over/.test(msg);
+  return hasSubject && hasIssue;
+}
+function errorMessage(error) {
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message ?? "");
+  }
+  return String(error ?? "");
+}
+async function reactiveCompactIfApplicable(messages, provider, error) {
+  if (!isPromptTooLongError(error)) {
+    return { recovered: false, messages, reason: "not a prompt-too-long error" };
+  }
+  if (attemptedThisSession) {
+    return {
+      recovered: false,
+      messages,
+      reason: "already attempted this session \u2014 use /new or /compact manually"
+    };
+  }
+  attemptedThisSession = true;
+  try {
+    const r = await forceCompact(messages, provider);
+    return {
+      recovered: true,
+      messages: r.messages,
+      reason: `LLM \u538B\u7F29\u6210\u529F\uFF08${r.before} \u2192 ${r.after} tokens\uFF09`,
+      before: r.before,
+      after: r.after
+    };
+  } catch (compactErr) {
+  }
+  const beforeSnip = countMessagesTokens(messages);
+  const snipped = snipCompactIfNeeded(messages, {
+    force: true,
+    snipPercent: 0.4
+  });
+  if (snipped.messagesRemoved > 0) {
+    const afterSnip = countMessagesTokens(snipped.messages);
+    return {
+      recovered: true,
+      messages: snipped.messages,
+      reason: `snip \u515C\u5E95\u6210\u529F\uFF08\u5220\u9664 ${snipped.messagesRemoved} \u6761\u6700\u8001\u6D88\u606F\uFF0C\u91CA\u653E ~${snipped.tokensFreed} tokens\uFF09`,
+      before: beforeSnip,
+      after: afterSnip
+    };
+  }
+  return {
+    recovered: false,
+    messages,
+    reason: "\u53CD\u5E94\u5F0F\u538B\u7F29\u5931\u8D25\uFF1ALLM \u538B\u7F29\u629B\u9519\u4E14 snip \u4E5F\u6CA1\u4E1C\u897F\u53EF\u780D"
+  };
+}
+
+// src/context/microCompactLite.ts
+import { createHash } from "crypto";
+var MAX_REPEAT_COUNT = 3;
+var MAX_RESULT_SIZE = 4e3;
+var HEAD_KEEP_CHARS = 2e3;
+var TAIL_KEEP_CHARS = 1e3;
+var MAX_KEEP_ROUNDS = 10;
+var SHORT_CONTENT_THRESHOLD = 200;
+var currentTurn = 0;
+var contentCache = /* @__PURE__ */ new Map();
+function incrementTurn() {
+  currentTurn++;
+}
+var COMPRESSIBLE_TOOLS = /* @__PURE__ */ new Set([
+  "Grep",
+  "Bash",
+  "WebFetch",
+  "Glob"
+]);
+function microCompact(toolName, content) {
+  if (!content) return content;
+  if (content.startsWith("Error:") || content.startsWith("\u9519\u8BEF")) {
+    return content;
+  }
+  if (content.length <= SHORT_CONTENT_THRESHOLD) {
+    return content;
+  }
+  const hash = sha1(content);
+  const existing = contentCache.get(hash);
+  if (existing) {
+    existing.count++;
+    if (existing.count > MAX_REPEAT_COUNT) {
+      return `[\u2191 ${existing.firstToolName} \u7ED3\u679C\u5DF2\u91CD\u590D\u51FA\u73B0 ${existing.count} \u6B21\uFF08\u76F8\u540C\u5185\u5BB9\u5DF2\u7701\u7565\uFF09]`;
+    }
+    return content;
+  }
+  contentCache.set(hash, { count: 1, firstToolName: toolName, firstSeenTurn: currentTurn });
+  if (content.length > MAX_RESULT_SIZE && COMPRESSIBLE_TOOLS.has(toolName)) {
+    return truncateContent(content);
+  }
+  return content;
+}
+function expireOldEntries() {
+  let expired = 0;
+  for (const [hash, entry] of contentCache) {
+    if (currentTurn - entry.firstSeenTurn > MAX_KEEP_ROUNDS) {
+      contentCache.delete(hash);
+      expired++;
+    }
+  }
+  return expired;
+}
+function sha1(str) {
+  return createHash("sha1").update(str).digest("hex");
+}
+function truncateContent(content) {
+  const omitted = content.length - HEAD_KEEP_CHARS - TAIL_KEEP_CHARS;
+  return content.slice(0, HEAD_KEEP_CHARS) + `
+
+[... \u7701\u7565\u4E86 ${omitted.toLocaleString()} \u5B57\u7B26 ...]
+
+` + content.slice(-TAIL_KEEP_CHARS);
+}
+
+// src/loop.ts
+async function* runQuery(userInput, options) {
+  const { provider, history, signal } = options;
+  const maxTurns = options.maxTurns ?? 50;
+  history.push({ role: "user", content: userInput });
+  let reactiveAttempted = false;
+  let turn = 0;
+  while (turn < maxTurns) {
+    turn++;
+    incrementTurn();
+    expireOldEntries();
+    if (signal?.aborted) {
+      history.push({
+        role: "user",
+        content: "(\u7528\u6237\u6309\u4E0B\u4E86 ESC/Ctrl+C \u4E2D\u65AD\u4E86\u4EFB\u52A1)"
+      });
+      yield { type: "error", error: "\u5DF2\u88AB\u7528\u6237\u4E2D\u65AD" };
+      return;
+    }
+    try {
+      const compact = await autoCompactIfNeeded(history, provider);
+      if (compact.compacted) {
+        yield { type: "compact_start" };
+        history.length = 0;
+        history.push(...compact.messages);
+        yield { type: "compact_done", before: compact.before, after: compact.after };
+      }
+    } catch (e) {
+      yield {
+        type: "error",
+        error: `\u81EA\u52A8\u538B\u7F29\u5931\u8D25\uFF08\u7EE7\u7EED\u4E0D\u538B\u7F29\uFF09\uFF1A${e.message}`
+      };
+    }
+    let assistantText = "";
+    const toolCallsByIndex = [];
+    let reasoningContent = "";
+    let reasoningString = "";
+    const reasoningDetails = [];
+    try {
+      for await (const ev of chat({
+        provider,
+        messages: history,
+        tools: ALL_TOOLS,
+        signal
+      })) {
+        if (ev.type === "text_delta") {
+          assistantText += ev.delta;
+          yield { type: "text", delta: ev.delta };
+        } else if (ev.type === "tool_call_delta") {
+          mergeToolCallDelta(toolCallsByIndex, ev);
+        } else if (ev.type === "reasoning_delta") {
+          if (ev.field === "reasoning_content" && ev.delta) {
+            reasoningContent += ev.delta;
+          } else if (ev.field === "reasoning" && ev.delta) {
+            reasoningString += ev.delta;
+          } else if (ev.field === "reasoning_details" && ev.items) {
+            reasoningDetails.push(...ev.items);
+          }
+        }
+      }
+    } catch (e) {
+      if (e.name === "AbortError") {
+        history.push({
+          role: "user",
+          content: "(\u7528\u6237\u6309\u4E0B\u4E86 ESC/Ctrl+C \u4E2D\u65AD\u4E86\u4EFB\u52A1)"
+        });
+        yield { type: "interrupted" };
+        return;
+      }
+      if (isPromptTooLongError(e) && !reactiveAttempted) {
+        reactiveAttempted = true;
+        yield { type: "compact_start" };
+        const result = await reactiveCompactIfApplicable(history, provider, e);
+        if (result.recovered) {
+          history.length = 0;
+          history.push(...result.messages);
+          yield {
+            type: "compact_done",
+            before: result.before ?? 0,
+            after: result.after ?? 0
+          };
+          turn--;
+          continue;
+        }
+      }
+      yield { type: "error", error: `LLM \u8C03\u7528\u5931\u8D25\uFF1A${e.message}` };
+      return;
+    }
+    const assistantMsg = {
+      role: "assistant",
+      content: assistantText.length > 0 ? assistantText : null,
+      ...toolCallsByIndex.length > 0 ? { tool_calls: toolCallsByIndex } : {},
+      ...reasoningContent ? { reasoning_content: reasoningContent } : {},
+      ...reasoningString ? { reasoning: reasoningString } : {},
+      ...reasoningDetails.length > 0 ? { reasoning_details: reasoningDetails } : {}
+    };
+    history.push(assistantMsg);
+    yield { type: "assistant_message", message: assistantMsg };
+    if (toolCallsByIndex.length === 0) {
+      yield { type: "turn_done" };
+      return;
+    }
+    for (const tc of toolCallsByIndex) {
+      if (signal?.aborted) {
+        history.push({
+          role: "user",
+          content: "(\u7528\u6237\u6309\u4E0B\u4E86 ESC/Ctrl+C \u4E2D\u65AD\u4E86\u4EFB\u52A1)"
+        });
+        yield { type: "error", error: "\u5DF2\u88AB\u7528\u6237\u4E2D\u65AD" };
+        return;
+      }
+      const argsPreview = previewArgs(tc.function.arguments);
+      yield {
+        type: "tool_start",
+        toolName: tc.function.name,
+        toolCallId: tc.id,
+        argsPreview
+      };
+      const result = await executeTool(tc.function.name, tc.function.arguments, signal);
+      const rawContent = result.ok ? result.content : `Error: ${result.error}`;
+      const content = microCompact(tc.function.name, rawContent);
+      history.push({
+        role: "tool",
+        content,
+        tool_call_id: tc.id
+      });
+      yield {
+        type: "tool_end",
+        toolName: tc.function.name,
+        toolCallId: tc.id,
+        ok: result.ok,
+        content
+      };
+    }
+  }
+  yield {
+    type: "error",
+    error: `\u8FBE\u5230\u6700\u5927\u8F6E\u6570 ${maxTurns}\uFF0C\u63D0\u524D\u7ED3\u675F\uFF08\u9632\u6B62\u5931\u63A7\uFF09\u3002\u5982\u679C\u5408\u7406\u53EF\u4EE5\u63D0\u9AD8 maxTurns\u3002`
+  };
+}
+function mergeToolCallDelta(acc, ev) {
+  let slot = acc[ev.index];
+  if (!slot) {
+    slot = {
+      id: "",
+      type: "function",
+      function: { name: "", arguments: "" }
+    };
+    acc[ev.index] = slot;
+  }
+  if (ev.id) slot.id = ev.id;
+  if (ev.name) slot.function.name += ev.name;
+  if (ev.argumentsDelta) slot.function.arguments += ev.argumentsDelta;
+}
+function previewArgs(rawJson) {
+  const oneLine = rawJson.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= 60) return oneLine;
+  return oneLine.slice(0, 60) + "...";
+}
+
+// src/ui/hooks/useChat.ts
+function useChat(args) {
+  const historyRef = useRef3(args.initialHistory.slice());
+  const [version, setVersion] = useState5(0);
+  const bump = useCallback5(() => setVersion((v) => v + 1), []);
+  const [streamingText, setStreamingText] = useState5("");
+  const [toolStatus, setToolStatus] = useState5(null);
+  const [isLoading, setIsLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [interrupted, setInterrupted] = useState5(false);
+  const [compacting, setCompacting] = useState5(false);
+  const abortRef = useRef3(null);
+  useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const submit = useCallback5(
+    async (input) => {
+      if (isLoading) return;
+      const trimmed = input.trim();
+      if (trimmed.length === 0) return;
+      setIsLoading(true);
+      setError(null);
+      setInterrupted(false);
+      setStreamingText("");
+      const ac = new AbortController();
+      abortRef.current = ac;
+      try {
+        for await (const ev of runQuery(trimmed, {
+          provider: args.provider,
+          history: historyRef.current,
+          signal: ac.signal
+        })) {
+          handleEvent(ev, {
+            setStreamingText,
+            setToolStatus,
+            setCompacting,
+            setError,
+            setInterrupted,
+            bump
+          });
+        }
+      } catch (e) {
+        setError(`\u672A\u6355\u83B7\u5F02\u5E38\uFF1A${e.message}`);
+      } finally {
+        setIsLoading(false);
+        setStreamingText("");
+        setToolStatus(null);
+        setCompacting(false);
+        abortRef.current = null;
+        args.onPersist?.(historyRef.current);
+      }
+    },
+    [args.provider, args.onPersist, bump, isLoading]
+  );
+  const abort = useCallback5(() => {
+    abortRef.current?.abort();
+  }, []);
+  const clearHistory = useCallback5(async () => {
+    if (isLoading) return;
+    const newSystemPrompt = await buildFullSystemPrompt(process.cwd(), ALL_TOOLS);
+    historyRef.current.length = 0;
+    historyRef.current.push({ role: "system", content: newSystemPrompt });
+    resetReactiveCompactState();
+    setStreamingText("");
+    setToolStatus(null);
+    setError(null);
+    setInterrupted(false);
+    setCompacting(false);
+    bump();
+    await clearContext();
+  }, [bump, isLoading]);
+  const compactNow = useCallback5(async () => {
+    if (isLoading) return;
+    setIsLoading(true);
+    setCompacting(true);
+    setError(null);
+    let success = false;
+    try {
+      const r = await forceCompact(historyRef.current, args.provider);
+      historyRef.current.length = 0;
+      historyRef.current.push(...r.messages);
+      bump();
+      success = true;
+    } catch (e) {
+      setError(`\u624B\u52A8\u538B\u7F29\u5931\u8D25\uFF1A${e.message}`);
+    } finally {
+      setCompacting(false);
+      setIsLoading(false);
+      if (success) {
+        args.onPersist?.(historyRef.current);
+        args.onCompactDone?.();
+      }
+    }
+  }, [args.provider, args.onPersist, args.onCompactDone, bump, isLoading]);
+  const history = useMemo3(() => historyRef.current, [version]);
+  return {
+    history,
+    streamingText,
+    toolStatus,
+    isLoading,
+    error,
+    interrupted,
+    compacting,
+    submit,
+    abort,
+    clearHistory,
+    compactNow
+  };
+}
+function handleEvent(ev, setters) {
+  switch (ev.type) {
+    case "text":
+      setters.setStreamingText((prev) => prev + ev.delta);
+      break;
+    case "assistant_message":
+      setters.setStreamingText(() => "");
+      setters.bump();
+      break;
+    case "tool_start":
+      setters.setToolStatus({
+        toolName: ev.toolName,
+        argsPreview: ev.argsPreview,
+        status: "running"
+      });
+      setters.bump();
+      break;
+    case "tool_end":
+      setters.setToolStatus(null);
+      setters.bump();
+      break;
+    case "compact_start":
+      setters.setStreamingText(() => "");
+      setters.setCompacting(true);
+      setters.bump();
+      break;
+    case "compact_done":
+      setters.setCompacting(false);
+      setters.bump();
+      break;
+    case "turn_done":
+      setters.bump();
+      break;
+    case "interrupted":
+      setters.setInterrupted(true);
+      setters.bump();
+      break;
+    case "error":
+      setters.setError(ev.error);
+      setters.bump();
+      break;
+  }
+}
+
+// src/ui/App.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var CLEAR_SCREEN = "\x1B[2J\x1B[H";
+function App({ provider, initialHistory }) {
+  const onPersist = React3.useCallback((messages) => {
+    void saveContext(messages);
+  }, []);
+  const chat2 = useChat({
+    provider,
+    initialHistory,
+    onPersist,
+    onCompactDone: () => process.stdout.write(CLEAR_SCREEN)
+  });
+  const handleClear = React3.useCallback(async () => {
+    await chat2.clearHistory();
+    process.stdout.write(CLEAR_SCREEN);
+  }, [chat2]);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", bold: true, children: "minimal-agent" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "gray", children: `  \xB7 ${provider.name}/${provider.model} \xB7 /new \u6E05\u7A7A \xB7 /compact \u538B\u7F29 \xB7 /exit \u9000\u51FA \xB7 Ctrl+C \u4E2D\u65AD` })
+    ] }),
+    /* @__PURE__ */ jsx6(MessageList, { history: chat2.history, streamingText: chat2.streamingText }),
+    /* @__PURE__ */ jsx6(
+      ToolStatus,
+      {
+        status: chat2.toolStatus,
+        compacting: chat2.compacting
+      }
+    ),
+    chat2.error && /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+      "\u26A0 ",
+      chat2.error
+    ] }) }),
+    chat2.interrupted && /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "\u26A1 \u64CD\u4F5C\u88AB\u7528\u6237\u4E2D\u65AD\uFF0C\u7B49\u5F85\u65B0\u7684\u4EFB\u52A1\u8F93\u5165..." }) }),
+    /* @__PURE__ */ jsx6(
+      InputBox,
+      {
+        onSubmit: chat2.submit,
+        disabled: chat2.isLoading,
+        onAbort: chat2.abort,
+        onClear: handleClear,
+        onCompact: chat2.compactNow
+      }
+    ),
+    /* @__PURE__ */ jsx6(StatusLine, { provider, history: chat2.history })
+  ] });
+}
+
+// src/ui/Root.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function Root({ initialProvider }) {
+  const [phase, setPhase] = useState6(
+    initialProvider ? { kind: "loading-history", provider: initialProvider } : { kind: "wizard" }
+  );
+  useEffect2(() => {
+    if (phase.kind !== "loading-history") return;
+    let cancelled = false;
+    void (async () => {
+      const history = await buildInitialHistory();
+      if (cancelled) return;
+      setPhase({ kind: "app", provider: phase.provider, initialHistory: history });
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [phase]);
+  if (phase.kind === "wizard") {
+    return /* @__PURE__ */ jsx7(
+      ConfigWizard,
+      {
+        onSuccess: (provider) => {
+          setPhase({ kind: "loading-history", provider });
+        }
+      }
+    );
+  }
+  if (phase.kind === "loading-history") {
+    return /* @__PURE__ */ jsx7(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx7(Text7, { color: "gray", children: "\u6B63\u5728\u52A0\u8F7D\u5386\u53F2\u4E0A\u4E0B\u6587..." }) });
+  }
+  return /* @__PURE__ */ jsx7(App, { provider: phase.provider, initialHistory: phase.initialHistory });
+}
+async function buildInitialHistory() {
+  const content = await buildFullSystemPrompt(process.cwd(), ALL_TOOLS);
+  const fresh = { role: "system", content };
+  const persisted = await loadContext();
+  if (!persisted || persisted.length === 0) return [fresh];
+  const rest = persisted[0]?.role === "system" ? persisted.slice(1) : persisted;
+  return [fresh, ...rest];
+}
+
+// src/cli/print.ts
+var TOOL_OUTPUT_PREVIEW_MAX = 200;
+var STDIN_TIMEOUT_MS = 3e3;
+function handleEPIPE(stream) {
+  return (err) => {
+    if (err.code === "EPIPE") stream.destroy();
+  };
+}
+function truncateForDisplay(content, max = TOOL_OUTPUT_PREVIEW_MAX) {
+  if (content.length <= max) return content;
+  return content.slice(0, max) + "...";
+}
+function extractPromptArgs(args) {
+  const FLAGS = /* @__PURE__ */ new Set(["-p", "--print", "--verbose", "-v", "-h", "--help"]);
+  return args.filter((a) => !FLAGS.has(a));
+}
+async function runPrintMode(provider, args, initialHistory, options) {
+  process.stdout.on("error", handleEPIPE(process.stdout));
+  process.stderr.on("error", handleEPIPE(process.stderr));
+  const promptArgs = extractPromptArgs(args);
+  let prompt;
+  if (promptArgs.length > 0) {
+    prompt = promptArgs.join(" ");
+  } else if (!process.stdin.isTTY) {
+    prompt = await readFromStdin();
+  } else {
+    console.error("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u63D0\u793A\u6587\u672C\u6216\u4F7F\u7528\u7BA1\u9053\u8F93\u5165");
+    process.exit(1);
+  }
+  if (!prompt.trim()) {
+    console.error("\u9519\u8BEF: \u63D0\u793A\u4E0D\u80FD\u4E3A\u7A7A");
+    process.exit(1);
+  }
+  const abortController = new AbortController();
+  let interrupted = false;
+  process.on("SIGINT", () => {
+    if (interrupted) process.exit(130);
+    interrupted = true;
+    abortController.abort();
+    console.error("\n\u5DF2\u4E2D\u65AD");
+    void saveContext(initialHistory).finally(() => process.exit(130));
+  });
+  const history = initialHistory;
+  const output = { buffer: "" };
+  try {
+    for await (const event of runQuery(prompt, {
+      provider,
+      history,
+      signal: abortController.signal
+    })) {
+      const result = handleEvent2(event, output, options.verbose);
+      if (result.exitCode !== void 0) {
+        await saveContext(history);
+        process.exit(result.exitCode);
+      }
+    }
+  } catch (e) {
+    if (e.name === "AbortError") {
+      await saveContext(history);
+      process.exit(130);
+    }
+    console.error(`
+\u672A\u6355\u83B7\u5F02\u5E38: ${e.message}`);
+    await saveContext(history);
+    process.exit(1);
+  }
+  await saveContext(history);
+}
+function handleEvent2(event, output, verbose) {
+  switch (event.type) {
+    case "text":
+      if (verbose) process.stdout.write(event.delta);
+      output.buffer += event.delta;
+      return {};
+    case "assistant_message":
+      return {};
+    case "tool_start":
+      if (verbose) {
+        process.stderr.write(`
+\u{1F527} \u5DE5\u5177: ${event.toolName}(${event.argsPreview})
+`);
+      }
+      return {};
+    case "tool_end":
+      if (verbose) {
+        process.stderr.write(
+          `${event.ok ? "\u2705" : "\u274C"} ${event.toolName}: ${truncateForDisplay(event.content)}
+`
+        );
+      }
+      return {};
+    case "compact_start":
+      if (verbose) process.stderr.write("\n\u{1F4DD} \u6B63\u5728\u538B\u7F29\u4E0A\u4E0B\u6587...\n");
+      return {};
+    case "compact_done":
+      if (verbose) {
+        process.stderr.write(
+          `\u{1F4DD} \u538B\u7F29\u5B8C\u6210: ${event.before} \u2192 ${event.after} tokens
+`
+        );
+      }
+      return {};
+    case "turn_done":
+      if (!verbose) console.log(output.buffer);
+      return {};
+    case "error":
+      console.error(`
+\u9519\u8BEF: ${event.error}`);
+      return { exitCode: 1 };
+    default:
+      return {};
+  }
+}
+function readFromStdin() {
+  return new Promise((resolve7) => {
+    let data = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolve7("");
+      }
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.setEncoding("utf8");
+    function onData(chunk) {
+      data += chunk;
+    }
+    function onEnd() {
+      if (!settled) {
+        clearTimeout(timer);
+        settled = true;
+        resolve7(data.trim());
+      }
+    }
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+  });
+}
+
+// src/main.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    printHelp();
+    return;
+  }
+  if (args.includes("--version") || args.includes("-V")) {
+    console.log(`minimal-agent v${pkg.version}`);
+    return;
+  }
+  const isPrintMode = args.includes("-p") || args.includes("--print");
+  if (isPrintMode) {
+    let provider;
+    try {
+      provider = await loadProvider();
+    } catch (e) {
+      process.stderr.write(
+        `
+${e.message}
+
+\u63D0\u793A\uFF1A-p \u6A21\u5F0F\u4E0D\u652F\u6301\u4EA4\u4E92\u914D\u7F6E\u3002\u8BF7\u5148\u76F4\u63A5\u8FD0\u884C \`minimal-agent\` \u5B8C\u6210\u9996\u6B21\u914D\u7F6E\u5411\u5BFC\uFF0C\u6216\u5728 .env \u4E2D\u624B\u52A8\u586B\u597D BASE_URL / API_KEY / MODEL\u3002
+
+`
+      );
+      process.exit(1);
+    }
+    const initialHistory = await buildInitialHistory2();
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    await runPrintMode(provider, args, initialHistory, { verbose });
+    return;
+  }
+  const initialProvider = await loadProviderLayered();
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx8(Root, { initialProvider }));
+  await waitUntilExit();
+}
+async function buildInitialHistory2() {
+  const content = await buildFullSystemPrompt(process.cwd(), ALL_TOOLS);
+  const fresh = { role: "system", content };
+  const persisted = await loadContext();
+  if (!persisted || persisted.length === 0) return [fresh];
+  const rest = persisted[0]?.role === "system" ? persisted.slice(1) : persisted;
+  return [fresh, ...rest];
+}
+function printHelp() {
+  console.log(`
+minimal-agent - \u8F7B\u91CF\u7EA7 AI \u7F16\u7A0B\u52A9\u624B
+
+\u7528\u6CD5:
+  minimal-agent [\u9009\u9879] [\u63D0\u793A...]
+  echo "\u63D0\u793A" | minimal-agent [\u9009\u9879]
+
+\u9009\u9879:
+  -p, --print        \u975E\u4EA4\u4E92\u6A21\u5F0F\uFF0C\u76F4\u63A5\u6267\u884C\u5355\u6B21\u95EE\u7B54
+  -v, --verbose      \u663E\u793A\u8BE6\u7EC6\u8F93\u51FA\uFF08\u5DE5\u5177\u8C03\u7528\u3001\u538B\u7F29\u4FE1\u606F\uFF09
+  -h, --help         \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+
+\u4F1A\u8BDD\u8BB0\u5FC6:
+  \u81EA\u52A8\u52A0\u8F7D / \u4FDD\u5B58 ~/.minimal-agent/last-context.json
+  TUI \u4E0E -p \u5171\u4EAB\u540C\u4E00\u4EFD\u4E0A\u4E0B\u6587\uFF1BTUI \u4E2D\u8F93\u5165 /new \u6E05\u7A7A
+
+\u793A\u4F8B:
+  minimal-agent -p "\u5E2E\u6211\u5199\u4E00\u4E2A hello world"
+  echo "\u89E3\u91CA\u4EE3\u7801" | minimal-agent -p
+  minimal-agent -p --verbose "\u8FD0\u884C\u6D4B\u8BD5\u5E76\u62A5\u544A\u7ED3\u679C"
+  `);
+}
+main().catch((e) => {
+  process.stderr.write(`
+\u672A\u6355\u83B7\u5F02\u5E38\uFF1A${e.message}
+${e.stack ?? ""}
+`);
+  process.exit(1);
+});