@wonderwhy-er/desktop-commander 0.2.34 → 0.2.36

package/dist/tools/docx/builders/markdown-builder.js

@@ -0,0 +1,260 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// @ts-ignore
+import * as docx from 'docx';
+const { AlignmentType, Document, HeadingLevel, Paragraph, Table, TableCell, TableRow, TextRun, WidthType, Packer, } = docx;
+import { DocxErrorCode, withErrorContext } from '../errors.js';
+import { normalizeLineEndings, prepareImageForDocx, createImageRun, } from '../utils.js';
+export async function createDocxFromMarkdown(markdown, options = {}) {
+    return withErrorContext(async () => {
+        const children = [];
+        const baseDir = options.baseDir;
+        const lines = normalizeLineEndings(markdown).split('\n');
+        let i = 0;
+        while (i < lines.length) {
+            const rawLine = lines[i];
+            const line = rawLine.trimEnd();
+            // Skip empty lines
+            if (!line.trim()) {
+                i++;
+                continue;
+            }
+            // 1) Markdown table detection
+            const isHeader = isTableHeaderLine(line);
+            const hasSeparator = i + 1 < lines.length && isTableSeparatorLine(lines[i + 1]);
+            if (isHeader && hasSeparator) {
+                const tableLines = [line];
+                i++;
+                tableLines.push(lines[i]); // Add separator line
+                i++;
+                // Collect all subsequent table rows
+                while (i < lines.length) {
+                    const nextLine = lines[i].trim();
+                    if (!nextLine || !isTableRowLine(nextLine)) {
+                        break;
+                    }
+                    tableLines.push(nextLine);
+                    i++;
+                }
+                try {
+                    const table = createTableFromMarkdown(tableLines);
+                    children.push(table);
+                }
+                catch (error) {
+                    console.error('[DOCX Build] Failed to create table:', error);
+                    // Fallback: add table lines as plain text
+                    for (const tableLine of tableLines) {
+                        children.push(new Paragraph({ text: tableLine }));
+                    }
+                }
+                continue;
+            }
+            // 2) Images
+            const imageMatch = line.match(/!\[([^\]]*)\]\(([^)]+)\)/);
+            if (imageMatch) {
+                const altText = imageMatch[1] || '';
+                const src = imageMatch[2];
+                try {
+                    const imageData = await prepareImageForDocx(src, altText, baseDir);
+                    const imageRun = createImageRun(imageData);
+                    const paragraph = new Paragraph({
+                        children: [imageRun],
+                        alignment: AlignmentType.CENTER,
+                    });
+                    children.push(paragraph);
+                }
+                catch (error) {
+                    console.warn(`Failed to embed image ${src}:`, error);
+                    children.push(new Paragraph({
+                        text: `[Image: ${altText || src}]`,
+                    }));
+                }
+                i++;
+                continue;
+            }
+            // 3) Headings
+            const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headingMatch) {
+                const level = headingMatch[1].length;
+                const text = headingMatch[2].trim();
+                const textRuns = parseInlineFormatting(text);
+                const heading = new Paragraph({
+                    children: textRuns,
+                    heading: getHeadingLevel(level),
+                });
+                children.push(heading);
+                i++;
+                continue;
+            }
+            // 4) Regular paragraphs
+            const textRuns = parseInlineFormatting(rawLine);
+            const paragraph = new Paragraph({
+                children: textRuns,
+            });
+            children.push(paragraph);
+            i++;
+        }
+        const doc = new Document({
+            sections: [{
+                    properties: {},
+                    children: children,
+                }],
+        });
+        return await Packer.toBuffer(doc);
+    }, DocxErrorCode.DOCX_CREATE_FAILED, { markdownLength: markdown.length });
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function isTableHeaderLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('|'))
+        return false;
+    const startsWithPipe = trimmed.startsWith('|');
+    const endsWithPipe = trimmed.endsWith('|');
+    const pipeCount = (trimmed.match(/\|/g) || []).length;
+    if (startsWithPipe && endsWithPipe) {
+        return pipeCount >= 2;
+    }
+    return pipeCount >= 1;
+}
+function isTableSeparatorLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('|'))
+        return false;
+    let content = trimmed;
+    if (content.startsWith('|'))
+        content = content.substring(1);
+    if (content.endsWith('|'))
+        content = content.substring(0, content.length - 1);
+    const parts = content.split('|');
+    let validParts = 0;
+    for (const part of parts) {
+        const cleaned = part.trim();
+        if (cleaned.length === 0)
+            continue;
+        if (/^:?-+:?$/.test(cleaned)) {
+            validParts++;
+        }
+        else {
+            return false;
+        }
+    }
+    return validParts > 0;
+}
+function isTableRowLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('|'))
+        return false;
+    if (isTableSeparatorLine(trimmed))
+        return false;
+    const pipeCount = (trimmed.match(/\|/g) || []).length;
+    return pipeCount >= 1;
+}
+function splitTableRow(line) {
+    const trimmed = line.trim();
+    let withoutBorders = trimmed;
+    if (withoutBorders.startsWith('|')) {
+        withoutBorders = withoutBorders.substring(1);
+    }
+    if (withoutBorders.endsWith('|')) {
+        withoutBorders = withoutBorders.substring(0, withoutBorders.length - 1);
+    }
+    return withoutBorders.split('|').map(cell => cell.trim());
+}
+function createTableFromMarkdown(lines) {
+    if (lines.length < 2) {
+        return new Table({ rows: [] });
+    }
+    const headerCells = splitTableRow(lines[0]);
+    const rows = [];
+    // Header row
+    rows.push(new TableRow({
+        children: headerCells.map((cell) => {
+            const textRuns = parseInlineFormatting(cell.trim());
+            textRuns.forEach(run => {
+                run.bold = true;
+            });
+            return new TableCell({
+                children: [
+                    new Paragraph({
+                        children: textRuns,
+                        alignment: AlignmentType.CENTER,
+                    }),
+                ],
+            });
+        }),
+    }));
+    // Data rows (skip separator at index 1)
+    for (let i = 2; i < lines.length; i++) {
+        const cells = splitTableRow(lines[i]);
+        rows.push(new TableRow({
+            children: cells.map((cell) => {
+                const textRuns = parseInlineFormatting(cell.trim());
+                return new TableCell({
+                    children: [
+                        new Paragraph({
+                            children: textRuns,
+                        }),
+                    ],
+                });
+            }),
+        }));
+    }
+    return new Table({
+        width: { size: 100, type: WidthType.PERCENTAGE },
+        rows,
+    });
+}
+function parseInlineFormatting(text) {
+    const runs = [];
+    let currentText = '';
+    let i = 0;
+    while (i < text.length) {
+        // Check for **bold**
+        if (text.substring(i, i + 2) === '**') {
+            if (currentText) {
+                runs.push(new TextRun({ text: currentText }));
+                currentText = '';
+            }
+            const closeIndex = text.indexOf('**', i + 2);
+            if (closeIndex !== -1) {
+                const boldText = text.substring(i + 2, closeIndex);
+                runs.push(new TextRun({ text: boldText, bold: true }));
+                i = closeIndex + 2;
+                continue;
+            }
+        }
+        // Check for *italic*
+        if (text[i] === '*' && text[i + 1] !== '*') {
+            if (currentText) {
+                runs.push(new TextRun({ text: currentText }));
+                currentText = '';
+            }
+            const closeIndex = text.indexOf('*', i + 1);
+            if (closeIndex !== -1) {
+                const italicText = text.substring(i + 1, closeIndex);
+                runs.push(new TextRun({ text: italicText, italics: true }));
+                i = closeIndex + 1;
+                continue;
+            }
+        }
+        currentText += text[i];
+        i++;
+    }
+    if (currentText) {
+        runs.push(new TextRun({ text: currentText }));
+    }
+    return runs.length > 0 ? runs : [new TextRun({ text: text })];
+}
+function getHeadingLevel(level) {
+    const levelMap = {
+        1: HeadingLevel.HEADING_1,
+        2: HeadingLevel.HEADING_2,
+        3: HeadingLevel.HEADING_3,
+        4: HeadingLevel.HEADING_4,
+        5: HeadingLevel.HEADING_5,
+        6: HeadingLevel.HEADING_6,
+    };
+    return levelMap[level] ?? HeadingLevel.HEADING_1;
+}

