shenxiang-ai-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2813 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/chat.ts
+import readline from "readline";
+
+// src/core/providers/openai-compatible.ts
+import OpenAI from "openai";
+var OpenAICompatibleProvider = class {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  async *chatStream(messages, tools, config3) {
+    const isKimi = this.name === "kimi";
+    if (isKimi) {
+      yield* this.kimiChatStream(messages, tools, config3);
+      return;
+    }
+    const client = new OpenAI({
+      apiKey: config3.apiKey,
+      baseURL: config3.baseUrl
+    });
+    const openaiTools = tools.map((t2) => ({
+      type: "function",
+      function: {
+        name: t2.name,
+        description: t2.description,
+        parameters: t2.parameters
+      }
+    }));
+    const openaiMessages = messages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "tool",
+          content: m.content || "",
+          tool_call_id: m.tool_call_id || ""
+        };
+      }
+      if (m.role === "assistant" && m.tool_calls) {
+        return {
+          role: "assistant",
+          content: m.content,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            }
+          }))
+        };
+      }
+      return {
+        role: m.role,
+        content: m.content || ""
+      };
+    });
+    try {
+      const stream = await client.chat.completions.create({
+        model: config3.model,
+        messages: openaiMessages,
+        tools: openaiTools.length > 0 ? openaiTools : void 0,
+        stream: true,
+        stream_options: { include_usage: true },
+        temperature: 0.3,
+        max_tokens: 8192
+      });
+      const toolCallAccumulator = /* @__PURE__ */ new Map();
+      let tokenUsage;
+      for await (const chunk of stream) {
+        if (chunk.usage) {
+          tokenUsage = {
+            promptTokens: chunk.usage.prompt_tokens || 0,
+            completionTokens: chunk.usage.completion_tokens || 0,
+            totalTokens: chunk.usage.total_tokens || 0
+          };
+        }
+        const choice = chunk.choices[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        if (delta.content) {
+          yield { type: "text", content: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index;
+            if (!toolCallAccumulator.has(idx)) {
+              toolCallAccumulator.set(idx, { id: tc.id || "", functionName: tc.function?.name || "", arguments: "" });
+            }
+            const acc = toolCallAccumulator.get(idx);
+            if (tc.id) acc.id = tc.id;
+            if (tc.function?.name) acc.functionName = tc.function.name;
+            if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+          }
+        }
+        if (choice.finish_reason === "tool_calls" || choice.finish_reason === "stop") {
+          for (const [_, acc] of toolCallAccumulator) {
+            yield { type: "tool_call", toolCall: { id: acc.id, type: "function", function: { name: acc.functionName, arguments: acc.arguments } } };
+          }
+          yield { type: "done", usage: tokenUsage };
+          return;
+        }
+      }
+      for (const [_, acc] of toolCallAccumulator) {
+        yield { type: "tool_call", toolCall: { id: acc.id, type: "function", function: { name: acc.functionName, arguments: acc.arguments } } };
+      }
+      yield { type: "done", usage: tokenUsage };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      yield { type: "error", error: msg };
+    }
+  }
+  /**
+   * Kimi-specific streaming using raw fetch to handle reasoning_content
+   */
+  async *kimiChatStream(messages, tools, config3) {
+    const baseUrl = config3.baseUrl || "https://api.moonshot.cn/v1";
+    const kimiMessages = messages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "tool",
+          content: m.content || "",
+          tool_call_id: m.tool_call_id || ""
+        };
+      }
+      if (m.role === "assistant" && m.tool_calls) {
+        return {
+          role: "assistant",
+          content: m.content || "",
+          reasoning_content: m.reasoning_content || "",
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            }
+          }))
+        };
+      }
+      if (m.role === "assistant") {
+        const msg = {
+          role: "assistant",
+          content: m.content || ""
+        };
+        if (m.reasoning_content !== void 0) {
+          msg.reasoning_content = m.reasoning_content;
+        }
+        return msg;
+      }
+      return {
+        role: m.role,
+        content: m.content || ""
+      };
+    });
+    const kimiTools = tools.map((t2) => ({
+      type: "function",
+      function: {
+        name: t2.name,
+        description: t2.description,
+        parameters: t2.parameters
+      }
+    }));
+    const body = {
+      model: config3.model,
+      messages: kimiMessages,
+      stream: true,
+      stream_options: { include_usage: true },
+      temperature: 1,
+      max_tokens: 8192
+    };
+    if (kimiTools.length > 0) {
+      body.tools = kimiTools;
+    }
+    try {
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config3.apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errText = await response.text();
+        yield { type: "error", error: `${response.status} ${errText}` };
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        yield { type: "error", error: "No response stream" };
+        return;
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const toolCallAccumulator = /* @__PURE__ */ new Map();
+      let tokenUsage;
+      let reasoningContent = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (parsed.usage) {
+            tokenUsage = {
+              promptTokens: parsed.usage.prompt_tokens || 0,
+              completionTokens: parsed.usage.completion_tokens || 0,
+              totalTokens: parsed.usage.total_tokens || 0
+            };
+          }
+          const choice = parsed.choices?.[0];
+          if (!choice) continue;
+          const delta = choice.delta || {};
+          if (delta.reasoning_content) {
+            reasoningContent += delta.reasoning_content;
+          }
+          if (delta.content) {
+            yield { type: "text", content: delta.content };
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCallAccumulator.has(idx)) {
+                toolCallAccumulator.set(idx, { id: tc.id || "", functionName: tc.function?.name || "", arguments: "" });
+              }
+              const acc = toolCallAccumulator.get(idx);
+              if (tc.id) acc.id = tc.id;
+              if (tc.function?.name) acc.functionName = tc.function.name;
+              if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+            }
+          }
+          if (choice.finish_reason === "tool_calls" || choice.finish_reason === "stop") {
+            for (const [_, acc] of toolCallAccumulator) {
+              const toolCall = {
+                id: acc.id,
+                type: "function",
+                function: { name: acc.functionName, arguments: acc.arguments }
+              };
+              yield { type: "tool_call", toolCall };
+            }
+            yield {
+              type: "done",
+              usage: tokenUsage,
+              content: reasoningContent || void 0
+            };
+            return;
+          }
+        }
+      }
+      for (const [_, acc] of toolCallAccumulator) {
+        yield { type: "tool_call", toolCall: { id: acc.id, type: "function", function: { name: acc.functionName, arguments: acc.arguments } } };
+      }
+      yield { type: "done", usage: tokenUsage, content: reasoningContent || void 0 };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      yield { type: "error", error: msg };
+    }
+  }
+};
+
+// src/core/providers/anthropic.ts
+var AnthropicProvider = class {
+  name = "anthropic";
+  async *chatStream(messages, tools, config3) {
+    const baseUrl = config3.baseUrl || "https://api.anthropic.com";
+    const systemMessage = messages.find((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+    const anthropicMessages = nonSystemMessages.map((m) => {
+      if (m.role === "assistant" && m.tool_calls) {
+        return {
+          role: "assistant",
+          content: [
+            ...m.content ? [{ type: "text", text: m.content }] : [],
+            ...m.tool_calls.map((tc) => ({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input: JSON.parse(tc.function.arguments)
+            }))
+          ]
+        };
+      }
+      if (m.role === "tool") {
+        return {
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: m.tool_call_id,
+            content: m.content || ""
+          }]
+        };
+      }
+      return { role: m.role, content: m.content || "" };
+    });
+    const anthropicTools = tools.map((t2) => ({
+      name: t2.name,
+      description: t2.description,
+      input_schema: t2.parameters
+    }));
+    const body = {
+      model: config3.model,
+      max_tokens: 8192,
+      system: systemMessage?.content || "",
+      messages: anthropicMessages,
+      tools: anthropicTools.length > 0 ? anthropicTools : void 0,
+      stream: true,
+      temperature: 0.3
+    };
+    try {
+      const response = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": config3.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        yield { type: "error", error: `Anthropic API error (${response.status}): ${errorText}` };
+        return;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        yield { type: "error", error: "No response stream available" };
+        return;
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let currentToolId = "";
+      let currentToolName = "";
+      let currentToolArgs = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") continue;
+          try {
+            const event = JSON.parse(data);
+            if (event.type === "content_block_start") {
+              if (event.content_block?.type === "tool_use") {
+                currentToolId = event.content_block.id;
+                currentToolName = event.content_block.name;
+                currentToolArgs = "";
+              }
+            } else if (event.type === "content_block_delta") {
+              if (event.delta?.type === "text_delta") {
+                yield { type: "text", content: event.delta.text };
+              } else if (event.delta?.type === "input_json_delta") {
+                currentToolArgs += event.delta.partial_json || "";
+              }
+            } else if (event.type === "content_block_stop") {
+              if (currentToolId) {
+                const toolCall = {
+                  id: currentToolId,
+                  type: "function",
+                  function: {
+                    name: currentToolName,
+                    arguments: currentToolArgs || "{}"
+                  }
+                };
+                yield { type: "tool_call", toolCall };
+                currentToolId = "";
+                currentToolName = "";
+                currentToolArgs = "";
+              }
+            } else if (event.type === "message_stop") {
+              yield { type: "done" };
+              return;
+            }
+          } catch {
+          }
+        }
+      }
+      yield { type: "done" };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      yield { type: "error", error: msg };
+    }
+  }
+};
+
+// src/core/providers/types.ts
+var MODEL_PROVIDERS = {
+  // Kimi (月之暗面 Moonshot)
+  "kimi-k2.5": { provider: "kimi", displayName: "Kimi K2.5 (\u6700\u65B0\u591A\u6A21\u6001)" },
+  "kimi-k2-0905-preview": { provider: "kimi", displayName: "Kimi K2" },
+  "moonshot-v1-auto": { provider: "kimi", displayName: "Moonshot v1 Auto" },
+  // OpenAI
+  "gpt-4o": { provider: "openai", displayName: "GPT-4o" },
+  "gpt-4o-mini": { provider: "openai", displayName: "GPT-4o Mini" },
+  // Anthropic
+  "claude-sonnet-4-20250514": { provider: "anthropic", displayName: "Claude Sonnet 4" },
+  "claude-3-5-sonnet-20241022": { provider: "anthropic", displayName: "Claude 3.5 Sonnet" },
+  // DeepSeek
+  "deepseek-chat": { provider: "deepseek", displayName: "DeepSeek Chat" },
+  "deepseek-coder": { provider: "deepseek", displayName: "DeepSeek Coder" },
+  // Qwen (通义千问)
+  "qwen-turbo": { provider: "qwen", displayName: "\u901A\u4E49\u5343\u95EE Turbo" },
+  "qwen-plus": { provider: "qwen", displayName: "\u901A\u4E49\u5343\u95EE Plus" }
+};
+
+// src/core/providers/index.ts
+var providers = {
+  openai: new OpenAICompatibleProvider("openai"),
+  deepseek: new OpenAICompatibleProvider("deepseek"),
+  qwen: new OpenAICompatibleProvider("qwen"),
+  kimi: new OpenAICompatibleProvider("kimi"),
+  anthropic: new AnthropicProvider()
+};
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  deepseek: "https://api.deepseek.com",
+  qwen: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  kimi: "https://api.moonshot.cn/v1",
+  anthropic: "https://api.anthropic.com"
+};
+function getProvider(model) {
+  const info = MODEL_PROVIDERS[model];
+  if (!info) {
+    return providers.openai;
+  }
+  return providers[info.provider] || providers.openai;
+}
+function getProviderName(model) {
+  return MODEL_PROVIDERS[model]?.provider || "openai";
+}
+function getDefaultBaseUrl(providerName) {
+  return DEFAULT_BASE_URLS[providerName] || DEFAULT_BASE_URLS.openai;
+}
+function listModels() {
+  return Object.entries(MODEL_PROVIDERS).map(([id, info]) => ({
+    id,
+    name: info.displayName,
+    provider: info.provider
+  }));
+}
+
+// src/core/tools/file-read.ts
+import fs from "fs/promises";
+import path from "path";
+import { glob } from "glob";
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "Read the contents of a file. Returns the file content with line numbers.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path to the file from the project root"
+        },
+        start_line: {
+          type: "number",
+          description: "Start line number (1-based). Optional."
+        },
+        end_line: {
+          type: "number",
+          description: "End line number (1-based, inclusive). Optional."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const filePath = path.resolve(process.cwd(), args.path);
+      const stat = await fs.stat(filePath);
+      if (stat.size > 1024 * 1024) {
+        return {
+          success: false,
+          output: "",
+          error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Use start_line/end_line to read a portion.`
+        };
+      }
+      const BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".ico",
+        ".webp",
+        ".svg",
+        ".woff",
+        ".woff2",
+        ".ttf",
+        ".eot",
+        ".zip",
+        ".tar",
+        ".gz",
+        ".7z",
+        ".rar",
+        ".exe",
+        ".dll",
+        ".so",
+        ".dylib",
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".mp3",
+        ".mp4",
+        ".wav",
+        ".avi",
+        ".mov"
+      ]);
+      const ext = path.extname(filePath).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        return {
+          success: false,
+          output: "",
+          error: `Binary file (${ext}) cannot be read as text.`
+        };
+      }
+      const content = await fs.readFile(filePath, "utf-8");
+      const lines = content.split("\n");
+      const start = Math.max(1, args.start_line || 1);
+      const end = Math.min(lines.length, args.end_line || lines.length);
+      const effectiveEnd = !args.start_line && !args.end_line && lines.length > 500 ? 500 : end;
+      const numbered = lines.slice(start - 1, effectiveEnd).map((line, i) => `${String(start + i).padStart(5)}| ${line}`).join("\n");
+      let output = `File: ${args.path} (${lines.length} lines)
+${numbered}`;
+      if (effectiveEnd < lines.length && !args.end_line) {
+        output += `
+... (${lines.length - effectiveEnd} more lines, use start_line/end_line to read more)`;
+      }
+      return { success: true, output };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ENOENT")) {
+        return { success: false, output: "", error: `File not found: ${args.path}` };
+      }
+      if (msg.includes("EACCES")) {
+        return { success: false, output: "", error: `Permission denied: ${args.path}` };
+      }
+      return { success: false, output: "", error: `Failed to read file: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+var listFilesTool = {
+  definition: {
+    name: "list_files",
+    description: "List files and directories in a path. Returns a tree-like structure.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: 'Relative directory path to list. Defaults to "."'
+        },
+        pattern: {
+          type: "string",
+          description: 'Glob pattern to filter files. E.g. "**/*.ts"'
+        },
+        max_depth: {
+          type: "number",
+          description: "Maximum directory depth. Default 3."
+        }
+      },
+      required: []
+    }
+  },
+  handler: async (args) => {
+    try {
+      const targetPath = path.resolve(process.cwd(), args.path || ".");
+      const pattern = args.pattern || "**/*";
+      const maxDepth = args.max_depth || 3;
+      const files = await glob(pattern, {
+        cwd: targetPath,
+        maxDepth,
+        ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**", ".nuxt/**", "coverage/**"],
+        mark: true
+      });
+      if (files.length === 0) {
+        return { success: true, output: "No files found matching the pattern." };
+      }
+      const sorted = files.sort();
+      const output = `Directory: ${args.path || "."}
+Files (${sorted.length}):
+${sorted.map((f) => `  ${f}`).join("\n")}`;
+      return { success: true, output };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Failed to list files: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+
+// src/core/tools/file-write.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var writeFileTool = {
+  definition: {
+    name: "write_file",
+    description: "Create or overwrite a file with the given content. Parent directories are created automatically.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path to the file from the project root"
+        },
+        content: {
+          type: "string",
+          description: "The full content to write to the file"
+        }
+      },
+      required: ["path", "content"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const filePath = path2.resolve(process.cwd(), args.path);
+      await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+      await fs2.writeFile(filePath, args.content, "utf-8");
+      const lines = args.content.split("\n").length;
+      return {
+        success: true,
+        output: `File written: ${args.path} (${lines} lines)`
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Failed to write file: ${msg}` };
+    }
+  },
+  requiresConfirmation: true
+};
+var editFileTool = {
+  definition: {
+    name: "edit_file",
+    description: "Edit a file by replacing a specific string with new content. The old_string must match exactly (including whitespace and indentation).",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path to the file"
+        },
+        old_string: {
+          type: "string",
+          description: "The exact string to find and replace"
+        },
+        new_string: {
+          type: "string",
+          description: "The replacement string"
+        }
+      },
+      required: ["path", "old_string", "new_string"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const filePath = path2.resolve(process.cwd(), args.path);
+      const content = await fs2.readFile(filePath, "utf-8");
+      const oldStr = args.old_string;
+      const newStr = args.new_string;
+      if (!content.includes(oldStr)) {
+        return {
+          success: false,
+          output: "",
+          error: `String not found in file. Make sure old_string matches exactly.`
+        };
+      }
+      const count = content.split(oldStr).length - 1;
+      if (count > 1) {
+        return {
+          success: false,
+          output: "",
+          error: `Found ${count} occurrences of old_string. Please provide more context to uniquely identify the target.`
+        };
+      }
+      const newContent = content.replace(oldStr, newStr);
+      await fs2.writeFile(filePath, newContent, "utf-8");
+      const addedLines = newStr.split("\n").length;
+      const removedLines = oldStr.split("\n").length;
+      return {
+        success: true,
+        output: `File edited: ${args.path} (+${addedLines} -${removedLines} lines)`
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Failed to edit file: ${msg}` };
+    }
+  },
+  requiresConfirmation: true
+};
+var deleteFileTool = {
+  definition: {
+    name: "delete_file",
+    description: "Delete a file from the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path to the file to delete"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const filePath = path2.resolve(process.cwd(), args.path);
+      await fs2.unlink(filePath);
+      return { success: true, output: `File deleted: ${args.path}` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Failed to delete file: ${msg}` };
+    }
+  },
+  requiresConfirmation: true
+};
+
+// src/core/tools/search.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { glob as glob2 } from "glob";
+var searchCodeTool = {
+  definition: {
+    name: "search_code",
+    description: "Search for a pattern in project files. Returns matching lines with context. Similar to grep/ripgrep.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Text or regex pattern to search for"
+        },
+        file_pattern: {
+          type: "string",
+          description: 'Glob pattern to filter files. E.g. "**/*.ts", "src/**/*.vue". Defaults to all files.'
+        },
+        case_sensitive: {
+          type: "string",
+          description: 'Whether search is case sensitive. "true" or "false". Default "true".'
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const searchPattern = args.pattern;
+      const filePattern = args.file_pattern || "**/*";
+      const caseSensitive = args.case_sensitive !== "false";
+      const files = await glob2(filePattern, {
+        cwd: process.cwd(),
+        nodir: true,
+        ignore: [
+          "node_modules/**",
+          ".git/**",
+          "dist/**",
+          ".next/**",
+          ".nuxt/**",
+          "coverage/**",
+          "*.lock",
+          "package-lock.json",
+          "*.png",
+          "*.jpg",
+          "*.gif",
+          "*.ico",
+          "*.woff*",
+          "*.ttf"
+        ]
+      });
+      const regex = new RegExp(
+        searchPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+        caseSensitive ? "g" : "gi"
+      );
+      const results = [];
+      let matchCount = 0;
+      const maxResults = 50;
+      for (const file of files) {
+        if (matchCount >= maxResults) break;
+        try {
+          const filePath = path3.resolve(process.cwd(), file);
+          const content = await fs3.readFile(filePath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (matchCount >= maxResults) break;
+            if (regex.test(lines[i])) {
+              results.push(`${file}:${i + 1}: ${lines[i].trim()}`);
+              matchCount++;
+              regex.lastIndex = 0;
+            }
+          }
+        } catch {
+        }
+      }
+      if (results.length === 0) {
+        return { success: true, output: `No matches found for "${searchPattern}"` };
+      }
+      const output = `Found ${matchCount} matches${matchCount >= maxResults ? " (limited to 50)" : ""}:
+${results.join("\n")}`;
+      return { success: true, output };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Search failed: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+
+// src/core/tools/shell.ts
+import { exec } from "child_process";
+var MAX_OUTPUT_LENGTH = 1e4;
+var shellTool = {
+  definition: {
+    name: "run_command",
+    description: "Execute a shell command in the project directory. Use for installing packages, running scripts, building, testing, etc. Requires user confirmation.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute"
+        },
+        working_directory: {
+          type: "string",
+          description: "Working directory relative to project root. Optional."
+        }
+      },
+      required: ["command"]
+    }
+  },
+  handler: async (args) => {
+    const command = args.command;
+    const cwd = args.working_directory ? `${process.cwd()}/${args.working_directory}` : process.cwd();
+    return new Promise((resolve) => {
+      const child = exec(command, {
+        cwd,
+        timeout: 6e4,
+        // 60s timeout
+        maxBuffer: 1024 * 1024 * 5,
+        // 5MB
+        env: { ...process.env, FORCE_COLOR: "0" }
+      }, (error, stdout, stderr) => {
+        let output = "";
+        if (stdout) output += stdout;
+        if (stderr) output += (output ? "\n" : "") + stderr;
+        if (output.length > MAX_OUTPUT_LENGTH) {
+          output = output.substring(0, MAX_OUTPUT_LENGTH) + `
+... (output truncated, ${output.length} chars total)`;
+        }
+        if (error) {
+          resolve({
+            success: false,
+            output: output || error.message,
+            error: `Command failed with exit code ${error.code}: ${error.message}`
+          });
+        } else {
+          resolve({
+            success: true,
+            output: output || "(no output)"
+          });
+        }
+      });
+    });
+  },
+  requiresConfirmation: true
+};
+
+// src/core/tools/git.ts
+import simpleGit from "simple-git";
+function getGit() {
+  return simpleGit(process.cwd());
+}
+var gitStatusTool = {
+  definition: {
+    name: "git_status",
+    description: "Show the current git status including staged, unstaged, and untracked files.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  handler: async () => {
+    try {
+      const git = getGit();
+      const status = await git.status();
+      const lines = [];
+      if (status.staged.length > 0) {
+        lines.push("Staged:");
+        status.staged.forEach((f) => lines.push(`  + ${f}`));
+      }
+      if (status.modified.length > 0) {
+        lines.push("Modified:");
+        status.modified.forEach((f) => lines.push(`  ~ ${f}`));
+      }
+      if (status.not_added.length > 0) {
+        lines.push("Untracked:");
+        status.not_added.forEach((f) => lines.push(`  ? ${f}`));
+      }
+      if (status.deleted.length > 0) {
+        lines.push("Deleted:");
+        status.deleted.forEach((f) => lines.push(`  - ${f}`));
+      }
+      if (lines.length === 0) {
+        lines.push("Working directory clean.");
+      }
+      lines.push(`
+Branch: ${status.current || "HEAD detached"}`);
+      if (status.ahead > 0) lines.push(`Ahead: ${status.ahead} commit(s)`);
+      if (status.behind > 0) lines.push(`Behind: ${status.behind} commit(s)`);
+      return { success: true, output: lines.join("\n") };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Git status failed: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+var gitDiffTool = {
+  definition: {
+    name: "git_diff",
+    description: "Show git diff of changes. Can diff staged or unstaged changes, or between commits.",
+    parameters: {
+      type: "object",
+      properties: {
+        staged: {
+          type: "string",
+          description: 'If "true", show staged changes. Default shows unstaged.'
+        },
+        file: {
+          type: "string",
+          description: "Specific file to diff. Optional."
+        }
+      },
+      required: []
+    }
+  },
+  handler: async (args) => {
+    try {
+      const git = getGit();
+      const isStaged = args.staged === "true";
+      const file = args.file;
+      const diffArgs = isStaged ? ["--cached"] : [];
+      if (file) diffArgs.push("--", file);
+      const diff = await git.diff(diffArgs);
+      if (!diff) {
+        return { success: true, output: "No changes." };
+      }
+      const maxLen = 5e3;
+      const output = diff.length > maxLen ? diff.substring(0, maxLen) + `
+... (diff truncated, ${diff.length} chars total)` : diff;
+      return { success: true, output };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Git diff failed: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+var gitCommitTool = {
+  definition: {
+    name: "git_commit",
+    description: "Stage files and create a git commit. If no files specified, stages all changes.",
+    parameters: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string",
+          description: "Commit message"
+        },
+        files: {
+          type: "array",
+          description: "Files to stage. If empty, stages all changes.",
+          items: { type: "string" }
+        }
+      },
+      required: ["message"]
+    }
+  },
+  handler: async (args) => {
+    try {
+      const git = getGit();
+      const message = args.message;
+      const files = args.files;
+      if (files && files.length > 0) {
+        await git.add(files);
+      } else {
+        await git.add(".");
+      }
+      const result = await git.commit(message);
+      return {
+        success: true,
+        output: `Committed: ${result.commit}
+${result.summary.changes} file(s) changed, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Git commit failed: ${msg}` };
+    }
+  },
+  requiresConfirmation: true
+};
+var gitLogTool = {
+  definition: {
+    name: "git_log",
+    description: "Show recent git commit history.",
+    parameters: {
+      type: "object",
+      properties: {
+        count: {
+          type: "number",
+          description: "Number of commits to show. Default 10."
+        }
+      },
+      required: []
+    }
+  },
+  handler: async (args) => {
+    try {
+      const git = getGit();
+      const count = args.count || 10;
+      const log = await git.log({ maxCount: count });
+      const lines = log.all.map(
+        (c) => `${c.hash.substring(0, 7)} ${c.date.substring(0, 10)} ${c.message}`
+      );
+      return {
+        success: true,
+        output: lines.length > 0 ? lines.join("\n") : "No commits yet."
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Git log failed: ${msg}` };
+    }
+  },
+  requiresConfirmation: false
+};
+
+// src/ui/renderer.ts
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+
+// src/ui/theme.ts
+import chalk from "chalk";
+var theme = {
+  // Brand colors
+  brand: chalk.hex("#A78BFA"),
+  brandBold: chalk.hex("#A78BFA").bold,
+  brandDim: chalk.hex("#7C3AED"),
+  // Status
+  success: chalk.hex("#34D399"),
+  error: chalk.hex("#F87171"),
+  warning: chalk.hex("#FBBF24"),
+  info: chalk.hex("#60A5FA"),
+  // Text
+  dim: chalk.gray,
+  bold: chalk.bold,
+  italic: chalk.italic,
+  muted: chalk.hex("#6B7280"),
+  // Code
+  code: chalk.bgHex("#1F2937").hex("#E5E7EB"),
+  filePath: chalk.underline.hex("#60A5FA"),
+  // Roles
+  user: chalk.hex("#34D399").bold,
+  assistant: chalk.hex("#A78BFA").bold,
+  system: chalk.gray,
+  tool: chalk.hex("#FBBF24"),
+  // Token stats
+  tokenLabel: chalk.hex("#6B7280"),
+  tokenValue: chalk.hex("#A78BFA")
+};
+function banner() {
+  const line = theme.brandDim("\u2501".repeat(46));
+  const border = theme.brandDim("\u2503");
+  const topLeft = theme.brandDim("\u250F");
+  const topRight = theme.brandDim("\u2513");
+  const botLeft = theme.brandDim("\u2517");
+  const botRight = theme.brandDim("\u251B");
+  return `
+${topLeft}${line}${topRight}
+${border}                                              ${border}
+${border}    ${theme.brandBold("\u6C88\u7FD4\u7684AI\u52A9\u624B")}  ${theme.muted("v0.1.0")}                   ${border}
+${border}    ${theme.dim("\u7EC8\u7AEF\u91CC\u7684AI\u5168\u6808\u5F00\u53D1\u642D\u6863")}               ${border}
+${border}                                              ${border}
+${botLeft}${line}${botRight}`;
+}
+function separator() {
+  return theme.dim("\u2500".repeat(46));
+}
+
+// src/ui/renderer.ts
+var marked = new Marked(markedTerminal());
+function streamChunk(text) {
+  process.stdout.write(text);
+}
+function printToolCall(name, description) {
+  console.log(theme.tool(`  \u25B8 ${description}`));
+}
+function printToolResult(result, truncate = 500) {
+  const display = result.length > truncate ? result.substring(0, truncate) + theme.dim(`
+    ... (${result.length} \u5B57\u7B26)`) : result;
+  const indented = display.split("\n").map((l) => "    " + l).join("\n");
+  console.log(theme.dim(indented));
+}
+function printTokenUsage(usage, durationMs) {
+  const parts = [];
+  parts.push(theme.tokenLabel("  tokens: "));
+  parts.push(theme.tokenValue(`\u2191${usage.promptTokens}`));
+  parts.push(theme.tokenLabel(" + "));
+  parts.push(theme.tokenValue(`\u2193${usage.completionTokens}`));
+  parts.push(theme.tokenLabel(" = "));
+  parts.push(theme.brandBold(`${usage.totalTokens}`));
+  if (durationMs && durationMs > 0) {
+    const seconds = (durationMs / 1e3).toFixed(1);
+    const tokPerSec = usage.completionTokens > 0 ? (usage.completionTokens / (durationMs / 1e3)).toFixed(0) : "0";
+    parts.push(theme.tokenLabel(`  \u23F1 ${seconds}s`));
+    parts.push(theme.tokenLabel(` (${tokPerSec} tok/s)`));
+  }
+  console.log(parts.join(""));
+}
+function printError(message) {
+  console.log(theme.error(`  \u2717 ${message}`));
+}
+function printSuccess(message) {
+  console.log(theme.success(`  \u2713 ${message}`));
+}
+function printInfo(message) {
+  console.log(theme.info(`  \u2139 ${message}`));
+}
+function printWarning(message) {
+  console.log(theme.warning(`  \u26A0 ${message}`));
+}
+function printSeparator() {
+  console.log(separator());
+}
+
+// src/i18n/zh.ts
+var zh = {
+  welcome: "\u6B22\u8FCE\u4F7F\u7528\u6C88\u7FD4\u7684AI\u52A9\u624B \u2014 \u4F60\u7684AI\u5168\u6808\u5F00\u53D1\u642D\u6863",
+  description: "\u6C88\u7FD4\u7684AI\u52A9\u624B - \u7EC8\u7AEF\u91CC\u7684AI\u5168\u6808\u5F00\u53D1\u642D\u6863",
+  prompt: "\u4F60: ",
+  thinking: "AI \u601D\u8003\u4E2D...",
+  exit: "\u518D\u89C1\uFF01\u795D\u7F16\u7801\u6109\u5FEB \u{1F680}",
+  exitHint: "\u8F93\u5165 /exit \u9000\u51FA, /help \u67E5\u770B\u5E2E\u52A9",
+  help: `
+\u53EF\u7528\u547D\u4EE4:
+  /help      \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+  /exit      \u9000\u51FA DevPilot
+  /clear     \u6E05\u9664\u5BF9\u8BDD\u5386\u53F2
+  /model     \u5207\u6362AI\u6A21\u578B
+  /status    \u67E5\u770B\u9879\u76EE\u72B6\u6001
+  /config    \u67E5\u770B/\u4FEE\u6539\u914D\u7F6E
+  /login     \u767B\u5F55 DevPilot \u8D26\u6237
+  /logout    \u9000\u51FA\u767B\u5F55
+  /usage     \u67E5\u770B\u7528\u91CF\u7EDF\u8BA1
+
+\u5FEB\u6377\u952E:
+  Ctrl+C     \u4E2D\u65AD\u5F53\u524D\u64CD\u4F5C
+  Ctrl+D     \u9000\u51FA DevPilot
+`,
+  errors: {
+    noApiKey: "\u672A\u914D\u7F6EAPI\u5BC6\u94A5\u3002\u8BF7\u8FD0\u884C devpilot config \u6216 devpilot login \u914D\u7F6E\u3002",
+    networkError: "\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5\u3002",
+    apiError: "AI\u670D\u52A1\u8FD4\u56DE\u9519\u8BEF: {message}",
+    unknownCommand: "\u672A\u77E5\u547D\u4EE4: {command}\u3002\u8F93\u5165 /help \u67E5\u770B\u5E2E\u52A9\u3002",
+    fileNotFound: "\u6587\u4EF6\u4E0D\u5B58\u5728: {path}",
+    permissionDenied: "\u6743\u9650\u4E0D\u8DB3: {path}",
+    tokenLimit: "\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u8FC7\u957F\uFF0C\u5DF2\u81EA\u52A8\u88C1\u526A\u65E9\u671F\u6D88\u606F\u3002",
+    rateLimited: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+    notLoggedIn: "\u8BF7\u5148\u767B\u5F55: devpilot login",
+    dailyLimitReached: "\u4ECA\u65E5\u514D\u8D39\u989D\u5EA6\u5DF2\u7528\u5B8C\u3002\u5347\u7EA7\u5230\u4ED8\u8D39\u7248\u83B7\u53D6\u66F4\u591A\u7528\u91CF\u3002"
+  },
+  tool: {
+    readFile: "\u{1F4D6} \u8BFB\u53D6\u6587\u4EF6: {path}",
+    writeFile: "\u{1F4DD} \u5199\u5165\u6587\u4EF6: {path}",
+    editFile: "\u270F\uFE0F  \u7F16\u8F91\u6587\u4EF6: {path}",
+    deleteFile: "\u{1F5D1}\uFE0F  \u5220\u9664\u6587\u4EF6: {path}",
+    search: "\u{1F50D} \u641C\u7D22: {pattern}",
+    shell: "\u{1F5A5}\uFE0F  \u6267\u884C\u547D\u4EE4: {command}",
+    shellConfirm: "\u662F\u5426\u5141\u8BB8\u6267\u884C\u6B64\u547D\u4EE4\uFF1F(y/n)",
+    gitStatus: "\u{1F4CA} \u67E5\u770BGit\u72B6\u6001",
+    gitDiff: "\u{1F4CB} \u67E5\u770BGit\u5DEE\u5F02",
+    gitCommit: "\u{1F4BE} Git\u63D0\u4EA4: {message}",
+    listFiles: "\u{1F4C1} \u5217\u51FA\u6587\u4EF6: {path}"
+  },
+  auth: {
+    loginPrompt: "\u8BF7\u8F93\u5165\u4F60\u7684\u90AE\u7BB1\u5730\u5740:",
+    passwordPrompt: "\u8BF7\u8F93\u5165\u5BC6\u7801:",
+    loginSuccess: "\u767B\u5F55\u6210\u529F\uFF01\u6B22\u8FCE\u56DE\u6765, {email}",
+    loginFailed: "\u767B\u5F55\u5931\u8D25: {message}",
+    registerPrompt: "\u8BE5\u90AE\u7BB1\u5C1A\u672A\u6CE8\u518C\uFF0C\u662F\u5426\u7ACB\u5373\u6CE8\u518C\uFF1F",
+    registerSuccess: "\u6CE8\u518C\u6210\u529F\uFF01\u6B22\u8FCE\u4F7F\u7528 DevPilot\u3002",
+    logoutSuccess: "\u5DF2\u9000\u51FA\u767B\u5F55\u3002"
+  },
+  project: {
+    detected: "\u68C0\u6D4B\u5230\u9879\u76EE\u7C7B\u578B: {type}",
+    framework: "\u6846\u67B6: {framework}",
+    noProject: "\u5F53\u524D\u76EE\u5F55\u4E0D\u662F\u4E00\u4E2A\u9879\u76EE\u76EE\u5F55\uFF0C\u5C06\u4EE5\u901A\u7528\u6A21\u5F0F\u8FD0\u884C\u3002"
+  }
+};
+
+// src/i18n/en.ts
+var en = {
+  welcome: "Welcome to ShenXiang's AI Assistant \u2014 Your AI Full-Stack Dev Companion",
+  description: "ShenXiang's AI Assistant - AI full-stack dev companion in your terminal",
+  prompt: "You: ",
+  thinking: "AI thinking...",
+  exit: "Goodbye! Happy coding \u{1F680}",
+  exitHint: "Type /exit to quit, /help for help",
+  help: `
+Available commands:
+  /help      Show help
+  /exit      Exit DevPilot
+  /clear     Clear conversation history
+  /model     Switch AI model
+  /status    Show project status
+  /config    View/edit configuration
+  /login     Login to DevPilot
+  /logout    Logout
+  /usage     Show usage stats
+
+Shortcuts:
+  Ctrl+C     Interrupt current operation
+  Ctrl+D     Exit DevPilot
+`,
+  errors: {
+    noApiKey: "No API key configured. Run devpilot config or devpilot login.",
+    networkError: "Network error. Please check your connection.",
+    apiError: "AI service error: {message}",
+    unknownCommand: "Unknown command: {command}. Type /help for help.",
+    fileNotFound: "File not found: {path}",
+    permissionDenied: "Permission denied: {path}",
+    tokenLimit: "Conversation too long, early messages trimmed.",
+    rateLimited: "Rate limited. Please wait a moment.",
+    notLoggedIn: "Please login first: devpilot login",
+    dailyLimitReached: "Daily free quota reached. Upgrade for more usage."
+  },
+  tool: {
+    readFile: "\u{1F4D6} Reading file: {path}",
+    writeFile: "\u{1F4DD} Writing file: {path}",
+    editFile: "\u270F\uFE0F  Editing file: {path}",
+    deleteFile: "\u{1F5D1}\uFE0F  Deleting file: {path}",
+    search: "\u{1F50D} Searching: {pattern}",
+    shell: "\u{1F5A5}\uFE0F  Running command: {command}",
+    shellConfirm: "Allow this command? (y/n)",
+    gitStatus: "\u{1F4CA} Git status",
+    gitDiff: "\u{1F4CB} Git diff",
+    gitCommit: "\u{1F4BE} Git commit: {message}",
+    listFiles: "\u{1F4C1} Listing files: {path}"
+  },
+  auth: {
+    loginPrompt: "Enter your email:",
+    passwordPrompt: "Enter your password:",
+    loginSuccess: "Login successful! Welcome back, {email}",
+    loginFailed: "Login failed: {message}",
+    registerPrompt: "Email not registered. Register now?",
+    registerSuccess: "Registration successful! Welcome to DevPilot.",
+    logoutSuccess: "Logged out."
+  },
+  project: {
+    detected: "Project type detected: {type}",
+    framework: "Framework: {framework}",
+    noProject: "Not a project directory. Running in general mode."
+  }
+};
+
+// src/i18n/index.ts
+var locales = { zh, en };
+var currentLocale = "zh";
+function setLocale(locale) {
+  currentLocale = locale;
+}
+function t(key, params) {
+  const keys = key.split(".");
+  let value = locales[currentLocale];
+  for (const k of keys) {
+    if (value && typeof value === "object" && k in value) {
+      value = value[k];
+    } else {
+      return key;
+    }
+  }
+  if (typeof value !== "string") return key;
+  if (!params) return value;
+  return value.replace(/\{(\w+)\}/g, (_, k) => params[k] ?? `{${k}}`);
+}
+
+// src/utils/input.ts
+var _questionFn = null;
+function registerQuestionFn(fn) {
+  _questionFn = fn;
+}
+async function askQuestion(prompt) {
+  if (_questionFn) {
+    return _questionFn(prompt);
+  }
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const onData = (data) => {
+      process.stdin.removeListener("data", onData);
+      resolve(data.toString().trim());
+    };
+    process.stdin.once("data", onData);
+  });
+}
+
+// src/core/tools/index.ts
+var toolRegistry = /* @__PURE__ */ new Map();
+function registerAllTools() {
+  const tools = [
+    readFileTool,
+    listFilesTool,
+    writeFileTool,
+    editFileTool,
+    deleteFileTool,
+    searchCodeTool,
+    shellTool,
+    gitStatusTool,
+    gitDiffTool,
+    gitCommitTool,
+    gitLogTool
+  ];
+  for (const tool of tools) {
+    toolRegistry.set(tool.definition.name, tool);
+  }
+}
+function getToolDefinitions() {
+  return Array.from(toolRegistry.values()).map((t2) => t2.definition);
+}
+async function confirmExecution(toolName, args) {
+  let description = toolName;
+  if (toolName === "run_command") description = `\u6267\u884C\u547D\u4EE4: ${args.command}`;
+  else if (toolName === "write_file") description = `\u5199\u5165\u6587\u4EF6: ${args.path}`;
+  else if (toolName === "edit_file") description = `\u7F16\u8F91\u6587\u4EF6: ${args.path}`;
+  else if (toolName === "delete_file") description = `\u5220\u9664\u6587\u4EF6: ${args.path}`;
+  else if (toolName === "git_commit") description = `Git\u63D0\u4EA4: ${args.message}`;
+  const answer = await askQuestion(`  \u26A1 ${description}
+  \u5141\u8BB8\u6267\u884C\uFF1F(y/n) `);
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+async function executeTool(name, args, autoConfirm = false) {
+  const tool = toolRegistry.get(name);
+  if (!tool) {
+    return { success: false, output: "", error: `Unknown tool: ${name}` };
+  }
+  const descMap = {
+    read_file: t("tool.readFile", { path: String(args.path || "") }),
+    list_files: t("tool.listFiles", { path: String(args.path || ".") }),
+    write_file: t("tool.writeFile", { path: String(args.path || "") }),
+    edit_file: t("tool.editFile", { path: String(args.path || "") }),
+    delete_file: t("tool.deleteFile", { path: String(args.path || "") }),
+    search_code: t("tool.search", { pattern: String(args.pattern || "") }),
+    run_command: t("tool.shell", { command: String(args.command || "") }),
+    git_status: t("tool.gitStatus"),
+    git_diff: t("tool.gitDiff"),
+    git_commit: t("tool.gitCommit", { message: String(args.message || "") }),
+    git_log: "\u{1F4DC} \u67E5\u770BGit\u65E5\u5FD7"
+  };
+  printToolCall(name, descMap[name] || name);
+  if (tool.requiresConfirmation && !autoConfirm) {
+    const confirmed = await confirmExecution(name, args);
+    if (!confirmed) {
+      return { success: false, output: "", error: "User declined execution." };
+    }
+  }
+  const result = await tool.handler(args);
+  printToolResult(result.error || result.output);
+  return result;
+}
+
+// src/core/context.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { glob as glob3 } from "glob";
+async function buildProjectContext(rootDir) {
+  const ctx = {
+    rootDir,
+    projectType: "unknown",
+    frameworks: [],
+    packageManager: "npm",
+    languages: [],
+    structure: "",
+    hasGit: false
+  };
+  try {
+    await fs4.access(path4.join(rootDir, ".git"));
+    ctx.hasGit = true;
+  } catch {
+  }
+  try {
+    const pkgPath = path4.join(rootDir, "package.json");
+    const pkg = JSON.parse(await fs4.readFile(pkgPath, "utf-8"));
+    ctx.projectName = pkg.name;
+    ctx.projectType = "node";
+    ctx.languages.push("javascript", "typescript");
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps["next"]) ctx.frameworks.push("Next.js");
+    if (allDeps["nuxt"] || allDeps["nuxt3"]) ctx.frameworks.push("Nuxt");
+    if (allDeps["react"]) ctx.frameworks.push("React");
+    if (allDeps["vue"]) ctx.frameworks.push("Vue");
+    if (allDeps["svelte"] || allDeps["@sveltejs/kit"]) ctx.frameworks.push("Svelte");
+    if (allDeps["express"]) ctx.frameworks.push("Express");
+    if (allDeps["@nestjs/core"]) ctx.frameworks.push("NestJS");
+    if (allDeps["koa"]) ctx.frameworks.push("Koa");
+    if (allDeps["fastify"]) ctx.frameworks.push("Fastify");
+    if (allDeps["hono"]) ctx.frameworks.push("Hono");
+    if (allDeps["tailwindcss"]) ctx.frameworks.push("Tailwind CSS");
+    if (allDeps["prisma"] || allDeps["@prisma/client"]) ctx.frameworks.push("Prisma");
+    if (allDeps["drizzle-orm"]) ctx.frameworks.push("Drizzle ORM");
+    if (allDeps["typeorm"]) ctx.frameworks.push("TypeORM");
+    if (allDeps["mongoose"]) ctx.frameworks.push("Mongoose");
+    try {
+      await fs4.access(path4.join(rootDir, "pnpm-lock.yaml"));
+      ctx.packageManager = "pnpm";
+    } catch {
+      try {
+        await fs4.access(path4.join(rootDir, "yarn.lock"));
+        ctx.packageManager = "yarn";
+      } catch {
+        try {
+          await fs4.access(path4.join(rootDir, "bun.lockb"));
+          ctx.packageManager = "bun";
+        } catch {
+          ctx.packageManager = "npm";
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    await fs4.access(path4.join(rootDir, "requirements.txt"));
+    ctx.projectType = ctx.projectType === "node" ? "fullstack" : "python";
+    ctx.languages.push("python");
+  } catch {
+  }
+  try {
+    await fs4.access(path4.join(rootDir, "pyproject.toml"));
+    ctx.projectType = ctx.projectType === "node" ? "fullstack" : "python";
+    if (!ctx.languages.includes("python")) ctx.languages.push("python");
+  } catch {
+  }
+  try {
+    await fs4.access(path4.join(rootDir, "go.mod"));
+    ctx.projectType = "go";
+    ctx.languages.push("go");
+  } catch {
+  }
+  ctx.structure = await buildStructureTree(rootDir);
+  return ctx;
+}
+async function buildStructureTree(rootDir, maxDepth = 2) {
+  const files = await glob3("**/*", {
+    cwd: rootDir,
+    maxDepth,
+    mark: true,
+    ignore: [
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      ".next/**",
+      ".nuxt/**",
+      "coverage/**",
+      ".turbo/**"
+    ]
+  });
+  if (files.length === 0) return "(empty directory)";
+  const sorted = files.sort();
+  const limited = sorted.slice(0, 100);
+  let tree = limited.map((f) => `  ${f}`).join("\n");
+  if (sorted.length > 100) {
+    tree += `
+  ... and ${sorted.length - 100} more files`;
+  }
+  return tree;
+}
+function generateSystemPrompt(ctx) {
+  const parts = [];
+  parts.push(`\u4F60\u662F\u6C88\u7FD4\u7684AI\u52A9\u624B\uFF0C\u4E00\u4E2A\u4E13\u4E1A\u7684AI\u5168\u6808\u5F00\u53D1\u52A9\u624B\u3002\u4F60\u6B63\u5728\u5E2E\u52A9\u5F00\u53D1\u8005\u5728\u7EC8\u7AEF\u4E2D\u7F16\u5199\u548C\u4FEE\u6539\u4EE3\u7801\u3002`);
+  parts.push(`\u4F60\u7684\u98CE\u683C\uFF1A\u4E13\u4E1A\u4F46\u53CB\u597D\uFF0C\u89E3\u91CA\u6E05\u6670\uFF0C\u4EE3\u7801\u8D28\u91CF\u9AD8\u3002\u4F18\u5148\u4F7F\u7528\u4E2D\u6587\u56DE\u590D\u3002`);
+  parts.push(`
+## \u5DE5\u4F5C\u539F\u5219`);
+  parts.push(`1. \u5728\u4FEE\u6539\u6587\u4EF6\u524D\u5148\u9605\u8BFB\u6587\u4EF6\u5185\u5BB9\uFF0C\u786E\u4FDD\u7406\u89E3\u4E0A\u4E0B\u6587`);
+  parts.push(`2. \u505A\u51FA\u7684\u4FEE\u6539\u8981\u7CBE\u786E\uFF0C\u4F7F\u7528 edit_file \u8FDB\u884C\u5C40\u90E8\u7F16\u8F91\u800C\u975E\u8986\u5199\u6574\u4E2A\u6587\u4EF6`);
+  parts.push(`3. \u6D89\u53CA\u7834\u574F\u6027\u64CD\u4F5C\uFF08\u5220\u9664\u6587\u4EF6\u3001\u6267\u884C\u547D\u4EE4\uFF09\u65F6\u8981\u8C28\u614E`);
+  parts.push(`4. \u9075\u5FAA\u9879\u76EE\u73B0\u6709\u7684\u4EE3\u7801\u98CE\u683C\u548C\u7EA6\u5B9A`);
+  parts.push(`5. \u5982\u679C\u4E0D\u786E\u5B9A\uFF0C\u5148\u641C\u7D22\u4EE3\u7801\u4E86\u89E3\u73B0\u6709\u5B9E\u73B0`);
+  parts.push(`6. \u6267\u884C\u547D\u4EE4\u65F6\u4F7F\u7528\u9879\u76EE\u7684\u5305\u7BA1\u7406\u5668\uFF08\u5982 ${ctx.packageManager}\uFF09`);
+  parts.push(`7. \u6D89\u53CA\u591A\u4E2A\u6587\u4EF6\u7684\u4FEE\u6539\u65F6\uFF0C\u5148\u8BF4\u660E\u8BA1\u5212\u518D\u9010\u6B65\u6267\u884C`);
+  if (ctx.projectType !== "unknown") {
+    parts.push(`
+## \u5F53\u524D\u9879\u76EE\u4FE1\u606F`);
+    parts.push(`- \u9879\u76EE\u76EE\u5F55: ${ctx.rootDir}`);
+    if (ctx.projectName) parts.push(`- \u9879\u76EE\u540D\u79F0: ${ctx.projectName}`);
+    parts.push(`- \u9879\u76EE\u7C7B\u578B: ${ctx.projectType}`);
+    if (ctx.frameworks.length > 0) parts.push(`- \u4F7F\u7528\u6846\u67B6: ${ctx.frameworks.join(", ")}`);
+    if (ctx.languages.length > 0) parts.push(`- \u7F16\u7A0B\u8BED\u8A00: ${ctx.languages.join(", ")}`);
+    parts.push(`- \u5305\u7BA1\u7406\u5668: ${ctx.packageManager}`);
+    parts.push(`- Git: ${ctx.hasGit ? "\u5DF2\u521D\u59CB\u5316" : "\u672A\u521D\u59CB\u5316"}`);
+  }
+  if (ctx.structure) {
+    parts.push(`
+## \u76EE\u5F55\u7ED3\u6784`);
+    parts.push("```");
+    parts.push(ctx.structure);
+    parts.push("```");
+  }
+  parts.push(`
+## \u5168\u6808\u5F00\u53D1\u4E13\u4E1A\u77E5\u8BC6`);
+  parts.push(`\u4F60\u7CBE\u901A\u4EE5\u4E0B\u5168\u6808\u5F00\u53D1\u6280\u672F\u6808\uFF0C\u80FD\u6839\u636E\u9879\u76EE\u5B9E\u9645\u4F7F\u7528\u7684\u6846\u67B6\u63D0\u4F9B\u6700\u4F73\u5B9E\u8DF5\uFF1A`);
+  parts.push(``);
+  parts.push(`### \u524D\u7AEF`);
+  parts.push(`- React (Hooks, Server Components, Suspense), Vue 3 (Composition API), Svelte`);
+  parts.push(`- Next.js (App Router / Pages Router), Nuxt 3, SvelteKit`);
+  parts.push(`- Tailwind CSS, CSS Modules, Styled Components`);
+  parts.push(`- \u72B6\u6001\u7BA1\u7406: Zustand, Pinia, Redux Toolkit, Jotai`);
+  parts.push(`- \u8868\u5355: React Hook Form, Formik, VeeValidate`);
+  parts.push(``);
+  parts.push(`### \u540E\u7AEF`);
+  parts.push(`- Express, Fastify, Koa, Hono, NestJS`);
+  parts.push(`- RESTful API \u8BBE\u8BA1, GraphQL`);
+  parts.push(`- \u8BA4\u8BC1: JWT, OAuth2, Session`);
+  parts.push(`- \u4E2D\u95F4\u4EF6\u6A21\u5F0F, \u9519\u8BEF\u5904\u7406, \u8BF7\u6C42\u9A8C\u8BC1 (Zod, Joi)`);
+  parts.push(``);
+  parts.push(`### \u6570\u636E\u5E93`);
+  parts.push(`- PostgreSQL, MySQL, MongoDB, Redis`);
+  parts.push(`- ORM: Prisma, Drizzle, TypeORM, Mongoose`);
+  parts.push(`- \u6570\u636E\u5E93\u8FC1\u79FB, \u79CD\u5B50\u6570\u636E, \u67E5\u8BE2\u4F18\u5316`);
+  parts.push(``);
+  parts.push(`### \u5DE5\u7A0B\u5316`);
+  parts.push(`- TypeScript \u7C7B\u578B\u8BBE\u8BA1, \u6CDB\u578B, \u7C7B\u578B\u5B88\u536B`);
+  parts.push(`- \u6D4B\u8BD5: Vitest, Jest, Playwright, Cypress`);
+  parts.push(`- CI/CD, Docker, \u73AF\u5883\u53D8\u91CF\u7BA1\u7406`);
+  parts.push(`- ESLint, Prettier, Husky, lint-staged`);
+  if (ctx.frameworks.length > 0) {
+    parts.push(`
+## \u5F53\u524D\u9879\u76EE\u6846\u67B6\u6307\u5357`);
+    for (const fw of ctx.frameworks) {
+      const guide = getFrameworkGuide(fw);
+      if (guide) parts.push(guide);
+    }
+  }
+  parts.push(`
+## \u53EF\u7528\u5DE5\u5177`);
+  parts.push(`\u4F60\u53EF\u4EE5\u4F7F\u7528\u4EE5\u4E0B\u5DE5\u5177\u6765\u5E2E\u52A9\u5F00\u53D1\u8005\uFF1A`);
+  parts.push(`- read_file: \u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\uFF08\u652F\u6301\u884C\u8303\u56F4\uFF09`);
+  parts.push(`- list_files: \u5217\u51FA\u76EE\u5F55\u7ED3\u6784\uFF08\u652F\u6301glob\u6A21\u5F0F\uFF09`);
+  parts.push(`- write_file: \u521B\u5EFA\u6216\u8986\u5199\u6587\u4EF6\uFF08\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\uFF09`);
+  parts.push(`- edit_file: \u7CBE\u786E\u7F16\u8F91\u6587\u4EF6\u4E2D\u7684\u7279\u5B9A\u5185\u5BB9\uFF08\u5B57\u7B26\u4E32\u5339\u914D\u66FF\u6362\uFF09`);
+  parts.push(`- delete_file: \u5220\u9664\u6587\u4EF6`);
+  parts.push(`- search_code: \u5728\u9879\u76EE\u4E2D\u641C\u7D22\u4EE3\u7801\u6A21\u5F0F`);
+  parts.push(`- run_command: \u6267\u884C\u7EC8\u7AEF\u547D\u4EE4\uFF08\u9700\u7528\u6237\u786E\u8BA4\uFF09`);
+  parts.push(`- git_status: \u67E5\u770BGit\u72B6\u6001`);
+  parts.push(`- git_diff: \u67E5\u770BGit\u5DEE\u5F02\uFF08\u652F\u6301staged/unstaged\uFF09`);
+  parts.push(`- git_commit: \u6682\u5B58\u5E76\u63D0\u4EA4\u4EE3\u7801`);
+  parts.push(`- git_log: \u67E5\u770B\u63D0\u4EA4\u5386\u53F2`);
+  parts.push(`
+## \u56DE\u590D\u683C\u5F0F`);
+  parts.push(`- \u4F7F\u7528 Markdown \u683C\u5F0F\u56DE\u590D`);
+  parts.push(`- \u4EE3\u7801\u5757\u4F7F\u7528\u6B63\u786E\u7684\u8BED\u8A00\u6807\u6CE8`);
+  parts.push(`- \u91CD\u8981\u64CD\u4F5C\u524D\u5148\u89E3\u91CA\u539F\u56E0`);
+  parts.push(`- \u4FEE\u6539\u5B8C\u6210\u540E\u7ED9\u51FA\u7B80\u8981\u603B\u7ED3`);
+  return parts.join("\n");
+}
+function getFrameworkGuide(framework) {
+  const guides = {
+    "Next.js": `### Next.js
+- \u4F7F\u7528 App Router\uFF08app/ \u76EE\u5F55\uFF09\u65F6\u9075\u5FAA RSC \u89C4\u8303\uFF0C\u9ED8\u8BA4\u7EC4\u4EF6\u4E3A Server Component
+- \u5BA2\u6237\u7AEF\u4EA4\u4E92\u7EC4\u4EF6\u9700\u5728\u9876\u90E8\u6DFB\u52A0 'use client' \u6307\u4EE4
+- API \u8DEF\u7531\u653E\u5728 app/api/ \u76EE\u5F55\u4E0B\uFF0C\u4F7F\u7528 route.ts \u6587\u4EF6
+- \u5229\u7528 loading.ts, error.ts, layout.ts \u7B49\u7EA6\u5B9A\u6587\u4EF6
+- \u56FE\u7247\u4F7F\u7528 next/image\uFF0C\u94FE\u63A5\u4F7F\u7528 next/link`,
+    "Nuxt": `### Nuxt 3
+- \u9875\u9762\u653E\u5728 pages/ \u76EE\u5F55\uFF0C\u81EA\u52A8\u8DEF\u7531
+- \u7EC4\u4EF6\u653E\u5728 components/ \u76EE\u5F55\uFF0C\u81EA\u52A8\u5BFC\u5165
+- \u670D\u52A1\u7AEFAPI\u653E\u5728 server/api/ \u76EE\u5F55
+- \u4F7F\u7528 composables/ \u76EE\u5F55\u5B58\u653E\u7EC4\u5408\u5F0F\u51FD\u6570
+- \u4F7F\u7528 useFetch/useAsyncData \u83B7\u53D6\u6570\u636E`,
+    "React": `### React
+- \u4F7F\u7528\u51FD\u6570\u7EC4\u4EF6 + Hooks \u6A21\u5F0F
+- \u9075\u5FAA Hooks \u4F7F\u7528\u89C4\u5219\uFF08\u4E0D\u5728\u6761\u4EF6/\u5FAA\u73AF\u4E2D\u8C03\u7528\uFF09
+- \u5408\u7406\u62C6\u5206\u7EC4\u4EF6\uFF0C\u4FDD\u6301\u5355\u4E00\u804C\u8D23
+- \u4F7F\u7528 useMemo/useCallback \u907F\u514D\u4E0D\u5FC5\u8981\u7684\u91CD\u6E32\u67D3`,
+    "Vue": `### Vue 3
+- \u4F18\u5148\u4F7F\u7528 Composition API (setup / <script setup>)
+- \u4F7F\u7528 ref/reactive \u7BA1\u7406\u54CD\u5E94\u5F0F\u72B6\u6001
+- \u4F7F\u7528 computed \u521B\u5EFA\u6D3E\u751F\u72B6\u6001
+- \u9075\u5FAA Props \u5355\u5411\u6570\u636E\u6D41`,
+    "Express": `### Express
+- \u4F7F\u7528\u8DEF\u7531\u5206\u7EC4\u548C\u4E2D\u95F4\u4EF6
+- \u7EDF\u4E00\u9519\u8BEF\u5904\u7406\u4E2D\u95F4\u4EF6
+- \u8F93\u5165\u9A8C\u8BC1\u4F7F\u7528 zod \u6216 joi
+- \u8DEF\u7531\u53C2\u6570\u7C7B\u578B\u5B89\u5168`,
+    "NestJS": `### NestJS
+- \u9075\u5FAA\u6A21\u5757\u5316\u67B6\u6784\uFF08Module, Controller, Service\uFF09
+- \u4F7F\u7528 DTO \u8FDB\u884C\u8BF7\u6C42\u9A8C\u8BC1
+- \u5229\u7528\u4F9D\u8D56\u6CE8\u5165
+- Guards \u548C Interceptors \u5904\u7406\u6A2A\u5207\u5173\u6CE8\u70B9`,
+    "Prisma": `### Prisma
+- Schema \u4FEE\u6539\u540E\u8FD0\u884C prisma generate
+- \u4F7F\u7528 prisma migrate dev \u7BA1\u7406\u8FC1\u79FB
+- \u5229\u7528 Prisma Client \u7684\u7C7B\u578B\u5B89\u5168\u67E5\u8BE2
+- \u4F7F\u7528 include/select \u4F18\u5316\u67E5\u8BE2`,
+    "Drizzle ORM": `### Drizzle ORM
+- Schema \u5B9A\u4E49\u5728 TypeScript \u4E2D
+- \u4F7F\u7528 drizzle-kit \u7BA1\u7406\u8FC1\u79FB
+- \u5229\u7528\u67E5\u8BE2\u6784\u5EFA\u5668\u7684\u7C7B\u578B\u63A8\u65AD
+- \u4F7F\u7528 .where() \u94FE\u5F0F\u8C03\u7528\u6784\u5EFA\u67E5\u8BE2`,
+    "Tailwind CSS": `### Tailwind CSS
+- \u4F7F\u7528 utility-first \u65B9\u5F0F\u7F16\u5199\u6837\u5F0F
+- \u590D\u6742\u7EC4\u4EF6\u63D0\u53D6\u81EA\u5B9A\u4E49\u7EC4\u4EF6\u7C7B
+- \u5229\u7528 @apply \u51CF\u5C11\u91CD\u590D
+- \u54CD\u5E94\u5F0F\u8BBE\u8BA1\u4F7F\u7528 sm/md/lg/xl \u524D\u7F00`
+  };
+  return guides[framework] || null;
+}
+
+// src/utils/config.ts
+import Conf from "conf";
+var defaults = {
+  locale: "zh",
+  model: "kimi-k2.5",
+  apiBaseUrl: "http://localhost:3210"
+};
+var config = new Conf({
+  projectName: "devpilot",
+  defaults
+});
+function getConfig() {
+  return {
+    locale: config.get("locale"),
+    model: config.get("model"),
+    apiBaseUrl: config.get("apiBaseUrl"),
+    authToken: config.get("authToken"),
+    userEmail: config.get("userEmail"),
+    openaiApiKey: config.get("openaiApiKey"),
+    anthropicApiKey: config.get("anthropicApiKey"),
+    deepseekApiKey: config.get("deepseekApiKey"),
+    kimiApiKey: config.get("kimiApiKey")
+  };
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/core/agent.ts
+import ora from "ora";
+var MAX_CONTEXT_MESSAGES = 50;
+var MAX_TOOL_ITERATIONS = 20;
+var Agent = class {
+  messages = [];
+  tools = [];
+  context = null;
+  isRunning = false;
+  /** Accumulated token usage for the entire chat turn */
+  turnUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  turnStartTime = 0;
+  /**
+   * Initialize the agent: register tools, build project context
+   */
+  async init() {
+    registerAllTools();
+    this.tools = getToolDefinitions();
+    this.context = await buildProjectContext(process.cwd());
+    const systemPrompt = generateSystemPrompt(this.context);
+    this.messages = [{ role: "system", content: systemPrompt }];
+  }
+  /**
+   * Get project context
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Send a user message and get AI response (with tool execution loop)
+   */
+  async chat(userMessage) {
+    if (this.isRunning) {
+      printWarning("\u6B63\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u4E0A\u4E00\u6761\u6D88\u606F\u5B8C\u6210...");
+      return "";
+    }
+    this.isRunning = true;
+    this.turnUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    this.turnStartTime = Date.now();
+    try {
+      this.messages.push({ role: "user", content: userMessage });
+      this.trimMessages();
+      const response = await this.runAgentLoop();
+      const duration = Date.now() - this.turnStartTime;
+      if (this.turnUsage.totalTokens > 0) {
+        printTokenUsage(this.turnUsage, duration);
+      }
+      return response;
+    } finally {
+      this.isRunning = false;
+    }
+  }
+  /**
+   * The main agent loop: call AI, execute tools, repeat
+   */
+  async runAgentLoop() {
+    let iteration = 0;
+    let finalResponse = "";
+    while (iteration < MAX_TOOL_ITERATIONS) {
+      iteration++;
+      const config3 = this.getProviderConfig();
+      const provider = getProvider(config3.model);
+      let responseText = "";
+      const toolCalls = [];
+      let hasError = false;
+      let reasoningContent = "";
+      const spinner = ora({ text: t("thinking"), spinner: "dots" }).start();
+      let spinnerStopped = false;
+      try {
+        for await (const chunk of provider.chatStream(this.messages, this.tools, config3)) {
+          if (!spinnerStopped && (chunk.type === "text" || chunk.type === "tool_call")) {
+            spinner.stop();
+            spinnerStopped = true;
+            if (chunk.type === "text") {
+              process.stdout.write("\n");
+            }
+          }
+          switch (chunk.type) {
+            case "text":
+              responseText += chunk.content || "";
+              streamChunk(chunk.content || "");
+              break;
+            case "tool_call":
+              if (chunk.toolCall) {
+                toolCalls.push(chunk.toolCall);
+              }
+              break;
+            case "error":
+              hasError = true;
+              printError(t("errors.apiError", { message: chunk.error || "Unknown error" }));
+              break;
+            case "done":
+              if (chunk.usage) {
+                this.turnUsage.promptTokens += chunk.usage.promptTokens;
+                this.turnUsage.completionTokens += chunk.usage.completionTokens;
+                this.turnUsage.totalTokens += chunk.usage.totalTokens;
+              }
+              if (chunk.content) {
+                reasoningContent = chunk.content;
+              }
+              break;
+          }
+        }
+      } catch (err) {
+        if (!spinnerStopped) spinner.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        printError(t("errors.apiError", { message: msg }));
+        return "";
+      }
+      if (!spinnerStopped) spinner.stop();
+      if (responseText) {
+        process.stdout.write("\n");
+      }
+      if (hasError) return "";
+      if (toolCalls.length === 0) {
+        const msg = { role: "assistant", content: responseText };
+        if (reasoningContent) msg.reasoning_content = reasoningContent;
+        this.messages.push(msg);
+        finalResponse = responseText;
+        break;
+      }
+      const assistantMsg = {
+        role: "assistant",
+        content: responseText || null,
+        tool_calls: toolCalls
+      };
+      if (reasoningContent) assistantMsg.reasoning_content = reasoningContent;
+      this.messages.push(assistantMsg);
+      console.log();
+      for (const tc of toolCalls) {
+        let args;
+        try {
+          args = JSON.parse(tc.function.arguments);
+        } catch {
+          args = {};
+        }
+        const result = await executeTool(tc.function.name, args);
+        this.messages.push({
+          role: "tool",
+          content: result.error || result.output,
+          tool_call_id: tc.id,
+          name: tc.function.name
+        });
+      }
+    }
+    if (iteration >= MAX_TOOL_ITERATIONS) {
+      printWarning("\u5DF2\u8FBE\u5230\u6700\u5927\u5DE5\u5177\u8C03\u7528\u6B21\u6570\uFF0C\u505C\u6B62\u6267\u884C\u3002");
+    }
+    return finalResponse;
+  }
+  /**
+   * Get provider configuration based on current settings
+   */
+  getProviderConfig() {
+    const cfg = getConfig();
+    const model = cfg.model;
+    const providerName = getProviderName(model);
+    let apiKey = "";
+    if (cfg.authToken) {
+      apiKey = cfg.authToken;
+    } else {
+      switch (providerName) {
+        case "openai":
+          apiKey = cfg.openaiApiKey || "";
+          break;
+        case "anthropic":
+          apiKey = cfg.anthropicApiKey || "";
+          break;
+        case "deepseek":
+          apiKey = cfg.deepseekApiKey || "";
+          break;
+        case "kimi":
+          apiKey = cfg.kimiApiKey || "";
+          break;
+        case "qwen":
+          apiKey = cfg.openaiApiKey || "";
+          break;
+        default:
+          apiKey = cfg.openaiApiKey || "";
+      }
+    }
+    let baseUrl;
+    if (cfg.authToken) {
+      baseUrl = `${cfg.apiBaseUrl}/api/ai/proxy`;
+    } else {
+      baseUrl = getDefaultBaseUrl(providerName);
+    }
+    return { apiKey, baseUrl, model };
+  }
+  /**
+   * Trim old messages to prevent context overflow
+   */
+  trimMessages() {
+    if (this.messages.length > MAX_CONTEXT_MESSAGES) {
+      const systemMsg = this.messages[0];
+      const recentMessages = this.messages.slice(-MAX_CONTEXT_MESSAGES + 1);
+      this.messages = [systemMsg, ...recentMessages];
+      printWarning(t("errors.tokenLimit"));
+    }
+  }
+  /**
+   * Clear conversation history (keep system prompt)
+   */
+  clearHistory() {
+    const systemMsg = this.messages[0];
+    this.messages = [systemMsg];
+  }
+  /**
+   * Get current model name
+   */
+  getCurrentModel() {
+    return getConfig().model;
+  }
+  /**
+   * Cancel running operation
+   */
+  cancel() {
+    this.isRunning = false;
+  }
+};
+
+// src/commands/chat.ts
+function question(rl, prompt) {
+  return new Promise((resolve, reject) => {
+    const onClose = () => reject(new Error("readline closed"));
+    rl.once("close", onClose);
+    rl.question(prompt, (answer) => {
+      rl.removeListener("close", onClose);
+      resolve(answer);
+    });
+  });
+}
+async function chatCommand() {
+  const config3 = getConfig();
+  setLocale(config3.locale);
+  console.log(banner());
+  const currentModel = config3.model;
+  console.log(theme.dim(`  \u6A21\u578B ${theme.brandBold(currentModel)}  \xB7  ${t("exitHint")}`));
+  const hasAnyKey = config3.authToken || config3.kimiApiKey || config3.openaiApiKey || config3.anthropicApiKey || config3.deepseekApiKey;
+  if (!hasAnyKey) {
+    console.log();
+    printWarning("\u5C1A\u672A\u914D\u7F6EAPI\u5BC6\u94A5\u3002\u8BF7\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u4E4B\u4E00:");
+    console.log(theme.dim("    sxai set-key kimi <your-key>     # Kimi (\u6708\u4E4B\u6697\u9762)"));
+    console.log(theme.dim("    sxai set-key deepseek <your-key>"));
+    console.log(theme.dim("    sxai set-key openai <your-key>"));
+    console.log(theme.dim("    sxai config                      # \u4EA4\u4E92\u5F0F\u914D\u7F6E"));
+  }
+  const agent = new Agent();
+  try {
+    await agent.init();
+    const projectCtx = agent.getContext();
+    if (projectCtx && projectCtx.projectType !== "unknown") {
+      const parts = [projectCtx.projectType];
+      if (projectCtx.frameworks.length > 0) {
+        parts.push(projectCtx.frameworks.join(", "));
+      }
+      console.log(theme.dim(`  \u9879\u76EE ${theme.info(parts.join(" \xB7 "))}`));
+    }
+    printSeparator();
+    console.log();
+  } catch (err) {
+    printError(`\u521D\u59CB\u5316\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  registerQuestionFn((prompt2) => question(rl, prompt2));
+  let ctrlCCount = 0;
+  process.on("SIGINT", () => {
+    ctrlCCount++;
+    if (ctrlCCount >= 2) {
+      console.log();
+      printSuccess(t("exit"));
+      process.exit(0);
+    }
+    console.log(theme.dim("\n(\u518D\u6309\u4E00\u6B21 Ctrl+C \u9000\u51FA)"));
+    setTimeout(() => {
+      ctrlCCount = 0;
+    }, 2e3);
+  });
+  const prompt = theme.user(t("prompt"));
+  while (true) {
+    let input;
+    try {
+      input = await question(rl, prompt);
+    } catch {
+      break;
+    }
+    input = input.trim();
+    if (!input) continue;
+    ctrlCCount = 0;
+    if (input.startsWith("/")) {
+      const result = await handleSlashCommand(input, agent);
+      if (result === "exit") break;
+      continue;
+    }
+    try {
+      await agent.chat(input);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("API key")) {
+        printError("API\u5BC6\u94A5\u672A\u914D\u7F6E\u6216\u65E0\u6548\u3002\u8BF7\u8FD0\u884C sxai config \u914D\u7F6E\u3002");
+      } else if (err instanceof Error && (err.message.includes("ECONNREFUSED") || err.message.includes("fetch failed"))) {
+        printError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216API\u670D\u52A1\u662F\u5426\u53EF\u7528\u3002");
+      } else {
+        printError(`\u9519\u8BEF: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    console.log();
+  }
+  rl.close();
+  console.log();
+  printSuccess(t("exit"));
+  process.exit(0);
+}
+async function handleSlashCommand(input, agent) {
+  const [cmd, ...args] = input.split(" ");
+  switch (cmd) {
+    case "/exit":
+    case "/quit":
+    case "/q":
+      return "exit";
+    case "/help":
+    case "/h":
+      console.log(t("help"));
+      break;
+    case "/clear":
+      agent.clearHistory();
+      printSuccess("\u5BF9\u8BDD\u5386\u53F2\u5DF2\u6E05\u9664\u3002");
+      break;
+    case "/model": {
+      const models = listModels();
+      const currentModel = agent.getCurrentModel();
+      console.log("\n\u53EF\u7528\u6A21\u578B:");
+      for (const m of models) {
+        const marker = m.id === currentModel ? theme.success(" \u25C9") : "  \u25CB";
+        console.log(`${marker} ${theme.bold(m.name)} ${theme.dim(`(${m.id})`)}`);
+      }
+      if (args[0]) {
+        const target = args[0];
+        if (models.find((m) => m.id === target)) {
+          setConfig("model", target);
+          printSuccess(`\u6A21\u578B\u5DF2\u5207\u6362\u4E3A: ${target}`);
+        } else {
+          printError(`\u672A\u77E5\u6A21\u578B: ${target}`);
+        }
+      } else {
+        console.log(theme.dim("\n\u4F7F\u7528 /model <model-id> \u5207\u6362\u6A21\u578B"));
+      }
+      break;
+    }
+    case "/status": {
+      const ctx = agent.getContext();
+      if (ctx) {
+        console.log(`
+\u9879\u76EE: ${ctx.projectName || ctx.rootDir}`);
+        console.log(`\u7C7B\u578B: ${ctx.projectType}`);
+        console.log(`\u6846\u67B6: ${ctx.frameworks.join(", ") || "\u65E0"}`);
+        console.log(`\u8BED\u8A00: ${ctx.languages.join(", ") || "\u672A\u77E5"}`);
+        console.log(`\u5305\u7BA1\u7406\u5668: ${ctx.packageManager}`);
+        console.log(`Git: ${ctx.hasGit ? "\u662F" : "\u5426"}`);
+      }
+      break;
+    }
+    case "/config": {
+      const config3 = getConfig();
+      console.log("\n\u5F53\u524D\u914D\u7F6E:");
+      console.log(`  \u6A21\u578B: ${config3.model}`);
+      console.log(`  \u8BED\u8A00: ${config3.locale}`);
+      console.log(`  \u540E\u7AEF: ${config3.apiBaseUrl}`);
+      console.log(`  \u767B\u5F55: ${config3.userEmail || "\u672A\u767B\u5F55"}`);
+      console.log(`  Kimi Key: ${config3.kimiApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  OpenAI Key: ${config3.openaiApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  Anthropic Key: ${config3.anthropicApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  DeepSeek Key: ${config3.deepseekApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      break;
+    }
+    case "/login":
+      printInfo("\u8BF7\u4F7F\u7528 sxai login \u547D\u4EE4\u767B\u5F55\u3002");
+      break;
+    case "/logout":
+      setConfig("authToken", void 0);
+      setConfig("userEmail", void 0);
+      printSuccess(t("auth.logoutSuccess"));
+      break;
+    default:
+      printError(t("errors.unknownCommand", { command: cmd }));
+  }
+}
+
+// src/commands/config.ts
+import inquirer from "inquirer";
+async function configCommand() {
+  const config3 = getConfig();
+  console.log(`
+\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84: ${getConfigPath()}
+`);
+  const { action } = await inquirer.prompt([{
+    type: "list",
+    name: "action",
+    message: "\u9009\u62E9\u8981\u914D\u7F6E\u7684\u9879\u76EE:",
+    choices: [
+      { name: "\u8BBE\u7F6EAI\u6A21\u578B", value: "model" },
+      { name: "\u8BBE\u7F6EKimi API Key (\u6708\u4E4B\u6697\u9762)", value: "kimi" },
+      { name: "\u8BBE\u7F6EOpenAI API Key", value: "openai" },
+      { name: "\u8BBE\u7F6EAnthropic API Key", value: "anthropic" },
+      { name: "\u8BBE\u7F6EDeepSeek API Key", value: "deepseek" },
+      { name: "\u8BBE\u7F6E\u540E\u7AEF\u670D\u52A1\u5730\u5740", value: "apiBaseUrl" },
+      { name: "\u8BBE\u7F6E\u754C\u9762\u8BED\u8A00", value: "locale" },
+      { name: "\u67E5\u770B\u5F53\u524D\u914D\u7F6E", value: "show" },
+      { name: "\u9000\u51FA", value: "exit" }
+    ]
+  }]);
+  switch (action) {
+    case "model": {
+      const models = listModels();
+      const { model } = await inquirer.prompt([{
+        type: "list",
+        name: "model",
+        message: "\u9009\u62E9AI\u6A21\u578B:",
+        choices: models.map((m) => ({
+          name: `${m.name} (${m.provider})`,
+          value: m.id
+        })),
+        default: config3.model
+      }]);
+      setConfig("model", model);
+      printSuccess(`\u6A21\u578B\u5DF2\u8BBE\u7F6E\u4E3A: ${model}`);
+      break;
+    }
+    case "kimi": {
+      const { key } = await inquirer.prompt([{
+        type: "password",
+        name: "key",
+        message: "\u8F93\u5165Kimi API Key (\u6708\u4E4B\u6697\u9762):",
+        mask: "*"
+      }]);
+      if (key) {
+        setConfig("kimiApiKey", key);
+        printSuccess("Kimi API Key \u5DF2\u4FDD\u5B58\u3002");
+      }
+      break;
+    }
+    case "openai": {
+      const { key } = await inquirer.prompt([{
+        type: "password",
+        name: "key",
+        message: "\u8F93\u5165OpenAI API Key:",
+        mask: "*"
+      }]);
+      if (key) {
+        setConfig("openaiApiKey", key);
+        printSuccess("OpenAI API Key \u5DF2\u4FDD\u5B58\u3002");
+      }
+      break;
+    }
+    case "anthropic": {
+      const { key } = await inquirer.prompt([{
+        type: "password",
+        name: "key",
+        message: "\u8F93\u5165Anthropic API Key:",
+        mask: "*"
+      }]);
+      if (key) {
+        setConfig("anthropicApiKey", key);
+        printSuccess("Anthropic API Key \u5DF2\u4FDD\u5B58\u3002");
+      }
+      break;
+    }
+    case "deepseek": {
+      const { key } = await inquirer.prompt([{
+        type: "password",
+        name: "key",
+        message: "\u8F93\u5165DeepSeek API Key:",
+        mask: "*"
+      }]);
+      if (key) {
+        setConfig("deepseekApiKey", key);
+        printSuccess("DeepSeek API Key \u5DF2\u4FDD\u5B58\u3002");
+      }
+      break;
+    }
+    case "apiBaseUrl": {
+      const { url } = await inquirer.prompt([{
+        type: "input",
+        name: "url",
+        message: "\u8F93\u5165\u540E\u7AEF\u670D\u52A1\u5730\u5740:",
+        default: config3.apiBaseUrl
+      }]);
+      setConfig("apiBaseUrl", url);
+      printSuccess(`\u540E\u7AEF\u5730\u5740\u5DF2\u8BBE\u7F6E\u4E3A: ${url}`);
+      break;
+    }
+    case "locale": {
+      const { locale } = await inquirer.prompt([{
+        type: "list",
+        name: "locale",
+        message: "\u9009\u62E9\u754C\u9762\u8BED\u8A00:",
+        choices: [
+          { name: "\u4E2D\u6587", value: "zh" },
+          { name: "English", value: "en" }
+        ],
+        default: config3.locale
+      }]);
+      setConfig("locale", locale);
+      printSuccess(`\u8BED\u8A00\u5DF2\u8BBE\u7F6E\u4E3A: ${locale}`);
+      break;
+    }
+    case "show": {
+      console.log("\n\u5F53\u524D\u914D\u7F6E:");
+      console.log(`  \u6A21\u578B: ${config3.model}`);
+      console.log(`  \u8BED\u8A00: ${config3.locale}`);
+      console.log(`  \u540E\u7AEF: ${config3.apiBaseUrl}`);
+      console.log(`  \u767B\u5F55: ${config3.userEmail || "\u672A\u767B\u5F55"}`);
+      console.log(`  Kimi Key: ${config3.kimiApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  OpenAI Key: ${config3.openaiApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  Anthropic Key: ${config3.anthropicApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      console.log(`  DeepSeek Key: ${config3.deepseekApiKey ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`);
+      break;
+    }
+    case "exit":
+      break;
+  }
+}
+
+// src/commands/login.ts
+import inquirer2 from "inquirer";
+async function loginCommand() {
+  const config3 = getConfig();
+  if (config3.authToken && config3.userEmail) {
+    printInfo(`\u5F53\u524D\u5DF2\u767B\u5F55: ${config3.userEmail}`);
+    const { relogin } = await inquirer2.prompt([{
+      type: "confirm",
+      name: "relogin",
+      message: "\u662F\u5426\u91CD\u65B0\u767B\u5F55\uFF1F",
+      default: false
+    }]);
+    if (!relogin) return;
+  }
+  console.log(theme.brandBold("\n\u{1F511} \u767B\u5F55\u6C88\u7FD4\u7684AI\u52A9\u624B\n"));
+  const { email } = await inquirer2.prompt([{
+    type: "input",
+    name: "email",
+    message: "\u90AE\u7BB1:",
+    validate: (input) => {
+      if (!input.includes("@")) return "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740";
+      return true;
+    }
+  }]);
+  const { password } = await inquirer2.prompt([{
+    type: "password",
+    name: "password",
+    message: "\u5BC6\u7801:",
+    mask: "*"
+  }]);
+  try {
+    const response = await fetch(`${config3.apiBaseUrl}/api/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      setConfig("authToken", data.token);
+      setConfig("userEmail", data.user.email);
+      console.log();
+      printSuccess("\u767B\u5F55\u6210\u529F\uFF01");
+      console.log(theme.dim(`  \u90AE\u7BB1: ${data.user.email}`));
+      console.log(theme.dim(`  \u8BA1\u5212: ${data.user.plan}`));
+      if (data.user.role === "admin") {
+        console.log(theme.error(`  \u89D2\u8272: \u7BA1\u7406\u5458`));
+      }
+      console.log();
+    } else if (response.status === 404) {
+      printInfo("\u8BE5\u90AE\u7BB1\u5C1A\u672A\u6CE8\u518C");
+      const { register } = await inquirer2.prompt([{
+        type: "confirm",
+        name: "register",
+        message: "\u662F\u5426\u7ACB\u5373\u6CE8\u518C\uFF1F",
+        default: true
+      }]);
+      if (register) {
+        const regResponse = await fetch(`${config3.apiBaseUrl}/api/auth/register`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, password })
+        });
+        if (regResponse.ok) {
+          const data = await regResponse.json();
+          setConfig("authToken", data.token);
+          setConfig("userEmail", data.user.email);
+          printSuccess("\u6CE8\u518C\u5E76\u767B\u5F55\u6210\u529F\uFF01");
+        } else {
+          const err = await regResponse.json();
+          printError(`\u6CE8\u518C\u5931\u8D25: ${err.error || "\u672A\u77E5\u9519\u8BEF"}`);
+        }
+      }
+    } else {
+      const err = await response.json();
+      printError(`\u767B\u5F55\u5931\u8D25: ${err.error || "\u672A\u77E5\u9519\u8BEF"}`);
+    }
+  } catch (err) {
+    printError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\u3002\u8BF7\u68C0\u67E5\u540E\u7AEF\u670D\u52A1\u662F\u5426\u8FD0\u884C\u3002");
+    console.log(theme.dim(`  \u540E\u7AEF\u5730\u5740: ${config3.apiBaseUrl}`));
+    console.log(theme.dim("  \u4F7F\u7528 sxai config \u4FEE\u6539\u540E\u7AEF\u5730\u5740"));
+  }
+}
+
+// src/commands/register.ts
+import inquirer3 from "inquirer";
+async function registerCommand() {
+  const config3 = getConfig();
+  if (config3.authToken && config3.userEmail) {
+    printInfo(`\u5F53\u524D\u5DF2\u767B\u5F55: ${config3.userEmail}`);
+    const { proceed } = await inquirer3.prompt([{
+      type: "confirm",
+      name: "proceed",
+      message: "\u662F\u5426\u6CE8\u518C\u65B0\u8D26\u6237\uFF1F\uFF08\u5C06\u8986\u76D6\u5F53\u524D\u767B\u5F55\u72B6\u6001\uFF09",
+      default: false
+    }]);
+    if (!proceed) return;
+  }
+  console.log(theme.brandBold("\n\u{1F4DD} \u6CE8\u518C\u6C88\u7FD4\u7684AI\u52A9\u624B\u8D26\u6237\n"));
+  const { email } = await inquirer3.prompt([{
+    type: "input",
+    name: "email",
+    message: "\u90AE\u7BB1:",
+    validate: (input) => {
+      if (!input.includes("@")) return "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u90AE\u7BB1\u5730\u5740";
+      return true;
+    }
+  }]);
+  const { name } = await inquirer3.prompt([{
+    type: "input",
+    name: "name",
+    message: "\u6635\u79F0 (\u53EF\u9009):",
+    default: email.split("@")[0]
+  }]);
+  const { password } = await inquirer3.prompt([{
+    type: "password",
+    name: "password",
+    message: "\u5BC6\u7801 (\u81F3\u5C116\u4F4D):",
+    mask: "*",
+    validate: (input) => {
+      if (input.length < 6) return "\u5BC6\u7801\u81F3\u5C116\u4F4D";
+      return true;
+    }
+  }]);
+  const { confirmPassword } = await inquirer3.prompt([{
+    type: "password",
+    name: "confirmPassword",
+    message: "\u786E\u8BA4\u5BC6\u7801:",
+    mask: "*"
+  }]);
+  if (password !== confirmPassword) {
+    printError("\u4E24\u6B21\u5BC6\u7801\u4E0D\u4E00\u81F4");
+    return;
+  }
+  try {
+    const response = await fetch(`${config3.apiBaseUrl}/api/auth/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password, name })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      setConfig("authToken", data.token);
+      setConfig("userEmail", data.user.email);
+      console.log();
+      printSuccess("\u6CE8\u518C\u6210\u529F\uFF01");
+      console.log(theme.dim(`  \u90AE\u7BB1: ${data.user.email}`));
+      console.log(theme.dim(`  \u6635\u79F0: ${data.user.name}`));
+      console.log(theme.dim(`  \u8BA1\u5212: ${data.user.plan}`));
+      console.log(theme.dim(`  \u6BCF\u65E5\u8BF7\u6C42: ${data.user.dailyLimit}\u6B21`));
+      console.log(theme.dim(`  \u514D\u8D39Token: ${formatTokens(data.user.totalFreeTokens)}`));
+      console.log();
+      console.log(theme.info("\u73B0\u5728\u53EF\u4EE5\u76F4\u63A5\u4F7F\u7528 sxai \u5F00\u59CB\u5BF9\u8BDD\u4E86\uFF01"));
+    } else {
+      const err = await response.json();
+      printError(`\u6CE8\u518C\u5931\u8D25: ${err.error || "\u672A\u77E5\u9519\u8BEF"}`);
+    }
+  } catch (err) {
+    printError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\u3002\u8BF7\u68C0\u67E5\u540E\u7AEF\u670D\u52A1\u662F\u5426\u8FD0\u884C\u3002");
+    console.log(theme.dim(`  \u540E\u7AEF\u5730\u5740: ${config3.apiBaseUrl}`));
+    console.log(theme.dim("  \u4F7F\u7528 sxai config \u4FEE\u6539\u540E\u7AEF\u5730\u5740"));
+  }
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+
+// src/commands/account.ts
+async function accountCommand() {
+  const config3 = getConfig();
+  if (!config3.authToken) {
+    printWarning("\u5C1A\u672A\u767B\u5F55\u3002\u8BF7\u5148\u6CE8\u518C\u6216\u767B\u5F55:");
+    console.log(theme.dim("  sxai register   # \u6CE8\u518C\u65B0\u8D26\u6237"));
+    console.log(theme.dim("  sxai login      # \u767B\u5F55\u5DF2\u6709\u8D26\u6237"));
+    return;
+  }
+  try {
+    const response = await fetch(`${config3.apiBaseUrl}/api/auth/me`, {
+      headers: { "Authorization": `Bearer ${config3.authToken}` }
+    });
+    if (response.status === 401) {
+      printError("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55: sxai login");
+      return;
+    }
+    if (!response.ok) {
+      printError("\u83B7\u53D6\u8D26\u6237\u4FE1\u606F\u5931\u8D25");
+      return;
+    }
+    const data = await response.json();
+    const { user, quota, usage } = data;
+    console.log();
+    console.log(theme.brandBold("  \u{1F4CB} \u8D26\u6237\u4FE1\u606F"));
+    console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  \u90AE\u7BB1    ${theme.info(user.email)}`);
+    console.log(`  \u6635\u79F0    ${user.name || "-"}`);
+    console.log(`  \u89D2\u8272    ${user.role === "admin" ? theme.error("\u7BA1\u7406\u5458") : "\u666E\u901A\u7528\u6237"}`);
+    console.log(`  \u8BA1\u5212    ${planLabel(user.plan)}`);
+    console.log(`  \u72B6\u6001    ${user.isActive ? theme.success("\u2713 \u6B63\u5E38") : theme.error("\u2717 \u5DF2\u7981\u7528")}`);
+    console.log(`  \u6CE8\u518C    ${new Date(user.createdAt).toLocaleDateString("zh-CN")}`);
+    if (quota) {
+      console.log();
+      console.log(theme.brandBold("  \u{1F4CA} \u989D\u5EA6"));
+      console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      const dailyBar = progressBar(quota.daily.used, quota.daily.limit);
+      console.log(`  \u4ECA\u65E5\u8BF7\u6C42  ${dailyBar}  ${quota.daily.used}/${quota.daily.limit}`);
+      const monthBar = progressBar(quota.monthlyTokens.used, quota.monthlyTokens.limit);
+      console.log(`  \u672C\u6708Token ${monthBar}  ${fmtTokens(quota.monthlyTokens.used)}/${fmtTokens(quota.monthlyTokens.limit)}`);
+      const lifeBar = progressBar(quota.lifetimeTokens.used, quota.lifetimeTokens.limit);
+      console.log(`  \u514D\u8D39\u989D\u5EA6  ${lifeBar}  ${fmtTokens(quota.lifetimeTokens.used)}/${fmtTokens(quota.lifetimeTokens.limit)}`);
+      if (!quota.allowed) {
+        console.log();
+        printWarning(quota.reason || "\u989D\u5EA6\u5DF2\u7528\u5B8C");
+      }
+    }
+    if (usage) {
+      console.log();
+      console.log(theme.brandBold("  \u{1F4C8} \u7528\u91CF\u7EDF\u8BA1"));
+      console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(`  \u4ECA\u65E5    ${usage.today.requests}\u6B21\u8BF7\u6C42  \xB7  ${fmtTokens(usage.today.tokens)} tokens`);
+      console.log(`  \u672C\u6708    ${usage.thisMonth.requests}\u6B21\u8BF7\u6C42  \xB7  ${fmtTokens(usage.thisMonth.tokens)} tokens`);
+      console.log(`  \u7D2F\u8BA1    ${usage.lifetime.requests}\u6B21\u8BF7\u6C42  \xB7  ${fmtTokens(usage.lifetime.tokens)} tokens`);
+    }
+    console.log();
+  } catch (err) {
+    printError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\u3002\u8BF7\u68C0\u67E5\u540E\u7AEF\u670D\u52A1\u662F\u5426\u8FD0\u884C\u3002");
+    console.log(theme.dim(`  \u540E\u7AEF\u5730\u5740: ${config3.apiBaseUrl}`));
+  }
+}
+function planLabel(plan) {
+  switch (plan) {
+    case "free":
+      return theme.dim("\u514D\u8D39\u7248");
+    case "pro":
+      return theme.success("\u4E13\u4E1A\u7248");
+    case "enterprise":
+      return theme.info("\u4F01\u4E1A\u7248");
+    default:
+      return plan;
+  }
+}
+function fmtTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+function progressBar(used, limit, width = 16) {
+  if (limit === 0) return theme.dim("[" + "\u2591".repeat(width) + "]");
+  const ratio = Math.min(1, used / limit);
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  const color = ratio < 0.6 ? theme.success : ratio < 0.85 ? theme.warning : theme.error;
+  return color("[" + "\u2588".repeat(filled) + "\u2591".repeat(empty) + "]");
+}
+
+// src/commands/admin.ts
+import inquirer4 from "inquirer";
+async function adminCommand() {
+  const config3 = getConfig();
+  if (!config3.authToken) {
+    printWarning("\u8BF7\u5148\u767B\u5F55\u7BA1\u7406\u5458\u8D26\u6237: sxai login");
+    return;
+  }
+  console.log(theme.brandBold("\n\u2699\uFE0F  \u7BA1\u7406\u5458\u63A7\u5236\u53F0\n"));
+  const { action } = await inquirer4.prompt([{
+    type: "list",
+    name: "action",
+    message: "\u9009\u62E9\u64CD\u4F5C:",
+    choices: [
+      { name: "\u{1F4CB} \u67E5\u770B\u6240\u6709\u7528\u6237", value: "list" },
+      { name: "\u{1F3AF} \u8BBE\u7F6E\u7528\u6237\u989D\u5EA6", value: "quota" },
+      { name: "\u{1F4CA} \u4FEE\u6539\u7528\u6237\u8BA1\u5212", value: "plan" },
+      { name: "\u{1F451} \u7BA1\u7406\u7528\u6237\u89D2\u8272", value: "role" },
+      { name: "\u{1F504} \u91CD\u7F6E\u7528\u91CF\u8BA1\u6570", value: "reset" },
+      { name: "\u{1F6AB} \u542F\u7528/\u7981\u7528\u7528\u6237", value: "status" },
+      { name: "\u{1F4C8} \u5E73\u53F0\u7EDF\u8BA1", value: "stats" },
+      { name: "\u9000\u51FA", value: "exit" }
+    ]
+  }]);
+  switch (action) {
+    case "list":
+      await listUsers(config3);
+      break;
+    case "quota":
+      await setUserQuota(config3);
+      break;
+    case "plan":
+      await setUserPlan(config3);
+      break;
+    case "role":
+      await setUserRole(config3);
+      break;
+    case "reset":
+      await resetUsage(config3);
+      break;
+    case "status":
+      await toggleUserStatus(config3);
+      break;
+    case "stats":
+      await showStats(config3);
+      break;
+    case "exit":
+      break;
+  }
+}
+async function adminFetch(config3, path5, options) {
+  const response = await fetch(`${config3.apiBaseUrl}${path5}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config3.authToken}`,
+      ...options?.headers || {}
+    }
+  });
+  if (response.status === 403) {
+    printError("\u9700\u8981\u7BA1\u7406\u5458\u6743\u9650\u3002\u5F53\u524D\u8D26\u6237\u4E0D\u662F\u7BA1\u7406\u5458\u3002");
+    return null;
+  }
+  if (response.status === 401) {
+    printError("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55: sxai login");
+    return null;
+  }
+  return response;
+}
+async function listUsers(config3) {
+  try {
+    const resp = await adminFetch(config3, "/api/admin/users");
+    if (!resp) return;
+    const data = await resp.json();
+    console.log(theme.dim(`
+  \u5171 ${data.pagination.total} \u4E2A\u7528\u6237
+`));
+    console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  ${"\u90AE\u7BB1".padEnd(28)} ${"\u8BA1\u5212".padEnd(8)} ${"\u89D2\u8272".padEnd(8)} ${"\u65E5\u9650".padEnd(6)} ${"\u514D\u8D39\u989D\u5EA6".padEnd(12)} ${"\u5DF2\u7528"}`);
+    console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const u of data.users) {
+      const status = u.isActive ? "" : theme.error(" [\u7981\u7528]");
+      const roleTag = u.role === "admin" ? theme.error("\u7BA1\u7406\u5458") : "\u7528\u6237  ";
+      const planTag = u.plan === "free" ? theme.dim("\u514D\u8D39  ") : u.plan === "pro" ? theme.success("\u4E13\u4E1A  ") : theme.info("\u4F01\u4E1A  ");
+      console.log(
+        `  ${(u.email + status).padEnd(28)} ${planTag} ${roleTag} ${String(u.dailyLimit).padEnd(6)} ${fmtTokens2(u.totalFreeTokens).padEnd(12)} ${fmtTokens2(u.totalTokensUsed)}`
+      );
+    }
+    console.log();
+  } catch {
+    printError("\u83B7\u53D6\u7528\u6237\u5217\u8868\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function setUserQuota(config3) {
+  const users = await fetchUserList(config3);
+  if (!users) return;
+  const { userId } = await inquirer4.prompt([{
+    type: "list",
+    name: "userId",
+    message: "\u9009\u62E9\u7528\u6237:",
+    choices: users.map((u) => ({ name: `${u.email} (${u.plan})`, value: u.id }))
+  }]);
+  const selectedUser = users.find((u) => u.id === userId);
+  console.log(theme.dim(`
+  \u5F53\u524D\u989D\u5EA6: \u65E5\u9650=${selectedUser.dailyLimit}\u6B21  \u6708Token=${fmtTokens2(selectedUser.monthlyTokenLimit)}  \u514D\u8D39\u603B\u989D=${fmtTokens2(selectedUser.totalFreeTokens)}
+`));
+  const { dailyLimit } = await inquirer4.prompt([{
+    type: "number",
+    name: "dailyLimit",
+    message: "\u6BCF\u65E5\u8BF7\u6C42\u4E0A\u9650:",
+    default: selectedUser.dailyLimit
+  }]);
+  const { monthlyTokenLimit } = await inquirer4.prompt([{
+    type: "number",
+    name: "monthlyTokenLimit",
+    message: "\u6BCF\u6708Token\u4E0A\u9650:",
+    default: selectedUser.monthlyTokenLimit
+  }]);
+  const { totalFreeTokens } = await inquirer4.prompt([{
+    type: "number",
+    name: "totalFreeTokens",
+    message: "\u514D\u8D39Token\u603B\u989D:",
+    default: selectedUser.totalFreeTokens
+  }]);
+  try {
+    const resp = await adminFetch(config3, `/api/admin/users/${userId}/quota`, {
+      method: "PUT",
+      body: JSON.stringify({ dailyLimit, monthlyTokenLimit, totalFreeTokens })
+    });
+    if (!resp) return;
+    if (resp.ok) {
+      const data = await resp.json();
+      printSuccess(data.message);
+    } else {
+      const err = await resp.json();
+      printError(err.error);
+    }
+  } catch {
+    printError("\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function setUserPlan(config3) {
+  const users = await fetchUserList(config3);
+  if (!users) return;
+  const { userId } = await inquirer4.prompt([{
+    type: "list",
+    name: "userId",
+    message: "\u9009\u62E9\u7528\u6237:",
+    choices: users.map((u) => ({ name: `${u.email} (\u5F53\u524D: ${u.plan})`, value: u.id }))
+  }]);
+  const { plan } = await inquirer4.prompt([{
+    type: "list",
+    name: "plan",
+    message: "\u9009\u62E9\u8BA1\u5212:",
+    choices: [
+      { name: "\u514D\u8D39\u7248 (50\u6B21/\u5929, 500K tokens/\u6708, 1M \u603B\u989D)", value: "free" },
+      { name: "\u4E13\u4E1A\u7248 (500\u6B21/\u5929, 5M tokens/\u6708, 50M \u603B\u989D)", value: "pro" },
+      { name: "\u4F01\u4E1A\u7248 (5000\u6B21/\u5929, 50M tokens/\u6708, 500M \u603B\u989D)", value: "enterprise" }
+    ]
+  }]);
+  try {
+    const resp = await adminFetch(config3, `/api/admin/users/${userId}/plan`, {
+      method: "PUT",
+      body: JSON.stringify({ plan })
+    });
+    if (!resp) return;
+    if (resp.ok) {
+      const data = await resp.json();
+      printSuccess(data.message);
+    } else {
+      const err = await resp.json();
+      printError(err.error);
+    }
+  } catch {
+    printError("\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function setUserRole(config3) {
+  const users = await fetchUserList(config3);
+  if (!users) return;
+  const { userId } = await inquirer4.prompt([{
+    type: "list",
+    name: "userId",
+    message: "\u9009\u62E9\u7528\u6237:",
+    choices: users.map((u) => ({
+      name: `${u.email} (${u.role === "admin" ? "\u7BA1\u7406\u5458" : "\u666E\u901A\u7528\u6237"})`,
+      value: u.id
+    }))
+  }]);
+  const { role } = await inquirer4.prompt([{
+    type: "list",
+    name: "role",
+    message: "\u8BBE\u7F6E\u89D2\u8272:",
+    choices: [
+      { name: "\u666E\u901A\u7528\u6237", value: "user" },
+      { name: "\u7BA1\u7406\u5458", value: "admin" }
+    ]
+  }]);
+  try {
+    const resp = await adminFetch(config3, `/api/admin/users/${userId}/role`, {
+      method: "PUT",
+      body: JSON.stringify({ role })
+    });
+    if (!resp) return;
+    if (resp.ok) {
+      const data = await resp.json();
+      printSuccess(data.message);
+    } else {
+      const err = await resp.json();
+      printError(err.error);
+    }
+  } catch {
+    printError("\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function resetUsage(config3) {
+  const users = await fetchUserList(config3);
+  if (!users) return;
+  const { userId } = await inquirer4.prompt([{
+    type: "list",
+    name: "userId",
+    message: "\u9009\u62E9\u7528\u6237:",
+    choices: users.map((u) => ({
+      name: `${u.email} (\u5DF2\u7528 ${fmtTokens2(u.totalTokensUsed)} tokens)`,
+      value: u.id
+    }))
+  }]);
+  const { confirm } = await inquirer4.prompt([{
+    type: "confirm",
+    name: "confirm",
+    message: "\u786E\u5B9A\u8981\u91CD\u7F6E\u8BE5\u7528\u6237\u7684\u7D2F\u8BA1\u7528\u91CF\u5417\uFF1F",
+    default: false
+  }]);
+  if (!confirm) return;
+  try {
+    const resp = await adminFetch(config3, `/api/admin/users/${userId}/reset-usage`, {
+      method: "POST"
+    });
+    if (!resp) return;
+    if (resp.ok) {
+      printSuccess("\u7528\u91CF\u5DF2\u91CD\u7F6E");
+    } else {
+      const err = await resp.json();
+      printError(err.error);
+    }
+  } catch {
+    printError("\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function toggleUserStatus(config3) {
+  const users = await fetchUserList(config3);
+  if (!users) return;
+  const { userId } = await inquirer4.prompt([{
+    type: "list",
+    name: "userId",
+    message: "\u9009\u62E9\u7528\u6237:",
+    choices: users.map((u) => ({
+      name: `${u.email} (${u.isActive ? "\u6B63\u5E38" : "\u5DF2\u7981\u7528"})`,
+      value: u.id
+    }))
+  }]);
+  const user = users.find((u) => u.id === userId);
+  const newStatus = !user.isActive;
+  try {
+    const resp = await adminFetch(config3, `/api/admin/users/${userId}/status`, {
+      method: "PUT",
+      body: JSON.stringify({ isActive: newStatus })
+    });
+    if (!resp) return;
+    if (resp.ok) {
+      const data = await resp.json();
+      printSuccess(data.message);
+    } else {
+      const err = await resp.json();
+      printError(err.error);
+    }
+  } catch {
+    printError("\u64CD\u4F5C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function showStats(config3) {
+  try {
+    const resp = await adminFetch(config3, "/api/admin/stats");
+    if (!resp) return;
+    const data = await resp.json();
+    console.log(theme.brandBold("\n  \u{1F4C8} \u5E73\u53F0\u7EDF\u8BA1"));
+    console.log(theme.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`  \u7528\u6237\u603B\u6570    ${data.users.total}`);
+    console.log(`  \u6D3B\u8DC3\u7528\u6237    ${data.users.active}`);
+    console.log(`  \u603B\u8BF7\u6C42\u6570    ${data.usage.totalRequests}`);
+    console.log(`  \u603BToken\u7528\u91CF  ${fmtTokens2(Number(data.usage.totalTokens))}`);
+    console.log();
+  } catch {
+    printError("\u83B7\u53D6\u7EDF\u8BA1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u3002");
+  }
+}
+async function fetchUserList(config3) {
+  try {
+    const resp = await adminFetch(config3, "/api/admin/users?limit=100");
+    if (!resp) return null;
+    const data = await resp.json();
+    if (!data.users || data.users.length === 0) {
+      printInfo("\u6682\u65E0\u7528\u6237");
+      return null;
+    }
+    return data.users;
+  } catch {
+    printError("\u83B7\u53D6\u7528\u6237\u5217\u8868\u5931\u8D25");
+    return null;
+  }
+}
+function fmtTokens2(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+
+// src/index.ts
+var program = new Command();
+var config2 = getConfig();
+setLocale(config2.locale);
+program.name("sxai").description(t("description")).version("0.1.0");
+program.command("chat", { isDefault: true }).description("\u542F\u52A8\u4EA4\u4E92\u5F0FAI\u5BF9\u8BDD\uFF08\u9ED8\u8BA4\u547D\u4EE4\uFF09").option("-m, --model <model>", "\u6307\u5B9AAI\u6A21\u578B", config2.model).action(async (options) => {
+  if (options.model && options.model !== config2.model) {
+    setConfig("model", options.model);
+  }
+  await chatCommand();
+});
+program.command("register").description("\u6CE8\u518C\u65B0\u8D26\u6237").action(async () => {
+  await registerCommand();
+});
+program.command("login").description("\u767B\u5F55\u8D26\u6237").action(async () => {
+  await loginCommand();
+});
+program.command("logout").description("\u9000\u51FA\u767B\u5F55").action(() => {
+  setConfig("authToken", void 0);
+  setConfig("userEmail", void 0);
+  printSuccess("\u5DF2\u9000\u51FA\u767B\u5F55");
+});
+program.command("account").alias("me").description("\u67E5\u770B\u8D26\u6237\u4FE1\u606F\u3001\u989D\u5EA6\u548C\u7528\u91CF").action(async () => {
+  await accountCommand();
+});
+program.command("admin").description("\u7BA1\u7406\u5458\u63A7\u5236\u53F0\uFF08\u7BA1\u7406\u7528\u6237\u3001\u8BBE\u7F6E\u989D\u5EA6\uFF09").action(async () => {
+  await adminCommand();
+});
+program.command("config").description("\u914D\u7F6E\u6C88\u7FD4\u7684AI\u52A9\u624B").action(async () => {
+  await configCommand();
+});
+program.command("set-key <provider> <key>").description("\u8BBE\u7F6EAPI\u5BC6\u94A5 (provider: openai, anthropic, deepseek, kimi)").action((provider, key) => {
+  const keyMap = {
+    openai: "openaiApiKey",
+    anthropic: "anthropicApiKey",
+    deepseek: "deepseekApiKey",
+    kimi: "kimiApiKey"
+  };
+  const configKey = keyMap[provider];
+  if (!configKey) {
+    console.error(`\u672A\u77E5\u7684\u63D0\u4F9B\u5546: ${provider}\u3002\u652F\u6301: openai, anthropic, deepseek, kimi`);
+    process.exit(1);
+  }
+  setConfig(configKey, key);
+  printSuccess(`${provider} API Key \u5DF2\u4FDD\u5B58\u3002`);
+});
+program.parse();