@jagadeesh52423/atlassian-mcp-server 1.1.1 → 1.2.1

package/dist/formatters/adf-formatter.js

@@ -3,162 +3,400 @@
  * 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
  */
-export function extractTextFromADF(body) {
-    if (!body)
+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 '';
-    // If body is already a string (wiki markup), return it directly
-    if (typeof body === 'string') {
-        return formatWikiMarkup(body);
+    const lower = lang.toLowerCase();
+    return LANGUAGE_ALIASES[lower] ?? lower;
+}
+const TABLE_TOTAL_WIDTH_PX = 760;
+const TABLE_MIN_COL_WIDTH_PX = 60;
+const TABLE_MAX_COL_WIDTH_PX = 400;
+function extractCellText(cell) {
+    const para = cell?.content?.[0];
+    if (!para?.content)
+        return '';
+    return para.content.map((n) => n.text ?? '').join('');
+}
+/**
+ * Sets attrs.colwidth on every cell so Confluence renders columns proportional
+ * to their max content length, clamped to [TABLE_MIN_COL_WIDTH_PX, TABLE_MAX_COL_WIDTH_PX].
+ */
+function applyColWidths(tableRows) {
+    if (!tableRows.length)
+        return;
+    const numCols = Math.max(...tableRows.map(r => r.content?.length ?? 0));
+    if (numCols === 0)
+        return;
+    const maxLens = new Array(numCols).fill(1);
+    for (const row of tableRows) {
+        row.content?.forEach((cell, idx) => {
+            const len = extractCellText(cell).length || 1;
+            if (len > maxLens[idx])
+                maxLens[idx] = len;
+        });
     }
-    // If body doesn't have content property, it might be wiki markup in another format
-    if (!body.content) {
-        return formatWikiMarkup(String(body));
+    const totalLen = maxLens.reduce((a, b) => a + b, 0) || 1;
+    const widths = maxLens.map((len) => {
+        const proportional = (len / totalLen) * TABLE_TOTAL_WIDTH_PX;
+        return Math.round(Math.min(TABLE_MAX_COL_WIDTH_PX, Math.max(TABLE_MIN_COL_WIDTH_PX, proportional)));
+    });
+    for (const row of tableRows) {
+        row.content?.forEach((cell, idx) => {
+            cell.attrs = { ...(cell.attrs ?? {}), colwidth: [widths[idx]] };
+        });
     }
-    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);
-                }
+}
+const STORAGE_TABLE_MIN_PCT = 5;
+/**
+ * Builds a Confluence storage-format <colgroup> sized proportionally to the
+ * max content length per column. Returns '' for empty/single-column input.
+ */
+function buildColGroupHtml(tableRows) {
+    if (!tableRows.length)
+        return '';
+    const numCols = Math.max(...tableRows.map(r => r.length));
+    if (numCols < 2)
+        return '';
+    const maxLens = new Array(numCols).fill(1);
+    for (const row of tableRows) {
+        row.forEach((cell, idx) => {
+            const len = (cell ?? '').length || 1;
+            if (len > maxLens[idx])
+                maxLens[idx] = len;
+        });
+    }
+    const totalLen = maxLens.reduce((a, b) => a + b, 0) || 1;
+    const raw = maxLens.map((len) => Math.max(STORAGE_TABLE_MIN_PCT, (len / totalLen) * 100));
+    const sum = raw.reduce((a, b) => a + b, 0);
+    const normalized = raw.map((p) => (p / sum) * 100);
+    const cols = normalized
+        .map((p) => `<col style="width: ${p.toFixed(1)}%;" />`)
+        .join('');
+    return `<colgroup>${cols}</colgroup>`;
+}
+/**
+ * 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);
             }
-            else if (item.type === 'bulletList' || item.type === 'orderedList') {
-                if (item.content) {
-                    extractFromContent(item.content);
-                }
+            catch {
+                return String(timestamp);
             }
-            else if (item.type === 'listItem') {
-                text += '- ';
-                if (item.content) {
-                    extractFromContent(item.content);
+        }
+        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 (typeof body === 'string')
+        return formatWikiMarkup(body);
+    if (!body.content)
+        return formatWikiMarkup(String(body));
+    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();
+}
+/**
+ * Detects whether the given text uses Jira/Confluence wiki markup rather than markdown.
+ * Returns true if any wiki-specific patterns are found.
+ */
+function isWikiMarkup(text) {
+    // h1. through h6. headings at line start
+    if (/^h[1-6]\.\s/m.test(text))
+        return true;
+    // {code} or {code:lang} blocks
+    if (/\{code[}:]/.test(text))
+        return true;
+    // [text|url] wiki links — pipe inside brackets is unambiguous wiki syntax
+    if (/\[[^\]\|]+\|[^\]]+\]/.test(text))
+        return true;
+    // ||header|| wiki table headers at line start
+    if (/^\|\|/m.test(text))
+        return true;
+    // {panel blocks
+    if (/\{panel/.test(text))
+        return true;
+    return false;
 }
 /**
  * Parses inline formatting like **bold**, *italic*, `code`, {{code}}
+ * When wikiMode is true, single *text* is treated as bold (wiki convention).
+ * Also handles [text|url] wiki links and [text](url) markdown links.
  */