package/dist/tools/docx/builders/paragraph.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Paragraph builder — creates w:p elements with optional styles.
+ */
+import type { DocxContentParagraph } from '../types.js';
+/**
+ * Build a paragraph element from content structure.
+ *
+ * @param doc The XML document
+ * @param item The paragraph content item
+ * @returns A w:p element
+ */
+export declare function buildParagraph(doc: Document, item: DocxContentParagraph): Element;

package/dist/tools/docx/builders/paragraph.js

@@ -0,0 +1,29 @@
+/**
+ * Paragraph builder — creates w:p elements with optional styles.
+ */
+/**
+ * Build a paragraph element from content structure.
+ *
+ * @param doc The XML document
+ * @param item The paragraph content item
+ * @returns A w:p element
+ */
+export function buildParagraph(doc, item) {
+    const p = doc.createElement('w:p');
+    // Set style if provided
+    if (item.style) {
+        const pPr = doc.createElement('w:pPr');
+        const pStyle = doc.createElement('w:pStyle');
+        pStyle.setAttribute('w:val', item.style);
+        pPr.appendChild(pStyle);
+        p.appendChild(pPr);
+    }
+    // Add text run
+    const r = doc.createElement('w:r');
+    const t = doc.createElement('w:t');
+    t.setAttribute('xml:space', 'preserve');
+    t.textContent = item.text;
+    r.appendChild(t);
+    p.appendChild(r);
+    return p;
+}

