jinzd-ai-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,4439 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/config/config-manager.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/config/schema.ts
+import { z } from "zod";
+var CustomModelSchema = z.object({
+  id: z.string(),
+  displayName: z.string().optional(),
+  contextWindow: z.number().optional()
+});
+var CustomProviderConfigSchema = z.object({
+  id: z.string(),
+  // 唯一 ID，不能与内置 provider 重名
+  displayName: z.string(),
+  // 显示名称
+  apiKey: z.string().optional(),
+  // 可选：直接在此写 key（也可通过 apiKeys 字段或环境变量提供）
+  baseUrl: z.string(),
+  // OpenAI 兼容 API 的 base URL（必填）
+  defaultModel: z.string(),
+  // 默认使用的模型 ID
+  models: z.array(CustomModelSchema).default([]),
+  timeout: z.number().optional()
+  // 请求超时（ms），覆盖全局默认值
+});
+var ModelParamsSchema = z.object({
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  timeout: z.number().int().positive().optional(),
+  /** 是否启用深度思考（thinking）模式，GLM-5 等模型专用 */
+  thinking: z.boolean().optional()
+});
+var ConfigSchema = z.object({
+  version: z.string().default("1.0.0"),
+  defaultProvider: z.string().default("claude"),
+  // 每个 provider 的默认模型（key 为 provider ID）
+  defaultModels: z.record(z.string()).default({}),
+  // API Keys：放宽为任意 record，支持自定义 provider ID
+  apiKeys: z.record(z.string()).default({}),
+  customBaseUrls: z.record(z.string()).default({}),
+  // Per-provider timeout in ms (e.g. { deepseek: 60000 })
+  timeouts: z.record(z.number()).default({}),
+  // 自定义 Provider 列表（OpenAI 兼容接口，无需改代码）
+  customProviders: z.array(CustomProviderConfigSchema).default([]),
+  // 按模型 ID 存储的推理参数（key 为模型 ID，如 "deepseek-chat"）
+  modelParams: z.record(ModelParamsSchema).default({}),
+  ui: z.object({
+    streaming: z.boolean().default(true),
+    markdownRendering: z.boolean().default(true),
+    showTokenCount: z.boolean().default(false)
+  }).default({}),
+  session: z.object({
+    autoSave: z.boolean().default(true),
+    maxHistoryDays: z.number().default(30),
+    systemPrompt: z.string().optional()
+  }).default({}),
+  // 项目上下文文件配置
+  // 启动时自动读取并注入 system prompt，类似 Claude Code 的 CLAUDE.md 机制
+  // 默认按顺序查找：AICLI.md → CLAUDE.md → .aicli/context.md
+  // 设为 false 可禁用此功能
+  contextFile: z.union([z.string(), z.literal(false)]).default("auto")
+});
+
+// src/config/env-loader.ts
+var ENV_KEY_MAP = {
+  claude: "AICLI_API_KEY_CLAUDE",
+  gemini: "AICLI_API_KEY_GEMINI",
+  deepseek: "AICLI_API_KEY_DEEPSEEK",
+  zhipu: "AICLI_API_KEY_ZHIPU",
+  kimi: "AICLI_API_KEY_KIMI"
+};
+var EnvLoader = class {
+  /**
+   * 读取指定 provider 的 API Key 环境变量。
+   * 优先级：固定映射（如 AICLI_API_KEY_CLAUDE）> 动态格式（AICLI_API_KEY_<ID大写>）
+   * 自定义 provider 示例：id="siliconflow" → 读取 AICLI_API_KEY_SILICONFLOW
+   */
+  static getApiKey(providerId) {
+    const fixedEnvVar = ENV_KEY_MAP[providerId];
+    if (fixedEnvVar) {
+      const val = process.env[fixedEnvVar];
+      if (val) return val;
+    }
+    const dynamicEnvVar = `AICLI_API_KEY_${providerId.toUpperCase().replace(/-/g, "_")}`;
+    return process.env[dynamicEnvVar] || void 0;
+  }
+  static getDefaultProvider() {
+    return process.env["AICLI_PROVIDER"] || void 0;
+  }
+  static isStreamingDisabled() {
+    return process.env["AICLI_NO_STREAM"] === "1";
+  }
+};
+
+// src/core/constants.ts
+var VERSION = "0.1.0";
+var CONFIG_DIR_NAME = ".aicli";
+var CONFIG_FILE_NAME = "config.json";
+var HISTORY_DIR_NAME = "history";
+var PLUGINS_DIR_NAME = "plugins";
+var AUTHOR = "\u664B\u6B63\u4E1C";
+var AUTHOR_EMAIL = "zhengdong.jin@gmail.com";
+var DESCRIPTION = "\u8DE8\u5E73\u53F0 REPL \u98CE\u683C AI \u5BF9\u8BDD\u5DE5\u5177\uFF0C\u652F\u6301\u591A Provider \u4E0E Agentic \u5DE5\u5177\u8C03\u7528";
+
+// src/core/errors.ts
+var AiCliError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AiCliError";
+  }
+};
+var ProviderError = class extends AiCliError {
+  constructor(providerId, message, cause) {
+    super(`[${providerId}] ${message}`);
+    this.providerId = providerId;
+    this.cause = cause;
+    this.name = "ProviderError";
+  }
+};
+var AuthError = class extends ProviderError {
+  constructor(providerId) {
+    super(providerId, "Invalid or missing API key. Run: ai-cli config");
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends ProviderError {
+  constructor(providerId) {
+    super(providerId, "Rate limit exceeded. Please wait before trying again.");
+    this.name = "RateLimitError";
+  }
+};
+var ConfigError = class extends AiCliError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var ProviderNotFoundError = class extends AiCliError {
+  constructor(providerId) {
+    super(
+      `Provider '${providerId}' is not configured. Run: ai-cli config`
+    );
+    this.name = "ProviderNotFoundError";
+  }
+};
+
+// src/config/config-manager.ts
+var ConfigManager = class {
+  configDir;
+  configPath;
+  config;
+  constructor(configDir) {
+    this.configDir = configDir ?? join(homedir(), CONFIG_DIR_NAME);
+    this.configPath = join(this.configDir, CONFIG_FILE_NAME);
+    this.config = this.load();
+  }
+  load() {
+    if (!existsSync(this.configPath)) {
+      return ConfigSchema.parse({});
+    }
+    try {
+      const raw = JSON.parse(readFileSync(this.configPath, "utf-8"));
+      return ConfigSchema.parse(raw);
+    } catch (err) {
+      throw new ConfigError(
+        `Config file at ${this.configPath} is invalid. Delete it and run 'ai-cli config' to recreate.
+${err}`
+      );
+    }
+  }
+  save() {
+    mkdirSync(this.configDir, { recursive: true });
+    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  getApiKey(providerId) {
+    const envKey = EnvLoader.getApiKey(providerId);
+    if (envKey) return envKey;
+    return this.config.apiKeys[providerId];
+  }
+  setApiKey(providerId, key) {
+    this.config.apiKeys[providerId] = key;
+    this.save();
+  }
+  get(key) {
+    return this.config[key];
+  }
+  set(key, value) {
+    this.config[key] = value;
+    this.save();
+  }
+  isFirstRun() {
+    return !existsSync(this.configPath);
+  }
+  getConfigDir() {
+    return this.configDir;
+  }
+  getHistoryDir() {
+    return join(this.configDir, HISTORY_DIR_NAME);
+  }
+  getPluginsDir() {
+    return join(this.configDir, PLUGINS_DIR_NAME);
+  }
+  getDefaultProvider() {
+    return EnvLoader.getDefaultProvider() ?? this.config.defaultProvider;
+  }
+};
+
+// src/providers/claude.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/providers/base.ts
+var BaseProvider = class {
+  /**
+   * 将 Message[] 转换为 OpenAI API 格式的消息数组。
+   * content 为 string 时直接传递；为 MessageContentPart[] 时保留数组格式（vision 请求）。
+   */
+  normalizeMessages(messages) {
+    return messages.map((m) => ({ role: m.role, content: m.content }));
+  }
+};
+
+// src/providers/claude.ts
+var ClaudeProvider = class extends BaseProvider {
+  client;
+  info = {
+    id: "claude",
+    displayName: "Claude (Anthropic)",
+    defaultModel: "claude-sonnet-4-5-20250929",
+    apiKeyEnvVar: "AICLI_API_KEY_CLAUDE",
+    requiresApiKey: true,
+    models: [
+      {
+        id: "claude-opus-4-6",
+        displayName: "Claude Opus 4.6",
+        contextWindow: 2e5,
+        supportsStreaming: true
+      },
+      {
+        id: "claude-sonnet-4-5-20250929",
+        displayName: "Claude Sonnet 4.5",
+        contextWindow: 2e5,
+        supportsStreaming: true
+      },
+      {
+        id: "claude-haiku-4-5-20251001",
+        displayName: "Claude Haiku 4.5",
+        contextWindow: 2e5,
+        supportsStreaming: true
+      }
+    ]
+  };
+  async initialize(apiKey, options) {
+    this.client = new Anthropic({
+      apiKey,
+      baseURL: options?.baseUrl
+    });
+  }
+  async chat(request) {
+    try {
+      const messages = request.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      const response = await this.client.messages.create({
+        model: request.model,
+        messages,
+        system: request.systemPrompt,
+        max_tokens: request.maxTokens ?? 8192,
+        temperature: request.temperature
+      });
+      const content = response.content[0].type === "text" ? response.content[0].text : "";
+      return {
+        content,
+        model: response.model,
+        usage: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens
+        }
+      };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  async *chatStream(request) {
+    try {
+      const messages = request.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      const stream = this.client.messages.stream({
+        model: request.model,
+        messages,
+        system: request.systemPrompt,
+        max_tokens: request.maxTokens ?? 8192
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          yield { delta: event.delta.text, done: false };
+        }
+        if (event.type === "message_stop") {
+          yield { delta: "", done: true };
+        }
+      }
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  async chatWithTools(request, tools) {
+    try {
+      const anthropicTools = tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(t.parameters).map(([key, schema]) => [
+              key,
+              {
+                type: schema.type,
+                description: schema.description,
+                ...schema.enum ? { enum: schema.enum } : {}
+              }
+            ])
+          ),
+          required: Object.entries(t.parameters).filter(([, s]) => s.required).map(([k]) => k)
+        }
+      }));
+      const baseMessages = request.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+      const extraMessages = request._extraMessages ?? [];
+      const allMessages = [...baseMessages, ...extraMessages];
+      const response = await this.client.messages.create({
+        model: request.model,
+        messages: allMessages,
+        tools: anthropicTools,
+        system: request.systemPrompt,
+        max_tokens: request.maxTokens ?? 8192,
+        temperature: request.temperature
+      });
+      const usage = {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      };
+      const toolUseBlocks = response.content.filter(
+        (b) => b.type === "tool_use"
+      );
+      if (toolUseBlocks.length > 0) {
+        const toolCalls = toolUseBlocks.map((b) => ({
+          id: b.id,
+          name: b.name,
+          arguments: b.input
+        }));
+        return { toolCalls, usage };
+      }
+      const textBlock = response.content.find((b) => b.type === "text");
+      return { content: textBlock?.text ?? "", usage };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  buildToolResultMessages(assistantToolCalls, results) {
+    const assistantContent = assistantToolCalls.map((tc) => ({
+      type: "tool_use",
+      id: tc.id,
+      name: tc.name,
+      input: tc.arguments
+    }));
+    const userContent = results.map((r) => ({
+      type: "tool_result",
+      tool_use_id: r.callId,
+      content: r.content,
+      is_error: r.isError
+    }));
+    return [
+      { role: "assistant", content: assistantContent },
+      { role: "user", content: userContent }
+    ];
+  }
+  async validateApiKey(apiKey) {
+    try {
+      const testClient = new Anthropic({ apiKey });
+      await testClient.models.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listModels() {
+    return this.info.models;
+  }
+  wrapError(err) {
+    if (err instanceof Anthropic.AuthenticationError) {
+      return new AuthError("claude");
+    }
+    if (err instanceof Anthropic.RateLimitError) {
+      return new RateLimitError("claude");
+    }
+    if (err instanceof Error) {
+      return new ProviderError("claude", err.message, err);
+    }
+    return new ProviderError("claude", String(err));
+  }
+};
+
+// src/providers/gemini.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+// src/core/types.ts
+function getContentText(content) {
+  if (typeof content === "string") return content;
+  return content.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+
+// src/providers/gemini.ts
+var GeminiProvider = class extends BaseProvider {
+  client;
+  info = {
+    id: "gemini",
+    displayName: "Gemini (Google)",
+    defaultModel: "gemini-2.0-flash",
+    apiKeyEnvVar: "AICLI_API_KEY_GEMINI",
+    requiresApiKey: true,
+    models: [
+      {
+        id: "gemini-2.0-flash",
+        displayName: "Gemini 2.0 Flash",
+        contextWindow: 1e6,
+        supportsStreaming: true
+      },
+      {
+        id: "gemini-2.0-flash-lite",
+        displayName: "Gemini 2.0 Flash Lite",
+        contextWindow: 1e6,
+        supportsStreaming: true
+      },
+      {
+        id: "gemini-1.5-pro",
+        displayName: "Gemini 1.5 Pro",
+        contextWindow: 2e6,
+        supportsStreaming: true
+      }
+    ]
+  };
+  async initialize(apiKey) {
+    this.client = new GoogleGenerativeAI(apiKey);
+  }
+  toGeminiHistory(messages) {
+    return messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: getContentText(m.content) }]
+    }));
+  }
+  async chat(request) {
+    try {
+      const genModel = this.client.getGenerativeModel({
+        model: request.model,
+        systemInstruction: request.systemPrompt
+      });
+      const history = this.toGeminiHistory(request.messages.slice(0, -1));
+      const lastMessage = getContentText(request.messages[request.messages.length - 1].content);
+      const chat = genModel.startChat({ history });
+      const result = await chat.sendMessage(lastMessage);
+      return {
+        content: result.response.text(),
+        model: request.model
+      };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  async *chatStream(request) {
+    try {
+      const genModel = this.client.getGenerativeModel({
+        model: request.model,
+        systemInstruction: request.systemPrompt
+      });
+      const history = this.toGeminiHistory(request.messages.slice(0, -1));
+      const lastMessage = getContentText(request.messages[request.messages.length - 1].content);
+      const chat = genModel.startChat({ history });
+      const result = await chat.sendMessageStream(lastMessage);
+      for await (const chunk of result.stream) {
+        yield { delta: chunk.text(), done: false };
+      }
+      yield { delta: "", done: true };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  async chatWithTools(request, tools) {
+    try {
+      const geminiTools = [{
+        functionDeclarations: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(t.parameters).map(([key, schema]) => [
+                key,
+                {
+                  type: schema.type,
+                  description: schema.description,
+                  ...schema.enum ? { enum: schema.enum } : {}
+                }
+              ])
+            ),
+            required: Object.entries(t.parameters).filter(([, s]) => s.required).map(([k]) => k)
+          }
+        }))
+      }];
+      const baseHistory = this.toGeminiHistory(request.messages.slice(0, -1));
+      const lastMessage = getContentText(
+        request.messages[request.messages.length - 1].content
+      );
+      const extraHistory = request._extraMessages ?? [];
+      const fullHistory = [...baseHistory, ...extraHistory];
+      const genModel = this.client.getGenerativeModel({
+        model: request.model,
+        systemInstruction: request.systemPrompt
+      });
+      const chat = genModel.startChat({ history: fullHistory, tools: geminiTools });
+      const result = await chat.sendMessage(lastMessage);
+      const response = result.response;
+      const parts = response.candidates?.[0]?.content?.parts ?? [];
+      const fnCalls = parts.filter((p) => !!p.functionCall).map((p) => p.functionCall);
+      if (fnCalls.length > 0) {
+        const toolCalls = fnCalls.map((fc, i) => ({
+          id: `gemini-fn-${Date.now()}-${i}`,
+          name: fc.name,
+          arguments: fc.args
+        }));
+        return { toolCalls };
+      }
+      return { content: response.text() };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  buildToolResultMessages(assistantToolCalls, results) {
+    const modelParts = assistantToolCalls.map((tc) => ({
+      functionCall: { name: tc.name, args: tc.arguments }
+    }));
+    const fnParts = results.map((r, i) => ({
+      functionResponse: {
+        name: assistantToolCalls[i].name,
+        response: { result: r.content, isError: r.isError }
+      }
+    }));
+    return [
+      { role: "model", parts: modelParts },
+      { role: "function", parts: fnParts }
+    ];
+  }
+  async validateApiKey(apiKey) {
+    try {
+      const testClient = new GoogleGenerativeAI(apiKey);
+      const model = testClient.getGenerativeModel({ model: "gemini-2.0-flash" });
+      await model.generateContent("hi");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listModels() {
+    return this.info.models;
+  }
+  wrapError(err) {
+    if (err instanceof Error) {
+      if (err.message.includes("API key") || err.message.includes("PERMISSION_DENIED")) {
+        return new AuthError("gemini");
+      }
+      return new ProviderError("gemini", err.message, err);
+    }
+    return new ProviderError("gemini", String(err));
+  }
+};
+
+// src/providers/openai-compatible.ts
+import OpenAI from "openai";
+var OpenAICompatibleProvider = class extends BaseProvider {
+  client;
+  defaultTimeout = 6e4;
+  // ms
+  async initialize(apiKey, options) {
+    if (options?.timeout !== void 0) {
+      this.defaultTimeout = options.timeout;
+    }
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: options?.baseUrl ?? this.defaultBaseUrl,
+      timeout: this.defaultTimeout
+    });
+  }
+  /** 将 systemPrompt + messages 合并为 OpenAI messages 数组（system 消息放首位）。 */
+  buildMessages(request) {
+    const msgs = this.normalizeMessages(request.messages);
+    if (request.systemPrompt) {
+      return [{ role: "system", content: request.systemPrompt }, ...msgs];
+    }
+    return msgs;
+  }
+  async chat(request) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: request.model,
+        messages: this.buildMessages(request),
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        stream: false,
+        ...request.thinking ? { thinking: { type: "enabled" } } : {}
+      }, {
+        timeout: request.timeout ?? this.defaultTimeout
+      });
+      return {
+        content: response.choices[0].message.content ?? "",
+        model: response.model,
+        usage: response.usage ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens
+        } : void 0
+      };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  async *chatStream(request) {
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: request.model,
+        messages: this.buildMessages(request),
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        stream: true,
+        // 请求末尾 usage chunk，供 token 统计使用
+        stream_options: { include_usage: true },
+        ...request.thinking ? { thinking: { type: "enabled" } } : {}
+      }, {
+        timeout: request.timeout ?? this.defaultTimeout
+      });
+      for await (const chunk of stream) {
+        const choice = chunk.choices[0];
+        const done = choice?.finish_reason != null && choice.finish_reason !== "";
+        if (!choice && chunk.usage) {
+          yield {
+            delta: "",
+            done: true,
+            usage: {
+              inputTokens: chunk.usage.prompt_tokens,
+              outputTokens: chunk.usage.completion_tokens
+            }
+          };
+          continue;
+        }
+        const delta = choice?.delta?.content ?? "";
+        yield { delta, done };
+      }
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  /**
+   * 请求 AI 并获取工具调用列表（不执行，只解析）。
+   * 返回 { toolCalls, usage? } 时说明 AI 想要调用工具，
+   * 返回 { content, usage? } 时说明 AI 给出了最终回答。
+   */
+  async chatWithTools(request, tools) {
+    try {
+      const openaiTools = tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: {
+            type: "object",
+            properties: Object.fromEntries(
+              Object.entries(t.parameters).map(([key, schema]) => [
+                key,
+                {
+                  type: schema.type,
+                  description: schema.description,
+                  ...schema.enum ? { enum: schema.enum } : {}
+                }
+              ])
+            ),
+            required: Object.entries(t.parameters).filter(([, s]) => s.required).map(([k]) => k)
+          }
+        }
+      }));
+      const baseMessages = this.buildMessages(request);
+      const extraMessages = request._extraMessages ?? [];
+      const allMessages = [...baseMessages, ...extraMessages];
+      const response = await this.client.chat.completions.create({
+        model: request.model,
+        messages: allMessages,
+        tools: openaiTools,
+        tool_choice: "auto",
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        stream: false,
+        ...request.thinking ? { thinking: { type: "enabled" } } : {}
+      }, {
+        timeout: request.timeout ?? this.defaultTimeout
+      });
+      const message = response.choices[0].message;
+      const usage = response.usage ? {
+        inputTokens: response.usage.prompt_tokens,
+        outputTokens: response.usage.completion_tokens
+      } : void 0;
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        const toolCalls = message.tool_calls.map((tc) => {
+          const rawArgs = tc.function.arguments || "{}";
+          let parsedArgs;
+          try {
+            parsedArgs = JSON.parse(rawArgs);
+          } catch {
+            const truncated = rawArgs.trimEnd();
+            const lastComma = truncated.lastIndexOf(",");
+            const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
+            try {
+              parsedArgs = JSON.parse(fixed);
+            } catch {
+              parsedArgs = {};
+            }
+          }
+          return {
+            id: tc.id,
+            name: tc.function.name,
+            arguments: parsedArgs
+          };
+        });
+        return { toolCalls, usage };
+      }
+      return { content: message.content ?? "", usage };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
+  /**
+   * 将工具结果作为 tool_call 消息追加，供下一轮使用
+   */
+  buildToolResultMessages(assistantToolCalls, results) {
+    const assistantMsg = {
+      role: "assistant",
+      content: null,
+      tool_calls: assistantToolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: JSON.stringify(tc.arguments)
+        }
+      }))
+    };
+    const resultMsgs = results.map((r) => ({
+      role: "tool",
+      tool_call_id: r.callId,
+      content: r.content
+    }));
+    return [assistantMsg, ...resultMsgs];
+  }
+  async validateApiKey(apiKey) {
+    try {
+      const testClient = new OpenAI({ apiKey, baseURL: this.defaultBaseUrl });
+      await testClient.models.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listModels() {
+    return this.info.models;
+  }
+  wrapError(err) {
+    if (err instanceof OpenAI.AuthenticationError) {
+      return new AuthError(this.info.id);
+    }
+    if (err instanceof OpenAI.RateLimitError) {
+      return new RateLimitError(this.info.id);
+    }
+    if (err instanceof Error) {
+      return new ProviderError(this.info.id, err.message, err);
+    }
+    return new ProviderError(this.info.id, String(err));
+  }
+};
+
+// src/providers/deepseek.ts
+var DeepSeekProvider = class extends OpenAICompatibleProvider {
+  defaultBaseUrl = "https://api.deepseek.com/v1";
+  info = {
+    id: "deepseek",
+    displayName: "DeepSeek",
+    defaultModel: "deepseek-chat",
+    apiKeyEnvVar: "AICLI_API_KEY_DEEPSEEK",
+    requiresApiKey: true,
+    baseUrl: this.defaultBaseUrl,
+    models: [
+      {
+        id: "deepseek-chat",
+        displayName: "DeepSeek Chat (V3)",
+        contextWindow: 65536,
+        supportsStreaming: true
+      },
+      {
+        id: "deepseek-reasoner",
+        displayName: "DeepSeek Reasoner (R1)",
+        contextWindow: 65536,
+        supportsStreaming: true
+      }
+    ]
+  };
+};
+
+// src/providers/zhipu.ts
+var ZhipuProvider = class extends OpenAICompatibleProvider {
+  defaultBaseUrl = "https://open.bigmodel.cn/api/paas/v4";
+  info = {
+    id: "zhipu",
+    displayName: "\u667A\u8C31\u6E05\u8A00 (GLM)",
+    defaultModel: "glm-5",
+    apiKeyEnvVar: "AICLI_API_KEY_ZHIPU",
+    requiresApiKey: true,
+    baseUrl: this.defaultBaseUrl,
+    models: [
+      // GLM-5 旗舰系列（最新，支持深度思考）
+      {
+        id: "glm-5",
+        displayName: "GLM-5\uFF08\u65D7\u8230\uFF0C\u6DF1\u5EA6\u601D\u8003\uFF09",
+        contextWindow: 131072,
+        supportsStreaming: true,
+        supportsThinking: true
+      },
+      // GLM-4.6 系列（视觉 + 思考）
+      {
+        id: "glm-4.6v",
+        displayName: "GLM-4.6V\uFF08\u89C6\u89C9+\u601D\u8003\uFF09",
+        contextWindow: 131072,
+        supportsStreaming: true,
+        supportsThinking: true
+      },
+      // GLM-Z1 推理系列（支持深度思考）
+      {
+        id: "glm-z1",
+        displayName: "GLM-Z1\uFF08\u63A8\u7406\u65D7\u8230\uFF09",
+        contextWindow: 131072,
+        supportsStreaming: true,
+        supportsThinking: true
+      },
+      {
+        id: "glm-z1-air",
+        displayName: "GLM-Z1 Air\uFF08\u8F7B\u91CF\u63A8\u7406\uFF09",
+        contextWindow: 131072,
+        supportsStreaming: true,
+        supportsThinking: true
+      },
+      {
+        id: "glm-z1-flash",
+        displayName: "GLM-Z1 Flash\uFF08\u514D\u8D39\u63A8\u7406\uFF09",
+        contextWindow: 128e3,
+        supportsStreaming: true,
+        supportsThinking: true
+      },
+      // GLM-4 系列（稳定）
+      {
+        id: "glm-4-plus",
+        displayName: "GLM-4 Plus",
+        contextWindow: 128e3,
+        supportsStreaming: true
+      },
+      {
+        id: "glm-4-air",
+        displayName: "GLM-4 Air",
+        contextWindow: 128e3,
+        supportsStreaming: true
+      },
+      {
+        id: "glm-4-flash",
+        displayName: "GLM-4 Flash\uFF08\u514D\u8D39\uFF09",
+        contextWindow: 128e3,
+        supportsStreaming: true
+      }
+    ]
+  };
+};
+
+// src/providers/kimi.ts
+var KimiProvider = class extends OpenAICompatibleProvider {
+  defaultBaseUrl = "https://api.moonshot.ai/v1";
+  info = {
+    id: "kimi",
+    displayName: "Kimi (Moonshot AI)",
+    defaultModel: "kimi-k2-0711-preview",
+    apiKeyEnvVar: "AICLI_API_KEY_KIMI",
+    requiresApiKey: true,
+    baseUrl: this.defaultBaseUrl,
+    models: [
+      // Kimi K2 系列（新一代，推荐）
+      {
+        id: "kimi-k2-0711-preview",
+        displayName: "Kimi K2 Preview",
+        contextWindow: 131072,
+        supportsStreaming: true
+      },
+      {
+        id: "kimi-k2-turbo-preview",
+        displayName: "Kimi K2 Turbo",
+        contextWindow: 131072,
+        supportsStreaming: true
+      },
+      // moonshot-v1 系列（老一代，稳定）
+      {
+        id: "moonshot-v1-8k",
+        displayName: "Moonshot V1 8K",
+        contextWindow: 8192,
+        supportsStreaming: true
+      },
+      {
+        id: "moonshot-v1-32k",
+        displayName: "Moonshot V1 32K",
+        contextWindow: 32768,
+        supportsStreaming: true
+      },
+      {
+        id: "moonshot-v1-128k",
+        displayName: "Moonshot V1 128K",
+        contextWindow: 131072,
+        supportsStreaming: true
+      },
+      // moonshot-v1 Vision 系列（支持图片输入）
+      {
+        id: "moonshot-v1-8k-vision-preview",
+        displayName: "Moonshot V1 8K Vision",
+        contextWindow: 8192,
+        supportsStreaming: true
+      },
+      {
+        id: "moonshot-v1-32k-vision-preview",
+        displayName: "Moonshot V1 32K Vision",
+        contextWindow: 32768,
+        supportsStreaming: true
+      },
+      {
+        id: "moonshot-v1-128k-vision-preview",
+        displayName: "Moonshot V1 128K Vision",
+        contextWindow: 131072,
+        supportsStreaming: true
+      }
+    ]
+  };
+};
+
+// src/providers/custom.ts
+var CustomProvider = class extends OpenAICompatibleProvider {
+  defaultBaseUrl;
+  info;
+  constructor(cfg) {
+    super();
+    this.defaultBaseUrl = cfg.baseUrl;
+    this.info = {
+      id: cfg.id,
+      displayName: cfg.displayName,
+      defaultModel: cfg.defaultModel,
+      // 环境变量格式：AICLI_API_KEY_<ID大写>，如 AICLI_API_KEY_SILICONFLOW
+      apiKeyEnvVar: `AICLI_API_KEY_${cfg.id.toUpperCase()}`,
+      // 本地服务（如 Ollama）不需要 API Key，设为 false
+      requiresApiKey: false,
+      baseUrl: cfg.baseUrl,
+      models: cfg.models.length > 0 ? cfg.models.map((m) => ({
+        id: m.id,
+        displayName: m.displayName ?? m.id,
+        contextWindow: m.contextWindow ?? 4096,
+        supportsStreaming: true
+      })) : [
+        // 如果未配置 models 列表，以 defaultModel 作为唯一条目
+        {
+          id: cfg.defaultModel,
+          displayName: cfg.defaultModel,
+          contextWindow: 4096,
+          supportsStreaming: true
+        }
+      ]
+    };
+  }
+};
+
+// src/providers/registry.ts
+var BUILT_IN_PROVIDERS = [
+  ClaudeProvider,
+  GeminiProvider,
+  DeepSeekProvider,
+  ZhipuProvider,
+  KimiProvider
+];
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  // 记录自定义 provider 的状态（用于 listAll 展示）
+  customConfigs = [];
+  async initialize(getApiKey, getOptions, customProviderConfigs) {
+    for (const ProviderClass of BUILT_IN_PROVIDERS) {
+      const provider = new ProviderClass();
+      const apiKey = getApiKey(provider.info.id);
+      if (apiKey) {
+        const options = getOptions?.(provider.info.id) ?? {};
+        await provider.initialize(apiKey, options);
+        this.providers.set(provider.info.id, provider);
+      }
+    }
+    this.customConfigs = customProviderConfigs ?? [];
+    for (const cfg of this.customConfigs) {
+      const provider = new CustomProvider(cfg);
+      const apiKey = getApiKey(cfg.id) ?? cfg.apiKey ?? "no-key";
+      const extraOptions = getOptions?.(cfg.id) ?? {};
+      await provider.initialize(apiKey, {
+        baseUrl: cfg.baseUrl,
+        timeout: cfg.timeout,
+        ...extraOptions
+      });
+      this.providers.set(cfg.id, provider);
+    }
+  }
+  get(id) {
+    const provider = this.providers.get(id);
+    if (!provider) {
+      throw new ProviderNotFoundError(id);
+    }
+    return provider;
+  }
+  has(id) {
+    return this.providers.has(id);
+  }
+  listAvailable() {
+    return [...this.providers.values()];
+  }
+  listAll() {
+    const builtIn = BUILT_IN_PROVIDERS.map((P) => {
+      const p = new P();
+      return {
+        id: p.info.id,
+        displayName: p.info.displayName,
+        configured: this.providers.has(p.info.id),
+        defaultModel: p.info.defaultModel,
+        isCustom: false
+      };
+    });
+    const custom = this.customConfigs.map((cfg) => ({
+      id: cfg.id,
+      displayName: cfg.displayName,
+      configured: this.providers.has(cfg.id),
+      defaultModel: cfg.defaultModel,
+      isCustom: true
+    }));
+    return [...builtIn, ...custom];
+  }
+  getFirstAvailable() {
+    return this.providers.values().next().value;
+  }
+};
+
+// src/session/session-manager.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { v4 as uuidv4 } from "uuid";
+
+// src/session/session.ts
+var Session = class _Session {
+  id;
+  provider;
+  model;
+  created;
+  updated;
+  messages = [];
+  title;
+  constructor(id, provider, model) {
+    this.id = id;
+    this.provider = provider;
+    this.model = model;
+    this.created = /* @__PURE__ */ new Date();
+    this.updated = /* @__PURE__ */ new Date();
+  }
+  addMessage(message) {
+    this.messages.push(message);
+    this.updated = /* @__PURE__ */ new Date();
+    if (!this.title && message.role === "user") {
+      this.title = getContentText(message.content).slice(0, 50).replace(/\n/g, " ");
+    }
+  }
+  clear() {
+    this.messages = [];
+    this.title = void 0;
+    this.updated = /* @__PURE__ */ new Date();
+  }
+  getMeta() {
+    return {
+      id: this.id,
+      provider: this.provider,
+      model: this.model,
+      messageCount: this.messages.length,
+      created: this.created,
+      updated: this.updated,
+      title: this.title
+    };
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      provider: this.provider,
+      model: this.model,
+      created: this.created.toISOString(),
+      updated: this.updated.toISOString(),
+      title: this.title,
+      messages: this.messages.map((m) => ({
+        ...m,
+        timestamp: m.timestamp.toISOString()
+      }))
+    };
+  }
+  static fromJSON(data) {
+    const session = new _Session(data.id, data.provider, data.model);
+    session.title = data.title;
+    session.created = new Date(data.created);
+    session.updated = new Date(data.updated);
+    session.messages = data.messages.map((m) => ({
+      ...m,
+      timestamp: new Date(m.timestamp)
+    }));
+    return session;
+  }
+};
+
+// src/session/session-manager.ts
+var SessionManager = class {
+  constructor(config) {
+    this.config = config;
+    this.historyDir = config.getHistoryDir();
+  }
+  _current = null;
+  historyDir;
+  get current() {
+    return this._current;
+  }
+  createSession(provider, model) {
+    const session = new Session(uuidv4(), provider, model);
+    this._current = session;
+    return session;
+  }
+  async save() {
+    if (!this._current) return;
+    mkdirSync2(this.historyDir, { recursive: true });
+    const filePath = join2(this.historyDir, `${this._current.id}.json`);
+    writeFileSync2(filePath, JSON.stringify(this._current.toJSON(), null, 2), "utf-8");
+  }
+  loadSession(id) {
+    const filePath = join2(this.historyDir, `${id}.json`);
+    if (!existsSync2(filePath)) {
+      throw new Error(`Session ${id} not found`);
+    }
+    const data = JSON.parse(readFileSync2(filePath, "utf-8"));
+    const session = Session.fromJSON(data);
+    this._current = session;
+    return session;
+  }
+  listSessions() {
+    if (!existsSync2(this.historyDir)) return [];
+    const files = readdirSync(this.historyDir).filter((f) => f.endsWith(".json"));
+    const metas = [];
+    for (const file of files) {
+      try {
+        const data = JSON.parse(
+          readFileSync2(join2(this.historyDir, file), "utf-8")
+        );
+        metas.push({
+          id: data.id,
+          provider: data.provider,
+          model: data.model,
+          messageCount: data.messages?.length ?? 0,
+          created: new Date(data.created),
+          updated: new Date(data.updated),
+          title: data.title
+        });
+      } catch {
+      }
+    }
+    return metas.sort((a, b) => b.updated.getTime() - a.updated.getTime());
+  }
+};
+
+// src/repl/repl.ts
+import * as readline from "readline";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { join as join7, resolve as resolve3, extname as extname2 } from "path";
+import chalk5 from "chalk";
+
+// src/repl/renderer.ts
+import chalk from "chalk";
+import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
+import { dirname } from "path";
+function fmtContextWindow(tokens) {
+  if (tokens >= 1e6) return `${Math.round(tokens / 1e5) / 10}M`;
+  if (tokens >= 1e3) return `${Math.round(tokens / 1024)}K`;
+  return `${tokens}`;
+}
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner(text) {
+  if (!process.stdout.isTTY) {
+    return {
+      stop() {
+      },
+      start(_t) {
+      }
+    };
+  }
+  let frameIdx = 0;
+  let currentText = text;
+  let timer = null;
+  const render = () => {
+    const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
+    frameIdx++;
+    process.stdout.write(`\r${chalk.cyan(frame)} ${currentText}  `);
+  };
+  const clear = () => {
+    process.stdout.write("\r\x1B[2K");
+  };
+  timer = setInterval(render, 80);
+  render();
+  return {
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      clear();
+    },
+    start(t) {
+      currentText = t;
+      if (!timer) {
+        frameIdx = 0;
+        timer = setInterval(render, 80);
+        render();
+      }
+    }
+  };
+}
+var Renderer = class {
+  printWelcome(provider, model, contextWindow) {
+    const ctxStr = contextWindow ? chalk.dim(` (ctx: ${fmtContextWindow(contextWindow)})`) : "";
+    console.log();
+    console.log(chalk.bold.cyan("  \u{1F916} ai-cli") + chalk.gray(` v${VERSION}`) + chalk.dim("  \u2014  " + AUTHOR + " <" + AUTHOR_EMAIL + ">"));
+    console.log(chalk.dim("  " + "\u2500".repeat(55)));
+    console.log(chalk.gray(`  Provider : `) + chalk.green(provider));
+    console.log(chalk.gray(`  Model    : `) + chalk.white(model) + ctxStr);
+    console.log(chalk.gray("  Commands : ") + chalk.dim("/help \xB7 /about \xB7 Ctrl+C to exit"));
+    console.log();
+  }
+  printAbout() {
+    console.log();
+    console.log(chalk.bold.cyan("  \u{1F916} ai-cli") + chalk.gray(`  v${VERSION}`));
+    console.log(chalk.dim("  " + "\u2500".repeat(50)));
+    console.log(chalk.gray("  \u7B80\u4ECB  ") + chalk.white(DESCRIPTION));
+    console.log(chalk.dim("  " + "\u2500".repeat(50)));
+    console.log(chalk.gray("  \u4F5C\u8005  ") + chalk.yellow(AUTHOR));
+    console.log(chalk.gray("  \u90AE\u7BB1  ") + chalk.cyan(AUTHOR_EMAIL));
+    console.log(chalk.dim("  " + "\u2500".repeat(50)));
+    console.log(chalk.gray("  \u652F\u6301\u7684 Provider\uFF1A"));
+    console.log(chalk.dim("    DeepSeek \xB7 Kimi (Moonshot) \xB7 Claude (Anthropic)"));
+    console.log(chalk.dim("    Gemini (Google) \xB7 \u667A\u8C31\u6E05\u8A00 \xB7 \u81EA\u5B9A\u4E49 OpenAI \u517C\u5BB9"));
+    console.log(chalk.dim("  " + "\u2500".repeat(50)));
+    console.log(chalk.gray("  \u5DE5\u5177\u80FD\u529B\uFF1A"));
+    console.log(chalk.dim("    bash \xB7 read_file \xB7 write_file \xB7 edit_file"));
+    console.log(chalk.dim("    grep_files \xB7 list_dir \xB7 run_interactive"));
+    console.log();
+  }
+  printPrompt(provider, _model) {
+    process.stdout.write(chalk.green(`[${provider}]`) + chalk.white(" > "));
+  }
+  async renderStream(stream, options) {
+    process.stdout.write(chalk.cyan("Assistant: "));
+    let fileStream = null;
+    if (options?.saveToFile) {
+      mkdirSync3(dirname(options.saveToFile), { recursive: true });
+      fileStream = createWriteStream(options.saveToFile, { encoding: "utf-8" });
+    }
+    let fullContent = "";
+    let usage;
+    let inThinking = false;
+    let thinkingShown = false;
+    let buf = "";
+    const flushBuf = () => {
+      if (!buf) return;
+      let out = buf;
+      while (!inThinking) {
+        const openIdx = out.indexOf("<think>");
+        if (openIdx === -1) break;
+        if (openIdx > 0) process.stdout.write(out.slice(0, openIdx));
+        inThinking = true;
+        if (!thinkingShown) {
+          process.stdout.write(chalk.dim("\n\u{1F4AD} Thinking...\n"));
+          thinkingShown = true;
+        }
+        out = out.slice(openIdx + "<think>".length);
+      }
+      if (inThinking) {
+        const closeIdx = out.indexOf("</think>");
+        if (closeIdx !== -1) {
+          inThinking = false;
+          out = out.slice(closeIdx + "</think>".length);
+          buf = out;
+          flushBuf();
+          return;
+        } else {
+          buf = "";
+          return;
+        }
+      }
+      if (out) process.stdout.write(out);
+      buf = "";
+    };
+    for await (const chunk of stream) {
+      if (chunk.usage) {
+        usage = chunk.usage;
+      }
+      if (chunk.done) {
+        flushBuf();
+        break;
+      }
+      if (!chunk.delta) continue;
+      fullContent += chunk.delta;
+      buf += chunk.delta;
+      if (fileStream) fileStream.write(chunk.delta);
+      flushBuf();
+    }
+    process.stdout.write("\n\n");
+    if (fileStream) {
+      await new Promise((resolve4, reject) => {
+        fileStream.end((err) => err ? reject(err) : resolve4());
+      });
+      const kb = (Buffer.byteLength(fullContent, "utf-8") / 1024).toFixed(1);
+      process.stdout.write(chalk.green(`  \u2705 \u5DF2\u4FDD\u5B58: ${options.saveToFile} (${kb} KB)
+
+`));
+    }
+    return { content: fullContent, usage };
+  }
+  renderResponse(content) {
+    process.stdout.write(chalk.cyan("Assistant: "));
+    let displayed = content;
+    if (content.includes("<think>")) {
+      let hasThinking = false;
+      displayed = content.replace(/<think>[\s\S]*?<\/think>/g, () => {
+        hasThinking = true;
+        return "";
+      }).trimStart();
+      if (hasThinking) {
+        process.stdout.write(chalk.dim("\n\u{1F4AD} Thinking...\n"));
+      }
+    }
+    process.stdout.write(displayed);
+    process.stdout.write("\n\n");
+  }
+  renderError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`
+Error: ${message}
+`));
+  }
+  /**
+   * 在 AI 回复后显示 token 用量。
+   * @param usage     本次调用的 input/output tokens
+   * @param sessionTotal  本次会话累计 tokens（可选）
+   */
+  renderUsage(usage, sessionTotal) {
+    const total = usage.inputTokens + usage.outputTokens;
+    let line = chalk.dim("\u{1F4CA} ") + chalk.dim(`in ${usage.inputTokens.toLocaleString()}`) + chalk.dim(" + ") + chalk.dim(`out ${usage.outputTokens.toLocaleString()}`) + chalk.dim(` = ${total.toLocaleString()} tokens`);
+    if (sessionTotal) {
+      const sessionSum = sessionTotal.inputTokens + sessionTotal.outputTokens;
+      line += chalk.dim(`  \u2502  session total: ${sessionSum.toLocaleString()}`);
+    }
+    process.stdout.write(line + "\n\n");
+  }
+  printInfo(message) {
+    console.log(chalk.yellow(`  ${message}`));
+  }
+  printSuccess(message) {
+    console.log(chalk.green(`  ${message}`));
+  }
+  showSpinner(text) {
+    return createSpinner(text);
+  }
+  printTable(headers, rows) {
+    const colWidths = headers.map((h, i) => {
+      const maxRow = Math.max(...rows.map((r) => String(r[i] ?? "").length));
+      return Math.max(h.length, maxRow);
+    });
+    const separator = colWidths.map((w) => "-".repeat(w + 2)).join("+");
+    const headerLine = headers.map((h, i) => ` ${h.padEnd(colWidths[i])} `).join("|");
+    console.log(chalk.gray(separator));
+    console.log(chalk.bold(headerLine));
+    console.log(chalk.gray(separator));
+    for (const row of rows) {
+      const line = row.map((cell, i) => {
+        const val = String(cell ?? "");
+        const colored = cell === true ? chalk.green(val) : cell === false ? chalk.red(val) : val;
+        return ` ${colored.padEnd(colWidths[i])} `;
+      }).join("|");
+      console.log(line);
+    }
+    console.log(chalk.gray(separator));
+  }
+};
+
+// src/repl/commands/index.ts
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { resolve, dirname as dirname2 } from "path";
+
+// src/tools/undo-stack.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync, existsSync as existsSync3 } from "fs";
+var MAX_UNDO_DEPTH = 20;
+var UndoStack = class {
+  stack = [];
+  /**
+   * 在执行文件写入操作之前调用，保存当前状态。
+   * @param filePath 将要被写入的文件路径
+   * @param description 操作描述，如 "write_file: src/index.ts"
+   */
+  push(filePath, description) {
+    let previousContent = null;
+    if (existsSync3(filePath)) {
+      try {
+        previousContent = readFileSync3(filePath, "utf-8");
+      } catch {
+        return;
+      }
+    }
+    this.stack.push({
+      filePath,
+      previousContent,
+      description,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (this.stack.length > MAX_UNDO_DEPTH) {
+      this.stack.shift();
+    }
+  }
+  /**
+   * 弹出并执行最近一次撤销操作。
+   * @returns 撤销结果描述，或 null（栈为空时）
+   */
+  undo() {
+    const entry = this.stack.pop();
+    if (!entry) return null;
+    try {
+      if (entry.previousContent === null) {
+        if (existsSync3(entry.filePath)) {
+          unlinkSync(entry.filePath);
+        }
+        return { entry, result: `Deleted newly created file: ${entry.filePath}` };
+      } else {
+        writeFileSync3(entry.filePath, entry.previousContent, "utf-8");
+        const lines = entry.previousContent.split("\n").length;
+        return {
+          entry,
+          result: `Restored ${entry.filePath} to previous state (${lines} lines)`
+        };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { entry, result: `Undo failed: ${msg}` };
+    }
+  }
+  /** 查看栈顶条目（不弹出），用于 /undo 显示预览 */
+  peek() {
+    return this.stack[this.stack.length - 1] ?? null;
+  }
+  /** 当前栈深度 */
+  get depth() {
+    return this.stack.length;
+  }
+  /** 清空撤销栈（新会话时调用） */
+  clear() {
+    this.stack = [];
+  }
+};
+var undoStack = new UndoStack();
+
+// src/repl/commands/index.ts
+function fmtCtx(tokens) {
+  if (tokens >= 1e6) return `${Math.round(tokens / 1e5) / 10}M`;
+  if (tokens >= 1e3) return `${Math.round(tokens / 1024)}K`;
+  return `${tokens}`;
+}
+var CommandRegistry = class {
+  commands = /* @__PURE__ */ new Map();
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  listAll() {
+    return [...this.commands.values()];
+  }
+};
+function createDefaultCommands() {
+  return [
+    {
+      name: "help",
+      description: "List all available commands",
+      usage: "/help",
+      execute(_args, ctx) {
+        const commands = ctx.providers ? [
+          "  /help                    - Show this help",
+          "  /about                   - About ai-cli & author info",
+          "  /provider <name>         - Switch AI provider",
+          "  /model <name>            - Switch model",
+          "  /clear                   - Clear conversation history",
+          "  /session new             - Start a new session",
+          "  /session list            - List saved sessions",
+          "  /session load <id>       - Resume a session",
+          "  /system <prompt>         - Set system prompt",
+          "  /context                 - Show or reload project context file",
+          "  /status                  - Show current status",
+          "  /undo                    - Undo the last file write/edit operation",
+          "  /export [md|json] [file] - Export session to file (default: auto-named .md)",
+          "  /tools                   - List all AI tools available",
+          "  /exit                    - Exit"
+        ] : [];
+        console.log("\nAvailable commands:");
+        commands.forEach((c) => console.log(c));
+        console.log();
+      }
+    },
+    {
+      name: "about",
+      description: "Show information about ai-cli and its author",
+      usage: "/about",
+      execute(_args, ctx) {
+        ctx.renderer.printAbout();
+      }
+    },
+    {
+      name: "provider",
+      description: "Switch AI provider (interactive selector when no arg)",
+      usage: "/provider [name]",
+      async execute(args, ctx) {
+        const id = args[0];
+        if (!id) {
+          const all = ctx.providers.listAll();
+          const currentProvider = ctx.getCurrentProvider();
+          const items = all.map((p) => ({
+            value: p.id,
+            label: p.displayName,
+            hint: p.configured ? "\u2713 configured" : "\u2717 not configured"
+          }));
+          const initialIdx = Math.max(0, items.findIndex((i) => i.value === currentProvider));
+          const chosen = await ctx.select("Select provider:", items, initialIdx);
+          if (!chosen) return;
+          if (!ctx.providers.has(chosen)) {
+            ctx.renderer.renderError(`Provider '${chosen}' is not configured. Run: ai-cli config`);
+            return;
+          }
+          ctx.setProvider(chosen);
+          ctx.sessions.createSession(chosen, ctx.getCurrentModel());
+          ctx.renderer.printSuccess(`Switched to provider: ${chosen}`);
+          return;
+        }
+        if (!ctx.providers.has(id)) {
+          ctx.renderer.renderError(
+            `Provider '${id}' is not configured. Run: ai-cli config`
+          );
+          return;
+        }
+        ctx.setProvider(id);
+        ctx.sessions.createSession(id, ctx.getCurrentModel());
+        ctx.renderer.printSuccess(`Switched to provider: ${id}`);
+      }
+    },
+    {
+      name: "model",
+      description: "Switch model (interactive selector when no arg)",
+      usage: "/model [name]",
+      async execute(args, ctx) {
+        const name = args[0];
+        if (!name) {
+          const provider = ctx.providers.get(ctx.getCurrentProvider());
+          const currentModel = ctx.getCurrentModel();
+          const items = provider.info.models.map((m) => ({
+            value: m.id,
+            label: m.id,
+            hint: [
+              m.displayName,
+              `ctx:${fmtCtx(m.contextWindow)}`,
+              m.supportsThinking ? "\u{1F9E0}" : "",
+              m.id === currentModel ? "(current)" : ""
+            ].filter(Boolean).join("  ")
+          }));
+          const initialIdx = Math.max(0, items.findIndex((i) => i.value === currentModel));
+          const chosen = await ctx.select("Select model:", items, initialIdx);
+          if (!chosen) return;
+          ctx.setProvider(ctx.getCurrentProvider(), chosen);
+          ctx.sessions.createSession(ctx.getCurrentProvider(), chosen);
+          ctx.renderer.printSuccess(`Switched to model: ${chosen}`);
+          return;
+        }
+        ctx.setProvider(ctx.getCurrentProvider(), name);
+        ctx.sessions.createSession(ctx.getCurrentProvider(), name);
+        ctx.renderer.printSuccess(`Switched to model: ${name}`);
+      }
+    },
+    {
+      name: "clear",
+      description: "Clear conversation history",
+      usage: "/clear",
+      execute(_args, ctx) {
+        ctx.sessions.current?.clear();
+        ctx.renderer.printInfo("Conversation cleared.");
+      }
+    },
+    {
+      name: "session",
+      description: "Session management",
+      usage: "/session new|list|load <id>",
+      execute(args, ctx) {
+        const sub = args[0];
+        if (sub === "new") {
+          const provider = ctx.getCurrentProvider();
+          const model = ctx.getCurrentModel();
+          ctx.sessions.createSession(provider, model);
+          ctx.renderer.printSuccess("New session started.");
+        } else if (sub === "list") {
+          const sessions = ctx.sessions.listSessions();
+          if (sessions.length === 0) {
+            ctx.renderer.printInfo("No saved sessions.");
+            return;
+          }
+          console.log();
+          ctx.renderer.printTable(
+            ["ID (short)", "Provider", "Model", "Messages", "Date", "Title"],
+            sessions.map((s) => [
+              s.id.slice(0, 8),
+              s.provider,
+              s.model,
+              s.messageCount,
+              s.updated.toLocaleDateString(),
+              s.title ?? "(untitled)"
+            ])
+          );
+        } else if (sub === "load") {
+          const id = args[1];
+          if (!id) {
+            ctx.renderer.renderError("Usage: /session load <id>");
+            return;
+          }
+          const sessions = ctx.sessions.listSessions();
+          const match = sessions.find((s) => s.id.startsWith(id));
+          if (!match) {
+            ctx.renderer.renderError(`Session '${id}' not found.`);
+            return;
+          }
+          ctx.sessions.loadSession(match.id);
+          ctx.setProvider(match.provider, match.model);
+          ctx.renderer.printSuccess(
+            `Loaded session ${match.id.slice(0, 8)}: ${match.title ?? "(untitled)"}`
+          );
+        } else {
+          ctx.renderer.renderError("Usage: /session new|list|load <id>");
+        }
+      }
+    },
+    {
+      name: "system",
+      description: "Set system prompt",
+      usage: "/system <prompt>",
+      execute(args, ctx) {
+        const prompt = args.join(" ");
+        if (!prompt) {
+          const current = ctx.config.get("session").systemPrompt;
+          ctx.renderer.printInfo(
+            `Current system prompt: ${current ?? "(none)"}`
+          );
+          return;
+        }
+        const session = ctx.config.get("session");
+        ctx.config.set("session", { ...session, systemPrompt: prompt });
+        ctx.renderer.printSuccess("System prompt updated.");
+      }
+    },
+    {
+      name: "context",
+      description: "Show or reload project context file (AICLI.md / CLAUDE.md)",
+      usage: "/context [reload]",
+      execute(args, ctx) {
+        const sub = args[0];
+        if (sub === "reload") {
+          ctx.reloadContext();
+          const filePath2 = ctx.getContextFilePath();
+          if (filePath2) {
+            ctx.renderer.printSuccess(`Context reloaded from: ${filePath2}`);
+          } else {
+            ctx.renderer.printInfo("No context file found. Place AICLI.md or CLAUDE.md in your project root.");
+          }
+          return;
+        }
+        const filePath = ctx.getContextFilePath();
+        const prompt = ctx.getActiveSystemPrompt();
+        console.log();
+        if (filePath) {
+          console.log(`  Context file : ${filePath}`);
+          console.log(`  Total chars  : ${prompt?.length ?? 0}`);
+          console.log(`  Preview      : ${(prompt ?? "").slice(0, 120).replace(/\n/g, " ")}...`);
+        } else {
+          console.log("  No project context file loaded.");
+          console.log("  Create AICLI.md (or CLAUDE.md) in your project root to auto-load context.");
+          console.log('  Or set "contextFile": "your-file.md" in ~/.aicli/config.json');
+        }
+        console.log();
+      }
+    },
+    {
+      name: "status",
+      description: "Show current status",
+      usage: "/status",
+      execute(_args, ctx) {
+        const session = ctx.sessions.current;
+        const filePath = ctx.getContextFilePath();
+        const tokenUsage = ctx.getSessionTokenUsage();
+        const gitBranch = ctx.getGitBranch();
+        console.log();
+        const provider = ctx.providers.get(ctx.getCurrentProvider());
+        const currentModel = ctx.getCurrentModel();
+        const modelInfo = provider?.info.models.find((m) => m.id === currentModel);
+        const ctxStr = modelInfo ? `${fmtCtx(modelInfo.contextWindow)} tokens` : "unknown";
+        console.log(`  Provider : ${ctx.getCurrentProvider()}`);
+        console.log(`  Model    : ${currentModel}`);
+        console.log(`  Ctx Win  : ${ctxStr}`);
+        console.log(`  Messages : ${session?.messages.length ?? 0}`);
+        console.log(`  Session  : ${session?.id.slice(0, 8) ?? "none"}`);
+        console.log(`  Context  : ${filePath ?? "(none)"}`);
+        if (gitBranch) {
+          console.log(`  Git      : ${gitBranch}`);
+        }
+        const sys = ctx.config.get("session").systemPrompt;
+        if (sys) {
+          console.log(`  System   : ${sys.slice(0, 60)}...`);
+        }
+        const totalTokens = tokenUsage.inputTokens + tokenUsage.outputTokens;
+        if (totalTokens > 0) {
+          console.log(
+            `  Tokens   : in ${tokenUsage.inputTokens.toLocaleString()} + out ${tokenUsage.outputTokens.toLocaleString()} = ${totalTokens.toLocaleString()} (session total)`
+          );
+        }
+        console.log();
+      }
+    },
+    {
+      name: "export",
+      description: "Export current session to file or stdout",
+      usage: "/export [md|json] [filename]",
+      execute(args, ctx) {
+        let format = "md";
+        let outFile = null;
+        for (const arg of args) {
+          if (arg === "md" || arg === "json") {
+            format = arg;
+          } else if (arg) {
+            outFile = arg;
+          }
+        }
+        const session = ctx.sessions.current;
+        if (!session || session.messages.length === 0) {
+          ctx.renderer.printInfo("No messages to export.");
+          return;
+        }
+        let output;
+        if (format === "json") {
+          output = JSON.stringify(session.toJSON(), null, 2);
+        } else {
+          const dateStr = session.created.toISOString().replace("T", " ").slice(0, 19);
+          let md = `# Conversation Export
+
+`;
+          md += `| Field    | Value |
+|----------|-------|
+`;
+          md += `| Provider | ${session.provider} |
+`;
+          md += `| Model    | ${session.model} |
+`;
+          md += `| Date     | ${dateStr} |
+`;
+          md += `| Session  | ${session.id.slice(0, 8)} |
+
+---
+
+`;
+          for (const msg of session.messages) {
+            const role = msg.role === "user" ? "## \u{1F464} You" : "## \u{1F916} Assistant";
+            const text = getContentText(msg.content);
+            md += `${role}
+
+${text}
+
+---
+
+`;
+          }
+          output = md;
+        }
+        if (outFile) {
+          const absPath = resolve(process.cwd(), outFile);
+          try {
+            mkdirSync4(dirname2(absPath), { recursive: true });
+            writeFileSync4(absPath, output, "utf-8");
+            ctx.renderer.printSuccess(`Exported ${session.messages.length} messages \u2192 ${absPath}`);
+          } catch (err) {
+            ctx.renderer.renderError(`Failed to write file: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        } else {
+          const shortId = session.id.slice(0, 8);
+          const dateTag = session.created.toISOString().slice(0, 10);
+          const ext = format === "json" ? "json" : "md";
+          const autoName = `session-${dateTag}-${shortId}.${ext}`;
+          const absPath = resolve(process.cwd(), autoName);
+          try {
+            writeFileSync4(absPath, output, "utf-8");
+            ctx.renderer.printSuccess(`Exported ${session.messages.length} messages \u2192 ${absPath}`);
+          } catch (err) {
+            ctx.renderer.renderError(`Failed to write file: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      }
+    },
+    {
+      name: "tools",
+      description: "List all AI tools available in agentic mode",
+      usage: "/tools",
+      execute(_args, ctx) {
+        const tools = ctx.tools.listAll();
+        console.log("\nAvailable AI tools:");
+        for (const t of tools) {
+          console.log(
+            `  ${t.definition.name.padEnd(20)} ${t.definition.description}`
+          );
+        }
+        console.log();
+      }
+    },
+    {
+      name: "undo",
+      description: "Undo the last file write or edit operation",
+      usage: "/undo",
+      execute(_args, ctx) {
+        const top = undoStack.peek();
+        if (!top) {
+          ctx.renderer.printInfo("Nothing to undo.");
+          return;
+        }
+        const timeStr = top.timestamp.toLocaleTimeString();
+        ctx.renderer.printInfo(
+          `Undoing: ${top.description}  (${timeStr})`
+        );
+        const undoResult = undoStack.undo();
+        if (undoResult) {
+          ctx.renderer.printSuccess(undoResult.result);
+        } else {
+          ctx.renderer.printInfo("Nothing to undo.");
+        }
+      }
+    },
+    {
+      name: "exit",
+      description: "Exit the REPL",
+      usage: "/exit",
+      execute(_args, ctx) {
+        ctx.exit();
+      }
+    }
+  ];
+}
+
+// src/repl/select-list.ts
+import chalk2 from "chalk";
+var CLEAR_LINE = "\r\x1B[2K";
+var MOVE_UP = (n) => n > 0 ? `\x1B[${n}A` : "";
+var IGNORE_ENTER_MS = 80;
+function selectFromList(prompt, items, initialIndex = 0) {
+  if (items.length === 0) return Promise.resolve(null);
+  const PAGE = 12;
+  return new Promise((resolve4) => {
+    let selected = Math.max(0, Math.min(initialIndex, items.length - 1));
+    let windowStart = Math.max(0, selected - Math.floor(PAGE / 2));
+    let lastRenderedLines = 0;
+    let done = false;
+    const startTime = Date.now();
+    let escBuf = "";
+    let escTimer = null;
+    const flushEsc = () => {
+      if (escTimer) {
+        clearTimeout(escTimer);
+        escTimer = null;
+      }
+      const seq = escBuf;
+      escBuf = "";
+      handleSequence(seq);
+    };
+    const renderLine = (item, active, absIdx) => {
+      const cursor = active ? chalk2.cyan("\u276F ") : "  ";
+      const label = active ? chalk2.cyan(item.label) : item.label;
+      const hint = item.hint ? chalk2.dim("  " + item.hint) : "";
+      const num = chalk2.dim(String(absIdx + 1).padStart(2) + " ");
+      return cursor + num + label + hint;
+    };
+    const render = () => {
+      if (selected < windowStart) windowStart = selected;
+      if (selected >= windowStart + PAGE) windowStart = selected - PAGE + 1;
+      const windowEnd = Math.min(windowStart + PAGE, items.length);
+      const visible = items.slice(windowStart, windowEnd);
+      const lines = [];
+      lines.push(chalk2.bold(prompt));
+      if (windowStart > 0)
+        lines.push(chalk2.dim(`  \u2191 ${windowStart} more above`));
+      visible.forEach(
+        (item, i) => lines.push(renderLine(item, windowStart + i === selected, windowStart + i))
+      );
+      const below = items.length - windowEnd;
+      if (below > 0)
+        lines.push(chalk2.dim(`  \u2193 ${below} more below`));
+      lines.push(chalk2.dim("  \u2191\u2193 move \xB7 Enter select \xB7 Esc cancel"));
+      if (lastRenderedLines > 0) {
+        process.stdout.write(MOVE_UP(lastRenderedLines) + CLEAR_LINE);
+        for (let i = 1; i < lastRenderedLines; i++)
+          process.stdout.write("\x1B[1B" + CLEAR_LINE);
+        process.stdout.write(MOVE_UP(lastRenderedLines - 1));
+      }
+      process.stdout.write(lines.join("\n") + "\n");
+      lastRenderedLines = lines.length;
+    };
+    let savedDataListeners = [];
+    const cleanup = (result) => {
+      if (done) return;
+      done = true;
+      if (escTimer) {
+        clearTimeout(escTimer);
+        escTimer = null;
+      }
+      process.stdin.removeListener("data", onData);
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+      for (const listener of savedDataListeners) {
+        process.stdin.on("data", listener);
+      }
+      if (lastRenderedLines > 0) {
+        process.stdout.write(MOVE_UP(lastRenderedLines) + CLEAR_LINE);
+        for (let i = 1; i < lastRenderedLines; i++)
+          process.stdout.write("\x1B[1B" + CLEAR_LINE);
+        process.stdout.write(MOVE_UP(lastRenderedLines - 1));
+      }
+      if (result !== null) {
+        process.stdout.write(chalk2.dim(`  \u2714 ${result}
+`));
+      }
+      resolve4(result);
+    };
+    const handleSequence = (seq) => {
+      if (seq === "\x1B") {
+        cleanup(null);
+        return;
+      }
+      if (seq === "\x1B[A" || seq === "\x1BOA") {
+        selected = (selected - 1 + items.length) % items.length;
+        render();
+        return;
+      }
+      if (seq === "\x1B[B" || seq === "\x1BOB") {
+        selected = (selected + 1) % items.length;
+        render();
+        return;
+      }
+    };
+    const onData = (buf) => {
+      for (let i = 0; i < buf.length; ) {
+        const byte = buf[i];
+        if (escBuf.length > 0 || byte === 27) {
+          escBuf += String.fromCharCode(byte);
+          i++;
+          if (escTimer) clearTimeout(escTimer);
+          if (escBuf === "\x1B") {
+            escTimer = setTimeout(flushEsc, 30);
+          } else if (escBuf.length >= 3 || escBuf.length === 2 && escBuf[1] !== "[" && escBuf[1] !== "O") {
+            flushEsc();
+          } else {
+            escTimer = setTimeout(flushEsc, 30);
+          }
+          continue;
+        }
+        i++;
+        const ch = String.fromCharCode(byte);
+        const isEnter = byte === 13 || byte === 10;
+        if (isEnter) {
+          if (Date.now() - startTime < IGNORE_ENTER_MS) continue;
+          cleanup(items[selected].value);
+          return;
+        }
+        if (byte === 3 || ch === "q") {
+          cleanup(null);
+          return;
+        }
+        if (ch >= "1" && ch <= "9") {
+          const n = parseInt(ch, 10) - 1;
+          if (n < items.length) {
+            selected = n;
+            cleanup(items[selected].value);
+            return;
+          }
+        }
+        if (ch === "k") {
+          selected = (selected - 1 + items.length) % items.length;
+          render();
+        } else if (ch === "j") {
+          selected = (selected + 1) % items.length;
+          render();
+        }
+      }
+    };
+    if (!process.stdin.isTTY) {
+      resolve4(items[0]?.value ?? null);
+      return;
+    }
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+      resolve4(items[0]?.value ?? null);
+      return;
+    }
+    savedDataListeners = process.stdin.rawListeners("data");
+    process.stdin.removeAllListeners("data");
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+    render();
+  });
+}
+
+// src/tools/builtin/bash.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { platform } from "os";
+import { resolve as resolve2 } from "path";
+var IS_WINDOWS = platform() === "win32";
+var SHELL = IS_WINDOWS ? "powershell.exe" : process.env["SHELL"] ?? "/bin/bash";
+var persistentCwd = process.cwd();
+var bashTool = {
+  definition: {
+    name: "bash",
+    description: IS_WINDOWS ? `\u5728 PowerShell \u4E2D\u6267\u884C\u547D\u4EE4\u3002\u652F\u6301 mkdir\u3001ls\u3001cat\u3001python \u7B49\u3002
+\u91CD\u8981\u89C4\u5219\uFF1A
+1. \u6BCF\u6B21 bash \u8C03\u7528\u662F\u72EC\u7ACB\u5B50\u8FDB\u7A0B\uFF0Ccd \u547D\u4EE4\u4E0D\u4F1A\u6301\u4E45\u751F\u6548\u3002\u5982\u9700\u5728\u6307\u5B9A\u76EE\u5F55\u6267\u884C\uFF0C\u8BF7\u4F7F\u7528 cwd \u53C2\u6570\uFF0C\u6216\u5C06\u547D\u4EE4\u5408\u5E76\uFF1A\u5982 "cd mydir; ls" \u6216 "mkdir mydir; cd mydir; New-Item file.txt"\u3002
+2. \u5982\u679C\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF08\u8FD4\u56DE\u9519\u8BEF\u6216\u975E\u96F6\u9000\u51FA\u7801\uFF09\uFF0C\u8BF7\u7ACB\u5373\u505C\u6B62\uFF0C\u5C06\u9519\u8BEF\u4FE1\u606F\u544A\u77E5\u7528\u6237\uFF0C\u4E0D\u8981\u53CD\u590D\u5C1D\u8BD5\u76F8\u540C\u6216\u7C7B\u4F3C\u7684\u547D\u4EE4\u3002
+3. \u591A\u6761\u547D\u4EE4\u53EF\u7528\u5206\u53F7\u5408\u5E76\u4E3A\u4E00\u6B21\u8C03\u7528\u4EE5\u51CF\u5C11\u8F6E\u6B21\u3002
+4. \u5220\u9664\u76EE\u5F55\u8BF7\u4F7F\u7528 Remove-Item -Recurse\uFF08\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u4F18\u5316\u4E3A\u66F4\u53EF\u9760\u7684\u65B9\u5F0F\uFF09\u3002` : `\u5728 ${SHELL} \u4E2D\u6267\u884C\u547D\u4EE4\u3002
+\u91CD\u8981\u89C4\u5219\uFF1A
+1. \u6BCF\u6B21 bash \u8C03\u7528\u662F\u72EC\u7ACB\u5B50\u8FDB\u7A0B\uFF0Ccd \u547D\u4EE4\u4E0D\u4F1A\u6301\u4E45\u751F\u6548\u3002\u5982\u9700\u5728\u6307\u5B9A\u76EE\u5F55\u6267\u884C\uFF0C\u8BF7\u4F7F\u7528 cwd \u53C2\u6570\uFF0C\u6216\u5C06\u547D\u4EE4\u5408\u5E76\uFF1A\u5982 "cd mydir && ls" \u6216 "mkdir -p mydir && touch mydir/file.txt"\u3002
+2. \u5982\u679C\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF08\u8FD4\u56DE\u9519\u8BEF\u6216\u975E\u96F6\u9000\u51FA\u7801\uFF09\uFF0C\u8BF7\u7ACB\u5373\u505C\u6B62\uFF0C\u5C06\u9519\u8BEF\u4FE1\u606F\u544A\u77E5\u7528\u6237\uFF0C\u4E0D\u8981\u53CD\u590D\u5C1D\u8BD5\u76F8\u540C\u6216\u7C7B\u4F3C\u7684\u547D\u4EE4\u3002
+3. \u591A\u6761\u547D\u4EE4\u53EF\u7528 && \u5408\u5E76\u4E3A\u4E00\u6B21\u8C03\u7528\u4EE5\u51CF\u5C11\u8F6E\u6B21\u3002`,
+    parameters: {
+      command: {
+        type: "string",
+        description: IS_WINDOWS ? `\u8981\u6267\u884C\u7684 PowerShell \u547D\u4EE4\u3002\u53EF\u7528\u5206\u53F7\u5408\u5E76\u591A\u6761\u547D\u4EE4\uFF0C\u5982\uFF1A"mkdir mydir; Set-Content mydir/file.txt '\u5185\u5BB9'"` : `\u8981\u6267\u884C\u7684 ${SHELL} \u547D\u4EE4\u3002\u53EF\u7528 && \u5408\u5E76\u591A\u6761\u547D\u4EE4\uFF0C\u5982\uFF1A"mkdir -p mydir && echo '\u5185\u5BB9' > mydir/file.txt"`,
+        required: true
+      },
+      cwd: {
+        type: "string",
+        description: "\u547D\u4EE4\u6267\u884C\u7684\u5DE5\u4F5C\u76EE\u5F55\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\uFF09\u3002\u8BBE\u7F6E\u540E\u8BE5\u6B21\u547D\u4EE4\u5728\u6B64\u76EE\u5F55\u4E0B\u6267\u884C\uFF0C\u5E76\u81EA\u52A8\u8BB0\u4F4F\u8BE5\u76EE\u5F55\u4F9B\u540E\u7EED\u547D\u4EE4\u4F7F\u7528\u3002",
+        required: false
+      },
+      timeout: {
+        type: "number",
+        description: "\u8D85\u65F6\u6BEB\u79D2\u6570\uFF0C\u9ED8\u8BA4 30000",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const command = String(args["command"] ?? "");
+    const timeout = Number(args["timeout"] ?? 3e4);
+    const cwdArg = args["cwd"] ? String(args["cwd"]) : void 0;
+    if (!command.trim()) {
+      throw new Error("command is required");
+    }
+    let effectiveCwd = persistentCwd;
+    if (cwdArg) {
+      const resolved = resolve2(persistentCwd, cwdArg);
+      if (existsSync4(resolved)) {
+        effectiveCwd = resolved;
+        persistentCwd = resolved;
+      } else {
+        effectiveCwd = resolved;
+      }
+    }
+    let actualCommand;
+    if (IS_WINDOWS) {
+      const fixedCommand = fixWindowsDeleteCommand(command);
+      actualCommand = `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; $OutputEncoding = [System.Text.Encoding]::UTF8; ${fixedCommand}`;
+    } else {
+      actualCommand = command;
+    }
+    try {
+      const output = execSync(actualCommand, {
+        timeout,
+        encoding: IS_WINDOWS ? "buffer" : "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: effectiveCwd,
+        shell: SHELL,
+        env: {
+          ...process.env,
+          PYTHONUTF8: "1",
+          PYTHONIOENCODING: "utf-8"
+        }
+      });
+      updateCwdFromCommand(command, effectiveCwd);
+      const result = IS_WINDOWS && Buffer.isBuffer(output) ? output.toString("utf-8") : output;
+      return result || "(command completed with no output)";
+    } catch (err) {
+      if (err && typeof err === "object" && "status" in err) {
+        const execErr = err;
+        const stderr = IS_WINDOWS && Buffer.isBuffer(execErr.stderr) ? execErr.stderr.toString("utf-8").trim() : execErr.stderr?.toString().trim() ?? "";
+        const stdout = IS_WINDOWS && Buffer.isBuffer(execErr.stdout) ? execErr.stdout.toString("utf-8").trim() : execErr.stdout?.toString().trim() ?? "";
+        const combined = [stdout, stderr].filter(Boolean).join("\n");
+        throw new Error(
+          `Exit code ${execErr.status}:
+${combined || (execErr.message ?? "Unknown error")}
+
+[\u547D\u4EE4\u5931\u8D25\u3002\u8BF7\u5C06\u4E0A\u8FF0\u9519\u8BEF\u4FE1\u606F\u544A\u77E5\u7528\u6237\uFF0C\u4E0D\u8981\u7EE7\u7EED\u5C1D\u8BD5\u53D8\u4F53\u547D\u4EE4\u3002]`
+        );
+      }
+      throw err;
+    }
+  }
+};
+function fixWindowsDeleteCommand(command) {
+  return command.replace(
+    /Remove-Item\b([^;\n]*)/gi,
+    (match, args) => {
+      if (!/recurse/i.test(args)) return match;
+      let pathValue = "";
+      const pathMatch = args.match(/-Path\s+(['"]?)([^'";\s]+)\1/i) ?? args.match(/(?:^|\s)(['"]?)([^'";\s-][^'";\s]*)\1/);
+      if (pathMatch) {
+        pathValue = pathMatch[2] ?? "";
+      }
+      if (!pathValue) return match;
+      return `cmd /c rmdir /s /q "${pathValue}"`;
+    }
+  );
+}
+function updateCwdFromCommand(command, baseCwd) {
+  const cdMatches = [...command.matchAll(/(?:^|[;&|])\s*cd\s+([^\s;&|]+)/g)];
+  if (cdMatches.length === 0) return;
+  const lastMatch = cdMatches[cdMatches.length - 1];
+  const target = lastMatch?.[1];
+  if (!target || target.startsWith("$") || target === "~") return;
+  try {
+    const newDir = resolve2(baseCwd, target);
+    if (existsSync4(newDir)) {
+      persistentCwd = newDir;
+    }
+  } catch {
+  }
+}
+
+// src/tools/builtin/read-file.ts
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u6587\u672C\u6587\u4EF6\uFF0C\u8FD4\u56DE\u6587\u4EF6\u7684\u5B8C\u6574\u5185\u5BB9\u3002",
+    parameters: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u76F8\u5BF9\u8DEF\u5F84\uFF09",
+        required: true
+      },
+      encoding: {
+        type: "string",
+        description: "\u7F16\u7801\u683C\u5F0F\uFF0C\u9ED8\u8BA4 utf-8",
+        enum: ["utf-8", "utf8", "ascii", "base64"],
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    if (!filePath) throw new Error("path is required");
+    if (!existsSync5(filePath)) throw new Error(`File not found: ${filePath}`);
+    const content = readFileSync4(filePath, encoding);
+    const lines = content.split("\n").length;
+    return `[File: ${filePath} | ${lines} lines]
+
+${content}`;
+  }
+};
+
+// src/tools/builtin/write-file.ts
+import { writeFileSync as writeFileSync5, appendFileSync, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3 } from "path";
+var writeFileTool = {
+  definition: {
+    name: "write_file",
+    description: `\u5C06\u5185\u5BB9\u5199\u5165\u6587\u4EF6\u3002\u5982\u679C\u6587\u4EF6\u4E0D\u5B58\u5728\u5219\u521B\u5EFA\uFF0C\u5B58\u5728\u5219\u8986\u76D6\uFF08append=false\uFF09\u6216\u8FFD\u52A0\uFF08append=true\uFF09\u3002\u4F1A\u81EA\u52A8\u521B\u5EFA\u6240\u9700\u7684\u7236\u76EE\u5F55\u3002
+\u91CD\u8981\u63D0\u793A\uFF1A\u5F53\u5185\u5BB9\u8F83\u957F\uFF08\u8D85\u8FC7500\u884C\u62163000\u5B57\u7B26\uFF09\u65F6\uFF0C\u5FC5\u987B\u5206\u591A\u6B21\u8C03\u7528\u5E76\u4F7F\u7528 append=true \u8FFD\u52A0\u5199\u5165\uFF0C\u6BCF\u6B21\u5199\u5165\u4E0D\u8D85\u8FC7300\u884C\uFF0C\u4EE5\u907F\u514D\u5185\u5BB9\u622A\u65AD\u3002\u7B2C\u4E00\u6B21\u8C03\u7528\u4F7F\u7528 append=false\uFF08\u8986\u76D6\uFF09\uFF0C\u540E\u7EED\u8C03\u7528\u4F7F\u7528 append=true\uFF08\u8FFD\u52A0\uFF09\u3002`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84",
+        required: true
+      },
+      content: {
+        type: "string",
+        description: "\u8981\u5199\u5165\u7684\u5185\u5BB9",
+        required: true
+      },
+      append: {
+        type: "string",
+        description: "\u662F\u5426\u8FFD\u52A0\u5199\u5165\u3002true=\u8FFD\u52A0\u5230\u6587\u4EF6\u672B\u5C3E\uFF0Cfalse=\u8986\u76D6\uFF08\u9ED8\u8BA4\uFF09\u3002\u957F\u6587\u4EF6\u5FC5\u987B\u5206\u6BB5\u8FFD\u52A0\u5199\u5165\u3002",
+        required: false
+      },
+      encoding: {
+        type: "string",
+        description: "\u7F16\u7801\u683C\u5F0F\uFF0C\u9ED8\u8BA4 utf-8",
+        required: false
+      }
+    },
+    dangerous: false
+    // executor 会将 write_file 标记为 'write' 级别
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const content = String(args["content"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    const appendMode = String(args["append"] ?? "false").toLowerCase() === "true";
+    if (!filePath) throw new Error("path is required");
+    if (!appendMode) {
+      undoStack.push(filePath, `write_file: ${filePath}`);
+    }
+    mkdirSync5(dirname3(filePath), { recursive: true });
+    if (appendMode) {
+      appendFileSync(filePath, content, encoding);
+    } else {
+      writeFileSync5(filePath, content, encoding);
+    }
+    const lines = content.split("\n").length;
+    const mode = appendMode ? "appended" : "written";
+    return `File ${mode}: ${filePath} (${lines} lines, ${content.length} bytes)`;
+  }
+};
+
+// src/tools/builtin/edit-file.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, existsSync as existsSync6 } from "fs";
+var editFileTool = {
+  definition: {
+    name: "edit_file",
+    description: `\u7CBE\u51C6\u7F16\u8F91\u6587\u4EF6\u4E2D\u7684\u5185\u5BB9\uFF0C\u652F\u6301\u4E09\u79CD\u6A21\u5F0F\uFF1A
+1. \u5B57\u7B26\u4E32\u66FF\u6362\uFF08\u6700\u5E38\u7528\uFF09\uFF1A\u63D0\u4F9B old_str \u548C new_str\uFF0C\u5C06\u6587\u4EF6\u4E2D\u7CBE\u786E\u5339\u914D\u7684 old_str \u66FF\u6362\u4E3A new_str\u3002old_str \u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\u51FA\u73B0\u3002
+2. \u884C\u63D2\u5165\uFF1A\u63D0\u4F9B insert_after_line\uFF08\u884C\u53F7\uFF0C\u4ECE1\u5F00\u59CB\uFF09\u548C insert_content\uFF0C\u5728\u8BE5\u884C\u540E\u63D2\u5165\u65B0\u5185\u5BB9\u3002
+3. \u884C\u5220\u9664\uFF1A\u63D0\u4F9B delete_from_line \u548C delete_to_line\uFF08\u542B\uFF09\uFF0C\u5220\u9664\u8BE5\u8303\u56F4\u5185\u7684\u884C\u3002
+\u6CE8\u610F\uFF1A\u8DEF\u5F84\u53EF\u4EE5\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u8DEF\u5F84\u3002`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84",
+        required: true
+      },
+      old_str: {
+        type: "string",
+        description: "\u3010\u66FF\u6362\u6A21\u5F0F\u3011\u8981\u88AB\u66FF\u6362\u7684\u539F\u59CB\u5B57\u7B26\u4E32\uFF0C\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\u51FA\u73B0\uFF08\u5305\u542B\u8DB3\u591F\u4E0A\u4E0B\u6587\u4EE5\u786E\u4FDD\u552F\u4E00\u6027\uFF09",
+        required: false
+      },
+      new_str: {
+        type: "string",
+        description: "\u3010\u66FF\u6362\u6A21\u5F0F\u3011\u66FF\u6362\u540E\u7684\u65B0\u5B57\u7B26\u4E32\uFF0C\u53EF\u4EE5\u4E3A\u7A7A\u5B57\u7B26\u4E32\uFF08\u8868\u793A\u5220\u9664 old_str\uFF09",
+        required: false
+      },
+      insert_after_line: {
+        type: "number",
+        description: "\u3010\u63D2\u5165\u6A21\u5F0F\u3011\u5728\u7B2C\u51E0\u884C\u4E4B\u540E\u63D2\u5165\uFF0C\u4ECE 1 \u5F00\u59CB\u8BA1\u6570\uFF0C0 \u8868\u793A\u5728\u6587\u4EF6\u5F00\u5934\u63D2\u5165",
+        required: false
+      },
+      insert_content: {
+        type: "string",
+        description: "\u3010\u63D2\u5165\u6A21\u5F0F\u3011\u8981\u63D2\u5165\u7684\u5185\u5BB9\uFF08\u4E0D\u9700\u8981\u624B\u52A8\u52A0\u6362\u884C\u7B26\uFF09",
+        required: false
+      },
+      delete_from_line: {
+        type: "number",
+        description: "\u3010\u5220\u9664\u6A21\u5F0F\u3011\u4ECE\u7B2C\u51E0\u884C\u5F00\u59CB\u5220\u9664\uFF0C\u4ECE 1 \u5F00\u59CB\u8BA1\u6570",
+        required: false
+      },
+      delete_to_line: {
+        type: "number",
+        description: "\u3010\u5220\u9664\u6A21\u5F0F\u3011\u5220\u9664\u5230\u7B2C\u51E0\u884C\uFF08\u542B\uFF09\uFF0C\u4ECE 1 \u5F00\u59CB\u8BA1\u6570",
+        required: false
+      },
+      encoding: {
+        type: "string",
+        description: "\u6587\u4EF6\u7F16\u7801\uFF0C\u9ED8\u8BA4 utf-8",
+        required: false
+      }
+    },
+    dangerous: false
+    // executor 中 edit_file 按 write 级别处理
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    const encoding = args["encoding"] ?? "utf-8";
+    if (!filePath) throw new Error("path is required");
+    if (!existsSync6(filePath)) throw new Error(`File not found: ${filePath}`);
+    const original = readFileSync5(filePath, encoding);
+    if (args["old_str"] !== void 0) {
+      const oldStr = String(args["old_str"]);
+      const newStr = String(args["new_str"] ?? "");
+      if (oldStr === "") throw new Error("old_str cannot be empty");
+      const firstIndex = original.indexOf(oldStr);
+      if (firstIndex === -1) {
+        const lines = original.split("\n");
+        return `ERROR: old_str not found in file.
+File has ${lines.length} lines. Please read the file first and use exact text including whitespace/indentation.`;
+      }
+      const secondIndex = original.indexOf(oldStr, firstIndex + 1);
+      if (secondIndex !== -1) {
+        return `ERROR: old_str appears multiple times in file (at least at positions ${firstIndex} and ${secondIndex}). Please include more surrounding context to make it unique.`;
+      }
+      undoStack.push(filePath, `edit_file (replace): ${filePath}`);
+      const updated = original.slice(0, firstIndex) + newStr + original.slice(firstIndex + oldStr.length);
+      writeFileSync6(filePath, updated, encoding);
+      const oldLines = oldStr.split("\n").length;
+      const newLines = newStr.split("\n").length;
+      const linesBefore = original.slice(0, firstIndex).split("\n").length;
+      return `Successfully edited ${filePath}
+  Location: around line ${linesBefore}
+  Replaced: ${oldLines} line(s) \u2192 ${newLines} line(s)
+  Old: ${truncatePreview(oldStr)}
+  New: ${truncatePreview(newStr)}`;
+    }
+    if (args["insert_after_line"] !== void 0) {
+      const afterLine = Number(args["insert_after_line"]);
+      const content = String(args["insert_content"] ?? "");
+      const lines = original.split("\n");
+      if (afterLine < 0 || afterLine > lines.length) {
+        throw new Error(`insert_after_line ${afterLine} is out of range (file has ${lines.length} lines)`);
+      }
+      undoStack.push(filePath, `edit_file (insert): ${filePath}`);
+      lines.splice(afterLine, 0, content);
+      writeFileSync6(filePath, lines.join("\n"), encoding);
+      return `Successfully inserted ${content.split("\n").length} line(s) after line ${afterLine} in ${filePath}`;
+    }
+    if (args["delete_from_line"] !== void 0) {
+      const fromLine = Number(args["delete_from_line"]);
+      const toLine = Number(args["delete_to_line"] ?? args["delete_from_line"]);
+      const lines = original.split("\n");
+      if (fromLine < 1 || toLine < fromLine || toLine > lines.length) {
+        throw new Error(
+          `Invalid line range: ${fromLine}-${toLine} (file has ${lines.length} lines, lines are 1-indexed)`
+        );
+      }
+      undoStack.push(filePath, `edit_file (delete): ${filePath}`);
+      const deleted = lines.splice(fromLine - 1, toLine - fromLine + 1);
+      writeFileSync6(filePath, lines.join("\n"), encoding);
+      return `Successfully deleted lines ${fromLine}-${toLine} (${deleted.length} lines) from ${filePath}`;
+    }
+    throw new Error(
+      "No operation specified. Provide either: (old_str + new_str) for replace, (insert_after_line + insert_content) for insert, or (delete_from_line + delete_to_line) for delete."
+    );
+  }
+};
+function truncatePreview(str, maxLen = 80) {
+  const oneLine = str.replace(/\n/g, "\u21B5");
+  if (oneLine.length <= maxLen) return JSON.stringify(str);
+  return JSON.stringify(oneLine.slice(0, maxLen)) + "...";
+}
+
+// src/tools/builtin/list-dir.ts
+import { readdirSync as readdirSync2, statSync, existsSync as existsSync7 } from "fs";
+import { join as join3 } from "path";
+var listDirTool = {
+  definition: {
+    name: "list_dir",
+    description: "\u5217\u51FA\u76EE\u5F55\u5185\u5BB9\uFF0C\u663E\u793A\u6587\u4EF6\u540D\u3001\u7C7B\u578B\u548C\u5927\u5C0F\u3002",
+    parameters: {
+      path: {
+        type: "string",
+        description: "\u76EE\u5F55\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55",
+        required: false
+      },
+      recursive: {
+        type: "boolean",
+        description: "\u662F\u5426\u9012\u5F52\u5217\u51FA\u5B50\u76EE\u5F55\uFF0C\u9ED8\u8BA4 false",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const dirPath = String(args["path"] ?? process.cwd());
+    const recursive = Boolean(args["recursive"] ?? false);
+    if (!existsSync7(dirPath)) throw new Error(`Directory not found: ${dirPath}`);
+    const lines = [`Directory: ${dirPath}
+`];
+    listRecursive(dirPath, "", recursive, lines);
+    return lines.join("\n");
+  }
+};
+function listRecursive(basePath, indent, recursive, lines) {
+  let entries;
+  try {
+    entries = readdirSync2(basePath, { withFileTypes: true });
+  } catch {
+    lines.push(`${indent}(permission denied)`);
+    return;
+  }
+  const sorted = entries.sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of sorted) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      if (entry.isDirectory()) {
+        lines.push(`${indent}\u{1F4C1} ${entry.name}/  (skipped)`);
+      }
+      continue;
+    }
+    if (entry.isDirectory()) {
+      lines.push(`${indent}\u{1F4C1} ${entry.name}/`);
+      if (recursive) {
+        listRecursive(join3(basePath, entry.name), indent + "  ", true, lines);
+      }
+    } else {
+      try {
+        const stat = statSync(join3(basePath, entry.name));
+        const size = formatSize(stat.size);
+        lines.push(`${indent}\u{1F4C4} ${entry.name}  (${size})`);
+      } catch {
+        lines.push(`${indent}\u{1F4C4} ${entry.name}`);
+      }
+    }
+  }
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+// src/tools/builtin/grep-files.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync2, existsSync as existsSync8 } from "fs";
+import { join as join4, relative } from "path";
+var grepFilesTool = {
+  definition: {
+    name: "grep_files",
+    description: `\u5728\u6587\u4EF6\u4E2D\u641C\u7D22\u5339\u914D\u7684\u6587\u672C\u6216\u4EE3\u7801\uFF0C\u8FD4\u56DE\u5339\u914D\u884C\u53CA\u884C\u53F7\u3002\u9002\u7528\u4E8E\uFF1A
+- \u67E5\u627E\u51FD\u6570/\u7C7B\u5B9A\u4E49\u4F4D\u7F6E\uFF08\u5982\u641C\u7D22 "function handleChat" \u6216 "class ProviderRegistry"\uFF09
+- \u67E5\u627E\u7279\u5B9A\u53D8\u91CF\u6216\u5B57\u7B26\u4E32\u7684\u6240\u6709\u4F7F\u7528\u4F4D\u7F6E
+- \u5728\u4FEE\u6539\u4EE3\u7801\u524D\u5148\u786E\u8BA4\u5F71\u54CD\u8303\u56F4
+\u652F\u6301\u6B63\u5219\u8868\u8FBE\u5F0F\u3002\u81EA\u52A8\u8DF3\u8FC7 node_modules\u3001dist\u3001.git \u7B49\u76EE\u5F55\u3002`,
+    parameters: {
+      pattern: {
+        type: "string",
+        description: '\u641C\u7D22\u6A21\u5F0F\uFF0C\u652F\u6301\u6B63\u5219\u8868\u8FBE\u5F0F\uFF08\u5982 "function\\s+\\w+" \u6216\u5B57\u9762\u91CF "import React"\uFF09',
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "\u641C\u7D22\u6839\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55",
+        required: false
+      },
+      file_pattern: {
+        type: "string",
+        description: '\u6587\u4EF6\u540D\u8FC7\u6EE4\uFF0C\u652F\u6301\u7B80\u5355\u901A\u914D\u7B26\uFF08\u5982 "*.ts"\u3001"*.py"\u3001"*.json"\uFF09\uFF0C\u9ED8\u8BA4\u641C\u7D22\u6240\u6709\u6587\u672C\u6587\u4EF6',
+        required: false
+      },
+      ignore_case: {
+        type: "boolean",
+        description: "\u662F\u5426\u5FFD\u7565\u5927\u5C0F\u5199\uFF0C\u9ED8\u8BA4 false",
+        required: false
+      },
+      context_lines: {
+        type: "number",
+        description: "\u6BCF\u4E2A\u5339\u914D\u884C\u524D\u540E\u663E\u793A\u7684\u4E0A\u4E0B\u6587\u884C\u6570\uFF0C\u9ED8\u8BA4 0\uFF08\u4EC5\u663E\u793A\u5339\u914D\u884C\uFF09",
+        required: false
+      },
+      max_results: {
+        type: "number",
+        description: "\u6700\u5927\u8FD4\u56DE\u7ED3\u679C\u6570\uFF0C\u9ED8\u8BA4 50",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const pattern = String(args["pattern"] ?? "");
+    const rootPath = String(args["path"] ?? process.cwd());
+    const filePattern = args["file_pattern"] ? String(args["file_pattern"]) : void 0;
+    const ignoreCase = Boolean(args["ignore_case"] ?? false);
+    const contextLines = Math.max(0, Number(args["context_lines"] ?? 0));
+    const maxResults = Math.max(1, Number(args["max_results"] ?? 50));
+    if (!pattern) throw new Error("pattern is required");
+    if (!existsSync8(rootPath)) throw new Error(`Path not found: ${rootPath}`);
+    let regex;
+    try {
+      regex = new RegExp(pattern, ignoreCase ? "gi" : "g");
+    } catch {
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      regex = new RegExp(escaped, ignoreCase ? "gi" : "g");
+    }
+    const results = [];
+    const stat = statSync2(rootPath);
+    if (stat.isFile()) {
+      searchInFile(rootPath, rootPath, regex, contextLines, maxResults, results);
+    } else {
+      collectFiles(rootPath, filePattern, results, regex, contextLines, maxResults, rootPath);
+    }
+    if (results.length === 0) {
+      return `No matches found for pattern: ${pattern}
+Searched in: ${rootPath}${filePattern ? `
+File filter: ${filePattern}` : ""}`;
+    }
+    const lines = [
+      `Found ${results.length} match(es) for: ${pattern}`,
+      `Searched in: ${rootPath}`,
+      ""
+    ];
+    let currentFile = "";
+    for (const r of results) {
+      if (r.file !== currentFile) {
+        if (currentFile) lines.push("");
+        lines.push(`\u2500\u2500 ${r.file} \u2500\u2500`);
+        currentFile = r.file;
+      }
+      if (r.contextBefore) {
+        for (const [ln, text] of r.contextBefore) {
+          lines.push(`  ${String(ln).padStart(4)}\u2502 ${text}`);
+        }
+      }
+      lines.push(`\u25B6 ${String(r.lineNumber).padStart(4)}\u2502 ${r.lineText}`);
+      if (r.contextAfter) {
+        for (const [ln, text] of r.contextAfter) {
+          lines.push(`  ${String(ln).padStart(4)}\u2502 ${text}`);
+        }
+      }
+    }
+    if (results.length >= maxResults) {
+      lines.push("");
+      lines.push(`(Results truncated at ${maxResults}. Use max_results or narrow your search.)`);
+    }
+    return lines.join("\n");
+  }
+};
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", ".next", "__pycache__", ".cache", "coverage", ".nyc_output"]);
+var BINARY_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".ico", ".woff", ".woff2", ".ttf", ".eot", ".otf", ".mp3", ".mp4", ".wav", ".zip", ".tar", ".gz", ".rar", ".7z", ".exe", ".dll", ".so", ".dylib", ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"]);
+function matchesFilePattern(filename, pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i").test(filename);
+}
+function isBinary(filename) {
+  const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase();
+  return BINARY_EXTS.has(ext);
+}
+function collectFiles(dirPath, filePattern, results, regex, contextLines, maxResults, rootPath) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = readdirSync3(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) return;
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      collectFiles(join4(dirPath, entry.name), filePattern, results, regex, contextLines, maxResults, rootPath);
+    } else if (entry.isFile()) {
+      if (isBinary(entry.name)) continue;
+      if (filePattern && !matchesFilePattern(entry.name, filePattern)) continue;
+      const fullPath = join4(dirPath, entry.name);
+      const relPath = relative(rootPath, fullPath);
+      searchInFile(fullPath, relPath, regex, contextLines, maxResults, results);
+    }
+  }
+}
+function searchInFile(fullPath, displayPath, regex, contextLines, maxResults, results) {
+  let content;
+  try {
+    content = readFileSync6(fullPath, "utf-8");
+  } catch {
+    return;
+  }
+  if (content.length > 1e6) return;
+  const lines = content.split("\n");
+  regex.lastIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (results.length >= maxResults) return;
+    regex.lastIndex = 0;
+    if (regex.test(lines[i])) {
+      const result = {
+        file: displayPath,
+        lineNumber: i + 1,
+        lineText: lines[i].trimEnd()
+      };
+      if (contextLines > 0) {
+        result.contextBefore = [];
+        result.contextAfter = [];
+        for (let c = Math.max(0, i - contextLines); c < i; c++) {
+          result.contextBefore.push([c + 1, lines[c].trimEnd()]);
+        }
+        for (let c = i + 1; c <= Math.min(lines.length - 1, i + contextLines); c++) {
+          result.contextAfter.push([c + 1, lines[c].trimEnd()]);
+        }
+      }
+      results.push(result);
+    }
+  }
+}
+
+// src/tools/builtin/glob-files.ts
+import { readdirSync as readdirSync4, statSync as statSync3, existsSync as existsSync9 } from "fs";
+import { join as join5, relative as relative2, basename } from "path";
+var globFilesTool = {
+  definition: {
+    name: "glob_files",
+    description: `\u6309\u6587\u4EF6\u540D\u6216\u8DEF\u5F84\u6A21\u5F0F\u67E5\u627E\u6587\u4EF6\uFF0C\u8FD4\u56DE\u5339\u914D\u7684\u6587\u4EF6\u8DEF\u5F84\u5217\u8868\u3002\u9002\u7528\u4E8E\uFF1A
+- \u67E5\u627E\u6240\u6709\u67D0\u7C7B\u578B\u6587\u4EF6\uFF08\u5982 "**/*.ts" \u627E\u6240\u6709 TypeScript \u6587\u4EF6\uFF09
+- \u67E5\u627E\u7279\u5B9A\u540D\u79F0\u7684\u6587\u4EF6\uFF08\u5982 "**/index.ts" \u6216 "package.json"\uFF09
+- \u67E5\u627E\u67D0\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\uFF08\u5982 "src/components/**"\uFF09
+\u7ED3\u679C\u6309\u6700\u8FD1\u4FEE\u6539\u65F6\u95F4\u6392\u5E8F\u3002\u81EA\u52A8\u8DF3\u8FC7 node_modules\u3001dist\u3001.git \u7B49\u76EE\u5F55\u3002`,
+    parameters: {
+      pattern: {
+        type: "string",
+        description: 'glob \u6A21\u5F0F\uFF0C\u5982 "**/*.ts"\u3001"src/**/*.tsx"\u3001"**/package.json"\u3001"*.md"',
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "\u641C\u7D22\u6839\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55",
+        required: false
+      },
+      max_results: {
+        type: "number",
+        description: "\u6700\u5927\u8FD4\u56DE\u6587\u4EF6\u6570\uFF0C\u9ED8\u8BA4 100",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const pattern = String(args["pattern"] ?? "");
+    const rootPath = String(args["path"] ?? process.cwd());
+    const maxResults = Math.max(1, Number(args["max_results"] ?? 100));
+    if (!pattern) throw new Error("pattern is required");
+    if (!existsSync9(rootPath)) throw new Error(`Path not found: ${rootPath}`);
+    const regex = globToRegex(pattern);
+    const matches = [];
+    collectMatchingFiles(rootPath, rootPath, regex, matches, maxResults);
+    if (matches.length === 0) {
+      return `No files matched pattern: ${pattern}
+Searched in: ${rootPath}`;
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    const lines = [
+      `Found ${matches.length} file(s) matching: ${pattern}`,
+      `Searched in: ${rootPath}`,
+      "",
+      ...matches.map((m) => m.relPath)
+    ];
+    if (matches.length >= maxResults) {
+      lines.push("");
+      lines.push(`(Results truncated at ${maxResults}. Use max_results or narrow your pattern.)`);
+    }
+    return lines.join("\n");
+  }
+};
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "dist-cjs",
+  "release",
+  ".next",
+  "__pycache__",
+  ".cache",
+  "coverage",
+  ".nyc_output",
+  ".turbo",
+  ".vite",
+  "build",
+  "out"
+]);
+function globToRegex(pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  let regStr = "";
+  let i = 0;
+  while (i < normalized.length) {
+    const ch = normalized[i];
+    if (ch === "*" && normalized[i + 1] === "*") {
+      regStr += ".*";
+      i += 2;
+      if (normalized[i] === "/") i++;
+    } else if (ch === "*") {
+      regStr += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      regStr += "[^/]";
+      i++;
+    } else if (".+^${}()|[]\\".includes(ch)) {
+      regStr += "\\" + ch;
+      i++;
+    } else {
+      regStr += ch;
+      i++;
+    }
+  }
+  if (!normalized.includes("/")) {
+    return new RegExp(`(^|/)${regStr}$`, "i");
+  }
+  return new RegExp(`(^|/)${regStr}$`, "i");
+}
+function collectMatchingFiles(dirPath, rootPath, regex, results, maxResults) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = readdirSync4(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) break;
+    const fullPath = join5(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
+      collectMatchingFiles(fullPath, rootPath, regex, results, maxResults);
+    } else if (entry.isFile()) {
+      const relPath = relative2(rootPath, fullPath).replace(/\\/g, "/");
+      if (regex.test(relPath) || regex.test(basename(relPath))) {
+        try {
+          const stat = statSync3(fullPath);
+          results.push({ relPath, absPath: fullPath, mtime: stat.mtimeMs });
+        } catch {
+          results.push({ relPath, absPath: fullPath, mtime: 0 });
+        }
+      }
+    }
+  }
+}
+
+// src/tools/builtin/run-interactive.ts
+import { spawn } from "child_process";
+import { platform as platform2 } from "os";
+var IS_WINDOWS2 = platform2() === "win32";
+var runInteractiveTool = {
+  definition: {
+    name: "run_interactive",
+    description: '\u8FD0\u884C\u9700\u8981 stdin \u4EA4\u4E92\u7684\u547D\u4EE4\u884C\u7A0B\u5E8F\uFF08\u5982 Python \u731C\u6570\u6E38\u620F\u3001\u95EE\u7B54\u811A\u672C\u3001\u83DC\u5355\u7A0B\u5E8F\uFF09\u3002\u901A\u8FC7 stdin_lines \u6570\u7EC4\u63D0\u524D\u51C6\u5907\u597D\u6240\u6709\u8F93\u5165\u884C\uFF0C\u7A0B\u5E8F\u4F9D\u6B21\u6D88\u8D39\u5E76\u8FD4\u56DE\u5B8C\u6574\u8F93\u51FA\u3002\u3010\u91CD\u8981\u3011args \u53C2\u6570\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\uFF0C\u5982 ["workspace/guess.py"]\uFF0C\u4E0D\u80FD\u662F\u5B57\u7B26\u4E32\u3002\u3010\u731C\u6570\u7B56\u7565\u3011\u731C1-100\u7684\u6570\u7528\u4E8C\u5206\u6CD5\uFF1A\u4ECE50\u5F00\u59CB\uFF0C\u592A\u5927\u5219\u53D6\u4E2D\u95F4\u504F\u5C0F\u503C\uFF0C\u592A\u5C0F\u5219\u53D6\u4E2D\u95F4\u504F\u5927\u503C\uFF0C\u6700\u591A7\u6B21\u5FC5\u731C\u4E2D\u3002\u793A\u4F8B stdin_lines: ["50","25","37","43","40","41","n"]\uFF08"n"=\u4E0D\u518D\u73A9\u4E00\u6B21\uFF09\u3002Windows Python\u8DEF\u5F84: C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe',
+    parameters: {
+      executable: {
+        type: "string",
+        description: '\u53EF\u6267\u884C\u6587\u4EF6\u7684\u5B8C\u6574\u8DEF\u5F84\u6216\u547D\u4EE4\u540D\uFF0C\u5982 "python"\u3001"C:\\\\Users\\\\Jinzd\\\\anaconda3\\\\envs\\\\python312\\\\python.exe"\u3001"node"',
+        required: true
+      },
+      args: {
+        type: "array",
+        description: '\u4F20\u7ED9\u53EF\u6267\u884C\u6587\u4EF6\u7684\u53C2\u6570\u6570\u7EC4\uFF0C\u5982 ["workspace/guess.py"] \u6216 ["-c", "print(1)"]',
+        items: { type: "string" },
+        required: true
+      },
+      stdin_lines: {
+        type: "array",
+        description: '\u6309\u987A\u5E8F\u63D0\u4F9B\u7ED9\u7A0B\u5E8F stdin \u7684\u8F93\u5165\u884C\u6570\u7EC4\u3002\u4F8B\u5982\u731C\u6570\u6E38\u620F\u4E2D\u4F9D\u6B21\u8F93\u5165 ["50", "25", "37"]\u3002\u6BCF\u884C\u4F1A\u81EA\u52A8\u8FFD\u52A0\u6362\u884C\u7B26\u3002',
+        items: { type: "string" },
+        required: true
+      },
+      timeout: {
+        type: "number",
+        description: "\u6574\u4F53\u8D85\u65F6\u6BEB\u79D2\u6570\uFF0C\u9ED8\u8BA4 20000\uFF0820\u79D2\uFF09",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const executable = String(args["executable"] ?? "").trim();
+    const rawArgs = args["args"];
+    const cmdArgs = Array.isArray(rawArgs) ? rawArgs.map(String) : typeof rawArgs === "string" && rawArgs.trim() ? [rawArgs.trim()] : [];
+    const rawStdin = args["stdin_lines"];
+    const stdinLines = Array.isArray(rawStdin) ? rawStdin.map(String) : typeof rawStdin === "string" && rawStdin.trim() ? rawStdin.split(",").map((s) => s.trim()).filter(Boolean) : [];
+    const timeout = Number(args["timeout"] ?? 2e4);
+    if (!executable) {
+      throw new Error("executable is required");
+    }
+    const env = {
+      ...process.env,
+      // 强制 Python UTF-8 模式，修复 Windows 中文乱码
+      PYTHONUTF8: "1",
+      PYTHONIOENCODING: "utf-8",
+      PYTHONDONTWRITEBYTECODE: "1"
+    };
+    return new Promise((resolve4) => {
+      const child = spawn(executable, cmdArgs.map(String), {
+        cwd: process.cwd(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.setEncoding("utf-8");
+      child.stderr.setEncoding("utf-8");
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      let lineIdx = 0;
+      const writeNextLine = () => {
+        if (lineIdx < stdinLines.length && !child.stdin.destroyed) {
+          setTimeout(() => {
+            child.stdin.write(stdinLines[lineIdx++] + (IS_WINDOWS2 ? "\r\n" : "\n"));
+            writeNextLine();
+          }, 150);
+        } else if (!child.stdin.destroyed) {
+          child.stdin.end();
+        }
+      };
+      setTimeout(writeNextLine, 400);
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve4(`[Timeout after ${timeout}ms]
+${buildOutput(stdout, stderr)}`);
+      }, timeout);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const output = buildOutput(stdout, stderr);
+        if (code !== 0 && code !== null) {
+          resolve4(`Exit code ${code}:
+${output}`);
+        } else {
+          resolve4(output || "(no output)");
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve4(
+          `Failed to start process "${executable}": ${err.message}
+Hint: On Windows, use the full path to the executable, e.g.:
+  C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe`
+        );
+      });
+    });
+  }
+};
+function buildOutput(stdout, stderr) {
+  const parts = [];
+  if (stdout.trim()) parts.push(stdout);
+  if (stderr.trim()) parts.push(`[stderr]
+${stderr}`);
+  return parts.join("\n") || "(no output)";
+}
+
+// src/tools/builtin/web-fetch.ts
+function htmlToText(html) {
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<noscript[\s\S]*?<\/noscript>/gi, "").replace(/<svg[\s\S]*?<\/svg>/gi, "");
+  text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_m, lvl, content) => {
+    const prefix = "#".repeat(Number(lvl));
+    return `
+${prefix} ${stripTags(content).trim()}
+`;
+  });
+  text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_m, code) => {
+    return "\n```\n" + stripTags(code) + "\n```\n";
+  });
+  text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_m, item) => {
+    return `
+- ${stripTags(item).trim()}`;
+  });
+  text = text.replace(/<\/(p|div|section|article|blockquote|tr)>/gi, "\n");
+  text = text.replace(/<br\s*\/?>/gi, "\n");
+  text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_m, href, label) => {
+    const l = stripTags(label).trim();
+    if (href.startsWith("http") && l && l !== href) return `[${l}](${href})`;
+    return l || href;
+  });
+  text = stripTags(text);
+  text = text.replace(/\n{3,}/g, "\n\n");
+  text = text.split("\n").map((l) => l.trimEnd()).join("\n");
+  return text.trim();
+}
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, "");
+}
+function extractTitle(html) {
+  const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return m ? stripTags(m[1]).trim() : "";
+}
+function extractDescription(html) {
+  const m = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']+)["']/i) ?? html.match(/<meta[^>]+content=["']([^"']+)["'][^>]+name=["']description["']/i);
+  return m ? m[1].trim() : "";
+}
+var MAX_OUTPUT = 16e3;
+var webFetchTool = {
+  definition: {
+    name: "web_fetch",
+    description: "Fetch a URL and return its content as plain text / Markdown. Use this to read documentation, API references, READMEs, articles, or any public web page. Follows redirects automatically. Returns the first ~16000 characters of extracted text.",
+    parameters: {
+      url: {
+        type: "string",
+        description: "The full URL to fetch (must start with http:// or https://)",
+        required: true
+      },
+      selector: {
+        type: "string",
+        description: "Optional: keyword to search in the extracted text. If provided, returns only the paragraphs / sections that contain this keyword (case-insensitive).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const url = String(args["url"] ?? "").trim();
+    const selector = args["selector"] ? String(args["selector"]).trim() : "";
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      throw new Error(`Invalid URL: "${url}". URL must start with http:// or https://`);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2e4);
+    let rawHtml;
+    let finalUrl;
+    let contentType;
+    try {
+      const resp = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; ai-cli/1.0; +https://github.com/ai-cli)",
+          Accept: "text/html,application/xhtml+xml,text/plain,*/*",
+          "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8"
+        },
+        redirect: "follow"
+      });
+      clearTimeout(timeoutId);
+      finalUrl = resp.url;
+      contentType = resp.headers.get("content-type") ?? "";
+      if (!resp.ok) {
+        throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+      }
+      const buf = await resp.arrayBuffer();
+      rawHtml = new TextDecoder("utf-8", { fatal: false }).decode(buf.slice(0, 2e6));
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err.name === "AbortError") {
+        throw new Error(`Request timed out after 20s: ${url}`);
+      }
+      throw err;
+    }
+    let text;
+    if (contentType.includes("text/plain") || contentType.includes("application/json")) {
+      text = rawHtml;
+    } else {
+      const title = extractTitle(rawHtml);
+      const desc = extractDescription(rawHtml);
+      let body = htmlToText(rawHtml);
+      const header = [
+        title ? `# ${title}` : "",
+        desc ? `> ${desc}` : "",
+        `Source: ${finalUrl}`,
+        ""
+      ].filter(Boolean).join("\n");
+      text = header + "\n\n" + body;
+    }
+    if (selector) {
+      const lower = selector.toLowerCase();
+      const paragraphs = text.split("\n\n");
+      const matched = paragraphs.filter((p) => p.toLowerCase().includes(lower));
+      if (matched.length > 0) {
+        text = `[Filtered by keyword: "${selector}"]
+
+` + matched.join("\n\n");
+      } else {
+        text = `[No paragraphs contain keyword: "${selector}"]
+
+` + text;
+      }
+    }
+    if (text.length > MAX_OUTPUT) {
+      const kept = text.slice(0, MAX_OUTPUT);
+      text = kept + `
+
+... [\u5185\u5BB9\u5DF2\u622A\u65AD\uFF1A\u5171 ${text.length} \u5B57\u7B26\uFF0C\u4EC5\u8FD4\u56DE\u524D ${MAX_OUTPUT} \u5B57\u7B26\u3002\u5982\u9700\u67E5\u770B\u66F4\u591A\uFF0C\u8BF7\u4F7F\u7528 selector \u53C2\u6570\u7F29\u5C0F\u8303\u56F4] ...`;
+    }
+    return text;
+  }
+};
+
+// src/tools/builtin/save-last-response.ts
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname4 } from "path";
+var lastResponseStore = { content: "" };
+var saveLastResponseTool = {
+  definition: {
+    name: "save_last_response",
+    description: `\u751F\u6210\u5927\u578B\u6587\u6863\uFF08\u6A21\u8003\u8BD5\u5377\u3001\u62A5\u544A\u3001\u957F\u7BC7\u6587\u7AE0\u7B49\uFF09\u5E76\u4FDD\u5B58\u5230\u6587\u4EF6\u7684\u4E13\u7528\u5DE5\u5177\u3002
+
+\u3010\u6B63\u786E\u7528\u6CD5\u3011\u5F53\u7528\u6237\u8981\u6C42\u751F\u6210\u5E76\u4FDD\u5B58\u5927\u578B\u6587\u6863\u65F6\uFF0C\u76F4\u63A5\u8C03\u7528\u6B64\u5DE5\u5177\u5E76\u4F20\u5165\u76EE\u6807\u8DEF\u5F84\uFF1A
+  - \u7CFB\u7EDF\u4F1A\u81EA\u52A8\u53D1\u8D77\u6D41\u5F0F\u751F\u6210\u8BF7\u6C42\uFF0C\u5185\u5BB9\u540C\u65F6\u8F93\u51FA\u5230\u7EC8\u7AEF\u548C\u78C1\u76D8\uFF08tee \u6A21\u5F0F\uFF09
+  - \u65E0\u9700\u5148\u8F93\u51FA\u5185\u5BB9\u518D\u8C03\u7528\u2014\u2014\u7CFB\u7EDF\u81EA\u52A8\u5B8C\u6210"\u751F\u6210 + \u4FDD\u5B58"\u4E00\u6B65\u5230\u4F4D
+  - \u53C2\u6570\u53EA\u6709\u6587\u4EF6\u8DEF\u5F84\uFF0C\u4E0D\u901A\u8FC7\u53C2\u6570\u4F20\u9012\u5185\u5BB9\uFF0C\u5F7B\u5E95\u89C4\u907F API arguments \u622A\u65AD\u95EE\u9898
+
+\u3010\u7981\u6B62\u3011\u4E0D\u8981\u7528 write_file \u4FDD\u5B58\u5927\u5185\u5BB9\u2014\u2014write_file \u7684 content \u53C2\u6570\u5728\u5927\u6587\u6863\u65F6\u4F1A\u88AB API \u622A\u65AD\uFF0C\u5BFC\u81F4\u6587\u4EF6\u4E0D\u5B8C\u6574\u3002
+
+\u3010\u9002\u7528\u573A\u666F\u3011\u6A21\u8003\u8BD5\u5377\uFF08600-700\u884C\uFF0C15-25KB\uFF09\u3001\u6280\u672F\u62A5\u544A\u3001\u957F\u7BC7\u6587\u7AE0\u7B49\u8D85\u8FC7 2KB \u7684\u5185\u5BB9\u3002`,
+    parameters: {
+      path: {
+        type: "string",
+        description: "\u4FDD\u5B58\u6587\u4EF6\u7684\u8DEF\u5F84\uFF08\u542B\u6587\u4EF6\u540D\uFF09\uFF0C\u5982 exam_papers/20260221-01-\u6A21\u8003-\u8FDB\u9636.md",
+        required: true
+      }
+    },
+    dangerous: false
+    // getDangerLevel 中标记为 write
+  },
+  async execute(args) {
+    const filePath = String(args["path"] ?? "");
+    if (!filePath) throw new Error("path is required");
+    const content = lastResponseStore.content;
+    if (!content) {
+      throw new Error("\u6CA1\u6709\u53EF\u4FDD\u5B58\u7684\u5185\u5BB9\uFF1AAI \u5C1A\u672A\u4EA7\u751F\u4EFB\u4F55\u56DE\u590D\uFF0C\u6216\u4E0A\u6B21\u56DE\u590D\u4E3A\u7A7A\u3002");
+    }
+    undoStack.push(filePath, `save_last_response: ${filePath}`);
+    mkdirSync6(dirname4(filePath), { recursive: true });
+    writeFileSync7(filePath, content, "utf-8");
+    const lines = content.split("\n").length;
+    return `File saved: ${filePath} (${lines} lines, ${content.length} bytes)`;
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(bashTool);
+    this.register(readFileTool);
+    this.register(writeFileTool);
+    this.register(editFileTool);
+    this.register(listDirTool);
+    this.register(grepFilesTool);
+    this.register(globFilesTool);
+    this.register(runInteractiveTool);
+    this.register(webFetchTool);
+    this.register(saveLastResponseTool);
+  }
+  register(tool) {
+    this.tools.set(tool.definition.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** 返回所有工具的 schema，用于发送给 AI */
+  getDefinitions() {
+    return [...this.tools.values()].map((t) => t.definition);
+  }
+  listAll() {
+    return [...this.tools.values()];
+  }
+};
+
+// src/tools/executor.ts
+import chalk4 from "chalk";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+
+// src/tools/types.ts
+function getDangerLevel(toolName, args) {
+  if (toolName === "bash") {
+    const cmd = String(args["command"] ?? "");
+    if (/\brm\s+(-\w*f\w*|-\w*r\w*f\w*)\b|\brmdir\b|\bformat\b|\bmkfs\b/.test(cmd)) return "destructive";
+    if (/\bRemove-Item\b|\bri\s+.*-Recurse\b|\brd\s+\/s\b|\brmdir\s+\/s\b/.test(cmd)) return "destructive";
+    if (/\bdel\s+\S/.test(cmd) && !/\bmkdir\b/.test(cmd)) return "destructive";
+    if (/\becho\b.*>>?|\btee\b|\bcp\b|\bmv\b/.test(cmd)) return "write";
+    return "safe";
+  }
+  if (toolName === "write_file") return "write";
+  if (toolName === "edit_file") return "write";
+  if (toolName === "save_last_response") return "write";
+  if (toolName === "read_file" || toolName === "list_dir" || toolName === "grep_files" || toolName === "glob_files" || toolName === "run_interactive" || toolName === "web_fetch") return "safe";
+  return "write";
+}
+
+// src/tools/diff-utils.ts
+import chalk3 from "chalk";
+function renderDiff(oldText, newText, opts = {}) {
+  const contextLines = opts.contextLines ?? 3;
+  const maxLines = opts.maxLines ?? 120;
+  const filePath = opts.filePath ?? "";
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const hunks = computeHunks(oldLines, newLines, contextLines);
+  if (hunks.length === 0) {
+    return chalk3.dim("  (no changes)");
+  }
+  const output = [];
+  if (filePath) {
+    output.push(chalk3.bold.white(`--- ${filePath} (before)`));
+    output.push(chalk3.bold.white(`+++ ${filePath} (after)`));
+  }
+  let totalDisplayed = 0;
+  for (const hunk of hunks) {
+    if (totalDisplayed >= maxLines) {
+      output.push(chalk3.dim(`  ... (diff truncated, too many changes)`));
+      break;
+    }
+    output.push(
+      chalk3.cyan(
+        `@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@`
+      )
+    );
+    for (const line of hunk.lines) {
+      if (totalDisplayed >= maxLines) break;
+      totalDisplayed++;
+      if (line.type === "context") {
+        output.push(chalk3.dim(`  ${line.text}`));
+      } else if (line.type === "remove") {
+        output.push(chalk3.red(`- ${line.text}`));
+      } else {
+        output.push(chalk3.green(`+ ${line.text}`));
+      }
+    }
+  }
+  return output.join("\n");
+}
+function computeHunks(oldLines, newLines, contextLines) {
+  const edits = diffLines(oldLines, newLines);
+  if (edits.every((e) => e.type === "context")) return [];
+  const hunks = [];
+  let i = 0;
+  while (i < edits.length) {
+    if (edits[i].type === "context") {
+      i++;
+      continue;
+    }
+    const start = Math.max(0, i - contextLines);
+    let end = i;
+    while (end < edits.length) {
+      if (edits[end].type !== "context") {
+        end++;
+      } else {
+        let hasMoreChange = false;
+        for (let j = end + 1; j < Math.min(edits.length, end + contextLines * 2 + 1); j++) {
+          if (edits[j].type !== "context") {
+            hasMoreChange = true;
+            break;
+          }
+        }
+        if (hasMoreChange) {
+          end++;
+        } else {
+          break;
+        }
+      }
+    }
+    end = Math.min(edits.length, end + contextLines);
+    const hunkEdits = edits.slice(start, end);
+    let oldStart = 0;
+    let newStart = 0;
+    for (let k = 0; k < start; k++) {
+      if (edits[k].type !== "add") oldStart++;
+      if (edits[k].type !== "remove") newStart++;
+    }
+    let oldCount = 0;
+    let newCount = 0;
+    for (const e of hunkEdits) {
+      if (e.type !== "add") oldCount++;
+      if (e.type !== "remove") newCount++;
+    }
+    hunks.push({
+      oldStart,
+      oldCount,
+      newStart,
+      newCount,
+      lines: hunkEdits.map((e) => ({ type: e.type, text: e.text }))
+    });
+    i = end;
+  }
+  return hunks;
+}
+function diffLines(oldLines, newLines) {
+  const n = oldLines.length;
+  const m = newLines.length;
+  if (n * m > 25e4) {
+    return simpleDiff(oldLines, newLines);
+  }
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const result = [];
+  let i = n;
+  let j = m;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: "context", text: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "add", text: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: "remove", text: oldLines[i - 1] });
+      i--;
+    }
+  }
+  return result;
+}
+function simpleDiff(oldLines, newLines) {
+  const result = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  for (let i = 0; i < maxLen; i++) {
+    const o = oldLines[i];
+    const n = newLines[i];
+    if (o !== void 0 && n !== void 0) {
+      if (o === n) {
+        result.push({ type: "context", text: o });
+      } else {
+        result.push({ type: "remove", text: o });
+        result.push({ type: "add", text: n });
+      }
+    } else if (o !== void 0) {
+      result.push({ type: "remove", text: o });
+    } else if (n !== void 0) {
+      result.push({ type: "add", text: n });
+    }
+  }
+  return result;
+}
+
+// src/tools/executor.ts
+var MAX_TOOL_OUTPUT_CHARS = 12e3;
+function truncateOutput(content, toolName) {
+  if (content.length <= MAX_TOOL_OUTPUT_CHARS) return content;
+  const keepHead = Math.floor(MAX_TOOL_OUTPUT_CHARS * 0.7);
+  const keepTail = Math.floor(MAX_TOOL_OUTPUT_CHARS * 0.2);
+  const omitted = content.length - keepHead - keepTail;
+  const lines = content.split("\n").length;
+  const head = content.slice(0, keepHead);
+  const tail = content.slice(content.length - keepTail);
+  return head + `
+
+... [\u8F93\u51FA\u5DF2\u622A\u65AD\uFF1A\u5171 ${content.length} \u5B57\u7B26 / ${lines} \u884C\uFF0C\u7701\u7565\u4E86\u4E2D\u95F4 ${omitted} \u5B57\u7B26\u3002\u5982\u9700\u67E5\u770B\u5B8C\u6574\u5185\u5BB9\uFF0C\u8BF7\u4F7F\u7528 read_file \u5206\u6BB5\u8BFB\u53D6` + (toolName === "bash" ? "\uFF0C\u6216\u7F29\u5C0F\u547D\u4EE4\u8303\u56F4" : "") + `] ...
+
+` + tail;
+}
+var ToolExecutor = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  round = 0;
+  totalRounds = 0;
+  /** readline 接口引用，由 repl.ts 注入，用于 confirm() 读取用户输入 */
+  rl = null;
+  /**
+   * confirm() 进行中标志。
+   * repl.ts 的主循环 line handler 在此为 true 时忽略输入，
+   * 防止用户输入 "y"+Enter 被同时触发 once('line') 和主循环 on('line')。
+   */
+  confirming = false;
+  /** confirm() 的取消回调，由 SIGINT handler 调用 */
+  cancelConfirmFn = null;
+  /**
+   * 由外部（repl.ts SIGINT handler）调用，将当前 confirm() 等待视为用户按 N 取消。
+   * 若当前没有 confirm() 进行中，无操作。
+   */
+  cancelConfirm() {
+    if (this.cancelConfirmFn) {
+      this.cancelConfirmFn();
+    }
+  }
+  setRoundInfo(current, total) {
+    this.round = current;
+    this.totalRounds = total;
+  }
+  /**
+   * 注入 readline 接口，供 confirm() 使用。
+   * 必须在 start() 之前调用，rl 初始化后立即注入。
+   */
+  setReadline(rl) {
+    this.rl = rl;
+  }
+  async execute(call) {
+    const tool = this.registry.get(call.name);
+    if (!tool) {
+      return {
+        callId: call.id,
+        content: `Unknown tool: ${call.name}`,
+        isError: true
+      };
+    }
+    const dangerLevel = getDangerLevel(call.name, call.arguments);
+    if (dangerLevel === "destructive") {
+      const confirmed = await this.confirm(call, dangerLevel);
+      if (!confirmed) {
+        return {
+          callId: call.id,
+          content: "User cancelled the operation.",
+          isError: false
+        };
+      }
+    }
+    this.printToolCall(call);
+    this.printDiffPreview(call);
+    try {
+      const rawContent = await tool.execute(call.arguments);
+      const content = truncateOutput(rawContent, call.name);
+      const wasTruncated = content !== rawContent;
+      this.printToolResult(call.name, rawContent, false, wasTruncated);
+      return { callId: call.id, content, isError: false };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.printToolResult(call.name, message, true, false);
+      return { callId: call.id, content: message, isError: true };
+    }
+  }
+  async executeAll(calls) {
+    const results = [];
+    for (const call of calls) {
+      results.push(await this.execute(call));
+    }
+    return results;
+  }
+  printToolCall(call) {
+    const dangerLevel = getDangerLevel(call.name, call.arguments);
+    console.log();
+    const icon = dangerLevel === "write" ? chalk4.yellow("\u270E Tool: ") : chalk4.bold.cyan("\u2699 Tool: ");
+    const roundBadge = this.totalRounds > 0 ? chalk4.dim(` [${this.round}/${this.totalRounds}]`) : "";
+    console.log(icon + chalk4.white(call.name) + roundBadge);
+    for (const [key, val] of Object.entries(call.arguments)) {
+      let valStr;
+      if (Array.isArray(val)) {
+        const json = JSON.stringify(val);
+        valStr = json.length > 160 ? json.slice(0, 160) + "..." : json;
+      } else if (typeof val === "string" && val.length > 120) {
+        valStr = val.slice(0, 120) + "...";
+      } else {
+        valStr = String(val);
+      }
+      console.log(chalk4.gray(`  ${key}: `) + chalk4.white(valStr));
+    }
+  }
+  /**
+   * 对 write_file / edit_file 在执行前展示 diff 预览。
+   * - write_file：比较旧文件内容与新内容
+   * - edit_file (replace)：比较旧字符串与新字符串
+   * - edit_file (insert/delete)：显示操作摘要，不做 diff（变化明确）
+   */
+  printDiffPreview(call) {
+    if (call.name === "write_file") {
+      const filePath = String(call.arguments["path"] ?? "");
+      const newContent = String(call.arguments["content"] ?? "");
+      if (!filePath) return;
+      if (existsSync10(filePath)) {
+        let oldContent;
+        try {
+          oldContent = readFileSync7(filePath, "utf-8");
+        } catch {
+          return;
+        }
+        if (oldContent === newContent) {
+          console.log(chalk4.dim("  (file content unchanged)"));
+          return;
+        }
+        const diff = renderDiff(oldContent, newContent, { filePath, contextLines: 3 });
+        console.log(chalk4.dim("  \u2500\u2500 diff preview \u2500\u2500"));
+        console.log(diff);
+        console.log();
+      } else {
+        const lines = newContent.split("\n");
+        const preview = lines.slice(0, 20).map((l) => chalk4.green(`+ ${l}`)).join("\n");
+        const more = lines.length > 20 ? chalk4.dim(`
+  ... (+${lines.length - 20} more lines)`) : "";
+        console.log(chalk4.dim("  \u2500\u2500 new file preview \u2500\u2500"));
+        console.log(preview + more);
+        console.log();
+      }
+    } else if (call.name === "edit_file") {
+      const filePath = String(call.arguments["path"] ?? "");
+      if (!filePath || !existsSync10(filePath)) return;
+      const oldStr = call.arguments["old_str"];
+      const newStr = call.arguments["new_str"];
+      if (oldStr !== void 0) {
+        const diff = renderDiff(
+          String(oldStr),
+          String(newStr ?? ""),
+          { filePath, contextLines: 2 }
+        );
+        console.log(chalk4.dim("  \u2500\u2500 diff preview \u2500\u2500"));
+        console.log(diff);
+        console.log();
+      } else if (call.arguments["insert_after_line"] !== void 0) {
+        const line = Number(call.arguments["insert_after_line"]);
+        const insertContent = String(call.arguments["insert_content"] ?? "");
+        const insertLines = insertContent.split("\n");
+        const preview = insertLines.slice(0, 5).map((l) => chalk4.green(`+ ${l}`)).join("\n");
+        const more = insertLines.length > 5 ? chalk4.dim(`
+  ... (+${insertLines.length - 5} more lines)`) : "";
+        console.log(chalk4.dim(`  \u2500\u2500 insert after line ${line} \u2500\u2500`));
+        console.log(preview + more);
+        console.log();
+      } else if (call.arguments["delete_from_line"] !== void 0) {
+        const from = Number(call.arguments["delete_from_line"]);
+        const to = Number(call.arguments["delete_to_line"] ?? from);
+        let fileContent;
+        try {
+          fileContent = readFileSync7(filePath, "utf-8");
+        } catch {
+          return;
+        }
+        const fileLines = fileContent.split("\n");
+        const deleted = fileLines.slice(from - 1, to);
+        const preview = deleted.slice(0, 5).map((l) => chalk4.red(`- ${l}`)).join("\n");
+        const more = deleted.length > 5 ? chalk4.dim(`
+  ... (-${deleted.length - 5} more lines)`) : "";
+        console.log(chalk4.dim(`  \u2500\u2500 delete lines ${from}\u2013${to} \u2500\u2500`));
+        console.log(preview + more);
+        console.log();
+      }
+    }
+  }
+  printToolResult(name, content, isError, wasTruncated) {
+    if (isError) {
+      console.log(chalk4.red(`\u26A0 ${name} error: `) + chalk4.gray(content.slice(0, 300)));
+    } else {
+      const lines = content.split("\n");
+      const maxLines = name === "run_interactive" ? 40 : 8;
+      const preview = lines.slice(0, maxLines).join("\n");
+      const moreLines = lines.length > maxLines ? chalk4.gray(`
+  ... (${lines.length - maxLines} more lines)`) : "";
+      const truncatedNote = wasTruncated ? chalk4.yellow(`
+  \u26A1 \u8F93\u51FA\u5DF2\u622A\u65AD\u81F3 ${MAX_TOOL_OUTPUT_CHARS} \u5B57\u7B26\u540E\u8FD4\u56DE\u7ED9 AI`) : "";
+      console.log(chalk4.green("\u2713 Result: ") + chalk4.gray(preview) + moreLines + truncatedNote);
+    }
+    console.log();
+  }
+  confirm(call, level) {
+    const color = level === "destructive" ? chalk4.red : chalk4.yellow;
+    const label = level === "destructive" ? "\u26A0 DESTRUCTIVE" : "\u270E Write";
+    console.log();
+    console.log(color(`${label} operation: `) + chalk4.bold(call.name));
+    for (const [key, val] of Object.entries(call.arguments)) {
+      const valStr = typeof val === "string" && val.length > 200 ? val.slice(0, 200) + "..." : String(val);
+      console.log(chalk4.gray(`  ${key}: `) + valStr);
+    }
+    if (!this.rl) {
+      process.stdout.write(color("No readline: auto-rejected.\n"));
+      return Promise.resolve(false);
+    }
+    const rl = this.rl;
+    const rlAny = rl;
+    const savedOutput = rlAny.output;
+    rlAny.output = process.stdout;
+    rl.resume();
+    process.stdout.write(color("Proceed? [y/N] (type y + Enter to confirm) "));
+    this.confirming = true;
+    return new Promise((resolve4) => {
+      const cleanup = (answer) => {
+        rl.removeListener("line", onLine);
+        this.cancelConfirmFn = null;
+        rl.pause();
+        rlAny.output = savedOutput;
+        this.confirming = false;
+        resolve4(answer === "y");
+      };
+      const onLine = (line) => cleanup(line.trim().toLowerCase());
+      this.cancelConfirmFn = () => {
+        process.stdout.write(chalk4.gray("\n(cancelled)\n"));
+        cleanup("n");
+      };
+      rl.once("line", onLine);
+    });
+  }
+};
+
+// src/tools/git-context.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { join as join6 } from "path";
+function runGit(cmd, cwd) {
+  try {
+    return execSync2(`git ${cmd}`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function getGitContext(cwd = process.cwd()) {
+  if (!existsSync11(join6(cwd, ".git"))) {
+    const result = runGit("rev-parse --git-dir", cwd);
+    if (!result) return null;
+  }
+  const branch = runGit("rev-parse --abbrev-ref HEAD", cwd);
+  if (!branch) return null;
+  const statusOutput = runGit("status --porcelain", cwd) ?? "";
+  const statusLines = statusOutput ? statusOutput.split("\n").filter(Boolean) : [];
+  const stagedFiles = [];
+  const changedFiles = [];
+  for (const line of statusLines) {
+    const xy = line.slice(0, 2);
+    const file = line.slice(3).trim();
+    const indexStatus = xy[0];
+    const workStatus = xy[1];
+    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
+      stagedFiles.push(`${indexStatus} ${file}`);
+    }
+    if (workStatus && workStatus !== " ") {
+      changedFiles.push(`${workStatus} ${file}`);
+    }
+  }
+  const logOutput = runGit("log --oneline -3", cwd) ?? "";
+  const recentCommits = logOutput ? logOutput.split("\n").filter(Boolean) : [];
+  const unpushedOutput = runGit("log @{u}..HEAD --oneline 2>/dev/null", cwd);
+  const hasUnpushed = unpushedOutput !== null && unpushedOutput.trim().length > 0;
+  return {
+    branch,
+    changedFiles,
+    stagedFiles,
+    recentCommits,
+    hasUnpushed
+  };
+}
+function formatGitContextForPrompt(ctx) {
+  const lines = ["# Git Repository Status", ""];
+  lines.push(`- **Branch**: \`${ctx.branch}\``);
+  if (ctx.stagedFiles.length > 0) {
+    lines.push(`- **Staged** (${ctx.stagedFiles.length} files):`);
+    for (const f of ctx.stagedFiles.slice(0, 10)) {
+      lines.push(`  - ${f}`);
+    }
+    if (ctx.stagedFiles.length > 10) {
+      lines.push(`  - ... and ${ctx.stagedFiles.length - 10} more`);
+    }
+  }
+  if (ctx.changedFiles.length > 0) {
+    lines.push(`- **Modified** (${ctx.changedFiles.length} files):`);
+    for (const f of ctx.changedFiles.slice(0, 10)) {
+      lines.push(`  - ${f}`);
+    }
+    if (ctx.changedFiles.length > 10) {
+      lines.push(`  - ... and ${ctx.changedFiles.length - 10} more`);
+    }
+  }
+  if (ctx.stagedFiles.length === 0 && ctx.changedFiles.length === 0) {
+    lines.push("- **Working tree**: clean");
+  }
+  if (ctx.recentCommits.length > 0) {
+    lines.push("- **Recent commits**:");
+    for (const c of ctx.recentCommits) {
+      lines.push(`  - ${c}`);
+    }
+  }
+  if (ctx.hasUnpushed) {
+    lines.push("- \u26A0\uFE0F Has unpushed commits");
+  }
+  return lines.join("\n");
+}
+
+// src/repl/repl.ts
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function parseAtReferences(input, cwd) {
+  const atPattern = /@(?:"([^"]+)"|'([^']+)'|(\S+))/g;
+  const refs = [];
+  const imageParts = [];
+  let textBody = input;
+  let match;
+  while ((match = atPattern.exec(input)) !== null) {
+    const rawPath = match[1] ?? match[2] ?? match[3] ?? "";
+    const absPath = resolve3(cwd, rawPath);
+    const ext = extname2(rawPath).toLowerCase();
+    const mime = IMAGE_MIME[ext];
+    if (!existsSync12(absPath)) {
+      refs.push({ path: rawPath, type: "notfound" });
+      continue;
+    }
+    if (mime) {
+      const data = readFileSync8(absPath).toString("base64");
+      imageParts.push({
+        type: "image_url",
+        image_url: { url: `data:${mime};base64,${data}` }
+      });
+      refs.push({ path: rawPath, type: "image" });
+      textBody = textBody.replace(match[0], "").trim();
+    } else {
+      const content = readFileSync8(absPath, "utf-8");
+      const inlined = `
+
+[File: ${rawPath}]
+\`\`\`
+${content}
+\`\`\``;
+      textBody = textBody.replace(match[0], inlined);
+      refs.push({ path: rawPath, type: "text" });
+    }
+  }
+  const parts = [];
+  if (textBody.trim()) {
+    parts.push({ type: "text", text: textBody.trim() });
+  }
+  parts.push(...imageParts);
+  return { parts, hasImage: imageParts.length > 0, refs };
+}
+var MAX_TOOL_ROUNDS = 20;
+var CONTEXT_FILE_CANDIDATES = ["AICLI.md", "CLAUDE.md", ".aicli/context.md"];
+var Repl = class {
+  constructor(providers, sessions, config, events) {
+    this.providers = providers;
+    this.sessions = sessions;
+    this.config = config;
+    this.events = events;
+    this.renderer = new Renderer();
+    this.commands = new CommandRegistry();
+    for (const cmd of createDefaultCommands()) {
+      this.commands.register(cmd);
+    }
+    this.currentProvider = config.getDefaultProvider();
+    if (!providers.has(this.currentProvider)) {
+      const first = providers.getFirstAvailable();
+      if (!first) throw new Error("No providers configured");
+      this.currentProvider = first.info.id;
+    }
+    const defaultModels = config.get("defaultModels");
+    this.currentModel = defaultModels[this.currentProvider] ?? providers.get(this.currentProvider).info.defaultModel;
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+    this.toolRegistry = new ToolRegistry();
+    this.toolExecutor = new ToolExecutor(this.toolRegistry);
+    this.toolExecutor.setReadline(this.rl);
+  }
+  rl;
+  currentProvider;
+  currentModel;
+  running = false;
+  renderer;
+  commands;
+  toolRegistry;
+  toolExecutor;
+  /** 运行时有效的 system prompt（合并了项目上下文 + 用户配置） */
+  activeSystemPrompt;
+  /** 当前加载的项目上下文文件路径（用于 /context 命令显示状态） */
+  contextFilePath = null;
+  /** 本次会话累计 token 用量 */
+  sessionTokenUsage = { inputTokens: 0, outputTokens: 0 };
+  /** 启动时检测到的 Git 分支（无 git 仓库时为 null） */
+  gitBranch = null;
+  /**
+   * 交互式列表选择器进行中标志。
+   * 与 toolExecutor.confirming 类似：主循环 line handler 在此为 true 时忽略 line 事件，
+   * 防止 selectFromList 结束后 stdin.pause()/resume() 释放的残留字节被解析为新命令。
+   */
+  selecting = false;
+  /**
+   * 查找并读取项目上下文文件，返回其内容。
+   * 优先级：config.contextFile（若非 'auto'）> AICLI.md > CLAUDE.md > .aicli/context.md
+   * 返回 { content, filePath } 或 null（未找到 / 已禁用）
+   */
+  loadProjectContext() {
+    const setting = this.config.get("contextFile");
+    if (setting === false) return null;
+    const cwd = process.cwd();
+    if (setting !== "auto") {
+      const fullPath = join7(cwd, setting);
+      if (existsSync12(fullPath)) {
+        const content = readFileSync8(fullPath, "utf-8").trim();
+        if (content) return { content, filePath: setting };
+      }
+      return null;
+    }
+    for (const candidate of CONTEXT_FILE_CANDIDATES) {
+      const fullPath = join7(cwd, candidate);
+      if (existsSync12(fullPath)) {
+        const content = readFileSync8(fullPath, "utf-8").trim();
+        if (content) return { content, filePath: candidate };
+      }
+    }
+    return null;
+  }
+  /**
+   * 将项目上下文内容合并到 system prompt。
+   * 合并顺序：用户 systemPrompt → 项目上下文（AICLI.md） → Git 状态
+   */
+  buildSystemPromptWithContext(projectContext, gitContextStr = null) {
+    const userPrompt = this.config.get("session").systemPrompt;
+    const parts = [];
+    if (userPrompt) parts.push(userPrompt);
+    if (projectContext) parts.push(`# Project Context
+
+${projectContext}`);
+    if (gitContextStr) parts.push(gitContextStr);
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
+  }
+  /** 每次请求时动态生成含当前日期时间的 system prompt。 */
+  buildCurrentSystemPrompt() {
+    const now = /* @__PURE__ */ new Date();
+    const WEEKDAYS = ["\u661F\u671F\u65E5", "\u661F\u671F\u4E00", "\u661F\u671F\u4E8C", "\u661F\u671F\u4E09", "\u661F\u671F\u56DB", "\u661F\u671F\u4E94", "\u661F\u671F\u516D"];
+    const pad = (n) => String(n).padStart(2, "0");
+    const dateStr = `${now.getFullYear()}\u5E74${pad(now.getMonth() + 1)}\u6708${pad(now.getDate())}\u65E5 ${WEEKDAYS[now.getDay()]}`;
+    const timeStr = `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+    const dateTimeInfo = `\u5F53\u524D\u65E5\u671F\u65F6\u95F4\uFF1A${dateStr} ${timeStr}`;
+    if (this.activeSystemPrompt) {
+      return `${dateTimeInfo}
+
+---
+
+${this.activeSystemPrompt}`;
+    }
+    return dateTimeInfo;
+  }
+  refreshPrompt() {
+    const promptStr = chalk5.green(`[${this.currentProvider}]`) + chalk5.white(" > ");
+    this.rl.setPrompt(promptStr);
+  }
+  showPrompt() {
+    this.refreshPrompt();
+    const rlDbg = this.rl;
+    rlDbg.prevRows = 0;
+    if (rlDbg.line) {
+      process.stderr.write(`[DBG showPrompt] line=${JSON.stringify(rlDbg.line)}
+`);
+    }
+    this.rl.prompt();
+  }
+  async start() {
+    this.running = true;
+    this.sessions.createSession(this.currentProvider, this.currentModel);
+    this.events.emit("session.start", { sessionId: this.sessions.current.id });
+    const ctx = this.loadProjectContext();
+    this.contextFilePath = ctx?.filePath ?? null;
+    const gitCtx = getGitContext();
+    this.gitBranch = gitCtx?.branch ?? null;
+    const gitContextStr = gitCtx ? formatGitContextForPrompt(gitCtx) : null;
+    this.activeSystemPrompt = this.buildSystemPromptWithContext(
+      ctx?.content ?? null,
+      gitContextStr
+    );
+    const welcomeProvider = this.providers.get(this.currentProvider);
+    const welcomeModelInfo = welcomeProvider?.info.models.find((m) => m.id === this.currentModel);
+    this.renderer.printWelcome(this.currentProvider, this.currentModel, welcomeModelInfo?.contextWindow);
+    if (ctx) {
+      process.stdout.write(
+        chalk5.dim(`  \u{1F4C4} Project context loaded: ${ctx.filePath} (${ctx.content.length} chars)
+`)
+      );
+    }
+    if (gitCtx) {
+      const statusSummary = gitCtx.stagedFiles.length + gitCtx.changedFiles.length > 0 ? chalk5.yellow(` (${gitCtx.stagedFiles.length} staged, ${gitCtx.changedFiles.length} modified)`) : chalk5.dim(" (clean)");
+      process.stdout.write(
+        chalk5.dim(`  \u{1F500} Git branch: `) + chalk5.cyan(gitCtx.branch) + statusSummary + "\n"
+      );
+    }
+    this.rl.on("SIGINT", () => {
+      if (this.toolExecutor.confirming) {
+        this.toolExecutor.cancelConfirm();
+        return;
+      }
+      this.handleExit();
+    });
+    this.showPrompt();
+    await new Promise((resolve4) => {
+      let processing = false;
+      this.rl.on("line", async (line) => {
+        if (this.toolExecutor.confirming) return;
+        if (this.selecting) return;
+        const input = line.trim();
+        if (!input) {
+          this.showPrompt();
+          return;
+        }
+        processing = true;
+        this.rl.pause();
+        const rlAny = this.rl;
+        const savedOutput = rlAny.output;
+        rlAny.output = null;
+        try {
+          if (input.startsWith("/")) {
+            await this.handleCommand(input);
+          } else {
+            await this.handleChat(input);
+          }
+        } catch (err) {
+          this.renderer.renderError(err);
+        } finally {
+          processing = false;
+        }
+        if (this.running) {
+          rlAny.output = savedOutput;
+          const rlInternal = this.rl;
+          rlInternal.line = "";
+          rlInternal.cursor = 0;
+          rlInternal.paused = false;
+          process.stdin.resume();
+          this.showPrompt();
+        } else {
+          resolve4();
+        }
+      });
+      this.rl.on("close", () => {
+        if (!processing) {
+          resolve4();
+        }
+      });
+    });
+  }
+  async handleChat(userInput) {
+    const session = this.sessions.current;
+    const { parts, hasImage, refs } = parseAtReferences(userInput, process.cwd());
+    for (const ref of refs) {
+      if (ref.type === "notfound") {
+        process.stdout.write(chalk5.yellow(`  \u26A0 File not found: ${ref.path}
+`));
+      } else if (ref.type === "image") {
+        process.stdout.write(chalk5.dim(`  \u{1F4CE} Image: ${ref.path}
+`));
+      } else {
+        process.stdout.write(chalk5.dim(`  \u{1F4C4} File: ${ref.path}
+`));
+      }
+    }
+    const messageContent = parts.length > 0 ? parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts : userInput;
+    if (hasImage) {
+      const visionHint = this.getVisionModelHint();
+      if (visionHint) {
+        process.stdout.write(
+          chalk5.yellow(`  \u2716 Vision not supported \u2013 ${visionHint}
+`)
+        );
+        return;
+      }
+      process.stdout.write(
+        chalk5.dim(`  \u{1F5BC}  Vision request \u2013 sending image to ${this.currentProvider}
+`)
+      );
+    }
+    session.addMessage({
+      role: "user",
+      content: messageContent,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this.events.emit("message.before", { input: userInput });
+    try {
+      const provider = this.providers.get(this.currentProvider);
+      const supportsTools = "chatWithTools" in provider;
+      if (supportsTools) {
+        await this.handleChatWithTools(
+          provider,
+          session.messages
+        );
+      } else {
+        await this.handleChatSimple(provider, session.messages);
+      }
+      if (this.config.get("session").autoSave) {
+        await this.sessions.save();
+      }
+    } catch (err) {
+      this.renderer.renderError(err);
+    }
+  }
+  /**
+   * 当当前模型不支持视觉输入时，返回提示字符串（告知用户切换哪个模型）。
+   * 若当前模型已支持（model ID 含 vision），返回 null（不需要提示）。
+   */
+  getVisionModelHint() {
+    const model = this.currentModel;
+    const provider = this.currentProvider;
+    if (model.includes("vision") || model.includes("vl") || model.endsWith(".6v") || // glm-4.6v
+    model.endsWith("-v")) return null;
+    if (provider === "kimi") {
+      if (model.startsWith("moonshot-v1-")) {
+        const visionModel = model + "-vision-preview";
+        return `model "${model}" does not support images. Use /model ${visionModel}`;
+      }
+      return null;
+    }
+    if (provider === "zhipu") {
+      return `model "${model}" does not support images. Use /model glm-4.6v`;
+    }
+    return `model "${model}" may not support image input`;
+  }
+  /**
+   * 从 config.modelParams 读取当前模型的推理参数（temperature / maxTokens / timeout / thinking）。
+   * 用户可在 config.json 的 modelParams 字段按模型 ID 配置，例如：
+   *   "modelParams": { "glm-5": { "temperature": 1.0, "maxTokens": 65536, "thinking": true } }
+   */
+  getModelParams() {
+    const allParams = this.config.get("modelParams");
+    return allParams[this.currentModel] ?? {};
+  }
+  async handleChatSimple(provider, messages) {
+    const session = this.sessions.current;
+    const useStreaming = this.config.get("ui").streaming;
+    const modelParams = this.getModelParams();
+    if (useStreaming) {
+      const stream = provider.chatStream({
+        messages,
+        model: this.currentModel,
+        systemPrompt: this.buildCurrentSystemPrompt(),
+        stream: true,
+        temperature: modelParams.temperature,
+        maxTokens: modelParams.maxTokens,
+        timeout: modelParams.timeout,
+        thinking: modelParams.thinking
+      });
+      const { content, usage } = await this.renderer.renderStream(stream);
+      lastResponseStore.content = content;
+      session.addMessage({ role: "assistant", content, timestamp: /* @__PURE__ */ new Date() });
+      this.events.emit("message.after", { content });
+      if (usage) {
+        this.sessionTokenUsage.inputTokens += usage.inputTokens;
+        this.sessionTokenUsage.outputTokens += usage.outputTokens;
+        this.renderer.renderUsage(usage, this.sessionTokenUsage);
+      }
+    } else {
+      const spinner = this.renderer.showSpinner("Thinking...");
+      try {
+        const response = await provider.chat({
+          messages,
+          model: this.currentModel,
+          systemPrompt: this.buildCurrentSystemPrompt(),
+          stream: false,
+          temperature: modelParams.temperature,
+          maxTokens: modelParams.maxTokens,
+          timeout: modelParams.timeout,
+          thinking: modelParams.thinking
+        });
+        spinner.stop();
+        this.renderer.renderResponse(response.content);
+        lastResponseStore.content = response.content;
+        session.addMessage({ role: "assistant", content: response.content, timestamp: /* @__PURE__ */ new Date() });
+        this.events.emit("message.after", { content: response.content });
+        if (response.usage) {
+          this.sessionTokenUsage.inputTokens += response.usage.inputTokens;
+          this.sessionTokenUsage.outputTokens += response.usage.outputTokens;
+          this.renderer.renderUsage(response.usage, this.sessionTokenUsage);
+        }
+      } finally {
+        spinner.stop();
+      }
+    }
+  }
+  async handleChatWithTools(provider, messages) {
+    const session = this.sessions.current;
+    const toolDefs = this.toolRegistry.getDefinitions();
+    const apiMessages = [...messages];
+    const extraMessages = [];
+    const systemPrompt = this.buildCurrentSystemPrompt();
+    const modelParams = this.getModelParams();
+    const useStreaming = this.config.get("ui").streaming;
+    const spinner = this.renderer.showSpinner("Thinking...");
+    const roundUsage = { inputTokens: 0, outputTokens: 0 };
+    try {
+      for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+        this.toolExecutor.setRoundInfo(round + 1, MAX_TOOL_ROUNDS);
+        const result = await provider.chatWithTools(
+          {
+            messages: apiMessages,
+            model: this.currentModel,
+            systemPrompt,
+            stream: false,
+            temperature: modelParams.temperature,
+            maxTokens: modelParams.maxTokens,
+            timeout: modelParams.timeout,
+            thinking: modelParams.thinking,
+            ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+          },
+          toolDefs
+        );
+        if (result.usage) {
+          roundUsage.inputTokens += result.usage.inputTokens;
+          roundUsage.outputTokens += result.usage.outputTokens;
+        }
+        if ("content" in result) {
+          spinner.stop();
+          let finalContent;
+          if (useStreaming) {
+            const stream = provider.chatStream({
+              messages: apiMessages,
+              model: this.currentModel,
+              systemPrompt,
+              stream: true,
+              temperature: modelParams.temperature,
+              maxTokens: modelParams.maxTokens,
+              timeout: modelParams.timeout,
+              thinking: modelParams.thinking,
+              ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+            });
+            const { content: streamContent, usage: streamUsage } = await this.renderer.renderStream(stream);
+            finalContent = streamContent;
+            if (streamUsage) {
+              roundUsage.inputTokens += streamUsage.inputTokens;
+              roundUsage.outputTokens += streamUsage.outputTokens;
+            }
+          } else {
+            this.renderer.renderResponse(result.content);
+            finalContent = result.content;
+          }
+          lastResponseStore.content = finalContent;
+          session.addMessage({
+            role: "assistant",
+            content: finalContent,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+          this.events.emit("message.after", { content: finalContent });
+          if (roundUsage.inputTokens > 0 || roundUsage.outputTokens > 0) {
+            this.sessionTokenUsage.inputTokens += roundUsage.inputTokens;
+            this.sessionTokenUsage.outputTokens += roundUsage.outputTokens;
+            this.renderer.renderUsage(roundUsage, this.sessionTokenUsage);
+          }
+          return;
+        }
+        spinner.stop();
+        const saveLastResponseCall = result.toolCalls.find((tc) => tc.name === "save_last_response");
+        if (saveLastResponseCall) {
+          const saveToFile = String(saveLastResponseCall.arguments["path"] ?? "");
+          if (!saveToFile) {
+          } else {
+            const genStream = provider.chatStream({
+              messages: apiMessages,
+              model: this.currentModel,
+              systemPrompt,
+              stream: true,
+              temperature: modelParams.temperature,
+              maxTokens: modelParams.maxTokens,
+              timeout: modelParams.timeout,
+              thinking: modelParams.thinking,
+              ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+            });
+            const { content: genContent, usage: genUsage } = await this.renderer.renderStream(
+              genStream,
+              { saveToFile }
+            );
+            lastResponseStore.content = genContent;
+            if (genUsage) {
+              roundUsage.inputTokens += genUsage.inputTokens;
+              roundUsage.outputTokens += genUsage.outputTokens;
+            }
+            session.addMessage({ role: "assistant", content: genContent, timestamp: /* @__PURE__ */ new Date() });
+            this.events.emit("message.after", { content: genContent });
+            const lines = genContent.split("\n").length;
+            const bytes = Buffer.byteLength(genContent, "utf-8");
+            const syntheticResults = result.toolCalls.map((tc) => ({
+              callId: tc.id,
+              content: tc.name === "save_last_response" ? `File saved: ${saveToFile} (${lines} lines, ${bytes} bytes)` : `[skipped: file already saved by tee streaming]`,
+              isError: false
+            }));
+            const newMsgs2 = provider.buildToolResultMessages(result.toolCalls, syntheticResults);
+            extraMessages.push(...newMsgs2);
+            if (roundUsage.inputTokens > 0 || roundUsage.outputTokens > 0) {
+              this.sessionTokenUsage.inputTokens += roundUsage.inputTokens;
+              this.sessionTokenUsage.outputTokens += roundUsage.outputTokens;
+              this.renderer.renderUsage(roundUsage, this.sessionTokenUsage);
+            }
+            return;
+          }
+        }
+        const toolResults = await this.toolExecutor.executeAll(result.toolCalls);
+        const newMsgs = provider.buildToolResultMessages(result.toolCalls, toolResults);
+        extraMessages.push(...newMsgs);
+        const nextRound = round + 2;
+        spinner.start(
+          nextRound <= MAX_TOOL_ROUNDS ? `Thinking... (round ${nextRound}/${MAX_TOOL_ROUNDS})` : "Thinking..."
+        );
+      }
+      spinner.stop();
+      this.renderer.renderError(
+        `Reached maximum tool call rounds (${MAX_TOOL_ROUNDS}). Stopping.`
+      );
+    } finally {
+      spinner.stop();
+    }
+  }
+  async handleCommand(input) {
+    const parts = input.slice(1).split(" ");
+    const cmdName = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const cmd = this.commands.get(cmdName);
+    if (!cmd) {
+      this.renderer.renderError(
+        `Unknown command: /${cmdName}. Type /help for available commands.`
+      );
+      return;
+    }
+    const ctx = {
+      providers: this.providers,
+      sessions: this.sessions,
+      config: this.config,
+      renderer: this.renderer,
+      tools: this.toolRegistry,
+      // 交互式列表选择器：命令执行期间 rl 已 pause + output=null，
+      // selectFromList 直接用 process.stdout.write，完全绕过 readline。
+      // rl.output 保持 null，避免 readline terminal 模式把 line buffer
+      // ("/provider" 等命令字符串) 重绘到 stdout，造成界面污染。
+      select: (prompt, items, initialIndex) => {
+        this.selecting = true;
+        return selectFromList(prompt, items, initialIndex).finally(() => {
+          const rlInternal = this.rl;
+          rlInternal.line = "";
+          rlInternal.cursor = 0;
+          process.stdin.pause();
+          setImmediate(() => {
+            this.selecting = false;
+          });
+        });
+      },
+      setProvider: (id, model) => {
+        this.currentProvider = id;
+        this.currentModel = model ?? this.config.get("defaultModels")[id] ?? this.providers.get(id).info.defaultModel;
+        this.refreshPrompt();
+        this.events.emit("provider.switch", {
+          providerId: id,
+          model: this.currentModel
+        });
+      },
+      getCurrentProvider: () => this.currentProvider,
+      getCurrentModel: () => this.currentModel,
+      getContextFilePath: () => this.contextFilePath,
+      getActiveSystemPrompt: () => this.buildCurrentSystemPrompt(),
+      reloadContext: () => {
+        const projectCtx = this.loadProjectContext();
+        this.contextFilePath = projectCtx?.filePath ?? null;
+        const gitCtx = getGitContext();
+        this.gitBranch = gitCtx?.branch ?? null;
+        const gitContextStr = gitCtx ? formatGitContextForPrompt(gitCtx) : null;
+        this.activeSystemPrompt = this.buildSystemPromptWithContext(
+          projectCtx?.content ?? null,
+          gitContextStr
+        );
+      },
+      getSessionTokenUsage: () => ({ ...this.sessionTokenUsage }),
+      getGitBranch: () => this.gitBranch,
+      exit: () => this.handleExit()
+    };
+    await cmd.execute(args, ctx);
+  }
+  handleExit() {
+    this.running = false;
+    const sessionId = this.sessions.current?.id;
+    if (sessionId) {
+      this.events.emit("session.end", { sessionId });
+    }
+    this.rl.close();
+    console.log(chalk5.gray("\nGoodbye!"));
+    process.exit(0);
+  }
+};
+
+// src/repl/setup-wizard.ts
+import { password, select } from "@inquirer/prompts";
+import chalk6 from "chalk";
+var PROVIDERS = [
+  { value: "claude", name: "Claude (Anthropic)" },
+  { value: "gemini", name: "Gemini (Google)" },
+  { value: "deepseek", name: "DeepSeek" },
+  { value: "zhipu", name: "\u667A\u8C31\u6E05\u8A00 (GLM)" },
+  { value: "kimi", name: "Kimi (Moonshot AI)" }
+];
+function maskKey(key) {
+  if (key.length <= 10) return "****";
+  return key.slice(0, 6) + "****" + key.slice(-4);
+}
+var SetupWizard = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async runFirstRun() {
+    console.log(chalk6.bold.cyan("\nWelcome to ai-cli!\n"));
+    console.log("Let's set up your first AI provider.\n");
+    try {
+      const providerId = await select({
+        message: "Which AI provider do you want to set up first?",
+        choices: PROVIDERS
+      });
+      await this.setupProvider(providerId);
+      this.config.set("defaultProvider", providerId);
+      this.config.save();
+      console.log(chalk6.green("\nSetup complete! Starting ai-cli...\n"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async runFull() {
+    console.log(chalk6.bold.cyan("\nai-cli Configuration\n"));
+    let running = true;
+    while (running) {
+      const action = await select({
+        message: "What would you like to configure?",
+        choices: [
+          { value: "apikey", name: "Manage API key for a provider" },
+          { value: "default", name: "Change default provider" },
+          { value: "done", name: "Done" }
+        ]
+      });
+      if (action === "apikey") {
+        const choicesWithStatus = PROVIDERS.map((p) => {
+          const existingKey = this.config.getApiKey(p.value);
+          const status = existingKey ? chalk6.green(`[${maskKey(existingKey)}]`) : chalk6.gray("[\u672A\u914D\u7F6E]");
+          return { value: p.value, name: `${p.name}  ${status}` };
+        });
+        const providerId = await select({
+          message: "Select provider:",
+          choices: choicesWithStatus
+        });
+        await this.setupProvider(providerId);
+      } else if (action === "default") {
+        const providerId = await select({
+          message: "Select default provider:",
+          choices: PROVIDERS
+        });
+        this.config.set("defaultProvider", providerId);
+        this.config.save();
+        console.log(chalk6.green(`Default provider set to: ${providerId}
+`));
+      } else {
+        running = false;
+      }
+    }
+  }
+  async setupProvider(providerId) {
+    const provider = PROVIDERS.find((p) => p.value === providerId);
+    const displayName = provider?.name ?? providerId;
+    const existingKey = this.config.getApiKey(providerId);
+    console.log(`
+Managing ${displayName} API Key`);
+    if (existingKey) {
+      console.log(chalk6.gray(`  Current: ${maskKey(existingKey)}`));
+    } else {
+      console.log(chalk6.gray("  Current: (\u672A\u914D\u7F6E)"));
+    }
+    const choices = existingKey ? [
+      { value: "keep", name: "\u4FDD\u6301\u4E0D\u53D8 (keep current key)" },
+      { value: "show", name: "\u663E\u793A\u539F\u59CB Key (show full key)" },
+      { value: "change", name: "\u4FEE\u6539 Key (update key)" }
+    ] : [{ value: "change", name: "\u8F93\u5165 Key (enter key)" }, { value: "skip", name: "\u8DF3\u8FC7 (skip)" }];
+    const action = await select({
+      message: "Action:",
+      choices
+    });
+    if (action === "show" && existingKey) {
+      console.log(chalk6.yellow(`
+  \u5B8C\u6574 Key: ${existingKey}
+`));
+      const updateAfterShow = await select({
+        message: "Would you like to update this key?",
+        choices: [
+          { value: "keep", name: "\u4FDD\u6301\u4E0D\u53D8 (keep)" },
+          { value: "change", name: "\u4FEE\u6539 (update)" }
+        ]
+      });
+      if (updateAfterShow !== "change") return;
+    } else if (action === "keep" || action === "skip") {
+      return;
+    }
+    const newKey = await password({
+      message: `Enter ${displayName} API key:`,
+      validate: (val) => val.length > 0 || "API key cannot be empty"
+    });
+    this.config.setApiKey(providerId, newKey);
+    console.log(chalk6.green(`API key saved for ${displayName}: ${maskKey(newKey)}
+`));
+  }
+};
+
+// src/core/event-bus.ts
+import { EventEmitter } from "events";
+var EventBus = class extends EventEmitter {
+  emit(event, data) {
+    return super.emit(event, data);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+};
+
+// src/index.ts
+process.on("uncaughtException", (err) => {
+  process.stderr.write(`
+[Fatal] Uncaught exception: ${err.message}
+${err.stack ?? ""}
+`);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+  process.stderr.write(`
+[Fatal] Unhandled rejection: ${msg}
+`);
+  process.exit(1);
+});
+program.name("ai-cli").description("Cross-platform REPL-style AI CLI with multi-provider support").version(VERSION);
+program.option("-p, --provider <name>", "AI provider to use (claude/gemini/deepseek/zhipu/kimi or any custom provider)").option("-m, --model <name>", "Model to use").option("--no-stream", "Disable streaming output").action(async (options) => {
+  await startRepl(options);
+});
+program.command("config").description("Configure API keys and preferences").action(async () => {
+  const config = new ConfigManager();
+  const wizard = new SetupWizard(config);
+  await wizard.runFull();
+  console.log("Configuration saved.");
+});
+program.command("providers").description("List all AI providers and their configuration status").action(async () => {
+  const config = new ConfigManager();
+  const registry = new ProviderRegistry();
+  await registry.initialize(
+    (id) => config.getApiKey(id),
+    (id) => ({
+      baseUrl: config.get("customBaseUrls")[id],
+      timeout: config.get("timeouts")[id]
+    }),
+    config.get("customProviders")
+  );
+  const all = registry.listAll();
+  console.log("\nAvailable providers:\n");
+  console.log(
+    "Status".padEnd(8) + "Type".padEnd(10) + "ID".padEnd(16) + "Display Name".padEnd(26) + "Default Model"
+  );
+  console.log("-".repeat(80));
+  for (const p of all) {
+    const status = p.configured ? "\u2713" : "\u2717";
+    const color = p.configured ? "\x1B[32m" : "\x1B[31m";
+    const tag = p.isCustom ? "\x1B[36mcustom\x1B[0m    " : "built-in  ";
+    console.log(
+      `${color}${status}\x1B[0m      ` + tag + p.id.padEnd(16) + p.displayName.padEnd(26) + p.defaultModel
+    );
+  }
+  console.log();
+});
+program.command("sessions").description("List recent conversation sessions").action(async () => {
+  const config = new ConfigManager();
+  const sessions = new SessionManager(config);
+  const list = sessions.listSessions();
+  if (list.length === 0) {
+    console.log("\nNo saved sessions.\n");
+    return;
+  }
+  console.log("\nRecent sessions:\n");
+  console.log(
+    "ID".padEnd(10) + "Provider".padEnd(12) + "Model".padEnd(30) + "Msgs".padEnd(6) + "Date".padEnd(12) + "Title"
+  );
+  console.log("-".repeat(80));
+  for (const s of list) {
+    console.log(
+      s.id.slice(0, 8).padEnd(10) + s.provider.padEnd(12) + s.model.padEnd(30) + String(s.messageCount).padEnd(6) + s.updated.toLocaleDateString().padEnd(12) + (s.title ?? "(untitled)")
+    );
+  }
+  console.log();
+});
+program.parse();
+async function startRepl(options) {
+  const config = new ConfigManager();
+  if (config.isFirstRun()) {
+    const wizard = new SetupWizard(config);
+    const configured = await wizard.runFirstRun();
+    if (!configured) {
+      console.log('\nSetup cancelled. Run "ai-cli config" to configure later.');
+      process.exit(0);
+    }
+  }
+  if (options.provider) {
+    config.set("defaultProvider", options.provider);
+  }
+  if (options.stream === false) {
+    const ui = config.get("ui");
+    config.set("ui", { ...ui, streaming: false });
+  }
+  const events = new EventBus();
+  const providers = new ProviderRegistry();
+  await providers.initialize(
+    (id) => config.getApiKey(id),
+    (id) => ({
+      baseUrl: config.get("customBaseUrls")[id],
+      timeout: config.get("timeouts")[id]
+    }),
+    config.get("customProviders")
+  );
+  if (providers.listAvailable().length === 0) {
+    console.error(
+      "\nNo providers configured. Run: ai-cli config\n"
+    );
+    process.exit(1);
+  }
+  if (options.provider && !providers.has(options.provider)) {
+    console.error(
+      `
+Provider '${options.provider}' is not configured. Run: ai-cli config
+`
+    );
+    process.exit(1);
+  }
+  const sessions = new SessionManager(config);
+  const repl = new Repl(providers, sessions, config, events);
+  if (options.model) {
+    const defaultModels = config.get("defaultModels");
+    const provider = options.provider ?? config.getDefaultProvider();
+    config.set("defaultModels", { ...defaultModels, [provider]: options.model });
+  }
+  process.on("SIGTERM", async () => {
+    await sessions.save();
+    process.exit(0);
+  });
+  await repl.start();
+}