mm_ai 1.0.0

package/common/tool/data/excel/index.js

@@ -0,0 +1,139 @@
+const fs = require('fs');
+const path = require('path');
+const XLSX = require('xlsx');
+
+module.exports = {
+  async main(params) {
+    try {
+      let { action, data, sheet_name, output, input } = params;
+      
+      if (!action) {
+        return {
+          code: 10000,
+          msg: '操作类型(action)不能为空'
+        };
+      }
+      
+      let file_path = output || `./output_${Date.now()}.xlsx`;
+      
+      // 确保目录存在
+      let dir = path.dirname(file_path);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      let workbook;
+      let worksheet;
+      const sheetName = sheet_name || 'Sheet1';
+      
+      switch (action.toLowerCase()) {
+        case 'create':
+          // 创建新Excel文件
+          workbook = XLSX.utils.book_new();
+          if (data && Array.isArray(data)) {
+            worksheet = XLSX.utils.json_to_sheet(data);
+          } else {
+            worksheet = XLSX.utils.aoa_to_sheet([['', '']]);
+          }
+          XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+          XLSX.writeFile(workbook, file_path);
+          break;
+          
+        case 'read':
+          // 读取Excel文件
+          if (!input) {
+            return {
+              code: 10000,
+              msg: '读取操作需要输入文件路径(input)'
+            };
+          }
+          if (!fs.existsSync(input)) {
+            return {
+              code: 10000,
+              msg: '输入文件不存在: ' + input
+            };
+          }
+          workbook = XLSX.readFile(input);
+          worksheet = workbook.Sheets[sheetName] || workbook.Sheets[workbook.SheetNames[0]];
+          data = XLSX.utils.sheet_to_json(worksheet);
+          return {
+            code: 0,
+            msg: 'Excel读取成功',
+            data: data,
+            sheets: workbook.SheetNames
+          };
+          
+        case 'append':
+          // 追加数据到Excel
+          if (!input) {
+            return {
+              code: 10000,
+              msg: '追加操作需要输入文件路径(input)'
+            };
+          }
+          if (!data || !Array.isArray(data)) {
+            return {
+              code: 10000,
+              msg: '追加操作需要数据(data)且必须是数组'
+            };
+          }
+          if (fs.existsSync(input)) {
+            workbook = XLSX.readFile(input);
+            worksheet = workbook.Sheets[sheetName] || workbook.Sheets[workbook.SheetNames[0]];
+            const existingData = XLSX.utils.sheet_to_json(worksheet);
+            const newData = [...existingData, ...data];
+            worksheet = XLSX.utils.json_to_sheet(newData);
+          } else {
+            workbook = XLSX.utils.book_new();
+            worksheet = XLSX.utils.json_to_sheet(data);
+          }
+          XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+          XLSX.writeFile(workbook, file_path);
+          break;
+          
+        case 'modify':
+          // 修改Excel数据
+          if (!input) {
+            return {
+              code: 10000,
+              msg: '修改操作需要输入文件路径(input)'
+            };
+          }
+          if (!data || !Array.isArray(data)) {
+            return {
+              code: 10000,
+              msg: '修改操作需要数据(data)且必须是数组'
+            };
+          }
+          if (!fs.existsSync(input)) {
+            return {
+              code: 10000,
+              msg: '输入文件不存在: ' + input
+            };
+          }
+          workbook = XLSX.readFile(input);
+          worksheet = XLSX.utils.json_to_sheet(data);
+          XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+          XLSX.writeFile(workbook, file_path);
+          break;
+          
+        default:
+          return {
+            code: 10000,
+            msg: '不支持的操作类型: ' + action + '，支持的类型: create, read, append, modify'
+          };
+      }
+      
+      return {
+        code: 0,
+        msg: `Excel${action}操作成功`,
+        file_path: file_path
+      };
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: 'Excel操作失败，原因：' + error.message
+      };
+    }
+  }
+};

package/common/tool/data/excel/tool.json