package/dist/tools/docx/builders/table.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Table builder — creates w:tbl elements with headers, rows, and styling.
+ */
+import type { DocxContentTable, InsertTableOp } from '../types.js';
+/**
+ * Build a table element from content structure or operation.
+ */
+export declare function buildTable(doc: Document, spec: DocxContentTable | InsertTableOp): Element;

package/dist/tools/docx/builders/table.js

@@ -0,0 +1,94 @@
+/**
+ * Table builder — creates w:tbl elements with headers, rows, and styling.
+ */
+/**
+ * Build a table element from content structure or operation.
+ */
+export function buildTable(doc, spec) {
+    const tbl = doc.createElement('w:tbl');
+    // Table properties
+    const tblPr = doc.createElement('w:tblPr');
+    if (spec.style) {
+        const tblStyle = doc.createElement('w:tblStyle');
+        tblStyle.setAttribute('w:val', spec.style);
+        tblPr.appendChild(tblStyle);
+    }
+    const tblW = doc.createElement('w:tblW');
+    tblW.setAttribute('w:w', '0');
+    tblW.setAttribute('w:type', 'auto');
+    tblPr.appendChild(tblW);
+    // Table borders
+    const tblBorders = doc.createElement('w:tblBorders');
+    for (const side of ['top', 'left', 'bottom', 'right', 'insideH', 'insideV']) {
+        const border = doc.createElement(`w:${side}`);
+        border.setAttribute('w:val', 'single');
+        border.setAttribute('w:sz', '4');
+        border.setAttribute('w:space', '0');
+        border.setAttribute('w:color', '000000');
+        tblBorders.appendChild(border);
+    }
+    tblPr.appendChild(tblBorders);
+    tbl.appendChild(tblPr);
+    // Table grid
+    const colCount = spec.headers
+        ? spec.headers.length
+        : spec.rows.length > 0
+            ? spec.rows[0].length
+            : 0;
+    if (colCount > 0) {
+        const tblGrid = doc.createElement('w:tblGrid');
+        for (let c = 0; c < colCount; c++) {
+            const gridCol = doc.createElement('w:gridCol');
+            const w = spec.colWidths?.[c] ?? Math.floor(9000 / colCount);
+            gridCol.setAttribute('w:w', String(w));
+            tblGrid.appendChild(gridCol);
+        }
+        tbl.appendChild(tblGrid);
+    }
+    // Helper to build a cell
+    const buildCell = (text, isHeader, widthTwips) => {
+        const tc = doc.createElement('w:tc');
+        if (widthTwips) {
+            const tcPr = doc.createElement('w:tcPr');
+            const tcW = doc.createElement('w:tcW');
+            tcW.setAttribute('w:w', String(widthTwips));
+            tcW.setAttribute('w:type', 'dxa');
+            tcPr.appendChild(tcW);
+            tc.appendChild(tcPr);
+        }
+        const p = doc.createElement('w:p');
+        const r = doc.createElement('w:r');
+        if (isHeader) {
+            const rPr = doc.createElement('w:rPr');
+            const b = doc.createElement('w:b');
+            rPr.appendChild(b);
+            r.appendChild(rPr);
+        }
+        const t = doc.createElement('w:t');
+        t.setAttribute('xml:space', 'preserve');
+        t.textContent = text;
+        r.appendChild(t);
+        p.appendChild(r);
+        tc.appendChild(p);
+        return tc;
+    };
+    // Header row
+    if (spec.headers && spec.headers.length > 0) {
+        const tr = doc.createElement('w:tr');
+        for (let i = 0; i < spec.headers.length; i++) {
+            const width = spec.colWidths?.[i];
+            tr.appendChild(buildCell(spec.headers[i], true, width));
+        }
+        tbl.appendChild(tr);
+    }
+    // Data rows
+    for (const row of spec.rows) {
+        const tr = doc.createElement('w:tr');
+        for (let i = 0; i < row.length; i++) {
+            const width = spec.colWidths?.[i];
+            tr.appendChild(buildCell(row[i], false, width));
+        }
+        tbl.appendChild(tr);
+    }
+    return tbl;
+}

