mm_os 3.3.1 → 4.0.1

package/com/cmd/msg.json

@@ -0,0 +1,48 @@
+{
+  // 消息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": "",
+  // 会话ID，用于判断是否是同一个会话
+  "chatid": "",
+  // 发信人头像
+  "avatar": "",
+  // 除指令外，过滤、抽取后的词
+  "keyword": "",
+  // 表单，用于记录用户已填参数，json格式
+  "form": "",
+  // 聊天内容
+  "content": "",
+  // 消息传递数据，json格式
+  "data": "",
+  // 备注信息
+  "note": ""
+}

package/com/cmd/nlp.js

@@ -0,0 +1,525 @@
+require('mm_expand');
+const { Nlp } = require('@nlpjs/basic');
+
+/**
+ * 自然语言处理类
+ */
+class NLP {
+  static config = {
+    languages: ['zh', 'en'],
+    language: 'zh',
+    dir: './nlp',
+    // 模型文件
+    model: './model.nlp',
+    // 正则表达式文件
+    regex: './regex.json'
+  };
+
+  /**
+   * 构造函数
+   * @param {Object} config - 配置参数
+   */
+  constructor(config) {
+    this.config = {
+      ...NLP.config,
+      ...config
+    };
+    this._preset();
+  }
+}
+
+/**
+ * 获取模型文件路径
+ * @returns {string} 模型文件路径
+ */
+NLP.prototype.getModelFile = function () {
+  return this.config.model.fullname(this.config.dir);
+};
+
+/**
+ * 获取正则表达式文件路径
+ * @returns {string} 正则表达式文件路径
+ */
+NLP.prototype.getRegexFile = function () {
+  return this.config.regex.fullname(this.config.dir);
+};
+
+/**
+ * 预设
+ * @returns {string} 语言
+ */
+NLP.prototype._preset = function () {
+  console.log('[_init] 开始初始化NLP管理器');
+  console.log('[_init] 配置:', JSON.stringify(this.config, null, 2));
+
+  // 初始化NLP管理器
+  this.nlp = new Nlp(this.config);
+  console.log('[_init] NLP管理器创建成功');
+
+  this.load();
+  console.log('[_init] 初始化完成');
+};
+
+/**
+ * 加载模型
+ * @param {string} model_file - 模型文件路径
+ * @param {string} regex_file - 正则表达式文件路径
+ */
+NLP.prototype.load = function (model_file, regex_file) {
+  this.loadRegex(regex_file);
+  this.loadModel(model_file);
+};
+
+/**
+ * 加载模型
+ * @param {string} file - 模型文件路径
+ */
+NLP.prototype.loadModel = async function (file) {
+  let f = file || this.getModelFile();
+  console.log(`[loadModel] 加载模型文件: ${f}`);
+  let json = f.loadJson();
+  if (json) {
+    this.nlp.fromJSON(json);
+  }
+};
+
+/**
+ * 加载正则表达式
+ * @param {string} file - 正则表达式文件路径
+ */
+NLP.prototype.loadRegex = function (file) {
+  let f = file || this.getRegexFile();
+  console.log(`[loadRegex] 加载正则表达式文件: ${f}`);
+  this.regex = f.loadJson();
+};
+
+/**
+ * 保存模型
+ * @param {string} model_file - 模型文件路径
+ * @param {string} regex_file - 正则表达式文件路径
+ */
+NLP.prototype.save = function (model_file, regex_file) {
+  console.log(`[save] 开始保存模型...`);
+  // 保存模型
+  this.saveModel(model_file);
+  console.log(`[save] 模型保存成功`);
+
+  // 保存正则表达式
+  this.saveRegex(regex_file);
+  console.log(`[save] 正则表达式保存成功`);
+};
+
+/**
+ * 保存模型
+ * @param {string} file - 模型文件路径
+ */
+NLP.prototype.saveModel = function (file) {
+  let model = this.nlp.toJSON();
+  let f = file || this.getModelFile();
+  console.log(`[saveModel] 保存模型文件: ${f}`);
+  f.saveJson(model);
+};
+
+/**
+ * 保存正则表达式
+ * @param {string} file - 正则表达式文件路径
+ */
+NLP.prototype.saveRegex = function (file) {
+  let f = file || this.getRegexFile();
+  console.log(`[saveRegex] 保存正则表达式文件: ${f}`);
+  f.saveJson(this.regex);
+};
+
+/**
+ * 添加文档
+ * @param {string} doc - 文档
+ * @param {string} intent - 指令
+ */
+NLP.prototype.addDocument = function (doc, intent) {
+  console.log(`[addDocument] 添加文档: "${doc}" -> "${intent}"`);
+  console.log(`[addDocument] 语言配置: ${this.config.language}`);
+
+  try {
+    // 明确指定locale
+    this.nlp.addDocument(this.config.language, doc, intent);
+    console.log(`[addDocument] 文档添加完成`);
+  } catch (error) {
+    console.log(`[addDocument] 添加文档失败:`, error.message);
+    throw error;
+  }
+};
+
+/**
+ * 添加命名实体识别文本
+ * @param {string} name - 命名实体名称
+ * @param {string} value - 值
+ * @param {Array} langs - 语言数组
+ * @param {Array} values - 值数组
+ */
+NLP.prototype.addNamedEntityText = function (name, value, langs, values) {
+  this.nlp.addNamedEntityText(name, value, langs, values);
+};
+
+/**
+ * 处理文本
+ * @param {string} text - 输入文本
+ * @returns {Object} 响应对象
+ */
+NLP.prototype.process = async function (text) {
+  let res = await this.nlp.process(this.config.language, text);
+  return res;
+};
+
+/**
+ * 提取参数词汇
+ * @param {Object} params - 参数
+ * @returns {Array} 词汇数组
+ */
+NLP.prototype._extractWords = function (params) {
+  let words = [];
+
+  if (!Array.isArray(params)) {
+    return words;
+  }
+
+  for (let i = 0; i < params.length; i++) {
+    let param = params[i];
+    if (!param || !param.example) {
+      continue;
+    }
+    let arr = param.example.split('；');
+    for (let n = 0; n < arr.length; n++) {
+      let text = arr[n];
+      let values = text.split('|');
+      // 提取所有值，而不仅仅是第一个
+      for (let k = 0; k < values.length; k++) {
+        let value = values[k].trim();
+        if (value) {
+          words.push({
+            name: param.name,
+            value,
+            values
+          });
+        }
+      }
+    }
+  }
+  return words;
+};
+
+/**
+ * 训练文档
+ * @param {string} intent - 指令
+ * @param {Array} examples - 示例数组
+ * @param {Array} words - 词汇数组
+ */
+NLP.prototype._trainDocuments = function (intent, examples, words) {
+  if (!Array.isArray(examples)) {
+    return;
+  }
+
+  for (const tpl of examples) {
+    if (tpl.indexOf('](') === -1) {
+      let docs = this.toDocs(tpl, words);
+      for (const doc of docs) {
+        this.addDocument(doc, intent);
+      }
+    }
+    else {
+      this.addDocument(tpl, intent);
+    }
+  }
+};
+
+/**
+ * 训练命名实体识别模型
+ * @param {Array} words - 词汇数组
+ * @param {string} lang - 语言
+ */
+NLP.prototype._trainNamedEntities = function (words, lang) {
+  if (!Array.isArray(words)) {
+    return;
+  }
+
+  for (const word of words) {
+    let { name, value, values } = word;
+    this.addNamedEntityText(name, value, [lang], values);
+  }
+};
+
+/**
+ * 训练模型
+ * @param {string} intent - 指令，格式xxx_xxx
+ * @param {string} example - 示例组
+ * @param {Object} params - 参数
+ */
+NLP.prototype.train = async function (intent, example, params) {
+  console.log(`[train] 开始训练模型，意图: "${intent}"`);
+  console.log(`[train] 示例组: "${example}"`);
+  console.log(`[train] 参数:`, JSON.stringify(params, null, 2));
+
+  // 参数校验
+  if (typeof intent !== 'string') {
+    throw new TypeError('指令必须是字符串');
+  }
+  if (typeof example !== 'string') {
+    throw new TypeError('示例组必须是字符串');
+  }
+  if (!Array.isArray(params)) {
+    throw new TypeError('参数必须是数组');
+  }
+
+  try {
+    let lang = this.config.language;
+    let examples = example.split('；');
+    console.log(`[train] 拆分后的示例:`, examples);
+
+    let words = this._extractWords(params);
+    console.log(`[train] 提取的词汇:`, words);
+
+    this._trainDocuments(intent, examples, words);
+    console.log(`[train] 文档训练完成`);
+
+    this._trainNamedEntities(words, lang);
+    console.log(`[train] 命名实体训练完成`);
+
+    // 训练模型
+    console.log(`[train] 开始模型训练...`);
+    try {
+      await this.nlp.train({
+        trainByDomain: false,
+        useNeural: false,
+        log: false
+      });
+      console.log(`[train] 模型训练完成`);
+    } catch (error) {
+      // 如果训练过程中出现文件保存错误，继续执行
+      if (error.message.includes('File cannot be written in web')) {
+        console.log(`[train] 模型训练完成（文件保存错误已忽略）`);
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    console.log(`[train] 训练失败:`, error.message);
+    console.log(`[train] 错误堆栈:`, error.stack);
+    // 异步方法返回相应类型值，这里返回undefined
+    return undefined;
+  }
+};
+
+/**
+ * 转为文档
+ * @param {string} tpl - 模板
+ * @param {Array} words - 词汇数组
+ */
+NLP.prototype.toDocs = function (tpl, words) {
+  let docs = [tpl]; // 先添加原始模板
+
+  // 将大白话转为训练文档，例如：“我想听邓紫棋的喜欢你”转换为“我想听[邓紫棋](singer)的[喜欢你](music_name)”
+  // 正确的逻辑：模板包含value字段的词，替换为values中的词加上标注
+  
+  // 第一步：收集所有词汇的替换信息
+  let word_replacements = [];
+  
+  for (let i = 0; i < words.length; i++) {
+    let word = words[i];
+    if (!word || !word.value) continue;
+    let { name, value, values } = word;
+    
+    // 检查模板是否包含value字段的词
+    if (!tpl.includes(value)) {
+      continue;
+    }
+    
+    let replacements = [];
+    
+    // 处理每个词汇的values数组
+    for (let j = 0; j < values.length; j++) {
+      let value_str = values[j];
+      let value_arr = value_str.split('|');
+      
+      for (let k = 0; k < value_arr.length; k++) {
+        let val = value_arr[k].trim();
+        if (val) {
+          replacements.push({
+            name: name,
+            original_value: value, // 模板中实际出现的词
+            replacement_value: val, // 要替换成的词
+            replacement: `[${val}](${name})`
+          });
+        }
+      }
+    }
+    
+    if (replacements.length > 0) {
+      word_replacements.push(replacements);
+    }
+  }
+  
+  // 第二步：生成所有词汇值的笛卡尔积组合
+  if (word_replacements.length > 0) {
+    let combinations = this._generateCartesianProduct(word_replacements);
+    
+    for (let combination of combinations) {
+      let doc = tpl;
+      
+      for (let replacement of combination) {
+        // 将模板中的original_value替换为replacement
+        doc = doc.replace(replacement.original_value, replacement.replacement);
+      }
+      
+      if (!docs.includes(doc)) {
+        docs.push(doc);
+      }
+    }
+  }
+
+  return docs;
+};
+
+/**
+ * 生成笛卡尔积
+ * @param {Array} arrays - 输入数组的数组
+ * @returns {Array} 笛卡尔积结果
+ */
+NLP.prototype._generateCartesianProduct = function (arrays) {
+  if (arrays.length === 0) return [[]];
+  
+  let result = [];
+  
+  function cartesianHelper(arr, index, current) {
+    if (index === arrays.length) {
+      result.push([...current]);
+      return;
+    }
+    
+    for (let i = 0; i < arrays[index].length; i++) {
+      current.push(arrays[index][i]);
+      cartesianHelper(arr, index + 1, current);
+      current.pop();
+    }
+  }
+  
+  cartesianHelper(arrays, 0, []);
+  return result;
+};
+
+/**
+ * 生成正则表达式
+ * @returns {Object} 正则表达式对象
+ */
+NLP.prototype.genRegex = function (examples) {
+  // 生成正则表达式
+  let regex = {};
+  for (const example of examples) {
+    let res = this.process(example);
+    let intent = res.intent;
+    if (!regex[intent]) {
+      regex[intent] = [];
+    }
+    let rules = this.buildRule(example, res);
+    regex[intent].push(...rules);
+  }
+  return regex;
+};
+
+/**
+ * 构建正则表达式
+ * @param {string} text - 文本
+ * @param {Object} res - 处理结果
+ * @returns {array} 正则表达式数组
+ */
+NLP.prototype.buildRule = function (text, res) {
+  let rules = [];
+  for (const entity of res.entities) {
+    let regex =
+      rules.push({
+        // 正则表达式
+        regex,
+        // 参数名
+        props: []
+      });
+  }
+  return rules;
+};
+
+/**
+ * 获取正则表达式数组
+ * @returns {array} 正则表达式数组
+ */
+NLP.prototype._getRegexs = function () {
+  let regexs = ['[a-zA-Z0-9_]+', '[\\u4e00-\\u9fa5]+', '[\\s\\S]+', '\\d+', '\\w+', '\\S+', '(.*)'];
+  return regexs;
+};
+
+/**
+ * 获取符合的正则表达式
+ * @param {string} text - 文本
+ * @returns {array} 符合的正则表达式数组
+ */
+NLP.prototype._extractRegexs = function (text) {
+  let regexs = this._getRegexs();
+  let arr = [];
+  for (const re of regexs) {
+    let m = text.match(re);
+    if (m) {
+      arr.push(re);
+    }
+  }
+  return arr;
+};
+
+/**
+ * 通过正则表达式提取关键词
+ * @param {string} regex - 正则表达式
+ * @param {string} text - 文本
+ * @returns {array} 关键词数组
+ */
+NLP.prototype._extractKeywords = function (regex, text) {
+  let matches = text.match(regex);
+  return matches;
+};
+
+/**
+ * 聊天
+ * @param {string} text - 输入文本
+ * @returns {Object} 响应对象
+ */
+NLP.prototype.chat = async function (text) {
+  // 先尝试能否有输出
+  let res = await this.process(text);
+  // 如果没有尝试正则匹配
+  if (!res.intent) {
+    let matches = this._tryMatches(text);
+  }
+  return res;
+};
+
+/**
+ * 尝试匹配正则表达式
+ * @param {string} text - 文本
+ * @returns {array} 符合的正则表达式数组
+ */
+NLP.prototype._tryMatches = function (text) {
+  let dict = this.regex;
+  let intent = null;
+  let words = [];
+  for (const key of dict) {
+    let regexs = dict[key];
+    for (let i = 0; i < regexs.length; i++) {
+      let matches = this._extractKeywords(regexs[i], text);
+      if (matches) {
+        intent = key;
+        words.push(...matches);
+        break;
+      }
+    }
+  }
+  return {
+    intent,
+    words
+  };
+};
+
+module.exports = { NLP };

package/com/cmd/script.tpl.js

@@ -0,0 +1,32 @@
+module.exports = {
+  /**
+   * 聊天方式执行指令
+   * @param {object} msg 消息
+   * @param {object} db 数据管理器,如: { next: async function{}, ret: {} }
+   * @returns {object} 执行结果
+   */
+  async chat(msg, db) {
+    let ret = await this.main(msg, db);
+    let content = `${ret.location}${ret.datetime}的天气是${ret.weather}，温度${ret.temperature}度，湿度${ret.humidity}，风力${ret.wind}
+    `;
+    return content;
+  },
+
+  /**
+   * 执行指令主函数
+   * @param {object} msg 消息
+   * @param {object} db 数据管理器,如: { next: async function{}, ret: {} }
+   * @returns {object} 执行结果
+   */
+  async main(msg, db) {
+    let form = msg.form;
+    return {
+      "location": "梅州",
+      "datetime": "2023-08-25 12:00",
+      "weather": "晴朗",
+      "temperature": "25",
+      "humidity": "60%",
+      "wind": "3级"
+    }
+  }
+};

package/com/db/com.json

@@ -0,0 +1,5 @@
+{
+    "name": "DB",
+    "title": "数据管理器",
+    "state": 1
+}