@@ -0,0 +1,53 @@
+{
+  "name": "excel",
+  "title": "Excel文档生成",
+  "description": "生成和操作Excel文档。触发关键词：Excel、生成表格、电子表格",
+  "category": "文档处理",
+  "group": "data",
+  "type": "function",
+  "main": "./index.js",
+  "params": [
+    {
+      "name": "action",
+      "description": "操作类型：create(创建)/write(写入)/read(读取)",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "data",
+      "description": "要写入的数据，二维数组格式",
+      "type": "array",
+      "required": true
+    },
+    {
+      "name": "sheet_name",
+      "description": "工作表名称",
+      "type": "string",
+      "required": false
+    },
+    {
+      "name": "output",
+      "description": "输出文件路径",
+      "type": "string",
+      "required": false
+    }
+  ],
+  "returns": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "操作状态代码，0表示成功",
+      "default": 0
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "操作反馈消息"
+    },
+    {
+      "name": "file_path",
+      "type": "string",
+      "description": "生成的文件路径"
+    }
+  ]
+}

package/common/tool/data/sql/index.js

@@ -0,0 +1,58 @@
+const Sql = require('mm_sql');
+
+module.exports = {
+  // 操作数据库
+  async operation(params) {
+    const { db_type, database, sql } = params;
+    
+    if (!db_type) {
+      throw new TypeError('数据库类型(db_type)不能为空');
+    }
+    if (!sql) {
+      throw new TypeError('SQL语句(sql)不能为空');
+    }
+    
+    let conn;
+    switch (db_type) {
+      case 'mysql':
+        conn = new Sql('mysql', database);
+        break;
+      case 'sqlite':
+        conn = new Sql('sqlite', database);
+        break;
+      case 'postgresql':
+        conn = new Sql('postgresql', database);
+        break;
+      default:
+        throw new Error('不支持的数据库类型: ' + db_type);
+    }
+    return await conn.run(sql);
+  },
+
+  /**
+   * 主函数
+   * @description 对数据库数据进行增删改查操作。
+   * @param {string} db_type - 数据库类型
+   * @param {string} database - 数据库名称
+   * @param {string} sql - SQL语句
+   * @returns {Promise<any>} - 操作结果
+   * @throws {Error} - 抛出错误
+   */
+  async main(params) {
+    let ret;
+    try {
+      let res = await this.operation(params);
+      ret = {
+        code: 0,
+        msg: '操作成功',
+        data: res
+      }
+    } catch (error) {
+      ret = {
+        code: 10000,
+        msg: error.message,
+      };
+    }
+    return ret;
+  }
+}

package/common/tool/data/sql/tool.json

@@ -0,0 +1,47 @@
+{
+  "name": "sql",
+  "title": "SQL数据库操作",
+  "description": "用SQL语句对数据库进行增删改查等操作。",
+  "group": "data",
+  "params": [
+    {
+      "name": "db_type",
+      "type": "string",
+      "description": "数据库类型",
+      "enum": [
+        "mysql",
+        "postgresql",
+        "sqlite"
+      ],
+      "required": true
+    },
+    {
+      "name": "database",
+      "type": "string",
+      "description": "要操作的数据库名称，默认操作当前数据库"
+    },
+    {
+      "name": "sql",
+      "type": "string",
+      "description": "SQL语句",
+      "required": true
+    }
+  ],
+  "returns": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "操作状态码，0表示成功，其他表示失败"
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "操作状态描述，成功时为操作成功，失败时为错误信息"
+    },
+    {
+      "name": "data",
+      "type": "object",
+      "description": "操作结果"
+    }
+  ]
+}

package/common/tool/develop/apply_patch/index.js