-export function parseInlineFormatting(text) {
+export function parseInlineFormatting(text, wikiMode = false) {
     const result = [];
     let currentPos = 0;
     // Process patterns in order of precedence to avoid conflicts
     // **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)
     ];
     let matches = [];
-    // Find all formatting matches
+    // Process links FIRST to avoid conflicts with brackets and formatting markers
+    // Wiki links: [text|url]
+    const wikiLinkRegex = /\[([^\]\|]+)\|([^\]]+)\]/g;
+    let wikiLinkMatch;
+    while ((wikiLinkMatch = wikiLinkRegex.exec(text)) !== null) {
+        matches.push({
+            start: wikiLinkMatch.index,
+            end: wikiLinkMatch.index + wikiLinkMatch[0].length,
+            text: wikiLinkMatch[1],
+            type: 'link',
+            href: wikiLinkMatch[2],
+            fullMatch: wikiLinkMatch[0]
+        });
+    }
+    // Markdown links: [text](url)
+    const mdLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let mdLinkMatch;
+    while ((mdLinkMatch = mdLinkRegex.exec(text)) !== null) {
+        // Only add if not overlapping with an already-found wiki link
+        const overlaps = matches.some(existing => (mdLinkMatch.index >= existing.start && mdLinkMatch.index < existing.end) ||
+            (mdLinkMatch.index + mdLinkMatch[0].length > existing.start && mdLinkMatch.index + mdLinkMatch[0].length <= existing.end));
+        if (!overlaps) {
+            matches.push({
+                start: mdLinkMatch.index,
+                end: mdLinkMatch.index + mdLinkMatch[0].length,
+                text: mdLinkMatch[1],
+                type: 'link',
+                href: mdLinkMatch[2],
+                fullMatch: mdLinkMatch[0]
+            });
+        }
+    }
+    // Find all formatting matches (skip regions already claimed by links)
     patterns.forEach(pattern => {
         let match;
         const regex = new RegExp(pattern.regex.source, 'g');
         while ((match = regex.exec(text)) !== null) {
-            matches.push({
-                start: match.index,
-                end: match.index + match[0].length,
-                text: match[1],
-                type: pattern.type,
-                fullMatch: match[0]
-            });
+            const overlapsLink = matches.some(existing => (match.index >= existing.start && match.index < existing.end) ||
+                (match.index + match[0].length > existing.start && match.index + match[0].length <= existing.end) ||
+                (match.index <= existing.start && match.index + match[0].length >= existing.end));
+            if (!overlapsLink) {
+                matches.push({
+                    start: match.index,
+                    end: match.index + match[0].length,
+                    text: match[1],
+                    type: pattern.type,
+                    fullMatch: match[0]
+                });
+            }
         }
     });
     // Sort matches by position and remove overlapping matches