package/dist/tools/docx/builders/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XML escaping utilities.
+ */
+export declare function escapeXml(s: string): string;
+export declare function escapeXmlAttr(s: string): string;

package/dist/tools/docx/builders/utils.js

@@ -0,0 +1,18 @@
+/**
+ * XML escaping utilities.
+ */
+export function escapeXml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function escapeXmlAttr(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/dist/tools/docx/constants.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DOCX constants — shared values used across the module.
+ */
+export declare const IMAGE_MIME_TYPES: Record<string, string>;
+export declare function getMimeType(ext: string): string;
+/**
+ * Convert pixels to EMU (English Metric Units).
+ * 1 inch = 914400 EMU, 1 px ≈ 9525 EMU (at 96 DPI)
+ */
+export declare const PX_TO_EMU = 9525;
+export declare function pixelsToEmu(px: number): number;
+export declare const NAMESPACES: {
+    readonly W: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly WP: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+    readonly A: "http://schemas.openxmlformats.org/drawingml/2006/main";
+    readonly PIC: "http://schemas.openxmlformats.org/drawingml/2006/picture";
+    readonly R: "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    readonly RELS: "http://schemas.openxmlformats.org/package/2006/relationships";
+};
+export declare const DEFAULT_IMAGE_WIDTH = 300;
+export declare const DEFAULT_IMAGE_HEIGHT = 200;
+export declare const DOCX_PATHS: {
+    readonly CONTENT_TYPES: "[Content_Types].xml";
+    readonly DOCUMENT_XML: "word/document.xml";
+    readonly DOCUMENT_RELS: "word/_rels/document.xml.rels";
+    readonly ROOT_RELS: "_rels/.rels";
+    readonly STYLES_XML: "word/styles.xml";
+    readonly SETTINGS_XML: "word/settings.xml";
+    readonly WEB_SETTINGS_XML: "word/webSettings.xml";
+    readonly FONT_TABLE_XML: "word/fontTable.xml";
+    readonly MEDIA_FOLDER: "word/media";
+};

package/dist/tools/docx/constants.js

@@ -0,0 +1,61 @@
+/**
+ * DOCX constants — shared values used across the module.
+ */
+// ═══════════════════════════════════════════════════════════════════════
+// Image MIME types
+// ═══════════════════════════════════════════════════════════════════════
+export const IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.tiff': 'image/tiff',
+    '.tif': 'image/tiff',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+};
+export function getMimeType(ext) {
+    return IMAGE_MIME_TYPES[ext.toLowerCase()] ?? 'application/octet-stream';
+}
+// ═══════════════════════════════════════════════════════════════════════
+// EMU conversion (English Metric Units)
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Convert pixels to EMU (English Metric Units).
+ * 1 inch = 914400 EMU, 1 px ≈ 9525 EMU (at 96 DPI)
+ */
+export const PX_TO_EMU = 9525;
+export function pixelsToEmu(px) {
+    return px * PX_TO_EMU;
+}
+// ═══════════════════════════════════════════════════════════════════════
+// XML namespaces
+// ═══════════════════════════════════════════════════════════════════════
+export const NAMESPACES = {
+    W: 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    WP: 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    A: 'http://schemas.openxmlformats.org/drawingml/2006/main',
+    PIC: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
+    R: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    RELS: 'http://schemas.openxmlformats.org/package/2006/relationships',
+};
+// ═══════════════════════════════════════════════════════════════════════
+// Default values
+// ═══════════════════════════════════════════════════════════════════════
+export const DEFAULT_IMAGE_WIDTH = 300;
+export const DEFAULT_IMAGE_HEIGHT = 200;
+// ═══════════════════════════════════════════════════════════════════════
+// File paths
+// ═══════════════════════════════════════════════════════════════════════
+export const DOCX_PATHS = {
+    CONTENT_TYPES: '[Content_Types].xml',
+    DOCUMENT_XML: 'word/document.xml',
+    DOCUMENT_RELS: 'word/_rels/document.xml.rels',
+    ROOT_RELS: '_rels/.rels',
+    STYLES_XML: 'word/styles.xml',
+    SETTINGS_XML: 'word/settings.xml',
+    WEB_SETTINGS_XML: 'word/webSettings.xml',
+    FONT_TABLE_XML: 'word/fontTable.xml',
+    MEDIA_FOLDER: 'word/media',
+};

