@xjtlumedia/markdown-mcp-server 1.0.5 → 2.1.0

package/README.md

@@ -5,6 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@xjtlumedia/markdown-mcp-server.svg)](https://www.npmjs.com/package/@xjtlumedia/markdown-mcp-server)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![MCP Registry](https://img.shields.io/badge/MCP-Registry-purple)](https://registry.modelcontextprotocol.io)
+[![Glama](https://glama.ai/mcp/servers/XJTLUmedia/AI_answer_copier/badge)](https://glama.ai/mcp/servers/XJTLUmedia/AI_answer_copier)
 [![GitHub](https://img.shields.io/github/stars/XJTLUmedia/AI_answer_copier?style=social)](https://github.com/XJTLUmedia/AI_answer_copier)
 
 **A Model Context Protocol (MCP) server that gives your AI assistant the power to convert Markdown into 14 professional document formats** — PDF, DOCX, HTML, LaTeX, CSV, JSON, XML, XLSX, RTF, PNG, and more. Stop copy-pasting. Let the AI do the exporting.

package/dist/document-analysis.js

@@ -0,0 +1,223 @@
+// ── Document Analysis Functions ──────────────────────────────────────
+// ── Code Block Extraction ────────────────────────────────────────────
+export function extractCodeBlocks(md) {
+    const blocks = [];
+    const lines = md.split('\n');
+    let inBlock = false;
+    let currentLang = '';
+    let currentCode = [];
+    let startLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fenceMatch = line.match(/^(`{3,}|~{3,})([\w+-]*)\s*$/);
+        if (fenceMatch) {
+            if (!inBlock) {
+                inBlock = true;
+                currentLang = fenceMatch[2] || 'text';
+                currentCode = [];
+                startLine = i + 1;
+            }
+            else {
+                blocks.push({
+                    language: currentLang,
+                    code: currentCode.join('\n'),
+                    startLine: startLine + 1, // 1-indexed
+                    endLine: i + 1,
+                });
+                inBlock = false;
+            }
+        }
+        else if (inBlock) {
+            currentCode.push(line);
+        }
+    }
+    // Handle unclosed fence
+    if (inBlock && currentCode.length > 0) {
+        blocks.push({
+            language: currentLang,
+            code: currentCode.join('\n'),
+            startLine: startLine + 1,
+            endLine: lines.length,
+        });
+    }
+    return blocks;
+}
+// ── Link Extraction ──────────────────────────────────────────────────
+export function extractLinks(md) {
+    const links = [];
+    const lines = md.split('\n');
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        // Images: ![alt](url)
+        const imgRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+        let match;
+        while ((match = imgRegex.exec(line)) !== null) {
+            links.push({ text: match[1], url: match[2], line: i + 1, type: 'image' });
+        }
+        // Inline links: [text](url) — but not images
+        const linkRegex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
+        while ((match = linkRegex.exec(line)) !== null) {
+            links.push({ text: match[1], url: match[2], line: i + 1, type: 'inline' });
+        }
+        // Reference links: [text][ref]
+        const refRegex = /\[([^\]]+)\]\[([^\]]*)\]/g;
+        while ((match = refRegex.exec(line)) !== null) {
+            links.push({ text: match[1], url: match[2] || match[1], line: i + 1, type: 'reference' });
+        }
+        // Autolinks: <url>
+        const autoRegex = /<(https?:\/\/[^>]+)>/g;
+        while ((match = autoRegex.exec(line)) !== null) {
+            links.push({ text: match[1], url: match[1], line: i + 1, type: 'autolink' });
+        }
+    }
+    return links;
+}
+// ── Table of Contents Generation ─────────────────────────────────────
+export function generateTOC(md, maxDepth = 6) {
+    const entries = extractTocEntries(md, maxDepth);
+    if (entries.length === 0)
+        return '';
+    const minLevel = Math.min(...entries.map(e => e.level));
+    const lines = entries.map(entry => {
+        const indent = '  '.repeat(entry.level - minLevel);
+        return `${indent}- [${entry.text}](#${entry.slug})`;
+    });
+    return '## Table of Contents\n\n' + lines.join('\n') + '\n';
+}
+export function extractTocEntries(md, maxDepth = 6) {
+    const entries = [];
+    const lines = md.split('\n');
+    let inCodeBlock = false;
+    const slugCounts = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            if (level > maxDepth)
+                continue;
+            const text = headingMatch[2].replace(/\s*#+\s*$/, '').trim();
+            let slug = text.toLowerCase()
+                .replace(/[^\w\s-]/g, '')
+                .replace(/\s+/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '');
+            // Handle duplicate slugs
+            const count = slugCounts.get(slug) || 0;
+            slugCounts.set(slug, count + 1);
+            if (count > 0)
+                slug = `${slug}-${count}`;
+            entries.push({ level, text, slug, line: i + 1 });
+        }
+    }
+    return entries;
+}
+// ── Document Statistics ──────────────────────────────────────────────
+export function analyzeDocument(md) {
+    const lines = md.split('\n');
+    const plainText = md
+        .replace(/```[\s\S]*?```/g, '')
+        .replace(/`[^`]+`/g, '')
+        .replace(/<[^>]+>/g, '')
+        .replace(/[#*_~`>\[\]|()!]/g, ' ');
+    const words = plainText.split(/\s+/).filter(w => w.length > 0).length;
+    const sentences = plainText.split(/[.!?]+\s/).filter(s => s.trim().length > 0).length;
+    const paragraphs = md.split(/\n\s*\n/).filter(p => p.trim().length > 0).length;
+    let headings = 0;
+    let codeBlocks = 0;
+    let tables = 0;
+    let images = 0;
+    let lists = 0;
+    let blockquotes = 0;
+    let inCodeBlock = false;
+    let inTable = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^(`{3,}|~{3,})/.test(trimmed)) {
+            if (!inCodeBlock)
+                codeBlocks++;
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        if (/^#{1,6}\s/.test(trimmed))
+            headings++;
+        if (/^[-*+]\s|^\d+\.\s/.test(trimmed))
+            lists++;
+        if (/^>\s/.test(trimmed))
+            blockquotes++;
+        if (/!\[/.test(trimmed))
+            images += (trimmed.match(/!\[/g) || []).length;
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (!inTable) {
+                tables++;
+                inTable = true;
+            }
+        }
+        else {
+            inTable = false;
+        }
+    }
+    const linkMatches = md.match(/(?<!!)\[([^\]]+)\]\(([^)]+)\)/g);
+    const linkCount = linkMatches ? linkMatches.length : 0;
+    return {
+        lines: lines.length,
+        words,
+        characters: md.length,
+        paragraphs,
+        sentences,
+        headings,
+        codeBlocks,
+        tables,
+        links: linkCount,
+        images,
+        lists,
+        blockquotes,
+        estimatedReadingTimeMinutes: Math.max(1, Math.ceil(words / 200)),
+    };
+}
+// ── Heading Structure Extraction ─────────────────────────────────────
+export function extractStructure(md) {
+    const entries = extractTocEntries(md);
+    const stats = analyzeDocument(md);
+    const codeBlocks = extractCodeBlocks(md);
+    const links = extractLinks(md);
+    return {
+        stats,
+        outline: entries.map(e => ({
+            level: e.level,
+            text: e.text,
+            line: e.line,
+        })),
+        codeBlocks: codeBlocks.map(b => ({
+            language: b.language,
+            lineCount: b.code.split('\n').length,
+            startLine: b.startLine,
+            endLine: b.endLine,
+        })),
+        linkSummary: {
+            total: links.length,
+            byType: {
+                inline: links.filter(l => l.type === 'inline').length,
+                image: links.filter(l => l.type === 'image').length,
+                reference: links.filter(l => l.type === 'reference').length,
+                autolink: links.filter(l => l.type === 'autolink').length,
+            },
+            uniqueUrls: [...new Set(links.map(l => l.url))].length,
+        },
+    };
+}

package/dist/email-html.js

@@ -0,0 +1,94 @@
+// ── Email-Optimized HTML ─────────────────────────────────────────────
+// Generates HTML with all styles inlined for email client compatibility
+// No external CSS references, no class-based styles
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkRehype from 'remark-rehype';
+import rehypeStringify from 'rehype-stringify';
+export async function markdownToEmailHtml(md) {
+    // First convert to basic HTML
+    const htmlFile = await unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        // @ts-ignore
+        .use(remarkRehype)
+        // @ts-ignore
+        .use(rehypeStringify)
+        .process(md);
+    let html = String(htmlFile);
+    // Inline all styles for email client compatibility
+    html = inlineEmailStyles(html);
+    return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<!--[if mso]>
+<noscript>
+<xml>
+<o:OfficeDocumentSettings>
+<o:PixelsPerInch>96</o:PixelsPerInch>
+</o:OfficeDocumentSettings>
+</xml>
+</noscript>
+<![endif]-->
+</head>
+<body style="margin:0;padding:0;background-color:#f6f6f6;">
+<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="background-color:#f6f6f6;">
+<tr>
+<td align="center" style="padding:20px 0;">
+<table role="presentation" cellpadding="0" cellspacing="0" width="600" style="background-color:#ffffff;border-radius:4px;border:1px solid #e0e0e0;">
+<tr>
+<td style="padding:30px 40px;font-family:Arial,Helvetica,sans-serif;font-size:16px;line-height:1.6;color:#333333;">
+${html}
+</td>
+</tr>
+</table>
+</td>
+</tr>
+</table>
+</body>
+</html>`;
+}
+function inlineEmailStyles(html) {
+    let out = html;
+    // Headings
+    out = out.replace(/<h1([^>]*)>/gi, '<h1$1 style="font-family:Arial,Helvetica,sans-serif;font-size:28px;font-weight:bold;color:#1a1a1a;margin:24px 0 12px 0;line-height:1.3;">');
+    out = out.replace(/<h2([^>]*)>/gi, '<h2$1 style="font-family:Arial,Helvetica,sans-serif;font-size:24px;font-weight:bold;color:#1a1a1a;margin:20px 0 10px 0;line-height:1.3;">');
+    out = out.replace(/<h3([^>]*)>/gi, '<h3$1 style="font-family:Arial,Helvetica,sans-serif;font-size:20px;font-weight:bold;color:#1a1a1a;margin:18px 0 8px 0;line-height:1.3;">');
+    out = out.replace(/<h4([^>]*)>/gi, '<h4$1 style="font-family:Arial,Helvetica,sans-serif;font-size:18px;font-weight:bold;color:#333333;margin:16px 0 8px 0;line-height:1.3;">');
+    out = out.replace(/<h5([^>]*)>/gi, '<h5$1 style="font-family:Arial,Helvetica,sans-serif;font-size:16px;font-weight:bold;color:#333333;margin:14px 0 6px 0;line-height:1.3;">');
+    out = out.replace(/<h6([^>]*)>/gi, '<h6$1 style="font-family:Arial,Helvetica,sans-serif;font-size:14px;font-weight:bold;color:#555555;margin:12px 0 6px 0;line-height:1.3;">');
+    // Paragraphs
+    out = out.replace(/<p([^>]*)>/gi, '<p$1 style="margin:0 0 16px 0;font-size:16px;line-height:1.6;color:#333333;">');
+    // Links
+    out = out.replace(/<a([^>]*?)>/gi, '<a$1 style="color:#0066cc;text-decoration:underline;">');
+    // Code blocks (pre)
+    out = out.replace(/<pre([^>]*)>/gi, '<pre$1 style="background-color:#f4f4f4;border:1px solid #dddddd;border-radius:4px;padding:12px;overflow-x:auto;font-family:Consolas,Monaco,monospace;font-size:14px;line-height:1.4;margin:16px 0;">');
+    // Inline code
+    out = out.replace(/<code([^>]*)>/gi, (match, attrs) => {
+        // Don't re-style code inside pre
+        if (match.includes('style='))
+            return match;
+        return `<code${attrs} style="background-color:#f0f0f0;border:1px solid #e0e0e0;border-radius:3px;padding:2px 6px;font-family:Consolas,Monaco,monospace;font-size:14px;">`;
+    });
+    // Tables
+    out = out.replace(/<table([^>]*)>/gi, '<table$1 style="border-collapse:collapse;width:100%;margin:16px 0;border:1px solid #dddddd;">');
+    out = out.replace(/<th([^>]*)>/gi, '<th$1 style="border:1px solid #dddddd;padding:10px 12px;text-align:left;background-color:#f8f8f8;font-weight:bold;font-size:14px;">');
+    out = out.replace(/<td([^>]*)>/gi, '<td$1 style="border:1px solid #dddddd;padding:10px 12px;text-align:left;font-size:14px;">');
+    // Blockquotes
+    out = out.replace(/<blockquote([^>]*)>/gi, '<blockquote$1 style="border-left:4px solid #cccccc;margin:16px 0;padding:8px 16px;color:#666666;background-color:#fafafa;">');
+    // Lists
+    out = out.replace(/<ul([^>]*)>/gi, '<ul$1 style="margin:8px 0 16px 0;padding-left:24px;">');
+    out = out.replace(/<ol([^>]*)>/gi, '<ol$1 style="margin:8px 0 16px 0;padding-left:24px;">');
+    out = out.replace(/<li([^>]*)>/gi, '<li$1 style="margin:4px 0;line-height:1.6;">');
+    // Horizontal rules
+    out = out.replace(/<hr([^>]*)\/?>/gi, '<hr$1 style="border:none;border-top:1px solid #dddddd;margin:24px 0;">');
+    // Images
+    out = out.replace(/<img([^>]*)>/gi, '<img$1 style="max-width:100%;height:auto;border:0;">');
+    // Strong and em (just ensure they work)
+    out = out.replace(/<strong([^>]*)>/gi, '<strong$1 style="font-weight:bold;">');
+    out = out.replace(/<em([^>]*)>/gi, '<em$1 style="font-style:italic;">');
+    return out;
+}

package/dist/html-import.js

@@ -0,0 +1,158 @@
+// ── HTML to Markdown (round-trip import) ─────────────────────────────
+// Pure TypeScript implementation, no external dependencies
+export function htmlToMarkdown(html) {
+    let md = html;
+    // Remove doctype, html/head/body wrappers
+    md = md.replace(/<!DOCTYPE[^>]*>/gi, '');
+    md = md.replace(/<html[^>]*>/gi, '');
+    md = md.replace(/<\/html>/gi, '');
+    md = md.replace(/<head[\s\S]*?<\/head>/gi, '');
+    md = md.replace(/<body[^>]*>/gi, '');
+    md = md.replace(/<\/body>/gi, '');
+    // Remove scripts and styles
+    md = md.replace(/<script[\s\S]*?<\/script>/gi, '');
+    md = md.replace(/<style[\s\S]*?<\/style>/gi, '');
+    // Convert block elements first (order matters)
+    // Pre/code blocks
+    md = md.replace(/<pre[^>]*><code[^>]*(?:class="[^"]*language-(\w+)[^"]*")?[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_m, lang, code) => `\n\`\`\`${lang || ''}\n${decodeHtmlEntities(code).trim()}\n\`\`\`\n`);
+    md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_m, code) => `\n\`\`\`\n${decodeHtmlEntities(code).trim()}\n\`\`\`\n`);
+    // Headings
+    md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '\n# $1\n');
+    md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n## $1\n');
+    md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '\n### $1\n');
+    md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '\n#### $1\n');
+    md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '\n##### $1\n');
+    md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '\n###### $1\n');
+    // Blockquotes
+    md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (_m, content) => {
+        return content.trim().split('\n').map((l) => '> ' + l.trim()).join('\n') + '\n';
+    });
+    // Tables
+    md = convertHtmlTables(md);
+    // Lists
+    md = convertHtmlLists(md);
+    // Horizontal rules
+    md = md.replace(/<hr[^>]*\/?>/gi, '\n---\n');
+    // Paragraphs
+    md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '\n$1\n');
+    // Line breaks
+    md = md.replace(/<br\s*\/?>/gi, '  \n');
+    // Now convert inline elements
+    // Bold
+    md = md.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, '**$2**');
+    // Italic
+    md = md.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, '*$2*');
+    // Strikethrough
+    md = md.replace(/<(del|s|strike)[^>]*>([\s\S]*?)<\/\1>/gi, '~~$2~~');
+    // Code
+    md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+    // Links
+    md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+    // Images
+    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
+    md = md.replace(/<img[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*\/?>/gi, '![$1]($2)');
+    md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
+    // Remove remaining HTML tags
+    md = md.replace(/<[^>]+>/g, '');
+    // Decode HTML entities
+    md = decodeHtmlEntities(md);
+    // Clean up whitespace
+    md = md.replace(/\n{3,}/g, '\n\n');
+    md = md.trim() + '\n';
+    return md;
+}
+function convertHtmlTables(html) {
+    return html.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_m, tableContent) => {
+        const rows = [];
+        // Extract thead rows
+        const theadMatch = tableContent.match(/<thead[^>]*>([\s\S]*?)<\/thead>/i);
+        if (theadMatch) {
+            const headerCells = extractCells(theadMatch[1], 'th');
+            if (headerCells.length === 0) {
+                const tdCells = extractCells(theadMatch[1], 'td');
+                if (tdCells.length > 0)
+                    rows.push(tdCells);
+            }
+            else {
+                rows.push(headerCells);
+            }
+        }
+        // Extract tbody rows
+        const tbodyMatch = tableContent.match(/<tbody[^>]*>([\s\S]*?)<\/tbody>/i);
+        const bodyContent = tbodyMatch ? tbodyMatch[1] : tableContent;
+        const rowMatches = bodyContent.match(/<tr[^>]*>([\s\S]*?)<\/tr>/gi);
+        if (rowMatches) {
+            for (const row of rowMatches) {
+                if (theadMatch && row === rowMatches[0] && !tbodyMatch)
+                    continue;
+                let cells = extractCells(row, 'td');
+                if (cells.length === 0)
+                    cells = extractCells(row, 'th');
+                if (cells.length > 0) {
+                    rows.push(cells);
+                }
+            }
+        }
+        if (rows.length === 0)
+            return '';
+        let result = '\n';
+        result += '| ' + rows[0].join(' | ') + ' |\n';
+        result += '| ' + rows[0].map(() => '---').join(' | ') + ' |\n';
+        for (let i = 1; i < rows.length; i++) {
+            // Pad to match column count
+            while (rows[i].length < rows[0].length)
+                rows[i].push('');
+            result += '| ' + rows[i].join(' | ') + ' |\n';
+        }
+        return result;
+    });
+}
+function extractCells(rowHtml, tag) {
+    const cells = [];
+    const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'gi');
+    let match;
+    while ((match = regex.exec(rowHtml)) !== null) {
+        cells.push(match[1].replace(/<[^>]+>/g, '').trim());
+    }
+    return cells;
+}
+function convertHtmlLists(html) {
+    // Process nested lists from inside out (multiple passes)
+    let out = html;
+    for (let pass = 0; pass < 5; pass++) {
+        // Unordered lists
+        out = out.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_m, content) => {
+            const items = extractListItems(content);
+            return '\n' + items.map(item => '- ' + item.trim()).join('\n') + '\n';
+        });
+        // Ordered lists
+        out = out.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (_m, content) => {
+            const items = extractListItems(content);
+            return '\n' + items.map((item, idx) => `${idx + 1}. ` + item.trim()).join('\n') + '\n';
+        });
+    }
+    return out;
+}
+function extractListItems(listHtml) {
+    const items = [];
+    const regex = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+    let match;
+    while ((match = regex.exec(listHtml)) !== null) {
+        let item = match[1].trim();
+        // Indent nested list content
+        item = item.replace(/\n([-\d])/g, '\n  $1');
+        items.push(item);
+    }
+    return items;
+}
+function decodeHtmlEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(parseInt(code)))
+        .replace(/&#x([0-9a-f]+);/gi, (_m, code) => String.fromCharCode(parseInt(code, 16)));
+}