@@ -169,16 +407,17 @@ export function parseInlineFormatting(text) {
     matches.forEach(match => {
         tempText = tempText.substring(0, match.start) + ' '.repeat(match.end - match.start) + tempText.substring(match.end);
     });
-    // Now find italic patterns in the remaining text
-    const italicRegex = /\*([^*]+?)\*/g;
-    let italicMatch;
-    while ((italicMatch = italicRegex.exec(tempText)) !== null) {
+    // Now find single *text* patterns in the remaining text
+    // In wiki mode: *text* = bold (strong). In markdown mode: *text* = italic (em).
+    const singleStarRegex = /\*([^*]+?)\*/g;
+    let singleStarMatch;
+    while ((singleStarMatch = singleStarRegex.exec(tempText)) !== null) {
         matches.push({
-            start: italicMatch.index,
-            end: italicMatch.index + italicMatch[0].length,
-            text: italicMatch[1],
-            type: 'em',
-            fullMatch: italicMatch[0]
+            start: singleStarMatch.index,
+            end: singleStarMatch.index + singleStarMatch[0].length,
+            text: singleStarMatch[1],
+            type: wikiMode ? 'strong' : 'em',
+            fullMatch: singleStarMatch[0]
         });
     }
     // Sort matches by position and remove overlapping matches
@@ -208,11 +447,20 @@ export function parseInlineFormatting(text) {
             }
         }
         // Add formatted text
-        result.push({
-            type: 'text',
-            text: match.text,
-            marks: [{ type: match.type }]
-        });
+        if (match.type === 'link') {
+            result.push({
+                type: 'text',
+                text: match.text,
+                marks: [{ type: 'link', attrs: { href: match.href } }]
+            });
+        }
+        else {
+            result.push({
+                type: 'text',
+                text: match.text,
+                marks: [{ type: match.type }]
+            });
+        }
         currentPos = match.end;
     });
     // Add remaining text
@@ -235,10 +483,28 @@ export function parseInlineFormatting(text) {
     return result;
 }
 /**
- * Enhanced description parser that converts text to proper ADF format
+ * Enhanced description parser that converts text to proper ADF format.
+ * Auto-detects wiki markup vs markdown and adjusts parsing accordingly.
  */
 export function parseDescriptionToADF(description) {
-    const lines = description.split('\n');
+    const wikiMode = isWikiMarkup(description);
+    // Extract {code}...{code} blocks before line-by-line processing (wiki mode only)
+    const codeBlockStore = [];
+    let processedDesc = description;
+    if (wikiMode) {
+        processedDesc = description.replace(/\{code(?::([^}]*))?\}([\s\S]*?)\{code\}/g, (_full, params, code) => {
+            const idx = codeBlockStore.length;
+            let lang = '';
+            if (params) {
+                const langMatch = params.match(/(?:language=)?(\w+)/);
+                if (langMatch)
+                    lang = normalizeCodeLanguage(langMatch[1]);
+            }
+            codeBlockStore.push({ lang, code: code.replace(/^\n/, '').replace(/\n$/, '') });
+            return `\x00WIKICODE_${idx}\x00`;
+        });
+    }
+    const lines = processedDesc.split('\n');
     const content = [];
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
@@ -246,6 +512,17 @@ export function parseDescriptionToADF(description) {
             // Skip empty lines - let Claude handle spacing naturally
             continue;
         }
