mm_os 3.3.1 → 4.0.1

package/com/cmd/index.js

@@ -0,0 +1,1066 @@
+const Manager = require('mm_machine').Manager;
+const Drive = require('./drive');
+const OpenAI = require('openai');
+
+/**
+ * Cmd指令类
+ * @augments {Manager}
+ * @class
+ */
+class Cmd extends Manager {
+  /**
+   * 配置参数
+   * @type {object}
+   */
+  static config = {
+    // 模块名称
+    name: '',
+    // 模块标题
+    title: 'Cmd指令管理',
+    // 文件名
+    filename: 'cmd.json',
+    // 模板目录
+    tpl_dir: __dirname,
+    // 自定义目录，加载项目自定义资源
+    dir: './app'.fullname(),
+    /**
+     * 搜索模式 dir按目录搜索 | file按文件名搜索
+     * @type {string}
+     */
+    search_way: 'file',
+    // 数据库表名
+    table: 'wechat_message',
+    // 主键
+    key: 'message_id',
+    // 缓存前缀
+    cache_prefix: 'cmd_',
+    // 聊天间隔时长，单位：秒，600秒为10分钟
+    interval: 600,
+    // 是否启用AI对话, 如果为空则不使用
+    ai: 'deepseek',
+    // AI API密钥
+    api_key: 'sk-0521b7b3e9494a5e844b66ec4787f89d',
+    // API端点
+    base_url: 'https://api.deepseek.com',
+    // 模型名称
+    model: 'deepseek-chat',
+    // 最大对话轮数
+    max_turns: 50,
+    // 最大令牌数
+    max_tokens: 2048,
+    // 温度参数
+    temperature: 0.8
+  };
+
+  /**
+   * 消息对象
+   * @type {object}
+   */
+  static msg = {
+    // 消息ID
+    'message_id': 0,
+    // 结束状态 0-正常 1-结束
+    'end': 0,
+    // 阶段 1-9阶段
+    'stage': 1,
+    // 微信/公众号消息ID
+    'msgid': '',
+    // 更新时间
+    'update_time': '',
+    // 创建时间
+    'create_time': '',
+    // 群组
+    'group': '',
+    // 消息类型 text-文本 image-图片 voice-语音 video-视频 file-文件 location-位置 link-链接 event-事件 other-其他
+    'msg_type': 'text',
+    // 媒体ID，图片、语音、视频、文件
+    'media_id': '',
+    // 发信人姓名
+    'name': '',
+    // 一般情况下，1永久会话/群、2临时会话/群
+    'type': 1,
+    // 指令
+    'cmd': '',
+    // 应用ID
+    'appid': '',
+    // 发信人
+    'from_user': '',
+    // 收信人
+    'to_user': '',
+    // 机器人，是否机器人回复
+    'robot': 'system',
+    // 会话ID，用于判断是否是同一个会话
+    'chatid': '',
+    // 发信人头像
+    'avatar': '',
+    // 除指令外，过滤、抽取后的词，多个词用空格分隔
+    'keyword': '',
+    // 表单，用于记录用户已填参数，json格式字符串
+    'form': '',
+    // 聊天内容
+    'content': '',
+    // 消息传递数据，json格式字符串
+    'data': '',
+    // 备注信息
+    'note': ''
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父级模块
+   */
+  constructor(config, parent) {
+    super({ ...Cmd.config, ...config }, parent);
+    this.list_before = [];
+    this.list_check = [];
+    this.list_main = [];
+    this.list_render = [];
+    this.list_after = [];
+    // 智能指令工具函数
+    this.tools = [];
+  }
+}
+
+/**
+ * Cmd驱动类
+ */
+Cmd.prototype.Drive = Drive;
+
+/**
+ * 初始化
+ * @private
+ */
+Cmd.prototype._preset = function () {
+  // 初始化OpenAI客户端
+  this._initOpenAIClient();
+};
+
+/**
+ * 初始化OpenAI客户端
+ * @private
+ */
+Cmd.prototype._initOpenAIClient = function () {
+  var cg = this.config;
+
+  if (cg.ai && cg.api_key) {
+    try {
+      this.client = new OpenAI({
+        baseURL: cg.base_url,
+        apiKey: cg.api_key
+      });
+    } catch (error) {
+      this.log('error', 'AI客户端初始化失败', error.message);
+      this.client = null;
+    }
+  } else {
+    this.client = null;
+  }
+};
+
+/**
+ * 构建完整指令列表
+ */
+Cmd.prototype._fullList = async function () {
+  this.list_before.clear();
+  this.list_check.clear();
+  this.list_main.clear();
+  this.list_render.clear();
+  this.list_after.clear();
+
+  let infos = this.getInfos();
+  for (var i = 0; i < infos.length; i++) {
+    var info = infos[i];
+    if (info.state === 1) {
+      let mod = this.getMod(info.name);
+      if (mod) {
+        switch (mod.config.tense) {
+          case 'before':
+            this.list_before.push(info);
+            break;
+          case 'check':
+            this.list_check.push(info);
+            break;
+          case 'render':
+            this.list_render.push(info);
+            break;
+          case 'after':
+            this.list_after.push(info);
+            break;
+          default:
+            this.list_main.push(info);
+            break;
+        }
+      }
+    }
+  }
+};
+
+/**
+ * 下达指令
+ * @param {string} name 名称
+ * @param {number} state 状态
+ * @param {...any} params 参数集合
+ * @returns {object|string} 返回指令执行结果
+ */
+Cmd.prototype.cmd = async function (name, state, ...params) {
+  var obj = this.get(name);
+  if (!obj) {
+    return '错误: 指令不存在';
+  }
+  return await obj.call('cmd', state, ...params);
+};
+
+/**
+ * 新建消息对象
+ * @returns {object} 返回新建的消息对象
+ */
+Cmd.prototype.newMsg = function () {
+  return { ...Cmd.msg };
+};
+
+/**
+ * 更新后
+ * @param {string} dir_path 目录路径
+ */
+Cmd.prototype.updateAfter = async function (dir_path) {
+  // 构建完整指令列表
+  this._fullList();
+  // 构建指令工具函数
+  this.tools = this._buildTools();
+};
+
+/**
+ * 获取智能指令的工具函数
+ * @param {number} index 当前阶段ID
+ * @returns {Array} 返回工具函数数组
+ */
+Cmd.prototype._buildTools = function (index = 0) {
+  let tools = [];
+  for (var i = 0; i < this.list_main.length; i++) {
+    var info = this.list_main[i];
+    if (info.state === 1) {
+      let mod = this.getMod(info.name);
+      if (mod) {
+        let tool = this._buildTool(mod.config, index);
+        if (tool) {
+          tools.push(tool);
+        }
+      }
+    }
+  }
+  return tools;
+};
+
+/**
+ * 构建智能指令工具函数
+ * @param {object} o 指令配置项
+ * @param {number} index 当前阶段ID
+ * @returns {object|null} 返回构建的工具函数对象，若失败则返回null
+ */
+Cmd.prototype._buildTool = function (o, index = 0) {
+  try {
+    let description = o.title + "，" + o.description;
+    if (o.example) {
+      description += "，例如：" + o.example;
+    }
+    let tool = {
+      // 类型
+      type: 'function',
+      // 函数定义
+      function: {
+        // 函数名称
+        name: o.name,
+        // 函数描述
+        description
+      },
+      // 启用结构化输出
+      strict: true
+    }
+    let pm = this._buildParams(o.stage, index);
+    if (pm) {
+      let { props, required } = pm;
+      tool.function.parameters = {
+        type: 'object',
+        properties: props,
+        required,
+        // 配合 strict 模式
+        additionalProperties: false
+      }
+    }
+    return tool;
+  } catch (error) {
+    this.log('error', `${o.name} 构建工具函数失败`, error);
+    return null;
+  }
+};
+
+/**
+ * 构建智能指令的参数
+ * @param {array} stage 指令阶段对象
+ * @param {number} index 当前阶段索引
+ * @returns {object} 返回当前阶段的参数对象
+ * @private
+ */
+Cmd.prototype._buildParams = function (stage, index) {
+  if (!stage || index < 0 || !stage.length || index >= stage.length) {
+    return null
+  }
+  let props = {};
+  let required = [];
+  var list = stage[index].param;
+  for (let i = 0; i < list.length; i++) {
+    let o = list[i];
+    let description = o.title + "，" + o.desc;
+    if (o.example) {
+      description += "，例如：" + o.example;
+    }
+    if (o.name) {
+      props[o.name] = {
+        type: o.type || 'string',
+        description
+      };
+      if (o.required) {
+        required.push(o.name);
+      }
+    }
+  }
+  return {
+    props,
+    required
+  };
+};
+
+/**
+ * 调用AI模型（公开通用）
+ * @param {array} messages 消息对象数组
+ * @param {array} tools 工具函数数组
+ * @param {string} model 模型名称
+ * @returns {object|string} 返回AI模型的响应消息对象，若失败则返回错误信息字符串
+ */
+Cmd.prototype.postToAI = async function (messages, tools = [], model = '') {
+  if (!this.client) {
+    return '错误: AI模型未初始化';
+  }
+  try {
+    let cg = this.config;
+    let body = {
+      model: model || cg.model,
+      messages,
+      temperature: cg.temperature,
+      max_tokens: cg.max_tokens || 2048,
+      stream: false
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = 'auto';
+    }
+    return res = await this.client.chat.completions.create(body);
+  } catch (error) {
+    this.log('error', 'AI API调用失败', error.message);
+
+    // 根据错误类型提供更具体的提示
+    if (error.code === 'insufficient_quota' || error.status === 402) {
+      return '抱歉，API配额不足，请检查账户余额';
+    } else if (error.code === 'invalid_api_key' || error.status === 401) {
+      return 'API密钥无效，请检查配置';
+    } else if (error.status === 429) {
+      return '请求过于频繁，请稍后重试';
+    } else {
+      return '抱歉，AI服务暂时不可用，请稍后再试';
+    }
+  }
+};
+
+/**
+ * 发布消息到AI模型
+ * @param {object} msg 消息对象
+ * @param {object} db 数据库对象
+ * @returns {object|string} 返回AI模型的响应消息对象，若失败则返回错误信息字符串
+ * @private
+ */
+Cmd.prototype.callAI = async function (msg, db) {
+  if (!msg || !msg.content) {
+    return '错误: 消息内容不能为空';
+  }
+  msg.robot = this.config.ai;
+  let content = '';
+  var messages = await this._buildMessages(msg, db);
+  if (!messages || messages.length === 0) {
+    throw new Error('消息数组不能为空');
+  }
+
+  // 最大迭代次数限制，防止无限循环
+  const max_iterations = 10;
+  let iteration_count = 0;
+  let has_tool_calls = false;
+
+  do {
+    has_tool_calls = false;
+    iteration_count++;
+
+    // 调用AI模型，始终包含工具函数以确保AI返回标准格式
+    let res = await this.postToAI(messages, this.tools);
+    if (!res || !res.choices || res.choices.length === 0) {
+      throw new Error('AI模型响应为空');
+    }
+
+    let message = res.choices[0].message;
+    messages.push(message);
+
+    // 检查是否有工具调用
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      has_tool_calls = true;
+
+      // 处理工具调用，返回工具调用信息
+      let rets = await this._handleToolCalls(msg, db, message.tool_calls);
+
+      if (!rets || rets.length === 0) {
+        this.log('warn', '处理工具调用失败', rets);
+        // 如果工具调用失败，移除工具调用相关的消息，然后让AI直接回复
+        // 保留系统消息和用户消息，移除AI的工具调用响应
+        messages = messages.filter(msg => msg.role !== 'assistant' || !msg.tool_calls);
+        // 重新调用AI，这次不包含工具函数，让AI直接回复
+        let direct_res = await this.postToAI(messages, []);
+        if (direct_res && direct_res.choices && direct_res.choices.length > 0) {
+          let direct_message = direct_res.choices[0].message;
+          content = direct_message.content || '抱歉，我无法处理这个请求';
+          // 添加直接回复到消息上下文
+          messages.push(direct_message);
+          has_tool_calls = false; // 结束循环
+        } else {
+          content = '抱歉，AI服务暂时不可用，请稍后再试';
+          has_tool_calls = false; // 结束循环
+        }
+      } else {
+        // 将工具调用结果添加到消息上下文
+        messages = messages.concat(rets);
+      }
+    } else {
+      // 没有工具调用，获取最终响应内容
+      content = message.content || '错误：AI未提供有效响应';
+    }
+
+    // 防止无限循环
+    if (iteration_count >= max_iterations) {
+      this.log('warn', '达到最大迭代次数限制', iteration_count);
+      if (!content) {
+        content = '错误：达到最大处理次数限制，请简化您的请求';
+      }
+      break;
+    }
+
+  } while (has_tool_calls && msg.robot);
+
+  // 保存指令执行日志
+  await this.saveHistory(msg, db, messages);
+  return content;
+};
+
+/**
+ * 构建消息数组
+ * @param {object} msg 消息对象
+ * @param {object} db 数据库对象
+ * @returns {array} 返回构建的消息数组
+ * @private
+ */
+Cmd.prototype._buildMessages = async function (msg, db) {
+  if (!msg || !msg.content) {
+    return [];
+  }
+  var messages = await this.getHistory(msg, db);
+  if (!messages || messages.length === 0) {
+    messages = [];
+    let system_prompt = this._getSystemPrompt();
+    messages.push({
+      role: 'system',
+      content: system_prompt
+    });
+  }
+  messages.push({
+    role: 'user',
+    content: msg.content
+  });
+  return messages;
+};
+
+/**
+ * 获取系统提示
+ * @returns {string} 返回系统提示字符串
+ * @private
+ */
+Cmd.prototype._getSystemPrompt = function () {
+  // 获取个性提示词
+  let personality_prompt = this._getPersonalityPrompt();
+
+  // 获取规范提示词
+  let standard_prompt = this._getStandardPrompt();
+
+  // 合并个性提示和规范提示
+  let system_prompt = `${personality_prompt}\n${standard_prompt}`;
+  return system_prompt;
+};
+
+/**
+ * 获取个性提示词
+ * @returns {string} 返回个性提示字符串
+ * @private
+ */
+Cmd.prototype._getPersonalityPrompt = function () {
+  let prompt = this.config.personality_prompt;
+  if (!prompt) {
+    prompt = `你是一个专业的智能指令转换专家，具备以下核心能力：
+
+## 角色定位
+- 智能指令解析专家，擅长将自然语言转换为结构化指令
+- 上下文理解大师，能够基于会话历史和状态进行智能判断
+- 多模态消息处理专家，支持文本、图片、语音、文件等多种消息类型
+
+## 核心能力
+1. **自然语言理解**：准确理解用户意图，识别关键指令和参数
+2. **上下文感知**：利用消息历史、会话状态、表单数据等上下文信息
+3. **指令映射**：将用户请求映射到合适的系统指令和工具函数
+4. **参数提取**：自动提取和补全指令执行所需的参数
+5. **多步骤规划**：处理复杂的多步骤指令执行场景
+
+## 专业特性
+- 响应速度快，判断准确，能够处理复杂的指令转换场景
+- 具备良好的容错能力，能够处理模糊或不完整的用户输入
+- 支持个性化定制，能够根据不同的用户和场景调整响应策略
+
+## 工具调用失败处理策略
+- 当系统工具调用失败时，基于自己的知识库直接回答用户问题
+- 回复时要自然流畅，不要提及工具调用失败或技术细节
+- 对于天气查询：直接提供一般性天气信息、季节特点或穿衣建议，就像自己知道这些信息一样
+- 对于时间查询：直接提供当前时间或相关时间信息
+- 对于计算问题：直接计算结果并给出答案
+- 对于其他问题：基于常识和经验提供有用的回答
+- 避免提及任何技术限制，保持回复的自然性和实用性`;
+  }
+  return prompt;
+};
+
+/**
+ * 获取规范提示词
+ * @returns {string} 返回规范提示字符串
+ * @private
+ */
+Cmd.prototype._getStandardPrompt = function () {
+  let prompt = this.config.standard_prompt;
+  if (!prompt) {
+    prompt = `
+## 消息上下文信息
+你可以利用以下消息上下文信息来更好地理解用户意图：
+
+### 基础消息属性
+- **消息类型**: 文本、图片、语音、视频、文件、位置、链接、事件等
+- **消息内容**: 原始消息文本、媒体文件URL、文件信息等
+- **时间信息**: 消息发送时间、创建时间、更新时间
+
+### 会话上下文
+- **会话类型**: 群组、私聊、临时会话、公众号会话
+- **参与者信息**: 发信人ID、收信人ID、机器人标识、群组成员
+- **会话状态**: 会话ID、会话阶段、结束状态、活跃状态
+
+### 历史状态
+- **关键词历史**: 用户历史关键词、常用指令模式
+- **表单数据**: 已填写的表单字段、待补充的参数
+- **备注信息**: 用户备注、会话标签、自定义属性
+
+## 智能指令映射规则
+
+### 1. 消息类型映射规则
+- **文本消息**: 
+  - 优先匹配文本处理指令（搜索、翻译、计算等）
+  - 识别指令关键词（如"搜索"、"查询"、"计算"等）
+  - 支持自然语言指令（如"帮我找一下资料"）
+
+- **媒体消息**（图片/语音/视频）:
+  - 优先匹配媒体处理指令（识别、分析、转换等）
+  - 结合文本内容进行多模态理解
+  - 支持媒体文件的分析和提取
+
+- **文件消息**:
+  - 优先匹配文件处理指令（上传、下载、解析等）
+  - 根据文件类型选择合适工具（文档、表格、图片等）
+  - 支持文件内容的智能提取
+
+- **位置消息**:
+  - 优先匹配位置相关指令（导航、周边搜索、地理信息）
+  - 结合位置坐标和描述信息
+
+### 2. 会话上下文映射规则
+- **群组消息**:
+  - 考虑群组特定的指令和权限
+  - 支持群组管理功能（成员管理、公告等）
+  - 适应群组交流场景
+
+- **私聊消息**:
+  - 考虑个人化指令和偏好设置
+  - 支持个性化服务和定制功能
+  - 保护用户隐私信息
+
+- **临时会话**:
+  - 考虑临时性指令和一次性服务
+  - 快速响应，简化流程
+  - 支持会话状态的快速清理
+
+### 3. 历史状态映射规则
+- **阶段信息**:
+  - 根据当前阶段选择合适的指令流程
+  - 支持多步骤指令的连续执行
+  - 维护阶段间的上下文连贯性
+
+- **表单数据**:
+  - 利用已有的表单数据自动补全参数
+  - 减少用户重复输入
+  - 支持表单数据的智能验证
+
+- **关键词历史**:
+  - 基于历史关键词理解用户意图
+  - 识别用户的使用习惯和偏好
+  - 支持个性化推荐和智能补全
+
+## 指令处理流程
+
+### 1. 意图识别阶段
+- 分析用户输入的自然语言
+- 识别关键指令词和参数
+- 结合上下文信息理解真实意图
+
+### 2. 指令映射阶段
+- 将用户意图映射到系统指令
+- 选择合适的工具函数
+- 确定指令执行优先级
+
+### 3. 参数处理阶段
+- 提取和验证指令参数
+- 补全缺失的参数信息
+- 处理参数格式转换
+
+### 4. 执行规划阶段
+- 规划指令执行步骤
+- 处理多步骤指令场景
+- 考虑异常情况和回退策略
+
+## 特别注意
+
+### 智能判断原则
+- 充分利用所有可用上下文信息
+- 优先考虑最相关的指令映射
+- 支持模糊匹配和容错处理
+
+### 用户体验优化
+- 减少用户输入，智能补全参数
+- 提供清晰的指令反馈
+- 支持指令的撤销和重做
+
+### 错误处理机制
+- 识别和处理无效指令
+- 提供友好的错误提示
+- 支持指令的重新解释和修正
+
+### 工具调用失败处理
+- 当工具调用失败时，基于自己的知识直接回答用户问题
+- 回复时要自然流畅，不要提及工具调用失败或技术细节
+- 对于常见问题（如天气、时间、计算等），直接提供一般性信息或建议，就像自己知道这些信息一样
+- 避免重复工具调用过程，直接给出有用的回答
+- 如果无法提供准确信息，可以给出替代方案或建议，但不要暴露技术限制
+
+### 性能考虑
+- 快速响应，减少等待时间
+- 优化指令映射算法
+- 支持并发指令处理`;
+  }
+  return prompt;
+};
+
+/**
+ * 执行指令
+ * @param {string} cmd 指令字符串
+ * @param {string} method 方法名
+ * @param {...*} args 指令参数
+ * @returns {string} 返回指令执行结果
+ * @private
+ */
+Cmd.prototype._exec = async function (tense, cmd, method, ...args) {
+  var list = this['list_' + tense];
+  if (!list) {
+    throw new Error(` 不存在时态: ${tense}`);
+  }
+  // 查找指令
+  for (var i = 0; i < list.length; i++) {
+    var info = list[i];
+    if (info.name === cmd) {
+      let mod = this.getMod(info.name);
+      if (mod) {
+        return await mod.call(method, ...args);
+      }
+    }
+  }
+};
+
+/**
+ * 推送工具调用消息
+ * @param {*} ret 工具调用执行结果
+ * @param {string} tool_call_id 工具调用ID
+ * @returns {object} 返回工具调用消息对象
+ * @private
+ */
+Cmd.prototype.getMessage = function (ret, tool_call_id) {
+  if (typeof ret === 'object') {
+    if (ret.error) {
+      return {
+        role: 'tool',
+        tool_call_id,
+        content: JSON.stringify({ error: ret.error.message }),
+      }
+    }
+    ret = JSON.stringify(ret);
+  }
+  else if (typeof ret === 'string') {
+    if (this._isError(ret)) {
+      // 记录工具调用信息
+      return {
+        role: 'tool',
+        tool_call_id,
+        content: JSON.stringify({ error: ret })
+      }
+    }
+  }
+  // 记录工具调用信息
+  return {
+    role: 'tool',
+    tool_call_id,
+    content: ret
+  }
+};
+
+/**
+ * 判断是否为错误信息
+ * @param {string} content 内容字符串
+ * @returns {boolean} 返回是否为错误信息
+ * @private
+ */
+Cmd.prototype._isError = function (content) {
+  return content.startsWith('错误') || content.startsWith('不能为');
+};
+
+/**
+ * 处理工具调用
+ * @description 处理消息中的工具调用，执行对应的指令并返回结果
+ * @param {object} msg 消息对象，包含工具调用信息
+ * @param {object} db 数据管理器，用于存储和检索数据
+ * @param {Array} tool_calls 工具调用数组，每个元素包含工具调用的信息
+ * @returns {string} 返回工具调用处理结果，格式为JSON字符串
+ * @private
+ */
+Cmd.prototype._handleToolCalls = async function (msg, db, tool_calls) {
+  var messages = [];
+
+  for (var i = 0; i < tool_calls.length; i++) {
+    var tool = tool_calls[i];
+    var cmd = tool.function.name;
+    var form = {};
+    try {
+      // 解析函数参数
+      var args = tool.function.arguments;
+      if (args) {
+        if (typeof args === 'string') {
+          form = JSON.parse(args);
+        } else {
+          form = args;
+        }
+      }
+      msg.form = form;
+      var ret = await this._exec('main', cmd, 'main', msg, db);
+      if (ret) {
+        messages.push(this.getMessage(ret, tool.id));
+      }
+    } catch (error) {
+      this.log('error', `解析工具调用参数失败: ${cmd} `, error.message);
+      messages.push({
+        role: 'tool',
+        tool_call_id: tool.id,
+        content: JSON.stringify({ error: `工具调用参数解析失败: ${error.message} ` })
+      });
+    }
+  }
+  return messages;
+};
+
+/**
+ * 获取指令执行日志
+ * @param {object} msg 消息对象，包含指令信息
+ * @param {object} db 数据管理器，用于存储和检索数据
+ * @returns {Array} 返回指令执行日志数组
+ */
+Cmd.prototype.getHistory = async function (msg, db) {
+  var key = this._getKey(msg);
+  var logs = await $.cache.get(key);
+  if (!logs) {
+    logs = [];
+  }
+  else if (typeof logs === 'string') {
+    logs = JSON.parse(logs);
+  }
+  return logs;
+};
+
+/**
+ * 保存指令执行日志
+ * @param {object} msg 消息对象，包含指令信息
+ * @param {object} db 数据管理器，用于存储和检索数据
+ * @param {Array} logs 指令执行日志数组
+ * @private
+ */
+Cmd.prototype.saveHistory = async function (msg, db, logs) {
+  var key = this._getKey(msg);
+  await $.cache.set(key, logs, this.config.interval);
+};
+
+/**
+ * 获取指令执行日志缓存键
+ * @param {object} msg 消息内容
+ * @returns {string} 返回指令执行日志缓存键
+ */
+Cmd.prototype._getKey = function (msg) {
+  return this.config.cache_prefix + msg.form + "_" + msg.to_user + "_" + msg.group;
+};
+
+/**
+ * 执行指令
+ * @param {object} msg 消息对象，包含指令信息
+ * @param {object} db 数据管理器，用于存储和检索数据
+ * @returns {string} 返回指令执行结果，格式为JSON字符串
+ * @private
+ */
+Cmd.prototype.run = async function (msg, db) {
+  // 判断是否含有消息和消息正文
+  if (!msg || !msg.content) {
+    return;
+  }
+
+  // 初始化数据库配置
+  db.table = this.config.table;
+  db.key = this.config.key;
+
+  // 统一的指令处理流程
+  var ret = await this._run(msg, db);
+
+  // 记录执行结果
+  db.ret = ret;
+  return ret;
+};
+
+/**
+ * 指令行为主函数
+ * @param {object} msg 消息
+ * @param {object} db 数据管理器,如: { next: async function{}, ret: {} }
+ * @returns {object} 执行结果
+ * @private
+ */
+Cmd.prototype._run = async function (msg, db) {
+  return null;
+  var cg = this.config;
+  if (cg.ai) {
+    msg.robot = cg.ai;
+    let ret = await this.callAI(msg, db);
+    return ret;
+  }
+  else {
+    let ret = await this._exec('main', msg.content, 'main', msg, db);
+    return ret;
+  }
+};
+
+/**
+ * 执行指令前处理
+ * @param {object} msg 消息对象
+ * @param {object} db 数据库对象
+ * @returns {object|string} 返回指令执行结果
+ */
+Cmd.prototype._runBefore = async function (msg, db) {
+  db.logs = await this._getLogs(msg, db);
+  await this._fullMsg(msg, db);
+  return await this.runSub(msg, db, 'before');
+};
+
+/**
+ * 执行主指令
+ * @param {object} msg 消息
+ * @param {object} db 数据管理器
+ * @returns {object} 返回执行结果
+ * @private
+ */
+Cmd.prototype._runMain = async function (msg, db) {
+  // 先判断本次内容是否为指令
+  var ret_main = await this.runSub(msg, db, 'main');
+  if (ret_main) {
+    return ret_main;
+  }
+  // 获取历史未完成的指令，拼接本次内容并执行
+  var log = await this.getContext(msg, db);
+  if (!log) {
+    return null;
+  }
+  return await this.runSub(m, db, 'main');
+};
+
+/**
+ * 执行后时态指令
+ * @param {object} msg 消息
+ * @param {object} db 数据管理器
+ * @returns {object|string} 返回指令执行结果
+ */
+Cmd.prototype._runAfter = async function (msg, db) {
+  var ret = await this.runSub(msg, db, 'after');
+  return ret;
+};
+
+/**
+ * 补全消息
+ * @param {object} msg 消息对象
+ * @param {object} db 数据管理器
+ * @returns {object} 返回合并后的消息对象
+ */
+Cmd.prototype._fullMsg = function (msg, db) {
+
+};
+
+/**
+ * 执行指令
+ * @param {object} msg 消息对象
+ * @param {object} db 数据库对象
+ * @param {string} tense 时态
+ * @returns {object|string} 返回指令执行结果
+ */
+Cmd.prototype.runSub = async function (msg, db, tense = 'main') {
+  var list = this['list_' + tense];
+  if (!list) {
+    return;
+  }
+  var ret;
+  for (var i = 0, info; info = list[i++];) {
+    if (info.state === 1) {
+      let mod = this.getMod(info.name);
+      if (mod) {
+        ret = await mod.run(msg, db);
+        if (ret) {
+          db.ret = ret;
+          // 如果匹配指令则将该消息定义为使用该指令
+          msg.cmd = info.name;
+          if (mod.config.end) {
+            break;
+          }
+        }
+      }
+    }
+  }
+  return ret;
+};
+
+/**
+ * 获取对话历史
+ * @param {object} msg 当前消息
+ * @param {object} db 数据库对象
+ * @returns {Array} 返回历史消息数组
+ */
+Cmd.prototype._getLogs = async function (msg, db) {
+  // 先尝试从缓存中获取对话历史
+  var logs = await this._getLogsFromCache(msg);
+  if (logs.length > 0) {
+    return logs;
+  }
+
+  // 如果缓存中没有，从数据库查询
+  logs = await this._getLogsFromDB(msg, db);
+  if (logs.length > 0) {
+    // 缓存查询结果
+    await this._setLogsToCache(msg, logs);
+  }
+
+  return logs;
+};
+
+/**
+ * 从数据库中获取对话历史
+ * @param {object} msg 当前消息
+ * @param {object} db 数据库对象
+ * @returns {Array} 返回历史消息数组
+ * @private
+ */
+Cmd.prototype._getLogsFromDB = async function (msg, db) {
+  var cg = this.config;
+  var max_turns = cg.max_turns;
+
+  // 基于实际数据库字段查询对话记录
+  var query = {
+    from_user: msg.from_user,
+    to_user: msg.to_user,
+    group: msg.group,
+    type: msg.type
+  };
+
+  // 如果当前消息有chatid，优先基于chatid查询同一个对话会话
+  if (msg.chatid) {
+    query.chatid = msg.chatid;
+  }
+
+  var db1 = db.new(cg.table, cg.key);
+  var logs = await db1.getList(query, '`time_create` desc', max_turns * 2);
+  return logs;
+};
+
+/**
+ * 从缓存中获取对话历史
+ * @param {object} msg 当前消息
+ * @returns {Array} 返回历史消息数组
+ * @private
+ */
+Cmd.prototype._getLogsFromCache = async function (msg) {
+  var logs = await $.cache.get(msg.chatid || this._getKey(msg));
+  if (!logs) {
+    logs = [];
+  }
+  else if (typeof logs === 'string') {
+    logs = JSON.parse(logs);
+  }
+  return logs;
+};
+
+/* 导出指令 */
+exports.Cmd = Cmd;
+
+/**
+ * Cmd事件池
+ */
+if (!$.pool.cmd) {
+  $.pool.cmd = {};
+}
+
+/**
+ * Cmd管理器，用于创建缓存
+ * @param {string} scope 作用域
+ * @param {string} title 标题
+ * @returns {object} 返回一个缓存类
+ */
+function cmdAdmin(scope, title) {
+  var sc = scope || $.val.scope + '';
+  var obj = $.pool.cmd[sc];
+  if (!obj) {
+    $.pool.cmd[sc] = new Cmd({
+      name: sc,
+      title: title || sc
+    });
+    obj = $.pool.cmd[sc];
+  }
+  return obj;
+}
+
+/**
+ * @module 导出Cmd管理器
+ */
+if ($.admin) {
+  $.admin.cmd = cmdAdmin;
+}