@xjtlumedia/markdown-mcp-server 1.0.2

package/dist/core-exports.js

@@ -0,0 +1,545 @@
+import { Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell, WidthType, BorderStyle, AlignmentType } from 'docx';
+import * as XLSX from 'xlsx';
+// ... (previous code)
+/**
+ * Export table content only as CSV string
+ */
+export function generateCSV(content) {
+    const tableLines = content.match(/\|.*\|/g);
+    if (!tableLines)
+        return "";
+    let csv = "";
+    tableLines.forEach(line => {
+        if (line.includes('---'))
+            return;
+        const cells = line.split('|').map(c => c.trim()).filter(c => c !== "").map(c => stripMarkdown(c));
+        if (cells.length > 0)
+            csv += cells.map(c => `"${c.replace(/"/g, '""')}"`).join(',') + "\n";
+    });
+    return csv;
+}
+/**
+ * Generate JSON string representation
+ */
+export function generateJSON(content, title = 'document') {
+    const data = {
+        title: title,
+        export_timestamp: new Date().toISOString(),
+        content: stripMarkdown(content),
+        structured_content: content.split('\n\n').map(block => stripMarkdown(block))
+    };
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Generate XML string representation
+ */
+export function generateXML(content, title = 'document') {
+    let xml = `<?xml version="1.0" encoding="UTF-8"?>\n<document>\n`;
+    xml += `  <title>${title}</title>\n`;
+    xml += `  <content><![CDATA[${stripMarkdown(content)}]]></content>\n`;
+    xml += `  <metadata>\n    <timestamp>${new Date().toISOString()}</timestamp>\n  </metadata>\n`;
+    xml += `</document>`;
+    return xml;
+}
+/**
+ * Parse markdown content to a 2D array of strings for table-like representations (CSV, XLSX)
+ */
+export function parseMarkdownToTableData(content) {
+    const tableData = [];
+    const paragraphs = content.split('\n\n');
+    paragraphs.forEach(para => {
+        const lines = para.trim().split('\n');
+        const isTable = lines.some(l => l.includes('|'));
+        if (isTable) {
+            lines.forEach(line => {
+                if (line.includes('---'))
+                    return;
+                const cells = line.split('|').map(c => c.trim()).filter(c => c !== "").map(c => stripMarkdown(c));
+                if (cells.length > 0)
+                    tableData.push(cells);
+            });
+        }
+        else {
+            const cleaned = stripMarkdown(para);
+            if (cleaned)
+                tableData.push([cleaned]);
+        }
+    });
+    return tableData;
+}
+/**
+ * Generate XLSX Buffer
+ */
+export function generateXLSXIndex(content) {
+    const tableData = parseMarkdownToTableData(content);
+    const ws = XLSX.utils.aoa_to_sheet(tableData);
+    const wb = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(wb, ws, "Document");
+    // Write to buffer
+    return XLSX.write(wb, { bookType: 'xlsx', type: 'buffer' });
+}
+export function stripMarkdown(text) {
+    if (!text)
+        return "";
+    let clean = text;
+    // 1. Block Level: Code Blocks
+    clean = clean.replace(/```[\s\S]*?```/g, m => m.replace(/```\w*\n?/g, '').replace(/```/g, '').trim());
+    // 2. Block Level: Tables (Separator rows)
+    clean = clean.replace(/^\|?[\s-:]+\|[\s-:|]*$/gm, '');
+    // 3. Block Level: Horizontal Rules & Alternate Headings
+    clean = clean.replace(/^[\s\t]*([*_-])\1{2,}\s*$/gm, '');
+    clean = clean.replace(/^[\s\t]*[=-]{3,}\s*$/gm, '');
+    // 4. Block Level: Blockquotes & ATX Headings
+    clean = clean.replace(/^[\s\t]*>+\s?/gm, '');
+    clean = clean.replace(/^#{1,6}\s+/gm, '');
+    // 5. Inline: Multi-pass Emphasis (Bold, Italic, Strikethrough)
+    for (let i = 0; i < 3; i++) {
+        clean = clean.replace(/[*_]{3}([^*_]+)[*_]{3}/g, '$1');
+        clean = clean.replace(/[*_]{2}([^*_]+)[*_]{2}/g, '$1');
+        clean = clean.replace(/[*_]{1}([^*_]+)[*_]{1}/g, '$1');
+        clean = clean.replace(/~~([^~]+)~~/g, '$1');
+    }
+    // 6. Inline: Math, Links, Images, and Extended Syntax
+    clean = clean.replace(/\$\$(.*?)\$\$/gs, '$1');
+    clean = clean.replace(/\$(.*?)\$/g, '$1');
+    clean = clean.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+    clean = clean.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    clean = clean.replace(/\[([^\]]+)\]\[[^\]]*\]/g, '$1');
+    clean = clean.replace(/\[[ xX]\]\s+/g, '');
+    clean = clean.replace(/\[\^[^\]]+\]/g, '');
+    clean = clean.replace(/\{#[^}]+\}/g, '');
+    clean = clean.replace(/[~^]([^~^]+)[~^]/g, '$1');
+    // 7. Inline: Code & HTML
+    clean = clean.replace(/`([^`]+)`/g, '$1');
+    clean = clean.replace(/<[^>]*>/g, '');
+    // 8. Final Polish: Pipes & Escaped Chars
+    clean = clean.replace(/\|/g, ' ');
+    clean = clean.replace(/\\([\\`*_{}[\]()#+\-.!|~^])/g, '$1');
+    // 9. Normalization
+    return clean
+        .split('\n')
+        .map(line => line.trim())
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+/**
+ * Parse markdown table to structured data
+ */
+export function parseMarkdownTable(tableText) {
+    const lines = tableText.trim().split('\n').filter(line => line.trim());
+    if (lines.length < 2)
+        return { headers: [], rows: [] };
+    const headers = lines[0].split('|').map(c => c.trim()).filter(c => c);
+    const rows = [];
+    for (let i = 2; i < lines.length; i++) {
+        const cells = lines[i].split('|').map(c => c.trim()).filter(c => c);
+        if (cells.length > 0)
+            rows.push(cells);
+    }
+    return { headers, rows };
+}
+/**
+ * Clean text by removing markdown symbols
+ */
+export function cleanMarkdownText(text) {
+    return stripMarkdown(text);
+}
+/**
+ * Parse markdown content to LaTeX
+ */
+export function parseMarkdownToLaTeX(content) {
+    let processed = content
+        .replace(/^# (.*)$/gm, '\\section{$1}')
+        .replace(/^## (.*)$/gm, '\\subsection{$1}')
+        .replace(/^### (.*)$/gm, '\\subsubsection{$1}')
+        .replace(/\*\*(.*)\*\*/g, '\\textbf{$1}')
+        .replace(/\*(.*)\*/g, '\\textit{$1}')
+        .replace(/\$\$(.*?)\$\$/gs, '\\begin{equation}\n$1\n\\end{equation}')
+        .replace(/\$(.*?)\$/g, '$ $1 $')
+        .replace(/^-\s(.*)$/gm, '\\begin{itemize}\n\\item $1\n\\end{itemize}')
+        .replace(/\\end{itemize}\n\\begin{itemize}/g, '');
+    // Escape LaTeX special chars but try not to break our commands
+    processed = processed.replace(/([_%$&~^\\{}])/g, (m) => m === '\\' ? m : `\\${m}`);
+    // Final pass to remove any markdown-only artifacts (hashes, backticks, pipe)
+    return processed.replace(/[*#`|]/g, '');
+}
+/**
+ * Parse text with inline formatting to TextRuns
+ */
+export function parseInlineFormatting(text) {
+    const runs = [];
+    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|`[^`]+`|<br\s*\/?>)/g;
+    const parts = text.split(regex);
+    for (const part of parts) {
+        if (!part)
+            continue;
+        if (part.startsWith('$$') && part.endsWith('$$')) {
+            runs.push(new TextRun({ text: part.slice(2, -2), italics: true, color: '4F46E5', font: 'Cambria Math' }));
+        }
+        else if (part.startsWith('$') && part.endsWith('$')) {
+            runs.push(new TextRun({ text: part.slice(1, -1), italics: true, color: '4F46E5', font: 'Cambria Math' }));
+        }
+        else if (part.startsWith('***') && part.endsWith('***')) {
+            runs.push(new TextRun({ text: part.slice(3, -3), bold: true, italics: true }));
+        }
+        else if (part.startsWith('___') && part.endsWith('___')) {
+            runs.push(new TextRun({ text: part.slice(3, -3), bold: true, italics: true }));
+        }
+        else if (part.startsWith('**') && part.endsWith('**')) {
+            runs.push(new TextRun({ text: part.slice(2, -2), bold: true }));
+        }
+        else if (part.startsWith('__') && part.endsWith('__')) {
+            runs.push(new TextRun({ text: part.slice(2, -2), bold: true }));
+        }
+        else if (part.startsWith('*') && part.endsWith('*')) {
+            runs.push(new TextRun({ text: part.slice(1, -1), italics: true }));
+        }
+        else if (part.startsWith('_') && part.endsWith('_')) {
+            runs.push(new TextRun({ text: part.slice(1, -1), italics: true }));
+        }
+        else if (part.startsWith('`') && part.endsWith('`')) {
+            runs.push(new TextRun({ text: part.slice(1, -1), font: 'Consolas', shading: { fill: 'F0F0F0' } }));
+        }
+        else if (part.match(/<br\s*\/?>/i)) {
+            runs.push(new TextRun({ text: '', break: 1 }));
+        }
+        else {
+            runs.push(new TextRun({ text: part }));
+        }
+    }
+    return runs.length > 0 ? runs : [new TextRun({ text })];
+}
+/**
+ * Create a Word table from parsed markdown table data
+ */
+export function createDocxTable(headers, rows) {
+    const allRows = [];
+    if (headers.length > 0) {
+        allRows.push(new TableRow({
+            children: headers.map(header => new TableCell({
+                children: [new Paragraph({ children: [new TextRun({ text: cleanMarkdownText(header), bold: true })], alignment: AlignmentType.LEFT })],
+                shading: { fill: 'E5E7EB' }
+            }))
+        }));
+    }
+    for (const row of rows) {
+        allRows.push(new TableRow({
+            children: row.map(cell => new TableCell({ children: [new Paragraph({ children: parseInlineFormatting(cell) })] }))
+        }));
+    }
+    return new Table({
+        rows: allRows,
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        borders: {
+            top: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' },
+            bottom: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' },
+            left: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' },
+            right: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' },
+            insideHorizontal: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' },
+            insideVertical: { style: BorderStyle.SINGLE, size: 1, color: 'CCCCCC' }
+        }
+    });
+}
+/**
+ * Parse markdown content to docx elements
+ */
+export function parseMarkdownToDocx(content) {
+    const elements = [];
+    const lines = content.split('\n');
+    let i = 0;
+    let inCodeBlock = false;
+    let codeBlockContent = [];
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (/^(\*\*\*|---|__{3,})\s*$/.test(trimmed)) {
+            elements.push(new Paragraph({ border: { bottom: { color: 'CCCCCC', space: 1, style: BorderStyle.SINGLE, size: 6 } }, spacing: { before: 200, after: 200 } }));
+            i++;
+            continue;
+        }
+        if (trimmed.startsWith('```')) {
+            if (inCodeBlock) {
+                elements.push(new Paragraph({ children: [new TextRun({ text: codeBlockContent.join('\n'), font: 'Consolas', size: 20 })], shading: { fill: 'F3F4F6' }, spacing: { before: 200, after: 200 } }));
+                codeBlockContent = [];
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            i++;
+            continue;
+        }
+        if (inCodeBlock) {
+            codeBlockContent.push(line);
+            i++;
+            continue;
+        }
+        if (i + 1 < lines.length) {
+            const nextLine = lines[i + 1].trim();
+            if (/^={3,}\s*$/.test(nextLine)) {
+                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed), spacing: { before: 400, after: 200 } }));
+                i += 2;
+                continue;
+            }
+            else if (/^-{3,}\s*$/.test(nextLine)) {
+                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed), spacing: { before: 300, after: 150 } }));
+                i += 2;
+                continue;
+            }
+        }
+        if (trimmed.includes('|') && trimmed.startsWith('|')) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().includes('|')) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            if (tableLines.length >= 2) {
+                const { headers, rows } = parseMarkdownTable(tableLines.join('\n'));
+                if (headers.length > 0) {
+                    elements.push(createDocxTable(headers, rows));
+                    elements.push(new Paragraph({ spacing: { after: 200 } }));
+                }
+            }
+            continue;
+        }
+        if (!trimmed) {
+            elements.push(new Paragraph({ spacing: { after: 100 } }));
+            i++;
+            continue;
+        }
+        if (trimmed.startsWith('# ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed.slice(2)), spacing: { before: 400, after: 200 } }));
+        }
+        else if (trimmed.startsWith('## ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed.slice(3)), spacing: { before: 300, after: 150 } }));
+        }
+        else if (trimmed.startsWith('### ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_3, children: parseInlineFormatting(trimmed.slice(4)), spacing: { before: 250, after: 100 } }));
+        }
+        else if (trimmed.startsWith('#### ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_4, children: parseInlineFormatting(trimmed.slice(5)), spacing: { before: 200, after: 100 } }));
+        }
+        else if (trimmed.startsWith('>')) {
+            const level = (trimmed.match(/^>+/g) || ['>'])[0].length;
+            const text = trimmed.replace(/^>+\s*/, '');
+            elements.push(new Paragraph({ indent: { left: 720 * level }, children: [new TextRun({ text: cleanMarkdownText(text), italics: true, color: '666666' })], spacing: { after: 100 }, shading: { fill: 'F9FAFB' } }));
+        }
+        else if (/^(\s*)[-*+]\s+/.test(line)) {
+            const match = line.match(/^(\s*)([-*+]\s+)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            const text = line.replace(/^\s*[-*+]\s+/, '');
+            elements.push(new Paragraph({ bullet: { level: indent }, children: parseInlineFormatting(text), spacing: { after: 80 } }));
+        }
+        else if (/^(\s*)\d+\.\s+/.test(line)) {
+            const match = line.match(/^(\s*)(\d+\.\s+)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            const text = line.replace(/^\s*\d+\.\s+/, '');
+            elements.push(new Paragraph({ numbering: { reference: 'default-numbering', level: indent }, children: parseInlineFormatting(text), spacing: { after: 80 } }));
+        }
+        else {
+            const paragraphChildren = parseInlineFormatting(trimmed);
+            if (line.endsWith('  '))
+                paragraphChildren.push(new TextRun({ text: '', break: 1 }));
+            elements.push(new Paragraph({ children: paragraphChildren, spacing: { after: 150 } }));
+        }
+        i++;
+    }
+    return elements;
+}
+/**
+ * RTF Helper: Encode string with Unicode support and RTF escaping
+ */
+export function encodeRTFText(str) {
+    let res = "";
+    for (let i = 0; i < str.length; i++) {
+        const charCode = str.charCodeAt(i);
+        if (charCode > 127) {
+            res += `\\u${charCode}?`;
+        }
+        else if (str[i] === '\\' || str[i] === '{' || str[i] === '}') {
+            res += '\\' + str[i];
+        }
+        else {
+            res += str[i];
+        }
+    }
+    return res;
+}
+/**
+ * RTF Helper: Parse inline markdown to RTF codes
+ */
+export function parseInlineToRTF(text) {
+    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|`[^`]+`|<br\s*\/?>)/g;
+    const parts = text.split(regex);
+    let result = "";
+    for (const part of parts) {
+        if (!part)
+            continue;
+        if (part.startsWith('$$') && part.endsWith('$$')) {
+            result += `{\\i\\cf4\\f2 ${encodeRTFText(part.slice(2, -2))}}`;
+        }
+        else if (part.startsWith('$') && part.endsWith('$')) {
+            result += `{\\i\\cf4\\f2 ${encodeRTFText(part.slice(1, -1))}}`;
+        }
+        else if (part.startsWith('***') && part.endsWith('***')) {
+            result += `{\\b\\i ${encodeRTFText(part.slice(3, -3))}}`;
+        }
+        else if (part.startsWith('___') && part.endsWith('___')) {
+            result += `{\\b\\i ${encodeRTFText(part.slice(3, -3))}}`;
+        }
+        else if (part.startsWith('**') && part.endsWith('**')) {
+            result += `{\\b ${encodeRTFText(part.slice(2, -2))}}`;
+        }
+        else if (part.startsWith('__') && part.endsWith('__')) {
+            result += `{\\b ${encodeRTFText(part.slice(2, -2))}}`;
+        }
+        else if (part.startsWith('*') && part.endsWith('*')) {
+            result += `{\\i ${encodeRTFText(part.slice(1, -1))}}`;
+        }
+        else if (part.startsWith('_') && part.endsWith('_')) {
+            result += `{\\i ${encodeRTFText(part.slice(1, -1))}}`;
+        }
+        else if (part.startsWith('`') && part.endsWith('`')) {
+            result += `{\\f1\\highlight3 ${encodeRTFText(part.slice(1, -1))}}`;
+        }
+        else if (part.match(/<br\s*\/?>/i)) {
+            result += "\\line ";
+        }
+        else {
+            result += encodeRTFText(part);
+        }
+    }
+    return result;
+}
+/**
+ * RTF Helper: Main parser for Markdown to RTF conversion
+ */
+export function parseMarkdownToRTF(content) {
+    const lines = content.split('\n');
+    let rtf = "";
+    let i = 0;
+    let inCodeBlock = false;
+    let codeBlockContent = [];
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Horizontal Rule
+        if (/^(\*\*\*|---|__{3,})\s*$/.test(trimmed)) {
+            rtf += "\\pard\\sb200\\sa200\\brdrb\\brdrs\\brdrw10\\brdrcf6\\par\n";
+            i++;
+            continue;
+        }
+        // Code Block
+        if (trimmed.startsWith('```')) {
+            if (inCodeBlock) {
+                rtf += "{\\pard\\f1\\fs20\\highlight3 " + encodeRTFText(codeBlockContent.join("\\line\n")) + "\\par}\n";
+                codeBlockContent = [];
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            i++;
+            continue;
+        }
+        if (inCodeBlock) {
+            codeBlockContent.push(line);
+            i++;
+            continue;
+        }
+        // Setext Headings
+        if (i + 1 < lines.length) {
+            const nextLine = lines[i + 1].trim();
+            if (/^={3,}\s*$/.test(nextLine)) {
+                rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed) + "\\par}\n";
+                i += 2;
+                continue;
+            }
+            else if (/^-{3,}\s*$/.test(nextLine)) {
+                rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed) + "\\par}\n";
+                i += 2;
+                continue;
+            }
+        }
+        // Tables
+        if (trimmed.includes('|') && trimmed.startsWith('|')) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().includes('|')) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            if (tableLines.length >= 2) {
+                const { headers, rows } = parseMarkdownTable(tableLines.join('\n'));
+                if (headers.length > 0) {
+                    const cellWidth = 3000;
+                    // Header Row
+                    rtf += "\\trowd\\trgaph108\\trleft-108";
+                    for (let j = 0; j < headers.length; j++) {
+                        rtf += `\\clcbpat5\\clbrdrt\\brdrs\\brdrw10\\clbrdrl\\brdrs\\brdrw10\\clbrdrb\\brdrs\\brdrw10\\clbrdrr\\brdrs\\brdrw10\\cellx${(j + 1) * cellWidth}`;
+                    }
+                    rtf += "\\pard\\intbl\\ql ";
+                    for (const h of headers) {
+                        rtf += "{\\b " + parseInlineToRTF(h) + "}\\cell ";
+                    }
+                    rtf += "\\row\n";
+                    // Data Rows
+                    for (const row of rows) {
+                        rtf += "\\trowd\\trgaph108\\trleft-108";
+                        for (let j = 0; j < row.length; j++) {
+                            rtf += `\\clbrdrt\\brdrs\\brdrw10\\clbrdrl\\brdrs\\brdrw10\\clbrdrb\\brdrs\\brdrw10\\clbrdrr\\brdrs\\brdrw10\\cellx${(j + 1) * cellWidth}`;
+                        }
+                        rtf += "\\pard\\intbl\\ql ";
+                        for (const cell of row) {
+                            rtf += parseInlineToRTF(cell) + "\\cell ";
+                        }
+                        rtf += "\\row\n";
+                    }
+                    rtf += "\\pard\\sa200\\par\n";
+                }
+            }
+            continue;
+        }
+        if (!trimmed) {
+            rtf += "\\pard\\sa100\\par\n";
+            i++;
+            continue;
+        }
+        // Headings
+        if (trimmed.startsWith('# ')) {
+            rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed.slice(2)) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('## ')) {
+            rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed.slice(3)) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('### ')) {
+            rtf += "{\\pard\\b\\fs28\\sb250\\sa100 " + parseInlineToRTF(trimmed.slice(4)) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('#### ')) {
+            rtf += "{\\pard\\b\\fs26\\sb200\\sa100 " + parseInlineToRTF(trimmed.slice(5)) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('>')) {
+            const level = (trimmed.match(/^>+/g) || ['>'])[0].length;
+            const text = trimmed.replace(/^>+\s*/, '');
+            rtf += `{\\pard\\li${level * 720}\\cf2\\i\\sa100 ` + parseInlineToRTF(text) + "\\par}\n";
+        }
+        else if (/^(\s*)[-*+]\s+/.test(line)) {
+            const match = line.match(/^(\s*)([-*+]\s+)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            const text = line.replace(/^\s*[-*+]\s+/, '');
+            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360\\'b7\\tab ` + parseInlineToRTF(text) + "\\par}\n";
+        }
+        else if (/^(\s*)\d+\.\s+/.test(line)) {
+            const match = line.match(/^(\s*)(\d+\.\s+)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            const number = match ? match[2] : "1. ";
+            const text = line.replace(/^\s*\d+\.\s+/, '');
+            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360 ${number}\\tab ` + parseInlineToRTF(text) + "\\par}\n";
+        }
+        else {
+            rtf += "{\\pard\\sa150 " + parseInlineToRTF(trimmed) + "\\par}\n";
+        }
+        i++;
+    }
+    return rtf;
+}

package/dist/index.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import remarkStringify from 'remark-stringify';
+import remarkRehype from 'remark-rehype';
+import rehypeKatex from 'rehype-katex';
+import rehypeStringify from 'rehype-stringify';
+import puppeteer from 'puppeteer';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { parseMarkdownToRTF, parseMarkdownToDocx, parseMarkdownToLaTeX, generateCSV, generateJSON, generateXML, generateXLSXIndex, cleanMarkdownText } from "./core-exports.js";
+import { Packer } from "docx";
+const server = new Server({
+    name: "markdown-formatter-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Binary format types that need special handling
+const BINARY_FORMATS = ['docx', 'pdf', 'xlsx', 'png', 'image'];
+// Helper to handle output (save to file or return content)
+async function handleOutput(content, outputPath, options) {
+    if (outputPath) {
+        try {
+            await fs.mkdir(path.dirname(outputPath), { recursive: true });
+            await fs.writeFile(outputPath, content);
+            const stats = await fs.stat(outputPath);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Successfully saved to ${outputPath}`,
+                            file_path: outputPath,
+                            file_size_bytes: stats.size,
+                            format: options?.format || 'unknown'
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error saving to file: ${err.message}` }], isError: true };
+        }
+    }
+    // For binary content without output_path, return helpful guidance
+    if (Buffer.isBuffer(content)) {
+        const sizeBytes = content.length;
+        const format = options?.format || 'binary';
+        // For AI usability, don't dump raw Base64 - provide actionable guidance
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        format: format,
+                        file_size_bytes: sizeBytes,
+                        description: options?.description || `Generated ${format.toUpperCase()} binary content`,
+                        hint: `This is a binary file format. To save the file, call this tool again with the 'output_path' parameter specifying where to save it (e.g., "C:/Documents/output.${format}" or "./output.${format}").`,
+                        base64_preview: content.toString('base64').substring(0, 100) + '...',
+                        full_base64_length: content.toString('base64').length
+                    }, null, 2)
+                }]
+        };
+    }
+    else {
+        return { content: [{ type: "text", text: content }] };
+    }
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "harmonize_markdown",
+                description: "Standardize markdown syntax (headers, list markers, etc.)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_txt",
+                description: "Convert Markdown to Plain Text (strips formatting)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_rtf",
+                description: "Convert Markdown to RTF (Rich Text Format)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_latex",
+                description: "Convert Markdown to LaTeX",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_docx",
+                description: "Convert Markdown to DOCX (Word)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_pdf",
+                description: "Convert Markdown to PDF (uses Puppeteer)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_image",
+                description: "Convert Markdown to PNG Image (uses Puppeteer)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_csv",
+                description: "Extract tables from Markdown to CSV",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_json",
+                description: "Convert Markdown to JSON structure",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    title: z.string().optional(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_xml",
+                description: "Convert Markdown to XML",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    title: z.string().optional(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_xlsx",
+                description: "Convert Markdown tables to Excel (XLSX)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_html",
+                description: "Convert Markdown to HTML",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "convert_to_md",
+                description: "Export original Markdown content (with optional harmonization)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    harmonize: z.boolean().optional(),
+                    output_path: z.string().optional(),
+                })),
+            },
+            {
+                name: "generate_html",
+                description: "Generate a complete HTML document from Markdown with inline styles (returns full HTML string)",
+                inputSchema: zodSchemaToToolInput(z.object({
+                    markdown: z.string(),
+                    title: z.string().optional(),
+                })),
+            }
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args } = request.params;
+        const markdown = args.markdown;
+        const outputPath = args.output_path;
+        if (!markdown && name !== 'list_tools') {
+            // Basic validation
+            throw new Error("Markdown content is required");
+        }
+        if (name === "harmonize_markdown") {
+            const file = await unified()
+                .use(remarkParse)
+                .use(remarkGfm)
+                .use(remarkMath)
+                .use(remarkStringify, {
+                bullet: '-',
+                fence: '`',
+                fences: true,
+                incrementListMarker: true,
+                listItemIndent: 'one',
+            })
+                .process(markdown);
+            return handleOutput(String(file), outputPath);
+        }
+        if (name === "convert_to_txt") {
+            const txt = cleanMarkdownText(markdown);
+            return handleOutput(txt, outputPath);
+        }
+        if (name === "convert_to_rtf") {
+            const rtf = parseMarkdownToRTF(markdown);
+            return handleOutput(rtf, outputPath);
+        }
+        if (name === "convert_to_latex") {
+            const latex = parseMarkdownToLaTeX(markdown);
+            return handleOutput(latex, outputPath);
+        }
+        if (name === "convert_to_docx") {
+            const elements = parseMarkdownToDocx(markdown);
+            const doc = new ((await import("docx")).Document)({
+                sections: [{ children: elements }]
+            });
+            const buffer = await Packer.toBuffer(doc);
+            return handleOutput(buffer, outputPath, {
+                format: 'docx',
+                description: 'Microsoft Word document generated from Markdown'
+            });
+        }
+        if (name === "convert_to_csv") {
+            const csv = generateCSV(markdown);
+            return handleOutput(csv, outputPath);
+        }
+        if (name === "convert_to_json") {
+            const title = args.title || "document";
+            const json = generateJSON(markdown, title);
+            return handleOutput(json, outputPath);
+        }
+        if (name === "convert_to_xml") {
+            const title = args.title || "document";
+            const xml = generateXML(markdown, title);
+            return handleOutput(xml, outputPath);
+        }
+        if (name === "convert_to_xlsx") {
+            const buffer = generateXLSXIndex(markdown);
+            return handleOutput(buffer, outputPath, {
+                format: 'xlsx',
+                description: 'Microsoft Excel spreadsheet generated from Markdown tables'
+            });
+        }
+        if (name === "convert_to_html" || name === "convert_to_pdf" || name === "convert_to_image") {
+            const htmlProcessor = unified()
+                .use(remarkParse)
+                .use(remarkGfm)
+                // @ts-ignore
+                .use(remarkRehype)
+                // @ts-ignore
+                .use(rehypeKatex)
+                // @ts-ignore
+                .use(rehypeStringify);
+            const htmlFile = await htmlProcessor.process(markdown);
+            const htmlDoc = `<!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css" integrity="sha384-n8MVd4RsNIU0tAv4ct0nTaAbDJwPJzDEaqSD1odI+WdtXRGWt2kTvGFasHpSy3SV" crossorigin="anonymous">
+            <style>
+                body { font-family: system-ui, -apple-system, sans-serif; padding: 40px; line-height: 1.6; max-width: 800px; margin: 0 auto; background: white; color: black; }
+                img { max-width: 100%; }
+                pre { background: #f4f4f4; padding: 15px; border-radius: 5px; overflow-x: auto; }
+                table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+                th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+                th { background-color: #f2f2f2; }
+            </style>
+        </head>
+        <body>${String(htmlFile)}</body>
+        </html>`;
+            if (name === "convert_to_html") {
+                return handleOutput(htmlDoc, outputPath);
+            }
+            const browser = await puppeteer.launch({ headless: true });
+            const page = await browser.newPage();
+            await page.setContent(htmlDoc);
+            let resultBuffer;
+            if (name === "convert_to_pdf") {
+                resultBuffer = await page.pdf({ format: 'A4' });
+                await browser.close();
+                return handleOutput(resultBuffer, outputPath, {
+                    format: 'pdf',
+                    description: 'PDF document generated from Markdown via Puppeteer'
+                });
+            }
+            else {
+                const screenshot = await page.screenshot({ fullPage: true, encoding: 'binary' });
+                resultBuffer = screenshot;
+                await browser.close();
+                return handleOutput(resultBuffer, outputPath, {
+                    format: 'png',
+                    description: 'PNG image screenshot of the rendered Markdown'
+                });
+            }
+        }
+        // New tools: convert_to_md and generate_html
+        if (name === "convert_to_md") {
+            const shouldHarmonize = args.harmonize;
+            let result = markdown;
+            if (shouldHarmonize) {
+                const file = await unified()
+                    .use(remarkParse)
+                    .use(remarkGfm)
+                    .use(remarkMath)
+                    .use(remarkStringify, {
+                    bullet: '-',
+                    fence: '`',
+                    fences: true,
+                    incrementListMarker: true,
+                    listItemIndent: 'one',
+                })
+                    .process(markdown);
+                result = String(file);
+            }
+            return handleOutput(result, outputPath);
+        }
+        if (name === "generate_html") {
+            const title = args.title || 'Document';
+            const htmlProcessor = unified()
+                .use(remarkParse)
+                .use(remarkGfm)
+                // @ts-ignore
+                .use(remarkRehype)
+                // @ts-ignore
+                .use(rehypeKatex)
+                // @ts-ignore
+                .use(rehypeStringify);
+            const htmlFile = await htmlProcessor.process(markdown);
+            const htmlDoc = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css">
+    <style>
+        body { font-family: system-ui, -apple-system, sans-serif; max-width: 800px; margin: 40px auto; padding: 20px; line-height: 1.6; color: #1a1a1a; }
+        h1, h2, h3 { color: #111; margin-top: 2em; }
+        pre { background: #f4f4f4; padding: 15px; border-radius: 5px; overflow-x: auto; }
+        code { font-family: monospace; background: #eee; padding: 2px 4px; border-radius: 3px; }
+        table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+        th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
+        th { background: #f8f8f8; }
+        blockquote { border-left: 4px solid #ddd; margin: 0; padding-left: 1em; color: #666; }
+    </style>
+</head>
+<body>${String(htmlFile)}</body>
+</html>`;
+            return { content: [{ type: "text", text: htmlDoc }] };
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+function zodSchemaToToolInput(schema) {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const key in shape) {
+        const field = shape[key];
+        const isOptional = field.isOptional?.() || field instanceof z.ZodOptional;
+        properties[key] = { type: "string" };
+        if (!isOptional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required
+    };
+}
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@xjtlumedia/markdown-mcp-server",
+    "version": "1.0.2",
+    "description": "MCP Server for Markdown Processing and Multi-Format Exporting — convert Markdown to HTML, PDF, DOCX, LaTeX, CSV, JSON, XML, XLSX, RTF, PNG and more",
+    "mcpName": "io.github.XJTLUmedia/markdown-formatter",
+    "type": "module",
+    "main": "dist/index.js",
+    "bin": {
+        "markdown-mcp-server": "dist/index.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/XJTLUmedia/AI_answer_copier.git"
+    },
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "markdown",
+        "converter",
+        "exporter",
+        "pdf",
+        "docx",
+        "latex",
+        "html",
+        "csv",
+        "json",
+        "xml",
+        "xlsx",
+        "rtf"
+    ],
+    "license": "MIT",
+    "scripts": {
+        "start": "node dist/index.js",
+        "dev": "tsx src/index.ts",
+        "build": "tsc",
+        "prepublishOnly": "npm run build",
+        "inspector": "npx @modelcontextprotocol/inspector"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^0.6.0",
+        "@types/node": "^20.11.0",
+        "docx": "^9.5.1",
+        "puppeteer": "^23.0.0",
+        "rehype-katex": "^7.0.0",
+        "rehype-parse": "^9.0.0",
+        "rehype-stringify": "^10.0.0",
+        "remark-gfm": "^4.0.1",
+        "remark-math": "^6.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.1.0",
+        "remark-stringify": "^11.0.0",
+        "tsx": "^4.7.1",
+        "typescript": "^5.3.3",
+        "unified": "^11.0.5",
+        "xlsx": "^0.18.5",
+        "zod": "^3.23.8"
+    }
+}