@@ -0,0 +1,248 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 解析 unified diff format 中的 hunk 头
+ * @@ -start,count +start,count @@
+ */
+function parseHunkHeader(line) {
+  const match = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+  if (!match) return null;
+  return {
+    oldStart: parseInt(match[1], 10),
+    oldCount: parseInt(match[2] || '1', 10),
+    newStart: parseInt(match[3], 10),
+    newCount: parseInt(match[4] || '1', 10)
+  };
+}
+
+/**
+ * 解析 unified diff 文本，提取 hunks
+ * @param {string} patchText - unified diff 格式的补丁文本
+ * @returns {Array} - hunks 数组
+ */
+function parsePatch(patchText) {
+  const lines = patchText.split(/\r?\n/);
+  const hunks = [];
+  let currentHunk = null;
+  let headerLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // 跳过文件头（---/+++）
+    if (line.startsWith('--- ') || line.startsWith('+++ ') || line.startsWith('diff --git')) {
+      headerLines.push(line);
+      continue;
+    }
+
+    // 检测 hunk 头
+    const header = parseHunkHeader(line);
+    if (header) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        header: header,
+        lines: []
+      };
+      continue;
+    }
+
+    if (currentHunk) {
+      if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+        currentHunk.lines.push({
+          type: line[0] === '+' ? 'added' : line[0] === '-' ? 'removed' : 'equal',
+          content: line.substring(1)
+        });
+      } else if (line.startsWith('\\')) {
+        // 无换行符标记，忽略
+        continue;
+      }
+      // 其他情况（空行等）当作 context 行
+      else {
+        // 空行在 diff 中可能是 context
+        if (line === '') {
+          currentHunk.lines.push({ type: 'equal', content: '' });
+        }
+      }
+    }
+  }
+
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+
+  return { hunks, headerLines };
+}
+
+/**
+ * 将 hunks 应用到文件内容
+ * @param {string[]} fileLines - 原始文件行数组
+ * @param {Array} hunks - 解析后的 hunks
+ * @returns {{ result: string[], applied: number, failed: number }}
+ */
+function applyHunks(fileLines, hunks) {
+  let result = [...fileLines];
+  let applied = 0;
+  let failed = 0;
+  let offset = 0; // 行号偏移累积
+
+  for (const hunk of hunks) {
+    const { oldStart, oldCount } = hunk.header;
+    // 调整行号（考虑之前 hunk 的偏移）
+    const startIdx = oldStart - 1 + offset;
+
+    // 检查上下文是否匹配
+    let match = true;
+    let ctxIdx = startIdx;
+    for (const line of hunk.lines) {
+      if (line.type === 'equal' || line.type === 'removed') {
+        if (ctxIdx >= result.length || result[ctxIdx] !== line.content) {
+          match = false;
+          break;
+        }
+        ctxIdx++;
+      } else if (line.type === 'added') {
+        // added 行不参与上下文匹配，只占位置
+      }
+    }
+
+    if (!match) {
+      failed++;
+      continue;
+    }
+
+    // 应用 hunk
+    const before = result.slice(0, startIdx);
+    const after = result.slice(startIdx + (oldCount > 0 ? hunk.lines.filter(l => l.type !== 'added').length : 0));
+    const newLines = hunk.lines
+      .filter(l => l.type !== 'removed')
+      .map(l => l.content);
+
+    result = [...before, ...newLines, ...after];
+
+    // 计算偏移：新行数 - 旧行数
+    const newCount = hunk.lines.filter(l => l.type !== 'removed').length;
+    const removedCount = hunk.lines.filter(l => l.type === 'removed').length;
+    offset += newCount - removedCount;
+
+    applied++;
+  }
+
+  return { result, applied, failed };
+}
+
+module.exports = {
+  /**
+   * 应用补丁到文件
+   * @param {Object} config - 配置参数
+   * @param {string} config.file - 目标文件路径
+   * @param {string} config.patch - unified diff 格式的补丁文本
+   * @param {boolean} config.dry_run - 是否仅预览（不实际写入文件），默认 false
+   * @param {string} config.encoding - 文件编码，默认 utf-8
+   * @returns {Promise} - 执行结果
+   */
+  async main(config) {
+    try {
+      const { file, patch, dry_run, encoding } = config;
+
+      if (!file) {
+        return { code: 10001, msg: '参数不足：需要提供 file（目标文件路径）' };
+      }
+      if (!patch) {
+        return { code: 10001, msg: '参数不足：需要提供 patch（补丁文本）' };
+      }
+
+      // 解析路径
+      let f = file;
+      if (!path.isAbsolute(f)) {
+        if (f.fullname) {
+          f = f.fullname($.run_path);
+        } else {
+          f = path.resolve(process.cwd(), f);
+        }
+      }
+
+      if (!fs.existsSync(f)) {
+        return { code: 10002, msg: `文件不存在: ${f}` };
+      }
+
+      const enc = encoding || 'utf-8';
+      const content = fs.readFileSync(f, enc);
+      const fileLines = content.split(/\r?\n/);
+
+      // 解析补丁
+      const { hunks, headerLines } = parsePatch(patch);
+      if (hunks.length === 0) {
+        return { code: 10003, msg: '补丁格式无效：未找到有效的 hunk（差异块）' };
+      }
+
+      // 应用补丁
+      const { result, applied, failed } = applyHunks(fileLines, hunks);
+
+      if (applied === 0) {
+        return {
+          code: 10004,
+          msg: '补丁应用失败：所有 hunk 均无法匹配文件内容。可能补丁版本与文件版本不一致。',
+          total_hunks: hunks.length,
+          applied: 0,
+          failed: failed,
+          file: f
+        };
+      }
+
+      // 构造预览差异
+      const newContent = result.join('\n');
+      const previewLines = [];
+      let added = 0, removed = 0;
+
+      // 简单对比差异
+      const oldLines = content.split(/\r?\n/);
+      const newLinesArr = result;
+      const maxLen = Math.max(oldLines.length, newLinesArr.length);
+      for (let i = 0; i < maxLen; i++) {
+        const oldL = i < oldLines.length ? oldLines[i] : null;
+        const newL = i < newLinesArr.length ? newLinesArr[i] : null;
+        if (oldL !== newL) {
+          if (oldL !== null) { previewLines.push(`- ${oldL}`); removed++; }
+          if (newL !== null) { previewLines.push(`+ ${newL}`); added++; }
+        }
+      }
+
+      // dry_run 模式：不写入文件
+      if (dry_run) {
+        return {
+          code: 0,
+          msg: `预览模式：将应用 ${applied}/${hunks.length} 个 hunk（${added} 行新增，${removed} 行删除）`,
+          total_hunks: hunks.length,
+          applied: applied,
+          failed: failed,
+          added_lines: added,
+          removed_lines: removed,
+          file: f,
+          preview: previewLines.join('\n')
+        };
+      }
+
+      // 写入文件
+      fs.writeFileSync(f, newContent, enc);
+
+      return {
+        code: 0,
+        msg: `补丁应用成功：${applied}/${hunks.length} 个 hunk 已应用（${added} 行新增，${removed} 行删除）`,
+        total_hunks: hunks.length,
+        applied: applied,
+        failed: failed,
+        added_lines: added,
+        removed_lines: removed,
+        file: f
+      };
+    } catch (error) {
+      return {
+        code: 10099,
+        msg: '补丁应用失败，原因：' + error.message
+      };
+    }
+  }
+};