package/dist/tools/docx/converters/markdown-to-html.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markdown → HTML Converter
+ *
+ * Provides markdown-to-HTML conversion for DOCX content operations
+ * (appendMarkdown, insertTable with markdown input, etc.).
+ *
+ * @module docx/converters/markdown-to-html
+ */
+/** Convert basic markdown text to HTML. */
+export declare function markdownToHtml(markdown: string): string;
+/**
+ * Convert a markdown table to an HTML `<table>` with inline CSS borders.
+ * html-to-docx needs explicit border styles — without them, tables are invisible in Word.
+ */
+export declare function markdownTableToHtml(markdown: string): string;
+/** Build a markdown table string from a 2-D rows array (first row = header). */
+export declare function buildMarkdownTableFromRows(rows: string[][]): string;

package/dist/tools/docx/converters/markdown-to-html.js

@@ -0,0 +1,111 @@
+/**
+ * Markdown → HTML Converter
+ *
+ * Provides markdown-to-HTML conversion for DOCX content operations
+ * (appendMarkdown, insertTable with markdown input, etc.).
+ *
+ * @module docx/converters/markdown-to-html
+ */
+import { escapeHtml } from '../utils/escaping.js';
+// ─── Markdown → HTML ─────────────────────────────────────────────────────────
+/** Convert basic markdown text to HTML. */
+export function markdownToHtml(markdown) {
+    if (!markdown?.trim())
+        return '';
+    let html = markdown.trim();
+    // Headings (h6 → h1 to avoid partial matches)
+    html = html.replace(/^######\s+(.+)$/gm, '<h6>$1</h6>');
+    html = html.replace(/^#####\s+(.+)$/gm, '<h5>$1</h5>');
+    html = html.replace(/^####\s+(.+)$/gm, '<h4>$1</h4>');
+    html = html.replace(/^###\s+(.+)$/gm, '<h3>$1</h3>');
+    html = html.replace(/^##\s+(.+)$/gm, '<h2>$1</h2>');
+    html = html.replace(/^#\s+(.+)$/gm, '<h1>$1</h1>');
+    // Bold (before italic to avoid conflicts)
+    html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+    html = html.replace(/__(.+?)__/g, '<strong>$1</strong>');
+    // Italic
+    html = html.replace(/\*(.+?)\*/g, '<em>$1</em>');
+    html = html.replace(/_(.+?)_/g, '<em>$1</em>');
+    // Images & links
+    html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" />');
+    html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    // Inline code
+    html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Paragraphs (double-newline separated)
+    return html
+        .split(/\n\n+/)
+        .map((p) => p.trim())
+        .filter(Boolean)
+        .map((p) => {
+        // Don't wrap blocks that are already complete HTML elements
+        if (p.startsWith('<') && p.endsWith('>'))
+            return p.replace(/\n/g, '<br>');
+        return `<p>${p.replace(/\n/g, '<br>')}</p>`;
+    })
+        .join('\n');
+}
+// ─── Markdown Table → HTML ───────────────────────────────────────────────────
+/** Parse a single markdown table row into cell values. */
+function parseTableRow(row) {
+    return row.replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+}
+/**
+ * Convert a markdown table to an HTML `<table>` with inline CSS borders.
+ * html-to-docx needs explicit border styles — without them, tables are invisible in Word.
+ */
+export function markdownTableToHtml(markdown) {
+    if (!markdown?.trim())
+        return '';
+    const lines = markdown
+        .trim()
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+    if (lines.length < 2)
+        return '';
+    const headerCells = parseTableRow(lines[0]);
+    if (headerCells.length === 0)
+        return '';
+    const dataRows = lines.slice(2).map(parseTableRow);
+    const BORDER = 'border:1px solid #000;';
+    const CELL = `${BORDER} padding:6px 10px;`;
+    const HEADER = `${CELL} background-color:#f2f2f2; font-weight:bold;`;
+    let html = `<table style="border-collapse:collapse; width:100%; ${BORDER}">\n`;
+    html += '  <thead>\n    <tr>\n';
+    for (const cell of headerCells) {
+        html += `      <th style="${HEADER}">${escapeHtml(cell)}</th>\n`;
+    }
+    html += '    </tr>\n  </thead>\n';
+    if (dataRows.length > 0) {
+        html += '  <tbody>\n';
+        for (const row of dataRows) {
+            html += '    <tr>\n';
+            for (const cell of row) {
+                html += `      <td style="${CELL}">${escapeHtml(cell)}</td>\n`;
+            }
+            html += '    </tr>\n';
+        }
+        html += '  </tbody>\n';
+    }
+    return html + '</table>';
+}
+// ─── Rows Array → Markdown Table ─────────────────────────────────────────────
+/** Build a markdown table string from a 2-D rows array (first row = header). */
+export function buildMarkdownTableFromRows(rows) {
+    if (!rows?.length)
+        return '';
+    const header = rows[0];
+    if (!header?.length)
+        return '';
+    const lines = [
+        `| ${header.join(' | ')} |`,
+        `| ${header.map(() => '---').join(' | ')} |`,
+    ];
+    for (const row of rows.slice(1)) {
+        const padded = [...row];
+        while (padded.length < header.length)
+            padded.push('');
+        lines.push(`| ${padded.slice(0, header.length).join(' | ')} |`);
+    }
+    return lines.join('\n');
+}