+        // Restore wiki {code} block placeholders
+        const wikiCodeMatch = line.match(/^\x00WIKICODE_(\d+)\x00$/);
+        if (wikiCodeMatch) {
+            const { lang, code } = codeBlockStore[parseInt(wikiCodeMatch[1])];
+            content.push({
+                type: 'codeBlock',
+                attrs: lang ? { language: lang } : {},
+                content: [{ type: 'text', text: code }]
+            });
+            continue;
+        }
         // Handle Confluence wiki markup headers (h1., h2., h3., etc.)
         const confluenceHeaderMatch = line.match(/^h([1-6])\.\s*(.*)$/);
         if (confluenceHeaderMatch) {
@@ -254,42 +531,51 @@ export function parseDescriptionToADF(description) {
             content.push({
                 type: 'heading',
                 attrs: { level },
-                content: [{
-                        type: 'text',
-                        text: headerText
-                    }]
+                content: parseInlineFormatting(headerText, wikiMode)
             });
             continue;
         }
+        // In wiki mode, # at line start = ordered list (not heading)
+        if (wikiMode && /^#+\s/.test(line)) {
+            const listText = line.replace(/^#+\s*/, '');
+            const lastItem = content[content.length - 1];
+            if (lastItem && lastItem.type === 'orderedList') {
+                lastItem.content.push({
+                    type: 'listItem',
+                    content: [{ type: 'paragraph', content: parseInlineFormatting(listText, wikiMode) }]
+                });
+            }
+            else {
+                content.push({
+                    type: 'orderedList',
+                    content: [{
+                            type: 'listItem',
+                            content: [{ type: 'paragraph', content: parseInlineFormatting(listText, wikiMode) }]
+                        }]
+                });
+            }
+            continue;
+        }
         // Handle markdown headers (## Header, ### Header)
         if (line.startsWith('###')) {
             content.push({
                 type: 'heading',
                 attrs: { level: 3 },
-                content: [{
-                        type: 'text',
-                        text: line.substring(3).trim()
-                    }]
+                content: parseInlineFormatting(line.substring(3).trim(), wikiMode)
             });
         }
         else if (line.startsWith('##')) {
             content.push({
                 type: 'heading',
                 attrs: { level: 2 },
-                content: [{
-                        type: 'text',
-                        text: line.substring(2).trim()
-                    }]
+                content: parseInlineFormatting(line.substring(2).trim(), wikiMode)
             });
         }
         else if (line.startsWith('#')) {
             content.push({
                 type: 'heading',
                 attrs: { level: 1 },
-                content: [{
-                        type: 'text',
-                        text: line.substring(1).trim()
-                    }]
+                content: parseInlineFormatting(line.substring(1).trim(), wikiMode)
             });
         }
         // Handle horizontal rules (---- or ----)
@@ -312,7 +598,7 @@ export function parseDescriptionToADF(description) {
                     if (panelLine) {
                         panelContent.push({
                             type: 'paragraph',
-                            content: parseInlineFormatting(panelLine)
+                            content: parseInlineFormatting(panelLine, wikiMode)
                         });
                     }
                     i++;
@@ -345,7 +631,7 @@ export function parseDescriptionToADF(description) {
                     type: 'listItem',
                     content: [{
                             type: 'paragraph',
-                            content: parseInlineFormatting(bulletText)
+                            content: parseInlineFormatting(bulletText, wikiMode)
                         }]
                 });
             }
@@ -356,7 +642,7 @@ export function parseDescriptionToADF(description) {
                             type: 'listItem',
                             content: [{
                                     type: 'paragraph',
-                                    content: parseInlineFormatting(bulletText)
+                                    content: parseInlineFormatting(bulletText, wikiMode)
                                 }]
                         }]
                 });
@@ -373,7 +659,7 @@ export function parseDescriptionToADF(description) {
                         type: 'listItem',
                         content: [{
                                 type: 'paragraph',
-                                content: parseInlineFormatting(listText)
+                                content: parseInlineFormatting(listText, wikiMode)
                             }]
                     });
                 }
