inspiration-agent 0.0.1

package/dist/agent/ai.agent.js

@@ -0,0 +1,712 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const logger = require("../utils/logger");
+
+const DeepSeekService = require("../model/deepseek.service");
+const KimiService = require("../model/kimi.service");
+const ZhipuService = require("../model/zhipu.service");
+const MiniMaxService = require("../model/minimax.service");
+const FileTools = require("../tools/file.tools");
+const CommandTools = require("../tools/command.tools");
+const SearchTools = require("../tools/search.tools");
+const BrowserTools = require("../tools/browser.tools");
+const SchedulerTools = require("../tools/scheduler.tools");
+const MemoryTools = require("../tools/memory.tools");
+const DatabaseService = require("../services/database.service");
+const MemoryManager = require("../services/memory.manager");
+const MessageQueue = require("../services/message.queue");
+const TerminalMarkdownRenderer = require("../utils/markdown-renderer");
+
+const SUPPORTED_LLM_PROVIDERS = {
+  deepseek: DeepSeekService,
+  kimi: KimiService,
+  zhipu: ZhipuService,
+  minimax: MiniMaxService,
+};
+
+/**
+ * AI 智能体类
+ * 负责处理用户消息，调用工具，并管理记忆
+ */
+class AIAgent {
+  constructor() {
+    this.llm = this.createLLMService();
+    this.fileTools = new FileTools();
+    this.commandTools = new CommandTools();
+    this.searchTools = new SearchTools();
+    this.browserTools = new BrowserTools();
+    this.dbService = new DatabaseService();
+    this.schedulerTools = new SchedulerTools(this.dbService, (prompt) =>
+      this.executeScheduledPrompt(prompt)
+    );
+    this.memoryManager = new MemoryManager(this.dbService, 20);
+    this.memoryTools = new MemoryTools(this.memoryManager);
+    this.messageQueue = new MessageQueue();
+    this.systemPrompt = this.loadSystemPrompt();
+    this.enableStream = process.env.ENABLE_STREAM !== "false";
+    this.markdownRenderer = new TerminalMarkdownRenderer();
+    this.startTime = Date.now();
+    this.shouldShutdown = false;
+
+    this.llm.setTokenUsageCallback((inputTokens, outputTokens) => {
+      this.recordTokenUsage(inputTokens, outputTokens);
+    });
+
+    this.setupMessageQueue();
+    this.registerToolHandlers();
+  }
+
+  createLLMService() {
+    const provider = (process.env.LLM_PROVIDER || "deepseek").toLowerCase();
+    const ServiceClass = SUPPORTED_LLM_PROVIDERS[provider];
+
+    if (!ServiceClass) {
+      logger.warn(`未知的 LLM 提供商: ${provider}，使用默认的 deepseek`);
+      return new DeepSeekService();
+    }
+
+    logger.info(`使用 LLM 提供商: ${provider}`);
+    return new ServiceClass();
+  }
+
+  getLLMProvider() {
+    return process.env.LLM_PROVIDER || "deepseek";
+  }
+
+  getLLMModel() {
+    return this.llm.model;
+  }
+
+  setupMessageQueue() {
+    this.messageQueue.registerHandler("feishu", async (message, metadata) => {
+      return await this.processMessageInternal(message, metadata);
+    });
+
+    this.messageQueue.registerHandler("terminal", async (message, metadata) => {
+      return await this.processMessageInternal(message, metadata);
+    });
+
+    this.messageQueue.registerHandler("scheduled", async (message, metadata) => {
+      return await this.processMessageInternal(message, metadata);
+    });
+
+    this.messageQueue.registerHandler("cli", async (message, metadata) => {
+      return await this.processMessageInternal(message, metadata);
+    });
+  }
+
+  async processMessageInternal(message, metadata = {}) {
+    let result;
+    if (this.enableStream) {
+      const response = await this.processMessageStream(message);
+      result = response?.content || "";
+      this.lastProcessedResponse = result;
+    } else {
+      const response = await this.processMessage(message);
+      result = response.content;
+      this.lastProcessedResponse = result;
+    }
+    return result;
+  }
+
+  enqueueMessage(message, source = "terminal", metadata = {}) {
+    return this.messageQueue.enqueue(message, source, metadata);
+  }
+
+  getQueueStatus() {
+    return this.messageQueue.getStatus();
+  }
+
+  /**
+   * 加载系统提示词
+   * @returns {string} 系统提示词内容
+   */
+  loadSystemPrompt() {
+    try {
+      const promptPath = path.join(__dirname, "../config/system.prompt.txt");
+      const prompt = fs.readFileSync(promptPath, "utf-8");
+      return prompt.trim();
+    } catch (error) {
+      logger.error(`无法读取 system prompt 文件: ${error.message}`);
+      return "你是一个智能 AI 助手。";
+    }
+  }
+
+  /**
+   * 初始化数据库
+   * @returns {Promise<{success: boolean, message: string}>} 初始化结果
+   */
+  async initDatabase() {
+    try {
+      await this.dbService.connect();
+      await this.dbService.initTables();
+      await this.schedulerTools.init();
+      return { success: true, message: "数据库初始化成功" };
+    } catch (error) {
+      logger.error(`数据库初始化失败: ${error.message}`);
+      return { success: false, message: `数据库初始化失败: ${error.message}` };
+    }
+  }
+
+  /**
+   * 设置飞书服务（用于定时任务推送）
+   * @param {Object} feishuService - 飞书服务实例
+   * @param {string} chatId - 默认推送的聊天 ID
+   */
+  setFeishuService(feishuService, chatId = null) {
+    this.schedulerTools.setFeishuService(feishuService);
+    if (chatId) {
+      this.schedulerTools.setDefaultChatId(chatId);
+    }
+    logger.info("已为定时任务设置飞书服务");
+  }
+
+  /**
+   * 注册工具处理器
+   * 将文件工具、命令行工具、智能体工具、搜索工具和浏览器工具注册到 DeepSeek 服务中
+   */
+  registerToolHandlers() {
+    // File tools handlers
+    this.llm.registerToolHandler("read_file", (args) => this.fileTools.readFile(args));
+    this.llm.registerToolHandler("write_file", (args) => this.fileTools.writeFile(args));
+    this.llm.registerToolHandler("list_files", (args) => this.fileTools.listFiles(args));
+    this.llm.registerToolHandler("delete_file", (args) => this.fileTools.deleteFile(args));
+
+    // Command tools handlers
+    this.llm.registerToolHandler("execute_command", (args) =>
+      this.commandTools.executeCommand(args)
+    );
+
+    // Search tools handlers
+    this.llm.registerToolHandler("web_search", (args) => this.searchTools.webSearch(args));
+    this.llm.registerToolHandler("fetch_web_page", (args) =>
+      this.searchTools.fetchWebPage(args)
+    );
+
+    // Browser tools handlers
+    this.llm.registerToolHandler("launch_browser", (args) =>
+      this.browserTools.launchBrowser(args)
+    );
+    this.llm.registerToolHandler("navigate_to", (args) => this.browserTools.navigateTo(args));
+    this.llm.registerToolHandler("click_element", (args) =>
+      this.browserTools.clickElement(args)
+    );
+    this.llm.registerToolHandler("fill_input", (args) => this.browserTools.fillInput(args));
+    this.llm.registerToolHandler("get_page_content", (args) =>
+      this.browserTools.getPageContent(args)
+    );
+    this.llm.registerToolHandler("wait_for_element", (args) =>
+      this.browserTools.waitForElement(args)
+    );
+    this.llm.registerToolHandler("execute_script", (args) =>
+      this.browserTools.executeScript(args)
+    );
+    this.llm.registerToolHandler("close_browser", (args) =>
+      this.browserTools.closeBrowser(args)
+    );
+
+    // Scheduler tools handlers
+    this.llm.registerToolHandler("create_scheduled_task", (args) =>
+      this.schedulerTools.createScheduledTask(args)
+    );
+    this.llm.registerToolHandler("get_all_scheduled_tasks", (args) =>
+      this.schedulerTools.getAllScheduledTasks(args)
+    );
+    this.llm.registerToolHandler("get_scheduled_task", (args) =>
+      this.schedulerTools.getScheduledTask(args)
+    );
+    this.llm.registerToolHandler("update_scheduled_task", (args) =>
+      this.schedulerTools.updateScheduledTask(args)
+    );
+    this.llm.registerToolHandler("delete_scheduled_task", (args) =>
+      this.schedulerTools.deleteScheduledTask(args)
+    );
+    this.llm.registerToolHandler("toggle_scheduled_task", (args) =>
+      this.schedulerTools.toggleScheduledTask(args)
+    );
+
+    // Memory tools handlers
+    this.llm.registerToolHandler("save_memory", (args) => this.memoryTools.saveMemory(args));
+    this.llm.registerToolHandler("save_short_term_memory", (args) =>
+      this.memoryTools.saveShortTermMemory(args)
+    );
+    this.llm.registerToolHandler("search_memories", (args) =>
+      this.memoryTools.searchMemories(args)
+    );
+    this.llm.registerToolHandler("get_all_memories", (args) =>
+      this.memoryTools.getAllMemories(args)
+    );
+    this.llm.registerToolHandler("delete_memory", (args) =>
+      this.memoryTools.deleteMemory(args)
+    );
+    this.llm.registerToolHandler("clear_short_term_memory", (args) =>
+      this.memoryTools.clearShortTermMemory(args)
+    );
+    this.llm.registerToolHandler("get_memory_stats", (args) =>
+      this.memoryTools.getMemoryStats(args)
+    );
+  }
+
+  /**
+   * 处理用户消息（流式输出）
+   * 构建上下文，调用 DeepSeek API，并更新记忆
+   * 支持函数调用，当模型返回 tool_calls 时自动处理
+   * @param {string} userMessage - 用户消息
+   * @returns {Promise<Object>} AI 响应
+   */
+  async processMessageStream(userMessage) {
+    const context = await this.memoryManager.buildFullContext(userMessage);
+
+    const messages = [
+      {
+        role: "system",
+        content: this.systemPrompt,
+      },
+      ...context,
+      {
+        role: "user",
+        content: userMessage,
+      },
+    ];
+
+    const limitedMessages = this.memoryManager.limitContextLength(messages);
+
+    const fileTools = this.fileTools.getFunctionDefinitions();
+    const commandTools = this.commandTools.getFunctionDefinitions();
+    const searchTools = this.searchTools.getFunctionDefinitions();
+    const browserTools = this.browserTools.getFunctionDefinitions();
+    const schedulerTools = this.schedulerTools.getFunctionDefinitions();
+    const memoryTools = this.memoryTools.getFunctionDefinitions();
+    const tools = [
+      ...fileTools,
+      ...commandTools,
+      ...searchTools,
+      ...browserTools,
+      ...schedulerTools,
+      ...memoryTools,
+    ];
+
+    let buffer = "";
+    let lastVisibleLength = 0;
+
+    process.stdout.write("AI: ");
+
+    const response = await this.llm.chatWithFunctionCallsStream(
+      limitedMessages,
+      (chunk) => {
+        buffer += chunk;
+        const rendered = this.markdownRenderer.render(buffer);
+        const currentVisibleLength = this.markdownRenderer.getVisibleLength(rendered);
+        const newContent = this.markdownRenderer.sliceByVisibleLength(
+          rendered,
+          lastVisibleLength,
+          currentVisibleLength
+        );
+        if (newContent) {
+          process.stdout.write(newContent);
+          lastVisibleLength = currentVisibleLength;
+        }
+      },
+      tools
+    );
+
+    process.stdout.write("\n\n");
+
+    this.memoryManager.addMessage("user", userMessage);
+    this.memoryManager.addMessage("assistant", response.content);
+
+    return response;
+  }
+
+  /**
+   * 处理用户消息
+   * 构建上下文，调用 DeepSeek API，并更新记忆
+   * @param {string} userMessage - 用户消息
+   * @returns {Promise<Object>} AI 响应
+   */
+  async processMessage(userMessage) {
+    const context = await this.memoryManager.buildFullContext(userMessage);
+
+    const messages = [
+      {
+        role: "system",
+        content: this.systemPrompt,
+      },
+      ...context,
+      {
+        role: "user",
+        content: userMessage,
+      },
+    ];
+
+    const limitedMessages = this.memoryManager.limitContextLength(messages);
+
+    const fileTools = this.fileTools.getFunctionDefinitions();
+    const commandTools = this.commandTools.getFunctionDefinitions();
+    const searchTools = this.searchTools.getFunctionDefinitions();
+    const browserTools = this.browserTools.getFunctionDefinitions();
+    const schedulerTools = this.schedulerTools.getFunctionDefinitions();
+    const memoryTools = this.memoryTools.getFunctionDefinitions();
+    const tools = [
+      ...fileTools,
+      ...commandTools,
+      ...searchTools,
+      ...browserTools,
+      ...schedulerTools,
+      ...memoryTools,
+    ];
+
+    const response = await this.llm.chatWithFunctionCalls(limitedMessages, tools);
+
+    const renderedContent = this.markdownRenderer.render(response.content);
+
+    this.memoryManager.addMessage("user", userMessage);
+    this.memoryManager.addMessage("assistant", response.content);
+
+    return response;
+  }
+
+  /**
+   * 清空会话上下文
+   */
+  clearContext() {
+    this.memoryManager.clearShortTerm();
+    logger.info("会话上下文已清空");
+  }
+
+  /**
+   * 执行定时任务的提示词
+   * @param {string} prompt - 定时任务的提示词
+   * @returns {Promise<string>} 执行结果
+   */
+  async executeScheduledPrompt(prompt) {
+    try {
+      logger.info(`执行定时任务提示词: ${prompt.substring(0, 50)}...`);
+
+      const queueStatus = this.getQueueStatus();
+      if (queueStatus.queueLength > 0 || queueStatus.isProcessing) {
+        logger.info(
+          `定时任务已加入队列 (队列长度: ${queueStatus.queueLength}, 处理中: ${queueStatus.isProcessing})`
+        );
+      }
+
+      this.enqueueMessage(prompt, "scheduled");
+
+      await this.messageQueue.waitForIdle(300000);
+
+      const result = this.lastProcessedResponse;
+      if (result) {
+        logger.info(`定时任务执行结果: ${result.substring(0, 100)}...`);
+      }
+      return result;
+    } catch (error) {
+      logger.error(`执行定时任务提示词失败: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 记录 token 使用量
+   * @param {number} inputTokens - 输入 token 数量
+   * @param {number} outputTokens - 输出 token 数量
+   */
+  async recordTokenUsage(inputTokens, outputTokens) {
+    try {
+      await this.dbService.recordTokenUsage(inputTokens, outputTokens);
+      logger.debug(`Token 使用已记录: 输入 ${inputTokens}, 输出 ${outputTokens}`);
+    } catch (error) {
+      logger.error(`记录 token 使用失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取 token 使用统计
+   * @returns {Promise<Object>} token 使用统计
+   */
+  async getTokenStats() {
+    try {
+      const todayUsage = await this.dbService?.getTodayTokenUsage() || {
+        date: new Date().toISOString().split("T")[0],
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        requestCount: 0,
+      };
+      const totalUsage = await this.dbService?.getTotalTokenUsage() || {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        totalRequestCount: 0,
+      };
+      return {
+        today: todayUsage,
+        total: totalUsage,
+      };
+    } catch (error) {
+      logger.error(`获取 token 统计失败: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 显示 token 使用统计
+   */
+  async showTokenStats() {
+    try {
+      const stats = await this.getTokenStats();
+      if (!stats) {
+        process.stdout.write("\n无法获取 token 统计信息\n\n");
+        return;
+      }
+
+      const formatNumber = (num) => num.toLocaleString();
+
+      process.stdout.write("\n========== Token 使用统计 ==========\n");
+      process.stdout.write(`\n今日消耗 (${stats.today.date}):\n`);
+      process.stdout.write(`  输入 Token: ${formatNumber(stats.today.inputTokens)}\n`);
+      process.stdout.write(`  输出 Token: ${formatNumber(stats.today.outputTokens)}\n`);
+      process.stdout.write(`  总计 Token: ${formatNumber(stats.today.totalTokens)}\n`);
+      process.stdout.write(`  请求次数: ${formatNumber(stats.today.requestCount)}\n`);
+      process.stdout.write(`\n累计消耗:\n`);
+      process.stdout.write(`  输入 Token: ${formatNumber(stats.total.totalInputTokens)}\n`);
+      process.stdout.write(`  输出 Token: ${formatNumber(stats.total.totalOutputTokens)}\n`);
+      process.stdout.write(`  总计 Token: ${formatNumber(stats.total.totalTokens)}\n`);
+      process.stdout.write(`  请求次数: ${formatNumber(stats.total.totalRequestCount)}\n`);
+      process.stdout.write("====================================\n\n");
+    } catch (error) {
+      process.stdout.write(`\n获取 token 统计失败: ${error.message}\n\n`);
+    }
+  }
+
+  async getStatus() {
+    const memoryStats = await this.memoryManager?.getStats() || {
+      shortTermCount: 0,
+      shortTermLimit: 20,
+      longTermCount: 0,
+      archiveQueueLength: 0,
+      memoryExpiryDays: 30,
+    };
+    const queueStatus = this.messageQueue?.getStatus() || {
+      queueLength: 0,
+      isProcessing: false,
+      stats: {},
+    };
+    const uptime = Date.now() - this.startTime;
+    const uptimeHours = Math.floor(uptime / (1000 * 60 * 60));
+    const uptimeMinutes = Math.floor((uptime % (1000 * 60 * 60)) / (1000 * 60));
+    const uptimeSeconds = Math.floor((uptime % (1000 * 60)) / 1000);
+
+    const memoryUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage();
+    const loadAvg = os.loadavg();
+
+    return {
+      status: "running",
+      uptime: `${uptimeHours}小时 ${uptimeMinutes}分钟 ${uptimeSeconds}秒`,
+      startTime: new Date(this.startTime).toISOString(),
+      memory: {
+        shortTermCount: memoryStats.shortTermCount,
+        shortTermLimit: memoryStats.shortTermLimit,
+        longTermCount: memoryStats.longTermCount,
+        archiveQueueLength: memoryStats.archiveQueueLength,
+      },
+      queue: {
+        length: queueStatus.queueLength,
+        isProcessing: queueStatus.isProcessing,
+        stats: queueStatus.stats,
+      },
+      config: {
+        enableStream: this.enableStream,
+        maxContextTokens: this.memoryManager?.maxContextTokens || 100000,
+        memoryExpiryDays: memoryStats.memoryExpiryDays,
+      },
+      system: {
+        nodeVersion: process.version,
+        platform: `${os.type()} ${os.release()}`,
+        arch: os.arch(),
+        cpuCores: os.cpus().length,
+        loadAverage: loadAvg.map((v) => v.toFixed(2)).join(", "),
+        totalMemory: this.formatBytes(os.totalmem()),
+        freeMemory: this.formatBytes(os.freemem()),
+        usedMemory: this.formatBytes(os.totalmem() - os.freemem()),
+        memoryUsagePercent: ((1 - os.freemem() / os.totalmem()) * 100).toFixed(1),
+      },
+      process: {
+        pid: process.pid,
+        memoryRSS: this.formatBytes(memoryUsage.rss),
+        memoryHeapTotal: this.formatBytes(memoryUsage.heapTotal),
+        memoryHeapUsed: this.formatBytes(memoryUsage.heapUsed),
+        memoryExternal: this.formatBytes(memoryUsage.external),
+        heapUsagePercent: ((memoryUsage.heapUsed / memoryUsage.heapTotal) * 100).toFixed(1),
+        cpuUser: (cpuUsage.user / 1000).toFixed(0),
+        cpuSystem: (cpuUsage.system / 1000).toFixed(0),
+      },
+    };
+  }
+
+  formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  }
+
+  /**
+   * 停止服务
+   */
+  async shutdown() {
+    logger.info("正在停止服务...");
+    this.shouldShutdown = true;
+    this.schedulerTools.stopAllTasks();
+    await this.dbService.close();
+    logger.info("服务已停止");
+    process.exit(0);
+  }
+
+  async handleSpecialCommand(command, returnResult = false) {
+    const trimmedCommand = command.trim().toLowerCase();
+
+    if (trimmedCommand === "/new") {
+      this.clearContext();
+      return returnResult ? "上下文已清空" : true;
+    }
+
+    if (trimmedCommand === "/tokens") {
+      const stats = await this.getTokenStats();
+      if (returnResult) {
+        return stats;
+      }
+      await this.showTokenStats();
+      return true;
+    }
+
+    if (trimmedCommand === "/status") {
+      const status = await this.getStatus();
+      if (returnResult) {
+        return status;
+      }
+      process.stdout.write("\n========== 服务器状态 ==========\n");
+      process.stdout.write(`状态: ${status.status}\n`);
+      process.stdout.write(`运行时间: ${status.uptime}\n`);
+      process.stdout.write(`启动时间: ${status.startTime}\n`);
+      process.stdout.write(`\n记忆:\n`);
+      process.stdout.write(
+        `  短期记忆: ${status.memory.shortTermCount}/${status.memory.shortTermLimit}\n`
+      );
+      process.stdout.write(`  长期记忆: ${status.memory.longTermCount}\n`);
+      process.stdout.write(`  归档队列: ${status.memory.archiveQueueLength}\n`);
+      process.stdout.write(`\n消息队列:\n`);
+      process.stdout.write(`  队列长度: ${status.queue.length}\n`);
+      process.stdout.write(`  处理中: ${status.queue.isProcessing ? "是" : "否"}\n`);
+      process.stdout.write(`  总接收: ${status.queue.stats.totalReceived}\n`);
+      process.stdout.write(`  总处理: ${status.queue.stats.totalProcessed}\n`);
+      process.stdout.write(`  总丢弃: ${status.queue.stats.totalDropped}\n`);
+      process.stdout.write(`\n配置:\n`);
+      process.stdout.write(`  流式输出: ${status.config.enableStream ? "启用" : "禁用"}\n`);
+      process.stdout.write(`  最大上下文 Token: ${status.config.maxContextTokens}\n`);
+      process.stdout.write(`  记忆过期天数: ${status.config.memoryExpiryDays}\n`);
+      process.stdout.write(`\n系统信息:\n`);
+      process.stdout.write(`  Node.js: ${status.system.nodeVersion}\n`);
+      process.stdout.write(`  平台: ${status.system.platform}\n`);
+      process.stdout.write(`  架构: ${status.system.arch}\n`);
+      process.stdout.write(`  CPU 核心数: ${status.system.cpuCores}\n`);
+      process.stdout.write(`  系统负载: ${status.system.loadAverage}\n`);
+      process.stdout.write(`  总内存: ${status.system.totalMemory}\n`);
+      process.stdout.write(`  已用内存: ${status.system.usedMemory} (${status.system.memoryUsagePercent}%)\n`);
+      process.stdout.write(`  空闲内存: ${status.system.freeMemory}\n`);
+      process.stdout.write(`\n进程信息:\n`);
+      process.stdout.write(`  PID: ${status.process.pid}\n`);
+      process.stdout.write(`  内存占用 (RSS): ${status.process.memoryRSS}\n`);
+      process.stdout.write(`  堆内存: ${status.process.memoryHeapUsed} / ${status.process.memoryHeapTotal} (${status.process.heapUsagePercent}%)\n`);
+      process.stdout.write(`  外部内存: ${status.process.memoryExternal}\n`);
+      process.stdout.write(`  CPU 用户态: ${status.process.cpuUser}ms\n`);
+      process.stdout.write(`  CPU 内核态: ${status.process.cpuSystem}ms\n`);
+      process.stdout.write("===============================\n\n");
+      return true;
+    }
+
+    if (trimmedCommand === "/shutdown") {
+      this.shutdown();
+      return returnResult ? "服务正在停止..." : true;
+    }
+
+    return false;
+  }
+
+  /**
+   * 启动交互式聊天循环
+   * 持续接收用户输入并处理，直到用户输入 exit 或 quit
+   */
+  async chatLoop() {
+    const readline = require("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    await this.initDatabase();
+
+    process.stdout.write("\n========================================\n");
+    process.stdout.write("  AI 智能体 - 单智能体版\n");
+    process.stdout.write("========================================\n");
+    process.stdout.write('输入你的问题或指令，输入 "exit" 或 "quit" 退出\n');
+    process.stdout.write(
+      "特殊命令: /new (清空上下文), /tokens (查看token统计), /status (查看状态), /shutdown (停止服务)\n\n"
+    );
+
+    const askQuestion = (query) => {
+      return new Promise((resolve) => {
+        rl.question(query, resolve);
+      });
+    };
+
+    while (true) {
+      const userInput = await askQuestion("你: ");
+
+      if (this.shouldShutdown) {
+        break;
+      }
+
+      if (userInput.toLowerCase() === "exit" || userInput.toLowerCase() === "quit") {
+        process.stdout.write("\n再见！\n");
+        rl.close();
+        break;
+      }
+
+      if (userInput.trim() === "") {
+        continue;
+      }
+
+      if (await this.handleSpecialCommand(userInput)) {
+        continue;
+      }
+
+      try {
+        const queueStatus = this.getQueueStatus();
+        if (queueStatus.queueLength > 0 || queueStatus.isProcessing) {
+          process.stdout.write(
+            `消息已加入队列 (队列长度: ${queueStatus.queueLength}, 处理中: ${queueStatus.isProcessing ? "是" : "否"})\n`
+          );
+        }
+
+        this.enqueueMessage(userInput, "terminal");
+
+        await this.messageQueue.waitForIdle(300000);
+
+        if (this.lastProcessedResponse) {
+          const renderedContent = this.markdownRenderer.render(this.lastProcessedResponse);
+          process.stdout.write(`\nAI:\n${renderedContent}\n\n`);
+        }
+      } catch (error) {
+        logger.error(`处理消息失败: ${error.message}`, { error });
+        process.stdout.write(`\n错误: ${error.message}\n\n`);
+      }
+    }
+
+    await this.dbService.close();
+  }
+}
+
+module.exports = AIAgent;