adspecs 0.1.12

package/skills/adspecs-export-word/references/md-to-docx.js

@@ -0,0 +1,862 @@
+#!/usr/bin/env node
+/**
+ * md-to-docx.js — Markdown to Word (.docx) converter
+ *
+ * Features:
+ *   - Auto-generated cover page (company logo, project info, document metadata)
+ *   - Table of contents (Heading 1-3)
+ *   - Full Markdown element conversion (headings, tables, code blocks, lists, images, blockquotes)
+ *
+ * Usage:
+ *   node md-to-docx.js --input <file> --output <file> --meta '<json>'
+ *   node md-to-docx.js --dir <dir> --output <dir> --meta '<json>' [--recursive]
+ *   [--no-cover] [--no-toc]
+ */
+
+const fs = require("fs");
+const path = require("path");
+const {
+  Document,
+  Packer,
+  Paragraph,
+  TextRun,
+  HeadingLevel,
+  AlignmentType,
+  TableOfContents,
+  StyleLevel,
+  Table,
+  TableRow,
+  TableCell,
+  WidthType,
+  BorderStyle,
+  ImageRun,
+  PageBreak,
+  ShadingType,
+} = require("docx");
+const { marked } = require("marked");
+
+// ── Constants ──────────────────────────────────────────────────────────
+
+const DARK_BLUE = "1F4E79";
+const GRAY = "808080";
+const LIGHT_GRAY = "F2F2F2";
+
+const FONT_BODY = "DengXian";
+const FONT_HEADING = "Microsoft YaHei";
+const FONT_CODE = "Consolas";
+
+const HEADING_STYLES = {
+  1: { heading: HeadingLevel.HEADING_1, size: 44, font: FONT_HEADING },
+  2: { heading: HeadingLevel.HEADING_2, size: 32, font: FONT_HEADING },
+  3: { heading: HeadingLevel.HEADING_3, size: 28, font: FONT_HEADING },
+  4: { heading: HeadingLevel.HEADING_4, size: 24, font: FONT_HEADING },
+  5: { heading: HeadingLevel.HEADING_5, size: 22, font: FONT_HEADING },
+  6: { heading: HeadingLevel.HEADING_6, size: 20, font: FONT_HEADING },
+};
+
+// ── CLI Arguments ──────────────────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    input: null,
+    dir: null,
+    output: null,
+    meta: "{}",
+    noCover: false,
+    noToc: false,
+    recursive: false,
+  };
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--input":
+        result.input = args[++i];
+        break;
+      case "--dir":
+        result.dir = args[++i];
+        break;
+      case "--output":
+        result.output = args[++i];
+        break;
+      case "--meta":
+        result.meta = args[++i];
+        break;
+      case "--no-cover":
+        result.noCover = true;
+        break;
+      case "--no-toc":
+        result.noToc = true;
+        break;
+      case "--recursive":
+        result.recursive = true;
+        break;
+    }
+  }
+  return result;
+}
+
+// ── Markdown Reader ────────────────────────────────────────────────────
+
+function readMarkdown(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+
+  // Try YAML frontmatter
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  let frontmatter = {};
+  let body = content;
+
+  if (fmMatch) {
+    for (const line of fmMatch[1].split("\n")) {
+      const m = line.match(/^(\S+):\s*(.*)$/);
+      if (m) frontmatter[m[1]] = m[2].trim().replace(/^["']|["']$/g, "");
+    }
+    body = fmMatch[2];
+  } else {
+    // Try blockquote metadata: > **版本**: v1.0
+    const metaLines = [];
+    const restLines = [];
+    let inMeta = true;
+    for (const line of content.split("\n")) {
+      if (inMeta && line.startsWith(">")) {
+        metaLines.push(line);
+      } else {
+        inMeta = false;
+        restLines.push(line);
+      }
+    }
+    body = restLines.join("\n");
+    for (const line of metaLines) {
+      const m = line.match(/\*\*(.+?)\*\*[:：]\s*(.+)/);
+      if (m) frontmatter[m[1].trim()] = m[2].trim();
+    }
+  }
+
+  return { body, frontmatter };
+}
+
+// ── Inline Token Converter ─────────────────────────────────────────────
+
+function convertInline(tokens, overrides = {}) {
+  if (!tokens || !Array.isArray(tokens)) return [];
+  const runs = [];
+  const baseFont = overrides.font || FONT_BODY;
+  const baseSize = overrides.size || 24;
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text": {
+        const children = token.tokens ? convertInline(token.tokens, overrides) : [];
+        if (children.length > 0) {
+          runs.push(...children);
+        } else {
+          runs.push(new TextRun({ text: token.text || "", font: baseFont, size: baseSize, ...overrides }));
+        }
+        break;
+      }
+      case "strong":
+        runs.push(...convertInline(token.tokens, { ...overrides, bold: true }));
+        break;
+      case "em":
+        runs.push(...convertInline(token.tokens, { ...overrides, italics: true }));
+        break;
+      case "del":
+        runs.push(...convertInline(token.tokens, { ...overrides, strike: true }));
+        break;
+      case "codespan":
+        runs.push(
+          new TextRun({ text: token.text || "", font: FONT_CODE, size: Math.min(baseSize, 20), ...overrides })
+        );
+        break;
+      case "link":
+        runs.push(
+          new TextRun({
+            text: token.text || (token.tokens ? token.tokens.map(t => t.text || t.raw || "").join("") : ""),
+            font: baseFont,
+            size: baseSize,
+            color: "0563C1",
+            underline: { type: "single" },
+            ...overrides,
+          })
+        );
+        break;
+      case "image":
+        try {
+          const imgPath = token.href;
+          if (imgPath && fs.existsSync(imgPath)) {
+            const buf = fs.readFileSync(imgPath);
+            runs.push(
+              new ImageRun({
+                data: buf,
+                transformation: { width: 200, height: 150 },
+                altText: { title: token.text || "Image", description: token.text || "Image", name: "image" },
+              })
+            );
+          } else {
+            runs.push(new TextRun({ text: `[Image: ${token.text || token.href}]`, font: baseFont, size: baseSize, italics: true, color: GRAY }));
+          }
+        } catch {
+          runs.push(new TextRun({ text: `[Image: ${token.text || token.href}]`, font: baseFont, size: baseSize, italics: true, color: GRAY }));
+        }
+        break;
+      case "br":
+        runs.push(new TextRun({ text: "", break: 1, font: baseFont, size: baseSize }));
+        break;
+      default:
+        if (token.text || token.raw) {
+          runs.push(new TextRun({ text: token.text || token.raw || "", font: baseFont, size: baseSize, ...overrides }));
+        }
+    }
+  }
+
+  return runs;
+}
+
+// ── Cover Page Builder ─────────────────────────────────────────────────
+
+function buildCoverPage(meta) {
+  const blocks = [];
+  const spacer = (n) => {
+    for (let i = 0; i < n; i++) blocks.push(new Paragraph({ children: [new TextRun("")] }));
+  };
+
+  // 1. Top spacing
+  spacer(3);
+
+  // 2. Company logo
+  if (meta.company_logo && fs.existsSync(meta.company_logo)) {
+    try {
+      const logoBuf = fs.readFileSync(meta.company_logo);
+      blocks.push(
+        new Paragraph({
+          alignment: AlignmentType.CENTER,
+          children: [
+            new ImageRun({
+              data: logoBuf,
+              transformation: { width: 200, height: 200 },
+              altText: { title: "Company Logo", description: "Company Logo", name: "logo" },
+            }),
+          ],
+        })
+      );
+      spacer(2);
+    } catch {
+      // Skip logo on error
+    }
+  }
+
+  // 3. Company name
+  if (meta.company_name) {
+    blocks.push(
+      new Paragraph({
+        alignment: AlignmentType.CENTER,
+        children: [new TextRun({ text: meta.company_name, bold: true, font: FONT_HEADING, size: 32, color: DARK_BLUE })],
+      })
+    );
+  }
+
+  spacer(1);
+
+  // 4. Project name
+  if (meta.project_name) {
+    blocks.push(
+      new Paragraph({
+        alignment: AlignmentType.CENTER,
+        children: [new TextRun({ text: meta.project_name, bold: true, font: FONT_HEADING, size: 36, color: DARK_BLUE })],
+      })
+    );
+  }
+
+  spacer(2);
+
+  // 5. Document title
+  if (meta.title) {
+    blocks.push(
+      new Paragraph({
+        alignment: AlignmentType.CENTER,
+        children: [new TextRun({ text: meta.title, bold: true, font: FONT_HEADING, size: 56, color: DARK_BLUE })],
+      })
+    );
+  }
+
+  // 6. Subtitle
+  if (meta.subtitle) {
+    blocks.push(
+      new Paragraph({
+        alignment: AlignmentType.CENTER,
+        spacing: { before: 200 },
+        children: [new TextRun({ text: meta.subtitle, font: FONT_HEADING, size: 28, color: GRAY })],
+      })
+    );
+  }
+
+  spacer(3);
+
+  // 7. Info table
+  const fields = [
+    ["文档编号", meta.document_number],
+    ["版本号", meta.version],
+    ["创建日期", meta.date],
+    ["作者", meta.author],
+    ["审核人", meta.reviewer],
+    ["批准人", meta.approver],
+    ["保密等级", meta.confidentiality],
+  ].filter(([, v]) => v);
+
+  if (fields.length > 0) {
+    const borderStyle = { style: BorderStyle.SINGLE, size: 1, color: "BBBBBB" };
+    const borders = { top: borderStyle, bottom: borderStyle, left: borderStyle, right: borderStyle };
+
+    const rows = fields.map(
+      ([label, value]) =>
+        new TableRow({
+          children: [
+            new TableCell({
+              borders,
+              width: { size: 3000, type: WidthType.DXA },
+              children: [
+                new Paragraph({
+                  alignment: AlignmentType.CENTER,
+                  children: [new TextRun({ text: label, bold: true, font: FONT_HEADING, size: 22 })],
+                }),
+              ],
+            }),
+            new TableCell({
+              borders,
+              width: { size: 5000, type: WidthType.DXA },
+              children: [
+                new Paragraph({
+                  children: [new TextRun({ text: value, font: FONT_BODY, size: 22 })],
+                }),
+              ],
+            }),
+          ],
+        })
+    );
+
+    blocks.push(
+      new Table({
+        rows,
+        width: { size: 8000, type: WidthType.DXA },
+      })
+    );
+  }
+
+  // 8. Page break
+  blocks.push(
+    new Paragraph({
+      children: [new PageBreak()],
+    })
+  );
+
+  return blocks;
+}
+
+// ── TOC Builder ────────────────────────────────────────────────────────
+
+function buildTOC() {
+  return [
+    new Paragraph({
+      heading: HeadingLevel.HEADING_1,
+      children: [new TextRun({ text: "目录", font: FONT_HEADING, size: 44, bold: true, color: DARK_BLUE })],
+    }),
+    new TableOfContents("目录", {
+      hyperlink: true,
+      headingStyleRange: "1-3",
+      stylesWithLevels: [
+        new StyleLevel("Heading1", 1),
+        new StyleLevel("Heading2", 2),
+        new StyleLevel("Heading3", 3),
+      ],
+    }),
+    new Paragraph({
+      children: [new PageBreak()],
+    }),
+  ];
+}
+
+// ── Markdown → docx Converter ──────────────────────────────────────────
+
+function convertTokens(tokens) {
+  const blocks = [];
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case "heading": {
+        const style = HEADING_STYLES[token.depth] || HEADING_STYLES[6];
+        const runs = token.tokens
+          ? convertInline(token.tokens, { font: style.font, size: style.size, bold: true, color: DARK_BLUE })
+          : [new TextRun({ text: token.text || "", font: style.font, size: style.size, bold: true, color: DARK_BLUE })];
+        blocks.push(
+          new Paragraph({
+            heading: style.heading,
+            spacing: { before: 300, after: 100 },
+            children: runs,
+          })
+        );
+        break;
+      }
+
+      case "paragraph": {
+        const runs = convertInline(token.tokens);
+        blocks.push(
+          new Paragraph({
+            spacing: { after: 120 },
+            children: runs,
+          })
+        );
+        break;
+      }
+
+      case "code": {
+        const lines = (token.text || "").split("\n");
+        for (const line of lines) {
+          blocks.push(
+            new Paragraph({
+              spacing: { after: 0 },
+              indent: { left: 400 },
+              shading: { type: ShadingType.CLEAR, color: "auto", fill: LIGHT_GRAY },
+              children: [new TextRun({ text: line || " ", font: FONT_CODE, size: 20 })],
+            })
+          );
+        }
+        // Add spacing after code block
+        blocks.push(new Paragraph({ spacing: { after: 120 }, children: [new TextRun("")] }));
+        break;
+      }
+
+      case "table": {
+        const borderStyle = { style: BorderStyle.SINGLE, size: 1, color: "999999" };
+        const borders = { top: borderStyle, bottom: borderStyle, left: borderStyle, right: borderStyle };
+
+        // Header row
+        const headerRow = new TableRow({
+          tableHeader: true,
+          children: (token.header || []).map(
+            (h) =>
+              new TableCell({
+                borders,
+                shading: { type: ShadingType.CLEAR, color: "auto", fill: "D9E2F3" },
+                children: [
+                  new Paragraph({
+                    children: [
+                      new TextRun({
+                        text: h.text || "",
+                        bold: true,
+                        font: FONT_HEADING,
+                        size: 22,
+                      }),
+                    ],
+                  }),
+                ],
+              })
+          ),
+        });
+
+        // Data rows
+        const dataRows = (token.rows || []).map(
+          (row) =>
+            new TableRow({
+              children: row.map(
+                (cell) =>
+                  new TableCell({
+                    borders,
+                    children: [
+                      new Paragraph({
+                        children: cell.tokens
+                          ? convertInline(cell.tokens)
+                          : [new TextRun({ text: cell.text || "", font: FONT_BODY, size: 22 })],
+                      }),
+                    ],
+                  })
+              ),
+            })
+        );
+
+        blocks.push(new Table({ rows: [headerRow, ...dataRows] }));
+        // Spacing after table
+        blocks.push(new Paragraph({ spacing: { after: 120 }, children: [new TextRun("")] }));
+        break;
+      }
+
+      case "list": {
+        blocks.push(...convertList(token, 0));
+        break;
+      }
+
+      case "blockquote": {
+        const innerTokens = token.tokens || [];
+        for (const inner of innerTokens) {
+          if (inner.type === "paragraph") {
+            const runs = convertInline(inner.tokens, { italics: true, color: "555555" });
+            blocks.push(
+              new Paragraph({
+                indent: { left: 720 },
+                spacing: { after: 120 },
+                border: {
+                  left: { style: BorderStyle.SINGLE, size: 6, color: DARK_BLUE, space: 10 },
+                },
+                shading: { type: ShadingType.CLEAR, color: "auto", fill: LIGHT_GRAY },
+                children: runs,
+              })
+            );
+          } else {
+            // Recursively handle other block types inside blockquote
+            const nested = convertTokens([inner]);
+            blocks.push(...nested);
+          }
+        }
+        break;
+      }
+
+      case "hr":
+        blocks.push(
+          new Paragraph({
+            spacing: { before: 200, after: 200 },
+            border: { bottom: { style: BorderStyle.SINGLE, size: 1, color: "CCCCCC" } },
+            children: [new TextRun("")],
+          })
+        );
+        break;
+
+      case "html":
+        // Skip HTML blocks or render as plain text
+        blocks.push(
+          new Paragraph({
+            spacing: { after: 120 },
+            children: [new TextRun({ text: token.text || "", font: FONT_BODY, size: 24, color: GRAY })],
+          })
+        );
+        break;
+
+      case "space":
+        break;
+
+      default:
+        if (token.raw && token.text) {
+          blocks.push(
+            new Paragraph({
+              spacing: { after: 120 },
+              children: [new TextRun({ text: token.text || token.raw || "", font: FONT_BODY, size: 24 })],
+            })
+          );
+        }
+    }
+  }
+
+  return blocks;
+}
+
+// ── List Converter (handles nesting) ───────────────────────────────────
+
+function convertList(token, level) {
+  const blocks = [];
+  const isOrdered = token.ordered;
+  const items = token.items || [];
+
+  let numIndex = 1;
+
+  for (const item of items) {
+    const numbering = isOrdered
+      ? { reference: "numbered-list", level }
+      : { reference: "bullet-list", level };
+
+    // Process item children (paragraphs, nested lists, code blocks)
+    const itemChildren = item.tokens || [];
+
+    for (const child of itemChildren) {
+      if (child.type === "list") {
+        // Nested list
+        blocks.push(...convertList(child, level + 1));
+      } else if (child.type === "text" && !child.tokens) {
+        // Plain text item
+        const prefix = item.task ? (item.checked ? "☑ " : "☐ ") : "";
+        blocks.push(
+          new Paragraph({
+            numbering,
+            spacing: { after: 60 },
+            children: [new TextRun({ text: prefix + (child.text || child.raw || ""), font: FONT_BODY, size: 24 })],
+          })
+        );
+      } else if (child.type === "text" && child.tokens) {
+        // Text with inline formatting
+        const runs = convertInline(child.tokens);
+        if (item.task) {
+          const prefix = item.checked ? "☑ " : "☐ ";
+          runs.unshift(new TextRun({ text: prefix, font: FONT_BODY, size: 24 }));
+        }
+        blocks.push(
+          new Paragraph({
+            numbering,
+            spacing: { after: 60 },
+            children: runs,
+          })
+        );
+      } else if (child.type === "paragraph") {
+        const runs = convertInline(child.tokens);
+        if (item.task) {
+          const prefix = item.checked ? "☑ " : "☐ ";
+          runs.unshift(new TextRun({ text: prefix, font: FONT_BODY, size: 24 }));
+        }
+        blocks.push(
+          new Paragraph({
+            numbering,
+            spacing: { after: 60 },
+            children: runs,
+          })
+        );
+      } else if (child.type === "code") {
+        // Code block inside list item
+        const lines = (child.text || "").split("\n");
+        for (const line of lines) {
+          blocks.push(
+            new Paragraph({
+              spacing: { after: 0 },
+              indent: { left: 400 + level * 720 },
+              shading: { type: ShadingType.CLEAR, color: "auto", fill: LIGHT_GRAY },
+              children: [new TextRun({ text: line || " ", font: FONT_CODE, size: 20 })],
+            })
+          );
+        }
+      }
+    }
+
+    // If no children processed, add a fallback
+    if (itemChildren.length === 0) {
+      const prefix = item.task ? (item.checked ? "☑ " : "☐ ") : "";
+      blocks.push(
+        new Paragraph({
+          numbering,
+          spacing: { after: 60 },
+          children: [new TextRun({ text: prefix + (item.text || item.raw || ""), font: FONT_BODY, size: 24 })],
+        })
+      );
+    }
+
+    numIndex++;
+  }
+
+  return blocks;
+}
+
+// ── Document Assembler ─────────────────────────────────────────────────
+
+function assembleDocument(coverBlocks, tocBlocks, contentBlocks, meta) {
+  const sections = [];
+
+  // Cover page section (no header/footer)
+  if (coverBlocks.length > 0) {
+    sections.push({
+      properties: {
+        page: {
+          size: { width: 11906, height: 16838 },
+          margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 },
+        },
+      },
+      children: coverBlocks,
+    });
+  }
+
+  // TOC + Content in main section
+  const mainChildren = [...tocBlocks, ...contentBlocks];
+
+  sections.push({
+    properties: {
+      page: {
+        size: { width: 11906, height: 16838 },
+        margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 },
+      },
+    },
+    children: mainChildren,
+  });
+
+  return new Document({
+    features: { updateFields: true },
+    styles: {
+      default: {
+        document: {
+          run: { font: FONT_BODY, size: 24 },
+          paragraph: { spacing: { line: 360 } },
+        },
+        heading1: {
+          run: { font: FONT_HEADING, size: 44, bold: true, color: DARK_BLUE },
+          paragraph: { spacing: { before: 400, after: 200 } },
+        },
+        heading2: {
+          run: { font: FONT_HEADING, size: 32, bold: true, color: DARK_BLUE },
+          paragraph: { spacing: { before: 300, after: 150 } },
+        },
+        heading3: {
+          run: { font: FONT_HEADING, size: 28, bold: true, color: DARK_BLUE },
+          paragraph: { spacing: { before: 240, after: 120 } },
+        },
+        heading4: {
+          run: { font: FONT_HEADING, size: 24, bold: true, color: DARK_BLUE },
+          paragraph: { spacing: { before: 200, after: 100 } },
+        },
+      },
+    },
+    numbering: {
+      config: [
+        {
+          reference: "bullet-list",
+          levels: [
+            { level: 0, format: "bullet", text: "•", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 720, hanging: 360 } } } },
+            { level: 1, format: "bullet", text: "◦", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 1440, hanging: 360 } } } },
+            { level: 2, format: "bullet", text: "▪", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 2160, hanging: 360 } } } },
+            { level: 3, format: "bullet", text: "•", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 2880, hanging: 360 } } } },
+          ],
+        },
+        {
+          reference: "numbered-list",
+          levels: [
+            { level: 0, format: "decimal", text: "%1.", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 720, hanging: 360 } } } },
+            { level: 1, format: "lowerLetter", text: "%2)", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 1440, hanging: 360 } } } },
+            { level: 2, format: "lowerRoman", text: "%3.", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 2160, hanging: 360 } } } },
+            { level: 3, format: "decimal", text: "%4.", alignment: AlignmentType.LEFT, style: { paragraph: { indent: { left: 2880, hanging: 360 } } } },
+          ],
+        },
+      ],
+    },
+    sections,
+  });
+}
+
+// ── Directory Scanner ──────────────────────────────────────────────────
+
+function scanDirectory(dir, recursive) {
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      // Skip hidden directories
+      if (entry.name.startsWith(".")) continue;
+      if (recursive) {
+        files.push(...scanDirectory(fullPath, true));
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      // Skip README.md
+      if (entry.name.toLowerCase() === "readme.md") continue;
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+// ── Single File Processor ──────────────────────────────────────────────
+
+async function processFile(inputFile, outputFile, meta, options) {
+  const { body, frontmatter } = readMarkdown(inputFile);
+
+  // Merge frontmatter into meta (meta takes priority)
+  const mergedMeta = { ...frontmatter, ...meta };
+  if (!mergedMeta.title) {
+    // Use first H1 or filename
+    const h1Match = body.match(/^#\s+(.+)$/m);
+    mergedMeta.title = h1Match ? h1Match[1] : path.basename(inputFile, ".md");
+  }
+
+  // Parse markdown
+  const tokens = marked.lexer(body);
+
+  // Build sections
+  const coverBlocks = options.noCover ? [] : buildCoverPage(mergedMeta);
+  const tocBlocks = options.noToc ? [] : buildTOC();
+  const contentBlocks = convertTokens(tokens);
+
+  // Assemble document
+  const doc = assembleDocument(coverBlocks, tocBlocks, contentBlocks, mergedMeta);
+
+  // Ensure output directory exists
+  const outDir = path.dirname(outputFile);
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+
+  // Write file
+  const buffer = await Packer.toBuffer(doc);
+  fs.writeFileSync(outputFile, buffer);
+}
+
+// ── Main ───────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = parseArgs();
+  const meta = JSON.parse(args.meta || "{}");
+  const options = { noCover: args.noCover, noToc: args.noToc };
+  const results = [];
+
+  try {
+    if (args.dir) {
+      // Directory mode
+      const dirPath = path.resolve(args.dir);
+      if (!fs.existsSync(dirPath)) {
+        throw new Error(`目录不存在: ${dirPath}`);
+      }
+
+      const files = scanDirectory(dirPath, args.recursive);
+      if (files.length === 0) {
+        throw new Error(`目录中未找到 .md 文件: ${dirPath}`);
+      }
+
+      const outDir = args.output ? path.resolve(args.output) : dirPath;
+
+      for (const file of files) {
+        const baseName = path.basename(file, ".md");
+        const outputFile = path.join(outDir, `${baseName}.docx`);
+
+        try {
+          await processFile(file, outputFile, { ...meta }, options);
+          results.push({ input: file, output: outputFile, status: "ok" });
+        } catch (err) {
+          results.push({ input: file, output: outputFile, status: "error", error: err.message });
+        }
+      }
+    } else if (args.input) {
+      // Single file mode
+      const inputFile = path.resolve(args.input);
+      if (!fs.existsSync(inputFile)) {
+        throw new Error(`文件不存在: ${inputFile}`);
+      }
+
+      const baseName = path.basename(inputFile, ".md");
+      const outputFile = args.output
+        ? path.resolve(args.output)
+        : path.join(path.dirname(inputFile), `${baseName}.docx`);
+
+      await processFile(inputFile, outputFile, meta, options);
+      results.push({ input: inputFile, output: outputFile, status: "ok" });
+    } else {
+      throw new Error("必须指定 --input 或 --dir 参数");
+    }
+
+    const failed = results.filter((r) => r.status === "error");
+    const status = failed.length === 0 ? "success" : failed.length === results.length ? "error" : "partial";
+
+    console.log(
+      JSON.stringify({
+        status,
+        files: results,
+        cover: !args.noCover,
+        toc: !args.noToc,
+        total: results.length,
+        success: results.length - failed.length,
+        failed: failed.length,
+      })
+    );
+  } catch (err) {
+    console.error(
+      JSON.stringify({
+        status: "error",
+        message: err.message,
+        files: results,
+      })
+    );
+    process.exit(1);
+  }
+}
+
+main();