mm_ai 1.0.0

package/common/tool/file/docx/index.js

@@ -0,0 +1,317 @@
+const fs = require('fs');
+const path = require('path');
+const mammoth = require('mammoth');
+const {
+  Document, Packer, Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell,
+  ImageRun, AlignmentType, convertInchesToTwip, Header, Footer, PageNumber, LevelFormat,
+  NumberFormat, TabStopPosition, TabStopType, UnderlineType
+} = require('docx');
+
+/**
+ * 解析 Markdown 行，构建 docx 段落/表格/列表
+ */
+function markdownToDocx(md, title) {
+  const lines = md.split(/\r?\n/);
+  const children = [];
+
+  // 文档标题
+  if (title) {
+    children.push(
+      new Paragraph({
+        text: title,
+        heading: HeadingLevel.TITLE,
+        alignment: AlignmentType.CENTER,
+        spacing: { after: 400 }
+      })
+    );
+  }
+
+  let i = 0;
+  // 处理列表缩进
+  let listIndent = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // 空行
+    if (!trimmed) {
+      i++;
+      continue;
+    }
+
+    // 表格：包含 |
+    if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+      if (trimmed.match(/^\|[\s:-]+\|[\s:-]+\|/)) {
+        // 分隔行，跳过
+        i++;
+        continue;
+      }
+      const rows = [];
+      while (i < lines.length && lines[i].trim().startsWith('|')) {
+        const rowLine = lines[i].trim();
+        if (rowLine.match(/^\|[\s:-]+\|[\s:-]+\|/)) {
+          i++;
+          continue;
+        }
+        const cells = rowLine.split('|').filter(c => c !== undefined).map(c => c.trim());
+        const row = new TableRow({
+          children: cells.map(cellText => new TableCell({
+            children: [new Paragraph({
+              children: parseInlineMarkdown(cellText),
+              spacing: { before: 40, after: 40 }
+            })]
+          }))
+        });
+        rows.push(row);
+        i++;
+      }
+      if (rows.length > 0) {
+        children.push(new Table({ rows, width: { size: 100, type: 'pct' } }));
+        children.push(new Paragraph({ spacing: { before: 200 } }));
+      }
+      continue;
+    }
+
+    // 标题：### 或 ## 或 #
+    const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const text = headingMatch[2];
+      const headingLevels = [undefined, HeadingLevel.HEADING_1, HeadingLevel.HEADING_2, HeadingLevel.HEADING_3, HeadingLevel.HEADING_4, HeadingLevel.HEADING_5, HeadingLevel.HEADING_6];
+      children.push(new Paragraph({
+        children: parseInlineMarkdown(text),
+        heading: headingLevels[level] || HeadingLevel.HEADING_1,
+        spacing: { before: 240, after: 120 }
+      }));
+      i++;
+      continue;
+    }
+
+    // 无序列表：- 或 *
+    const ulMatch = trimmed.match(/^[-*]\s+(.+)/);
+    if (ulMatch) {
+      const text = ulMatch[1];
+      // 检测缩进层级
+      const indent = Math.floor((line.length - line.trimLeft().length) / 2);
+      children.push(new Paragraph({
+        children: parseInlineMarkdown(text),
+        bullet: { level: indent },
+        spacing: { before: 40, after: 40 }
+      }));
+      i++;
+      continue;
+    }
+
+    // 有序列表：1. 2.
+    const olMatch = trimmed.match(/^(\d+)\.\s+(.+)/);
+    if (olMatch) {
+      const text = olMatch[2];
+      const indent = Math.floor((line.length - line.trimLeft().length) / 2);
+      children.push(new Paragraph({
+        children: parseInlineMarkdown(text),
+        numbering: { reference: 'default-numbering', level: indent },
+        spacing: { before: 40, after: 40 }
+      }));
+      i++;
+      continue;
+    }
+
+    // 水平线：---
+    if (trimmed.match(/^---+$/)) {
+      children.push(new Paragraph({
+        thematicBreak: true,
+        spacing: { before: 200, after: 200 }
+      }));
+      i++;
+      continue;
+    }
+
+    // 普通段落
+    children.push(new Paragraph({
+      children: parseInlineMarkdown(trimmed),
+      spacing: { before: 60, after: 60 }
+    }));
+    i++;
+  }
+
+  return children;
+}
+
+/**
+ * 解析行内 Markdown：粗体、斜体、内联代码、超链接
+ */
+function parseInlineMarkdown(text) {
+  const runs = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    // 图片 ![alt](url)
+    const imgMatch = remaining.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
+    if (imgMatch) {
+      const imgPath = imgMatch[2];
+      if (fs.existsSync(imgPath)) {
+        const imgBuffer = fs.readFileSync(imgPath);
+        runs.push(new ImageRun({
+          data: imgBuffer,
+          transformation: { width: 400, height: 300, type: 'png' }
+        }));
+      }
+      remaining = remaining.slice(imgMatch[0].length);
+      continue;
+    }
+
+    // 超链接 [text](url)
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+    if (linkMatch) {
+      runs.push(new TextRun({
+        text: linkMatch[1],
+        style: 'Hyperlink'
+      }));
+      remaining = remaining.slice(linkMatch[0].length);
+      continue;
+    }
+
+    // 粗体 **text**
+    const boldMatch = remaining.match(/^\*\*([^*]+)\*\*/);
+    if (boldMatch) {
+      runs.push(new TextRun({ text: boldMatch[1], bold: true }));
+      remaining = remaining.slice(boldMatch[0].length);
+      continue;
+    }
+
+    // 斜体 *text*
+    const italicMatch = remaining.match(/^\*([^*]+)\*/);
+    if (italicMatch) {
+      runs.push(new TextRun({ text: italicMatch[1], italics: true }));
+      remaining = remaining.slice(italicMatch[0].length);
+      continue;
+    }
+
+    // 内联代码 `code`
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch) {
+      runs.push(new TextRun({ text: codeMatch[1], font: 'Consolas', size: 20 }));
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+
+    // 普通文本（取到下一个特殊标记前）
+    const nextSpecial = remaining.search(/[*\[`!]/);
+    if (nextSpecial === 0) {
+      // 当前字符就是特殊字符，可能是误匹配，直接输出一个字符
+      runs.push(new TextRun({ text: remaining[0] }));
+      remaining = remaining.slice(1);
+    } else if (nextSpecial > 0) {
+      runs.push(new TextRun({ text: remaining.slice(0, nextSpecial) }));
+      remaining = remaining.slice(nextSpecial);
+    } else {
+      runs.push(new TextRun({ text: remaining }));
+      remaining = '';
+    }
+  }
+
+  return runs;
+}
+
+module.exports = {
+  /**
+   * 读取 docx 文件为 Markdown
+   */
+  async readDocx(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    if (!fs.existsSync(resolvedPath)) {
+      throw new Error('文件不存在: ' + filePath);
+    }
+
+    const result = await mammoth.convertToMarkdown({ path: resolvedPath });
+    return result.value;
+  },
+
+  /**
+   * 根据 Markdown 内容生成 docx 文件
+   */
+  async writeDocx(config) {
+    const { file, content, title, author } = config;
+    if (!file) throw new Error('输出文件路径(file)不能为空');
+    if (!content) throw new Error('内容(content)不能为空');
+
+    const resolvedPath = path.resolve(file);
+    const dir = path.dirname(resolvedPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const children = markdownToDocx(content, title || '');
+
+    const doc = new Document({
+      title: title || '',
+      description: 'Generated by MM_AI',
+      styles: {
+        default: {
+          document: {
+            run: { size: 24, font: 'Microsoft YaHei' }
+          }
+        }
+      },
+      numbering: {
+        config: [{
+          reference: 'default-numbering',
+          levels: [{
+            level: 0,
+            format: NumberFormat.DECIMAL,
+            text: '%1.',
+            alignment: AlignmentType.START
+          }]
+        }]
+      },
+      sections: [{
+        properties: {},
+        children: children
+      }]
+    });
+
+    const buffer = await Packer.toBuffer(doc);
+    fs.writeFileSync(resolvedPath, buffer);
+
+    return resolvedPath;
+  },
+
+  async main(params) {
+    try {
+      const { action, file, content, title, author } = params;
+
+      if (!action) {
+        return { code: 10001, msg: '操作类型(action)不能为空，可选: read, write' };
+      }
+      if (!file) {
+        return { code: 10001, msg: '文件路径(file)不能为空' };
+      }
+
+      if (action === 'read') {
+        const mdContent = await this.readDocx(file);
+        return {
+          code: 0,
+          msg: '读取 Word 文档成功',
+          content: mdContent
+        };
+      } else if (action === 'write') {
+        const filePath = await this.writeDocx(params);
+        const stats = fs.statSync(filePath);
+        return {
+          code: 0,
+          msg: '生成 Word 文档成功',
+          file_path: filePath,
+          size: stats.size
+        };
+      } else {
+        return { code: 10001, msg: '不支持的操作类型: ' + action + '，可选: read, write' };
+      }
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: 'Word 文档操作失败，原因：' + error.message
+      };
+    }
+  }
+};

package/common/tool/file/docx/tool.json

@@ -0,0 +1,62 @@
+{
+  "name": "docx",
+  "title": "Word文档读写",
+  "description": "读取和生成 Word(.docx) 文档。读取时输出 Markdown 格式文本；生成时接收 Markdown 格式内容创建标准 docx 文档。支持段落、标题、列表、表格、超链接、图片、字体样式等。",
+  "category": "文件管理",
+  "group": "file",
+  "type": "function",
+  "main": "./index.js",
+  "params": [
+    {
+      "name": "action",
+      "description": "操作类型：read(读取) / write(生成)",
+      "type": "string",
+      "enum": ["read", "write"],
+      "required": true
+    },
+    {
+      "name": "file",
+      "description": "文件路径，读取时为源文件路径，生成时为目标输出路径",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "content",
+      "description": "Markdown 格式的内容，write 操作时使用。支持标题(#)、列表(-/*)、表格(|)、超链接([text](url))、粗体(**)、斜体(*)等。",
+      "type": "string"
+    },
+    {
+      "name": "title",
+      "description": "文档标题（可选），write 操作时使用，将作为文档的第一行居中标题",
+      "type": "string"
+    },
+    {
+      "name": "author",
+      "description": "作者（可选），write 操作时使用",
+      "type": "string"
+    }
+  ],
+  "returns": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "返回代码，0表示成功",
+      "default": 0
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "返回消息"
+    },
+    {
+      "name": "content",
+      "type": "string",
+      "description": "读取操作返回的 Markdown 内容"
+    },
+    {
+      "name": "file_path",
+      "type": "string",
+      "description": "生成操作返回的文件路径"
+    }
+  ]
+}

package/common/tool/file/edit_file/index.js

@@ -0,0 +1,222 @@
+const fs = require('fs');
+const path = require('path');
+require('mm_expand');
+
+module.exports = {
+  /**
+   * 编辑文件内容
+   * @param {Object} config - 配置参数
+   * @param {string} config.file - 文件路径
+   * @param {string} [config.old_str] - 搜索文本，工具自动定位替换（文本模式推荐）
+   * @param {number} [config.start] - 起始位置（二进制模式必传；文本模式传了old_str时不传，否则必传）
+   * @param {number} [config.end] - 结束位置（二进制模式必传；文本模式传了old_str时不传，否则必传）
+   * @param {string|Buffer} config.content - 要写入的新内容
+   * @param {string} [config.encoding] - 文件编码
+   * @returns {Promise<object>} result - 编辑结果
+   */
+  async editFileContent(config) {
+    const { file, old_str, start, end, content, encoding } = config;
+
+    if (!file) {
+      throw new TypeError('文件路径(file)不能为空');
+    }
+
+    if (content === undefined || content === null) {
+      throw new TypeError('写入内容(content)不能为空');
+    }
+
+    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)) {
+      throw new Error(`文件不存在: ${f}`);
+    }
+
+    // 判断是否为二进制模式
+    const isBinary = (encoding === undefined || encoding === null || encoding === 'binary');
+
+    // 解析content中的转义序列（文本模式）
+    let resolvedContent = content;
+    if (!isBinary && typeof content === 'string') {
+      resolvedContent = content.replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t');
+    }
+
+    if (isBinary) {
+      // ========== 二进制模式：按字节位置操作 ==========
+      if (start === undefined || start === null) {
+        throw new TypeError('二进制模式下起始位置(start)不能为空');
+      }
+      if (end === undefined || end === null) {
+        throw new TypeError('二进制模式下结束位置(end)不能为空');
+      }
+      if (start < 0) {
+        throw new TypeError('起始位置(start)必须大于等于0');
+      }
+      if (end < start) {
+        throw new TypeError('结束位置(end)不能小于起始位置(start)');
+      }
+
+      const original = fs.readFileSync(f);
+      const total_bytes = original.length;
+
+      if (start > total_bytes) {
+        throw new Error(`起始位置(${start})超出文件总字节数(${total_bytes})，建议范围：0~${total_bytes}`);
+      }
+      if (end > total_bytes) {
+        throw new Error(`结束位置(${end})超出文件总字节数(${total_bytes})，建议范围：0~${total_bytes}`);
+      }
+
+      const contentBuf = Buffer.isBuffer(content) ? content : Buffer.from(content, 'binary');
+      const contentLen = contentBuf.length;
+
+      let result;
+      if (end === start) {
+        const before = original.subarray(0, start);
+        const after = original.subarray(start);
+        result = Buffer.concat([before, contentBuf, after]);
+      } else {
+        const before = original.subarray(0, start);
+        const after = original.subarray(end);
+        result = Buffer.concat([before, contentBuf, after]);
+      }
+
+      fs.writeFileSync(f, result);
+
+      return {
+        file: f,
+        bytes: result.length,
+        chars: result.length,
+        next_start: start + contentLen
+      };
+    } else {
+      // ========== 文本模式：按字符操作 ==========
+      const original = fs.readFileSync(f, encoding);
+      const chars = Array.from(original);
+      const total_chars = chars.length;
+
+      const contentChars = Array.from(resolvedContent);
+      const contentLen = contentChars.length;
+
+      let actualStart, actualEnd;
+
+      if (old_str !== undefined && old_str !== null && old_str !== '') {
+        // 通过 old_str 自动定位
+        const searchStr = String(old_str);
+        const searchChars = Array.from(searchStr);
+        const searchLen = searchChars.length;
+
+        let foundIndex = -1;
+        for (let i = 0; i <= total_chars - searchLen; i++) {
+          let match = true;
+          for (let j = 0; j < searchLen; j++) {
+            if (chars[i + j] !== searchChars[j]) {
+              match = false;
+              break;
+            }
+          }
+          if (match) {
+            foundIndex = i;
+            break;
+          }
+        }
+
+        if (foundIndex === -1) {
+          throw new Error(`在文件中未找到匹配的文本: "${old_str}"`);
+        }
+
+        actualStart = foundIndex;
+        actualEnd = foundIndex + searchLen;
+      } else {
+        // 通过 start/end 定位
+        if (start === undefined || start === null) {
+          throw new TypeError('文本模式下起始位置(start)不能为空（未传old_str时）');
+        }
+        if (end === undefined || end === null) {
+          throw new TypeError('文本模式下结束位置(end)不能为空（未传old_str时）');
+        }
+        if (start < 0) {
+          throw new TypeError('起始位置(start)必须大于等于0');
+        }
+        if (end < start) {
+          throw new TypeError('结束位置(end)不能小于起始位置(start)');
+        }
+        if (start > total_chars) {
+          throw new Error(`起始位置(${start})超出文件总字符数(${total_chars})，建议范围：0~${total_chars}`);
+        }
+        if (end > total_chars) {
+          throw new Error(`结束位置(${end})超出文件总字符数(${total_chars})，建议范围：0~${total_chars}`);
+        }
+
+        actualStart = start;
+        actualEnd = end;
+      }
+
+      // 执行替换/插入
+      let result;
+      if (actualEnd === actualStart) {
+        const before = chars.slice(0, actualStart).join('');
+        const after = chars.slice(actualStart).join('');
+        result = before + resolvedContent + after;
+      } else {
+        const before = chars.slice(0, actualStart).join('');
+        const after = chars.slice(actualEnd).join('');
+        result = before + resolvedContent + after;
+      }
+
+      fs.writeFileSync(f, result, encoding);
+      const stats = fs.statSync(f);
+
+      const ret = {
+        file: f,
+        bytes: stats.size,
+        chars: Array.from(result).length,
+        next_start: actualStart + contentLen
+      };
+      if (old_str) {
+        ret.matched = old_str;
+      }
+      return ret;
+    }
+  },
+
+  /**
+   * 主函数
+   * @param {Object} params - 参数
+   * @returns {Promise} - 执行结果
+   */
+  async main(params) {
+    let ret;
+    try {
+      const result = await this.editFileContent(params);
+      ret = {
+        code: 0,
+        msg: '编辑文件成功',
+        file: result.file,
+        bytes: result.bytes,
+        chars: result.chars,
+        next_start: result.next_start
+      };
+      if (result.matched) {
+        ret.matched = result.matched;
+      }
+    } catch (error) {
+      ret = {
+        code: 10000,
+        msg: `编辑文件失败！原因：${error.message}`,
+        file: '',
+        bytes: 0,
+        chars: 0,
+        next_start: -1
+      };
+    }
+    return ret;
+  }
+};

package/common/tool/file/edit_file/tool.json

@@ -0,0 +1,80 @@
+{
+  "name": "edit_file",
+  "title": "文件编辑",
+  "description": "编辑文件内容，支持按文本搜索自动定位或按字符/字节位置精确编辑。文本模式（默认）推荐用 old_str 自动定位替换，也可用 start/end 按字符位置操作；二进制模式（encoding=binary）通过 start/end 按字节位置操作。适用于对已存在的文件进行局部精确修改。如需按行号操作文本文件，推荐使用 write_text；如需整体覆盖或新建文件，推荐使用 write_file。",
+  "category": "文件操作",
+  "group": "file",
+  "type": "function",
+  "main": "./index.js",
+  "params": [
+    {
+      "name": "file",
+      "description": "要编辑的文件路径，必须使用绝对路径",
+      "type": "string",
+      "required": true
+    },
+    {
+      "name": "encoding",
+      "description": "文件编码。传binary按二进制（字节）处理；传utf-8/ascii时按文本（字符）处理",
+      "type": "string",
+      "enum": ["utf-8", "ascii", "binary"],
+      "required": true
+    },
+    {
+      "name": "old_str",
+      "description": "【文本模式推荐】搜索文本，工具自动在文件中查找并替换，无需手动计算字符位置。不传时使用start/end定位",
+      "type": "string",
+      "required": false
+    },
+    {
+      "name": "start",
+      "description": "覆盖的起始位置（从0开始）。文本模式为字符位置，二进制模式为字节位置。传了old_str时可不传；不传old_str时必传",
+      "type": "number",
+      "required": false
+    },
+    {
+      "name": "end",
+      "description": "覆盖的结束位置（不包含该位置）。等于start时表示在指定位置插入内容。传了old_str时可不传；不传old_str时必传",
+      "type": "number",
+      "required": false
+    },
+    {
+      "name": "content",
+      "description": "要写入的新内容。支持转义序列：\\n（换行）、\\r（回车）、\\t（制表符）",
+      "type": "string",
+      "required": true
+    }
+  ],
+  "returns": [
+    {
+      "name": "code",
+      "type": "number",
+      "description": "编辑状态码，0表示成功"
+    },
+    {
+      "name": "msg",
+      "type": "string",
+      "description": "编辑状态信息"
+    },
+    {
+      "name": "file",
+      "type": "string",
+      "description": "编辑的文件路径"
+    },
+    {
+      "name": "bytes",
+      "type": "number",
+      "description": "写入后的文件字节数"
+    },
+    {
+      "name": "chars",
+      "type": "number",
+      "description": "写入后的文件总字符数/字节数（二进制模式与bytes相同）"
+    },
+    {
+      "name": "next_start",
+      "type": "number",
+      "description": "下次编辑的推荐起始位置。连续编辑时直接使用此值作为下一次的start，无需手动计算偏移"
+    }
+  ]
+}