@@ -384,7 +670,7 @@ export function parseDescriptionToADF(description) {
                                 type: 'listItem',
                                 content: [{
                                         type: 'paragraph',
-                                        content: parseInlineFormatting(listText)
+                                        content: parseInlineFormatting(listText, wikiMode)
                                     }]
                             }]
                     });
@@ -393,19 +679,67 @@ 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 wiki tables (||header|| for headers, |cell| for data rows)
+        else if (wikiMode && line.startsWith('||')) {
+            const tableRows = [];
+            let tableIdx = i;
+            while (tableIdx < lines.length) {
+                const tableLine = lines[tableIdx].trim();
+                if (!tableLine || (!tableLine.startsWith('||') && !tableLine.startsWith('|')))
+                    break;
+                if (tableLine.startsWith('||')) {
+                    // Header row - split on || and filter empties
+                    const cells = tableLine.split('||').filter(c => c !== '');
+                    const headerCells = cells.map(cellText => ({
+                        type: 'tableHeader',
+                        attrs: {},
+                        content: [{ type: 'paragraph', content: parseInlineFormatting(cellText.trim(), wikiMode) }]
+                    }));
+                    tableRows.push({ type: 'tableRow', content: headerCells });
+                }
+                else if (tableLine.startsWith('|')) {
+                    // Data row - split on | and filter empties
+                    const cells = tableLine.split('|').filter(c => c !== '');
+                    // Skip separator rows like |-|-|
+                    if (!tableLine.match(/^\|[\s\-:|]+\|?$/)) {
+                        const dataCells = cells.map(cellText => ({
+                            type: 'tableCell',
+                            attrs: {},
+                            content: [{ type: 'paragraph', content: parseInlineFormatting(cellText.trim(), wikiMode) }]
+                        }));
+                        tableRows.push({ type: 'tableRow', content: dataCells });
+                    }
+                }
+                tableIdx++;
+            }
+            if (tableRows.length > 0) {
+                applyColWidths(tableRows);
+                content.push({
+                    type: 'table',
+                    attrs: { isNumberColumnEnabled: false, layout: 'default' },
+                    content: tableRows
+                });
+                i = tableIdx - 1; // -1 because the for loop will increment
+                continue;
+            }
         }
         // Handle markdown tables - convert to proper ADF table structure
         else if (line.includes('|') && line.trim() !== '|') {
@@ -454,7 +788,7 @@ export function parseDescriptionToADF(description) {
                             attrs: {},
                             content: [{
                                     type: 'paragraph',
-                                    content: parseInlineFormatting(cellText)
+                                    content: parseInlineFormatting(cellText, wikiMode)
                                 }]
                         }));
                         tableRows.push({
@@ -469,7 +803,7 @@ export function parseDescriptionToADF(description) {
                             attrs: {},
                             content: [{
                                     type: 'paragraph',
-                                    content: parseInlineFormatting(cellText)
+                                    content: parseInlineFormatting(cellText, wikiMode)
                                 }]
                         }));
                         tableRows.push({
@@ -477,6 +811,7 @@ export function parseDescriptionToADF(description) {
                             content: dataCells
                         });
                     }
+                    applyColWidths(tableRows);
                     // Create the complete table structure
                     content.push({
                         type: 'table',
@@ -494,14 +829,14 @@ export function parseDescriptionToADF(description) {
             // If we reach here, it's not a valid table, treat as regular paragraph
             content.push({
                 type: 'paragraph',
-                content: parseInlineFormatting(line)
+                content: parseInlineFormatting(line, wikiMode)
             });
         }
         // Regular paragraph
         else {
             content.push({
                 type: 'paragraph',
-                content: parseInlineFormatting(line)
+                content: parseInlineFormatting(line, wikiMode)
             });
         }
     }
@@ -525,14 +860,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 +970,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 data-layout="default" data-table-width="760">' + buildColGroupHtml(tableRows) + '<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