@jagadeesh52423/atlassian-mcp-server 1.1.0 → 1.1.2

package/dist/formatters/adf-formatter.js

@@ -3,135 +3,245 @@
  * Handles conversion between plain text/markdown and ADF format used by Jira API v3
  */
 /**
- * Extracts plain text from ADF (Atlassian Document Format) body
+ * Jira/Confluence ADF supported languages mapped from common LLM output aliases
+ */
+const LANGUAGE_ALIASES = {
+    tsx: 'javascript',
+    jsx: 'javascript',
+    sh: 'bash',
+    shell: 'bash',
+    zsh: 'bash',
+    dockerfile: 'bash',
+    tf: 'plaintext',
+    hcl: 'plaintext',
+    mdx: 'markdown',
+    yml: 'yaml',
+};
+function normalizeCodeLanguage(lang) {
+    if (!lang)
+        return '';
+    const lower = lang.toLowerCase();
+    return LANGUAGE_ALIASES[lower] ?? lower;
+}
+/**
+ * Recursively converts a single ADF node to plain text.
+ * Mirrors sooperset's adf_to_text recursive approach:
+ * - Content arrays are joined with '\n'
+ * - Marks (bold, italic, links) are stripped — plain text only
+ */
+function adfNodeToText(node) {
+    if (!node)
+        return '';
+    // Array: map each item and join with newline (mirrors sooperset's "\n".join)
+    if (Array.isArray(node)) {
+        return node.map(adfNodeToText).filter(Boolean).join('\n');
+    }
+    if (typeof node !== 'object')
+        return String(node);
+    switch (node.type) {
+        case 'text':
+            // Marks (bold, italic, link, etc.) are stripped — plain text only
+            return node.text ?? '';
+        case 'hardBreak':
+            return '\n';
+        case 'mention': {
+            const attrs = node.attrs ?? {};
+            return attrs.text ?? `@${attrs.id ?? 'unknown'}`;
+        }
+        case 'emoji': {
+            const attrs = node.attrs ?? {};
+            return attrs.text ?? attrs.shortName ?? '';
+        }
+        case 'date': {
+            const timestamp = node.attrs?.timestamp;
+            if (!timestamp)
+                return '';
+            try {
+                return new Date(Number(timestamp)).toISOString().slice(0, 10);
+            }
+            catch {
+                return String(timestamp);
+            }
+        }
+        case 'status':
+            return `[${node.attrs?.text ?? ''}]`;
+        case 'inlineCard': {
+            const attrs = node.attrs ?? {};
+            return attrs.url ?? attrs.data?.url ?? attrs.data?.name ?? '';
+        }
+        case 'heading': {
+            const level = node.attrs?.level ?? 1;
+            return `${'#'.repeat(level)} ${adfNodeToText(node.content ?? [])}`;
+        }
+        case 'listItem':
+            return `- ${adfNodeToText(node.content ?? [])}`;
+        case 'codeBlock': {
+            const lang = node.attrs?.language ? normalizeCodeLanguage(node.attrs.language) : '';
+            return `\`\`\`${lang}\n${adfNodeToText(node.content ?? [])}\n\`\`\``;
+        }
+        case 'table': {
+            if (!node.content)
+                return '';
+            const rows = node.content
+                .filter((row) => row.type === 'tableRow' && row.content)
+                .map((row) => row.content
+                .filter((cell) => cell.type === 'tableCell' || cell.type === 'tableHeader')
+                .map((cell) => adfNodeToText(cell.content ?? []).replace(/\n/g, ' ').trim()))
+                .filter((cells) => cells.length > 0);
+            if (rows.length === 0)
+                return '';
+            const [header, ...data] = rows;
+            return [
+                '| ' + header.join(' | ') + ' |',
+                '|' + header.map(() => '--------').join('|') + '|',
+                ...data.map(row => '| ' + row.join(' | ') + ' |'),
+            ].join('\n');
+        }
+        default:
+            if (node.content)
+                return adfNodeToText(node.content);
+            return '';
+    }
+}
+/**
+ * Extracts plain text from ADF (Atlassian Document Format) body.
+ * Follows sooperset's recursive '\n'-joining approach.
  */
 export function extractTextFromADF(body) {
     if (!body)
         return '';
-    // If body is already a string (wiki markup), return it directly
-    if (typeof body === 'string') {
+    if (typeof body === 'string')
         return formatWikiMarkup(body);
-    }
-    // If body doesn't have content property, it might be wiki markup in another format
-    if (!body.content) {
+    if (!body.content)
         return formatWikiMarkup(String(body));
-    }
-    let text = '';
-    const extractFromContent = (content) => {
-        for (const item of content) {
-            if (item.type === 'text' && item.text) {
-                text += item.text;
-            }
-            else if (item.type === 'hardBreak') {
-                text += '\n';
-            }
-            else if (item.type === 'paragraph') {
-                if (item.content) {
-                    extractFromContent(item.content);
-                }
-            }
-            else if (item.type === 'heading') {
-                const level = item.attrs?.level || 1;
-                const prefix = '#'.repeat(level);
-                text += `${prefix} `;
-                if (item.content) {
-                    extractFromContent(item.content);
-                }
-            }
-            else if (item.type === 'bulletList' || item.type === 'orderedList') {
-                if (item.content) {
-                    extractFromContent(item.content);
-                }
-            }
-            else if (item.type === 'listItem') {
-                text += '- ';
-                if (item.content) {
-                    extractFromContent(item.content);
+    return formatWikiMarkup(adfNodeToText(body.content).trim());
+}
+/**
+ * Converts wiki-style tables (||header||col||) to markdown tables.
+ * Only converts blocks that start with || (header row), leaving existing
+ * markdown tables untouched.
+ */
+function convertWikiTablesToMarkdown(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        // Only enter table mode when we see a wiki header row (||…)
+        if (line.startsWith('||')) {
+            const tableLines = [];
+            while (i < lines.length) {
+                const tl = lines[i].trim();
+                if (tl.startsWith('||') || tl.startsWith('|')) {
+                    tableLines.push(tl);
+                    i++;
                 }
-            }
-            else if (item.type === 'codeBlock') {
-                text += '```';
-                if (item.content) {
-                    extractFromContent(item.content);
+                else {
+                    break;
                 }
-                text += '```';
             }
-            else if (item.type === 'table') {
-                // Extract table as markdown
-                if (item.content) {
-                    const rows = [];
-                    item.content.forEach((row) => {
-                        if (row.type === 'tableRow' && row.content) {
-                            const cells = [];
-                            row.content.forEach((cell) => {
-                                if ((cell.type === 'tableCell' || cell.type === 'tableHeader') && cell.content) {
-                                    let cellText = '';
-                                    const extractCellText = (cellContent) => {
-                                        cellContent.forEach((cellItem) => {
-                                            if (cellItem.type === 'paragraph' && cellItem.content) {
-                                                cellItem.content.forEach((textItem) => {
-                                                    if (textItem.type === 'text' && textItem.text) {
-                                                        cellText += textItem.text;
-                                                    }
-                                                });
-                                            }
-                                        });
-                                    };
-                                    extractCellText(cell.content);
-                                    cells.push(cellText.trim());
-                                }
-                            });
-                            if (cells.length > 0) {
-                                rows.push(cells);
-                            }
-                        }
-                    });
-                    // Format as markdown table
-                    if (rows.length > 0) {
-                        const [headerRow, ...dataRows] = rows;
-                        // Header row
-                        text += '\n| ' + headerRow.join(' | ') + ' |\n';
-                        // Separator row
-                        text += '|' + headerRow.map(() => '--------').join('|') + '|\n';
-                        // Data rows
-                        dataRows.forEach(row => {
-                            text += '| ' + row.join(' | ') + ' |\n';
-                        });
+            const markdownRows = [];
+            let headerDone = false;
+            for (const tl of tableLines) {
+                if (tl.startsWith('||')) {
+                    const cells = tl.split('||').map(c => c.trim()).filter(c => c !== '');
+                    markdownRows.push('| ' + cells.join(' | ') + ' |');
+                    if (!headerDone) {
+                        markdownRows.push('| ' + cells.map(() => '---').join(' | ') + ' |');
+                        headerDone = true;
                     }
                 }
+                else {
+                    const cells = tl.split('|').map(c => c.trim()).filter(c => c !== '');
+                    if (cells.length > 0)
+                        markdownRows.push('| ' + cells.join(' | ') + ' |');
+                }
             }
-            else if (item.content) {
-                extractFromContent(item.content);
-            }
+            result.push(...markdownRows);
         }
-    };
-    extractFromContent(body.content);
-    return formatWikiMarkup(text.trim());
+        else {
+            result.push(lines[i]);
+            i++;
+        }
+    }
+    return result.join('\n');
 }
 /**
- * Formats wiki markup to cleaner text
+ * Formats wiki markup to cleaner markdown text.
+ *
+ * Handles (in order):
+ *  - {code} / {noformat} blocks  → fenced code (extracted as placeholders first
+ *    so their contents are never touched by later transforms)
+ *  - Wiki tables ||h||            → markdown tables (pre-pass)
+ *  - {quote}                      → > blockquote
+ *  - {note}/{warning}/{info}/{tip}→ labelled blockquote
+ *  - [text|url] / [~user] / [url] → markdown links / @mention / bare URL
+ *  - \\                           → newline
+ *  - # item / ## item             → 1. / nested ordered list (wiki list syntax)
+ *  - h1. … h6.                    → # … ###### (must come AFTER list conversion)
+ *  - ---- / {panel} / {color} / checkboxes  (existing)
  */
 export function formatWikiMarkup(text) {
     if (!text)
         return '';
-    return text
-        // Convert Confluence headers to markdown headers
-        .replace(/^h([1-6])\.\s*/gm, (match, level) => '#'.repeat(parseInt(level)) + ' ')
-        // Convert horizontal rules
+    // --- Phase 1: extract code/noformat blocks into placeholders so their
+    //              contents survive all subsequent regex transforms safely ---
+    const codeStore = [];
+    text = text.replace(/\{code(?::(?:language=)?(\w+))?\}([\s\S]*?)\{code\}/g, (_full, lang, code) => {
+        const langStr = lang ? lang.toLowerCase() : '';
+        const idx = codeStore.length;
+        codeStore.push(`\`\`\`${langStr}\n${code.replace(/^\n/, '').replace(/\n$/, '')}\n\`\`\``);
+        return `\x00CODE_${idx}\x00`;
+    });
+    text = text.replace(/\{noformat(?:[^}]*)?\}([\s\S]*?)\{noformat\}/g, (_full, code) => {
+        const idx = codeStore.length;
+        codeStore.push(`\`\`\`\n${code.replace(/^\n/, '').replace(/\n$/, '')}\n\`\`\``);
+        return `\x00CODE_${idx}\x00`;
+    });
+    // --- Phase 2: pre-process wiki tables ---
+    text = convertWikiTablesToMarkdown(text);
+    // --- Phase 3: remaining transforms ---
+    text = text
+        // {quote} blocks → blockquotes
+        .replace(/\{quote\}([\s\S]*?)\{quote\}/g, (_full, content) => content.trim().split('\n').map((l) => `> ${l}`).join('\n'))
+        // Notification panels {note:…}…{note} etc.
+        .replace(/\{(note|info|tip|warning)(?::[^}]*)?\}([\s\S]*?)\{\1\}/g, (_full, type, content) => {
+        const label = type.charAt(0).toUpperCase() + type.slice(1);
+        const ls = content.trim().split('\n');
+        return `> **[${label}]** ${ls[0]}` +
+            (ls.length > 1 ? '\n' + ls.slice(1).map((l) => `> ${l}`).join('\n') : '');
+    })
+        // Wiki links [text|url] → markdown
+        .replace(/\[([^\]|]+)\|([^\]]+)\]/g, '[$1]($2)')
+        // User mentions [~username] → @username
+        .replace(/\[~([^\]]+)\]/g, '@$1')
+        // Bare URL in brackets [https://…] → plain URL
+        .replace(/\[([a-z]+:\/\/[^\]]+)\]/g, '$1')
+        // Wiki line break \\ → newline
+        .replace(/\\\\/g, '\n')
+        // Wiki ordered lists (# item, ## nested) — MUST precede header conversion
+        // because in wiki markup headings are h1./h2. (never bare #)
+        .replace(/^(#+) /gm, (_, hashes) => '  '.repeat(hashes.length - 1) + '1. ')
+        // Confluence headers h1.–h6. → markdown #–######
+        .replace(/^h([1-6])\.\s*/gm, (_match, level) => '#'.repeat(parseInt(level)) + ' ')
+        // Horizontal rules
         .replace(/^----+$/gm, '---')
-        // Handle panels - convert to blockquotes for better readability
+        // Panels → blockquotes
         .replace(/\{panel:title=([^|]*)[^}]*\}/g, '\n> **$1**\n>')
         .replace(/\{panel\}/g, '\n')
-        // Handle colored text/backgrounds - keep the text but remove styling
+        // Colored text — strip styling, keep content
         .replace(/\{color:[^}]*\}([^{]*)\{color\}/g, '$1')
-        // Convert checkboxes
+        // Checkboxes
         .replace(/☐/g, '- [ ]')
         .replace(/☑/g, '- [x]')
-        // Clean up multiple newlines
+        // Tidy up
         .replace(/\n{3,}/g, '\n\n')
-        // Ensure proper spacing around headers
-        .replace(/\n(#{1,6}\s)/g, '\n\n$1')
-        .trim();
+        .replace(/\n(#{1,6}\s)/g, '\n\n$1');
+    // --- Phase 4: restore code blocks ---
+    codeStore.forEach((code, idx) => {
+        text = text.replace(`\x00CODE_${idx}\x00`, code);
+    });
+    return text.trim();
 }
 /**
  * Parses inline formatting like **bold**, *italic*, `code`, {{code}}
@@ -143,6 +253,7 @@ export function parseInlineFormatting(text) {
     // **bold** should be processed before *italic* to handle **text** correctly
     const patterns = [
         { regex: /\*\*(.*?)\*\*/g, type: 'strong' }, // **bold** (process first)
+        { regex: /~~(.*?)~~/g, type: 'strike' }, // ~~strikethrough~~
         { regex: /`([^`]+?)`/g, type: 'code' }, // `code` (markdown style)
         { regex: /\{\{(.+?)\}\}/g, type: 'code' }, // {{code}} (Confluence/Jira wiki style)
     ];
@@ -238,7 +349,8 @@ export function parseInlineFormatting(text) {
  * Enhanced description parser that converts text to proper ADF format
  */
 export function parseDescriptionToADF(description) {
-    const lines = description.split('\n');
+    // Normalise wiki-style tables (||header||) to markdown before line processing
+    const lines = convertWikiTablesToMarkdown(description).split('\n');
     const content = [];
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
@@ -393,19 +505,23 @@ export function parseDescriptionToADF(description) {
         }
         // Handle code blocks (```)
         else if (line.startsWith('```')) {
+            const rawLang = line.substring(3).trim();
+            const lang = normalizeCodeLanguage(rawLang);
             const codeLines = [];
             i++; // Skip the opening ```
             while (i < lines.length && !lines[i].trim().startsWith('```')) {
                 codeLines.push(lines[i]);
                 i++;
             }
-            content.push({
+            const codeBlock = {
                 type: 'codeBlock',
+                attrs: lang ? { language: lang } : {},
                 content: [{
                         type: 'text',
                         text: codeLines.join('\n')
                     }]
-            });
+            };
+            content.push(codeBlock);
         }
         // Handle markdown tables - convert to proper ADF table structure
         else if (line.includes('|') && line.trim() !== '|') {
@@ -525,14 +641,43 @@ export function parseDescriptionToADF(description) {
  * Convert description to wiki markup text format
  */
 export function parseDescriptionToWikiMarkup(description) {
-    const lines = description.split('\n');
+    // Extract code blocks before any line-by-line processing so their
+    // contents are never transformed by heading/table/list logic.
+    const codeBlockStore = [];
+    const protected_ = description.replace(/```(\w*)\n?([\s\S]*?)```/g, (_full, lang, code) => {
+        const idx = codeBlockStore.length;
+        const normalizedLang = normalizeCodeLanguage(lang);
+        const langSuffix = normalizedLang ? `:language=${normalizedLang}` : '';
+        codeBlockStore.push(`{code${langSuffix}}\n${code.replace(/^\n/, '').replace(/\n$/, '')}\n{code}`);
+        return `\x00CODEBLOCK_${idx}\x00`;
+    });
+    const lines = protected_.split('\n');
     const result = [];
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
+        // Restore code blocks
+        if (line.match(/^\x00CODEBLOCK_(\d+)\x00$/)) {
+            const idx = parseInt(line.match(/\x00CODEBLOCK_(\d+)\x00/)[1]);
+            result.push(codeBlockStore[idx]);
+            continue;
+        }
         if (line === '') {
             result.push('');
             continue;
         }
+        // Handle blockquotes (> text) — collect consecutive lines and wrap in {quote}
+        if (line.startsWith('> ')) {
+            const quoteLines = [];
+            while (i < lines.length && lines[i].trim().startsWith('> ')) {
+                quoteLines.push(lines[i].trim().substring(2).trim());
+                i++;
+            }
+            i--; // back up — outer loop will increment
+            result.push('{quote}');
+            result.push(...quoteLines);
+            result.push('{quote}');
+            continue;
+        }
         // Handle markdown headers
         if (line.startsWith('###')) {
             result.push('h3. ' + line.substring(3).trim());
@@ -606,4 +751,175 @@ export function parseDescriptionToWikiMarkup(description) {
     }
     return result.join('\n');
 }
+// ---------------------------------------------------------------------------
+// Confluence Storage Format Converter
+// ---------------------------------------------------------------------------
+/**
+ * Escapes special HTML characters for use inside storage-format text nodes.
+ */
+function escapeStorageHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/**
+ * Applies inline markdown formatting and converts it to Confluence storage
+ * format HTML (strong, em, strike, code, links).
+ * Code spans are protected from further transformation.
+ */
+function applyInlineStorageFormat(text) {
+    // Protect inline code spans first
+    const spans = [];
+    let out = text.replace(/`([^`]+)`/g, (_full, code) => {
+        const idx = spans.length;
+        spans.push(`<code>${escapeStorageHtml(code)}</code>`);
+        return `\x00SPAN_${idx}\x00`;
+    });
+    out = out
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/~~(.*?)~~/g, '<s>$1</s>')
+        .replace(/\*(.*?)\*/g, '<em>$1</em>')
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    // Restore code spans
+    spans.forEach((span, idx) => {
+        out = out.replace(`\x00SPAN_${idx}\x00`, span);
+    });
+    return out;
+}
+/**
+ * Returns true when the string already contains Confluence storage-format
+ * markup so that it can be passed through as-is.
+ */
+function isAlreadyStorageFormat(content) {
+    const trimmed = content.trim();
+    return (trimmed.startsWith('<') &&
+        (trimmed.includes('<ac:') ||
+            trimmed.includes('<ri:') ||
+            /^<(p|h[1-6]|ul|ol|table|blockquote|hr)\b/i.test(trimmed)));
+}
+/**
+ * Converts LLM-produced markdown to Confluence storage format (XHTML).
+ * If the input already looks like storage format it is returned unchanged.
+ *
+ * Supported elements:
+ *  - ATX headings (#–######)
+ *  - Fenced code blocks (``` lang … ```) → ac:structured-macro "code"
+ *  - Blockquotes (> …)
+ *  - Unordered lists (- / * / +)
+ *  - Ordered lists (1. …)
+ *  - Markdown tables
+ *  - Horizontal rules (---, ***, ___)
+ *  - Inline: **bold**, *italic*, ~~strike~~, `code`, [text](url)
+ */
+export function markdownToConfluenceStorage(markdown) {
+    if (isAlreadyStorageFormat(markdown)) {
+        return markdown;
+    }
+    // --- Phase 1: extract fenced code blocks into placeholders ---
+    const codeBlocks = [];
+    const withoutCode = markdown.replace(/```(\w*)\n?([\s\S]*?)```/g, (_full, rawLang, code) => {
+        const idx = codeBlocks.length;
+        const lang = normalizeCodeLanguage(rawLang);
+        const langParam = lang
+            ? `<ac:parameter ac:name="language">${lang}</ac:parameter>`
+            : '';
+        const body = code.replace(/^\n/, '').replace(/\n$/, '');
+        codeBlocks.push(`<ac:structured-macro ac:name="code">${langParam}` +
+            `<ac:plain-text-body><![CDATA[${body}]]></ac:plain-text-body>` +
+            `</ac:structured-macro>`);
+        return `\x00CODE_${idx}\x00`;
+    });
+    // --- Phase 2: line-by-line conversion ---
+    const lines = withoutCode.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const raw = lines[i];
+        const line = raw.trim();
+        // Code block placeholder
+        const codeMatch = line.match(/^\x00CODE_(\d+)\x00$/);
+        if (codeMatch) {
+            result.push(codeBlocks[parseInt(codeMatch[1])]);
+            i++;
+            continue;
+        }
+        // Heading
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            result.push(`<h${level}>${applyInlineStorageFormat(headingMatch[2])}</h${level}>`);
+            i++;
+            continue;
+        }
+        // Horizontal rule
+        if (/^([-*_])\1{2,}$/.test(line)) {
+            result.push('<hr/>');
+            i++;
+            continue;
+        }
+        // Blockquote
+        if (line.startsWith('> ')) {
+            result.push(`<blockquote><p>${applyInlineStorageFormat(line.substring(2))}</p></blockquote>`);
+            i++;
+            continue;
+        }
+        // Table — collect all consecutive table lines
+        if (line.startsWith('|')) {
+            const tableRows = [];
+            while (i < lines.length && lines[i].trim().startsWith('|')) {
+                const row = lines[i].trim();
+                // Skip separator lines (e.g. |---|---|)
+                if (!/^\|[\s\-:|]+\|?$/.test(row)) {
+                    const cells = row.split('|').map(c => c.trim()).filter(c => c !== '');
+                    if (cells.length > 0)
+                        tableRows.push(cells);
+                }
+                i++;
+            }
+            if (tableRows.length > 0) {
+                let html = '<table><tbody>';
+                html += '<tr>' + tableRows[0].map(c => `<th>${applyInlineStorageFormat(c)}</th>`).join('') + '</tr>';
+                for (let r = 1; r < tableRows.length; r++) {
+                    html += '<tr>' + tableRows[r].map(c => `<td>${applyInlineStorageFormat(c)}</td>`).join('') + '</tr>';
+                }
+                html += '</tbody></table>';
+                result.push(html);
+            }
+            continue;
+        }
+        // Unordered list — collect consecutive items
+        if (/^[-*+]\s/.test(line)) {
+            let html = '<ul>';
+            while (i < lines.length && /^[-*+]\s/.test(lines[i].trim())) {
+                html += `<li>${applyInlineStorageFormat(lines[i].trim().substring(2).trim())}</li>`;
+                i++;
+            }
+            html += '</ul>';
+            result.push(html);
+            continue;
+        }
+        // Ordered list — collect consecutive items
+        if (/^\d+\.\s/.test(line)) {
+            let html = '<ol>';
+            while (i < lines.length && /^\d+\.\s/.test(lines[i].trim())) {
+                const text = lines[i].trim().replace(/^\d+\.\s/, '');
+                html += `<li>${applyInlineStorageFormat(text)}</li>`;
+                i++;
+            }
+            html += '</ol>';
+            result.push(html);
+            continue;
+        }
+        // Empty line — skip (Confluence doesn't need explicit paragraph breaks between block elements)
+        if (line === '') {
+            i++;
+            continue;
+        }
+        // Regular paragraph
+        result.push(`<p>${applyInlineStorageFormat(line)}</p>`);
+        i++;
+    }
+    return result.join('\n');
+}
 //# sourceMappingURL=adf-formatter.js.map