package/common/tool/develop/apply_patch/tool.json

@@ -0,0 +1,83 @@
+{
+  "name": "apply_patch",
+  "title": "应用代码补丁",
+  "description": "将 unified diff 格式的补丁应用到目标文件。支持标准 unified diff 格式（@@ -start,count +start,count @@），可配合 diff_check 工具使用。支持 dry_run 预览模式预览变更而不写入文件。",
+  "category": "开发工具",
+  "group": "develop",
+  "type": "function",
+  "main": "./index.js",
+  "params": [
+    {
+      "name": "file",
+      "description": "目标文件路径，必须使用绝对路径",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "patch",
+      "description": "unified diff 格式的补丁文本，包含 @@ -start,count +start,count @@ 格式的 hunk 头和 +/- 标记的行。可以从 diff_check 工具的输出获取。",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "dry_run",
+      "description": "预览模式，设为 true 时仅显示变更预览而不实际写入文件",
+      "type": "boolean",
+      "default": false
+    },
+    {
+      "name": "encoding",
+      "description": "文件编码，默认 utf-8",
+      "type": "string",
+      "default": "utf-8"
+    }
+  ],
+  "returns": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "返回代码，0表示成功",
+      "default": 0
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "返回消息，包含应用统计"
+    },
+    {
+      "name": "total_hunks",
+      "type": "number",
+      "description": "补丁中的总 hunk 数"
+    },
+    {
+      "name": "applied",
+      "type": "number",
+      "description": "成功应用的 hunk 数"
+    },
+    {
+      "name": "failed",
+      "type": "number",
+      "description": "失败的 hunk 数"
+    },
+    {
+      "name": "added_lines",
+      "type": "number",
+      "description": "新增行数"
+    },
+    {
+      "name": "removed_lines",
+      "type": "number",
+      "description": "删除行数"
+    },
+    {
+      "name": "file",
+      "type": "string",
+      "description": "目标文件路径"
+    },
+    {
+      "name": "preview",
+      "type": "string",
+      "description": "dry_run 模式下返回的变更预览文本"
+    }
+  ]
+}