confluence-cli 1.3.2 → 1.4.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.4.1](https://github.com/pchuri/confluence-cli/compare/v1.4.0...v1.4.1) (2025-06-30)
+
+
+### Bug Fixes
+
+* correct version display in CLI ([#6](https://github.com/pchuri/confluence-cli/issues/6)) ([36f8419](https://github.com/pchuri/confluence-cli/commit/36f8419b309ae1ff99fa94c12ace9a527ee3f162))
+
+# [1.4.0](https://github.com/pchuri/confluence-cli/compare/v1.3.2...v1.4.0) (2025-06-30)
+
+
+### Features
+
+* Enhanced Markdown Support with Bidirectional Conversion ([#5](https://github.com/pchuri/confluence-cli/issues/5)) ([d17771b](https://github.com/pchuri/confluence-cli/commit/d17771b40d8d60ed68c0ac0a3594fed6b9a4e771))
+
 ## [1.3.2](https://github.com/pchuri/confluence-cli/compare/v1.3.1...v1.3.2) (2025-06-27)
 
 

package/CONTRIBUTING.md

@@ -126,6 +126,32 @@ node bin/confluence.js read 123456789
 - Add comments for complex logic
 - Keep functions small and focused
 
+### Markdown Support
+
+The CLI includes enhanced markdown support with:
+
+- **Native Confluence Storage Format**: Converts markdown to native Confluence elements instead of HTML macros
+- **Confluence Extensions**: Support for admonitions (`[!info]`, `[!warning]`, `[!note]`)
+- **Bidirectional Conversion**: Convert from markdown to storage format and back
+- **Rich Elements**: Tables, code blocks, lists, links, and formatting
+
+Example markdown with Confluence extensions:
+```markdown
+# My Page
+
+[!info]
+This is an info admonition that will render as a Confluence info macro.
+
+```javascript
+console.log("Code blocks preserve syntax highlighting");
+```
+
+| Feature | Status |
+|---------|--------|
+| Tables  | ✅     |
+| Lists   | ✅     |
+```
+
 ### File Structure
 
 ```

package/bin/confluence.js

@@ -5,11 +5,12 @@ const chalk = require('chalk');
 const ConfluenceClient = require('../lib/confluence-client');
 const { getConfig, initConfig } = require('../lib/config');
 const Analytics = require('../lib/analytics');
+const pkg = require('../package.json');
 
 program
   .name('confluence')
   .description('CLI tool for Atlassian Confluence')
-  .version('1.0.0');
+  .version(pkg.version);
 
 // Init command
 program
@@ -23,7 +24,7 @@ program
 program
   .command('read <pageId>')
   .description('Read a Confluence page by ID or URL')
-  .option('-f, --format <format>', 'Output format (html, text)', 'text')
+  .option('-f, --format <format>', 'Output format (html, text, markdown)', 'text')
   .action(async (pageId, options) => {
     const analytics = new Analytics();
     try {

package/lib/confluence-client.js

@@ -8,6 +8,7 @@ class ConfluenceClient {
     this.token = config.token;
     this.domain = config.domain;
     this.markdown = new MarkdownIt();
+    this.setupConfluenceMarkdownExtensions();
     
     this.client = axios.create({
       baseURL: this.baseURL,
@@ -62,6 +63,10 @@ class ConfluenceClient {
       return htmlContent;
     }
     
+    if (format === 'markdown') {
+      return this.storageToMarkdown(htmlContent);
+    }
+    
     // Convert HTML to text
     return convert(htmlContent, {
       wordwrap: 80,
@@ -139,11 +144,94 @@ class ConfluenceClient {
    * Convert markdown to Confluence storage format
    */
   markdownToStorage(markdown) {
-    // Use Confluence's markdown macro instead of HTML
-    return `<ac:structured-macro ac:name="markdown">
-      <ac:parameter ac:name="atlassian-macro-output-type">BLOCK</ac:parameter>
-      <ac:plain-text-body><![CDATA[${markdown}]]></ac:plain-text-body>
-    </ac:structured-macro>`;
+    // Convert markdown to HTML first
+    const html = this.markdown.render(markdown);
+    
+    // Convert HTML to native Confluence storage format elements
+    return this.htmlToConfluenceStorage(html);
+  }
+
+  /**
+   * Convert HTML to native Confluence storage format
+   */
+  htmlToConfluenceStorage(html) {
+    let storage = html;
+    
+    // Convert headings to native Confluence format
+    storage = storage.replace(/<h([1-6])>(.*?)<\/h[1-6]>/g, '<h$1>$2</h$1>');
+    
+    // Convert paragraphs
+    storage = storage.replace(/<p>(.*?)<\/p>/g, '<p>$1</p>');
+    
+    // Convert strong/bold text
+    storage = storage.replace(/<strong>(.*?)<\/strong>/g, '<strong>$1</strong>');
+    
+    // Convert emphasis/italic text
+    storage = storage.replace(/<em>(.*?)<\/em>/g, '<em>$1</em>');
+    
+    // Convert unordered lists
+    storage = storage.replace(/<ul>(.*?)<\/ul>/gs, '<ul>$1</ul>');
+    storage = storage.replace(/<li>(.*?)<\/li>/g, '<li><p>$1</p></li>');
+    
+    // Convert ordered lists
+    storage = storage.replace(/<ol>(.*?)<\/ol>/gs, '<ol>$1</ol>');
+    
+    // Convert code blocks to Confluence code macro
+    storage = storage.replace(/<pre><code(?:\s+class="language-(\w+)")?>(.*?)<\/code><\/pre>/gs, (_, lang, code) => {
+      const language = lang || 'text';
+      return `<ac:structured-macro ac:name="code">
+        <ac:parameter ac:name="language">${language}</ac:parameter>
+        <ac:plain-text-body><![CDATA[${code}]]></ac:plain-text-body>
+      </ac:structured-macro>`;
+    });
+    
+    // Convert inline code
+    storage = storage.replace(/<code>(.*?)<\/code>/g, '<code>$1</code>');
+    
+    // Convert blockquotes to appropriate macros based on content
+    storage = storage.replace(/<blockquote>(.*?)<\/blockquote>/gs, (_, content) => {
+      // Check for admonition patterns
+      if (content.includes('<strong>INFO</strong>')) {
+        const cleanContent = content.replace(/<p><strong>INFO<\/strong><\/p>\s*/, '');
+        return `<ac:structured-macro ac:name="info">
+          <ac:rich-text-body>${cleanContent}</ac:rich-text-body>
+        </ac:structured-macro>`;
+      } else if (content.includes('<strong>WARNING</strong>')) {
+        const cleanContent = content.replace(/<p><strong>WARNING<\/strong><\/p>\s*/, '');
+        return `<ac:structured-macro ac:name="warning">
+          <ac:rich-text-body>${cleanContent}</ac:rich-text-body>
+        </ac:structured-macro>`;
+      } else if (content.includes('<strong>NOTE</strong>')) {
+        const cleanContent = content.replace(/<p><strong>NOTE<\/strong><\/p>\s*/, '');
+        return `<ac:structured-macro ac:name="note">
+          <ac:rich-text-body>${cleanContent}</ac:rich-text-body>
+        </ac:structured-macro>`;
+      } else {
+        // Default to info macro for regular blockquotes
+        return `<ac:structured-macro ac:name="info">
+          <ac:rich-text-body>${content}</ac:rich-text-body>
+        </ac:structured-macro>`;
+      }
+    });
+    
+    // Convert tables
+    storage = storage.replace(/<table>(.*?)<\/table>/gs, '<table>$1</table>');
+    storage = storage.replace(/<thead>(.*?)<\/thead>/gs, '<thead>$1</thead>');
+    storage = storage.replace(/<tbody>(.*?)<\/tbody>/gs, '<tbody>$1</tbody>');
+    storage = storage.replace(/<tr>(.*?)<\/tr>/gs, '<tr>$1</tr>');
+    storage = storage.replace(/<th>(.*?)<\/th>/g, '<th><p>$1</p></th>');
+    storage = storage.replace(/<td>(.*?)<\/td>/g, '<td><p>$1</p></td>');
+    
+    // Convert links
+    storage = storage.replace(/<a href="(.*?)">(.*?)<\/a>/g, '<ac:link><ri:url ri:value="$1" /><ac:plain-text-link-body><![CDATA[$2]]></ac:plain-text-link-body></ac:link>');
+    
+    // Convert horizontal rules
+    storage = storage.replace(/<hr\s*\/?>/g, '<hr />');
+    
+    // Clean up any remaining HTML entities and normalize whitespace
+    storage = storage.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+    
+    return storage;
   }
 
   /**
@@ -182,6 +270,217 @@ class ConfluenceClient {
     return storage;
   }
 
+  /**
+   * Setup Confluence-specific markdown extensions
+   */
+  setupConfluenceMarkdownExtensions() {
+    // Enable additional markdown-it features
+    this.markdown.enable(['table', 'strikethrough', 'linkify']);
+    
+    // Add custom rule for Confluence macros in markdown
+    this.markdown.core.ruler.before('normalize', 'confluence_macros', (state) => {
+      const src = state.src;
+      
+      // Convert [!info] admonitions to info macro
+      state.src = src.replace(/\[!info\]\s*([\s\S]*?)(?=\n\s*\n|\n\s*\[!|$)/g, (_, content) => {
+        return `> **INFO**\n> ${content.trim().replace(/\n/g, '\n> ')}`;
+      });
+      
+      // Convert [!warning] admonitions to warning macro
+      state.src = state.src.replace(/\[!warning\]\s*([\s\S]*?)(?=\n\s*\n|\n\s*\[!|$)/g, (_, content) => {
+        return `> **WARNING**\n> ${content.trim().replace(/\n/g, '\n> ')}`;
+      });
+      
+      // Convert [!note] admonitions to note macro
+      state.src = state.src.replace(/\[!note\]\s*([\s\S]*?)(?=\n\s*\n|\n\s*\[!|$)/g, (_, content) => {
+        return `> **NOTE**\n> ${content.trim().replace(/\n/g, '\n> ')}`;
+      });
+      
+      // Convert task lists to proper format
+      state.src = state.src.replace(/^(\s*)- \[([ x])\] (.+)$/gm, (_, indent, checked, text) => {
+        return `${indent}- [${checked}] ${text}`;
+      });
+    });
+  }
+
+  /**
+   * Convert Confluence storage format to markdown
+   */
+  storageToMarkdown(storage) {
+    let markdown = storage;
+    
+    // Remove table of contents macro
+    markdown = markdown.replace(/<ac:structured-macro ac:name="toc"[^>]*\s*\/>/g, '');
+    markdown = markdown.replace(/<ac:structured-macro ac:name="toc"[^>]*>[\s\S]*?<\/ac:structured-macro>/g, '');
+    
+    // Convert Confluence code macros to markdown
+    markdown = markdown.replace(/<ac:structured-macro ac:name="code"[^>]*>[\s\S]*?<ac:parameter ac:name="language">([^<]*)<\/ac:parameter>[\s\S]*?<ac:plain-text-body><!\[CDATA\[([\s\S]*?)\]\]><\/ac:plain-text-body>[\s\S]*?<\/ac:structured-macro>/g, (_, lang, code) => {
+      return `\`\`\`${lang}\n${code}\n\`\`\``;
+    });
+    
+    // Convert code macros without language parameter
+    markdown = markdown.replace(/<ac:structured-macro ac:name="code"[^>]*>[\s\S]*?<ac:plain-text-body><!\[CDATA\[([\s\S]*?)\]\]><\/ac:plain-text-body>[\s\S]*?<\/ac:structured-macro>/g, (_, code) => {
+      return `\`\`\`\n${code}\n\`\`\``;
+    });
+    
+    // Convert info macro to admonition
+    markdown = markdown.replace(/<ac:structured-macro ac:name="info"[^>]*>[\s\S]*?<ac:rich-text-body>([\s\S]*?)<\/ac:rich-text-body>[\s\S]*?<\/ac:structured-macro>/g, (_, content) => {
+      const cleanContent = this.htmlToMarkdown(content);
+      return `[!info]\n${cleanContent}`;
+    });
+    
+    // Convert warning macro to admonition
+    markdown = markdown.replace(/<ac:structured-macro ac:name="warning"[^>]*>[\s\S]*?<ac:rich-text-body>([\s\S]*?)<\/ac:rich-text-body>[\s\S]*?<\/ac:structured-macro>/g, (_, content) => {
+      const cleanContent = this.htmlToMarkdown(content);
+      return `[!warning]\n${cleanContent}`;
+    });
+    
+    // Convert note macro to admonition  
+    markdown = markdown.replace(/<ac:structured-macro ac:name="note"[^>]*>[\s\S]*?<ac:rich-text-body>([\s\S]*?)<\/ac:rich-text-body>[\s\S]*?<\/ac:structured-macro>/g, (_, content) => {
+      const cleanContent = this.htmlToMarkdown(content);
+      return `[!note]\n${cleanContent}`;
+    });
+    
+    // Remove other unhandled macros (replace with empty string for now)
+    markdown = markdown.replace(/<ac:structured-macro[^>]*>[\s\S]*?<\/ac:structured-macro>/g, '');
+    
+    // Convert links
+    markdown = markdown.replace(/<ac:link><ri:url ri:value="([^"]*)" \/><ac:plain-text-link-body><!\[CDATA\[([^\]]*)\]\]><\/ac:plain-text-link-body><\/ac:link>/g, '[$2]($1)');
+    
+    // Convert remaining HTML to markdown
+    markdown = this.htmlToMarkdown(markdown);
+    
+    return markdown;
+  }
+
+  /**
+   * Convert basic HTML to markdown
+   */
+  htmlToMarkdown(html) {
+    let markdown = html;
+    
+    // Convert strong/bold BEFORE removing HTML attributes
+    markdown = markdown.replace(/<strong[^>]*>(.*?)<\/strong>/g, '**$1**');
+    
+    // Convert emphasis/italic BEFORE removing HTML attributes
+    markdown = markdown.replace(/<em[^>]*>(.*?)<\/em>/g, '*$1*');
+    
+    // Convert code BEFORE removing HTML attributes
+    markdown = markdown.replace(/<code[^>]*>(.*?)<\/code>/g, '`$1`');
+    
+    // Remove HTML attributes from tags (but preserve content formatting)
+    markdown = markdown.replace(/<(\w+)[^>]*>/g, '<$1>');
+    markdown = markdown.replace(/<\/(\w+)[^>]*>/g, '</$1>');
+    
+    // Convert headings first (they don't contain other elements typically)
+    markdown = markdown.replace(/<h([1-6])>(.*?)<\/h[1-6]>/g, (_, level, text) => {
+      return '\n' + '#'.repeat(parseInt(level)) + ' ' + text.trim() + '\n';
+    });
+    
+    // Convert tables BEFORE paragraphs
+    markdown = markdown.replace(/<table>(.*?)<\/table>/gs, (_, content) => {
+      const rows = [];
+      let isHeader = true;
+      
+      // Extract table rows
+      const rowMatches = content.match(/<tr>(.*?)<\/tr>/gs);
+      if (rowMatches) {
+        rowMatches.forEach(rowMatch => {
+          const cells = [];
+          const cellContent = rowMatch.replace(/<tr>(.*?)<\/tr>/s, '$1');
+          
+          // Extract cells (th or td)
+          const cellMatches = cellContent.match(/<t[hd]>(.*?)<\/t[hd]>/gs);
+          if (cellMatches) {
+            cellMatches.forEach(cellMatch => {
+              let cellText = cellMatch.replace(/<t[hd]>(.*?)<\/t[hd]>/s, '$1');
+              // Clean up cell content - remove nested HTML but preserve text and some formatting
+              cellText = cellText.replace(/<p>/g, '').replace(/<\/p>/g, ' ');
+              cellText = cellText.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+              cells.push(cellText || ' ');
+            });
+          }
+          
+          if (cells.length > 0) {
+            rows.push('| ' + cells.join(' | ') + ' |');
+            
+            if (isHeader) {
+              rows.push('| ' + cells.map(() => '---').join(' | ') + ' |');
+              isHeader = false;
+            }
+          }
+        });
+      }
+      
+      return rows.length > 0 ? '\n' + rows.join('\n') + '\n' : '';
+    });
+    
+    // Convert unordered lists BEFORE paragraphs
+    markdown = markdown.replace(/<ul>(.*?)<\/ul>/gs, (_, content) => {
+      let listItems = '';
+      const itemMatches = content.match(/<li>(.*?)<\/li>/gs);
+      if (itemMatches) {
+        itemMatches.forEach(itemMatch => {
+          let itemText = itemMatch.replace(/<li>(.*?)<\/li>/s, '$1');
+          // Clean up nested HTML but preserve some formatting
+          itemText = itemText.replace(/<p>/g, '').replace(/<\/p>/g, ' ');
+          itemText = itemText.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          if (itemText) {
+            listItems += '- ' + itemText + '\n';
+          }
+        });
+      }
+      return '\n' + listItems;
+    });
+    
+    // Convert ordered lists BEFORE paragraphs
+    markdown = markdown.replace(/<ol>(.*?)<\/ol>/gs, (_, content) => {
+      let listItems = '';
+      let counter = 1;
+      const itemMatches = content.match(/<li>(.*?)<\/li>/gs);
+      if (itemMatches) {
+        itemMatches.forEach(itemMatch => {
+          let itemText = itemMatch.replace(/<li>(.*?)<\/li>/s, '$1');
+          // Clean up nested HTML but preserve some formatting
+          itemText = itemText.replace(/<p>/g, '').replace(/<\/p>/g, ' ');
+          itemText = itemText.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          if (itemText) {
+            listItems += `${counter++}. ${itemText}\n`;
+          }
+        });
+      }
+      return '\n' + listItems;
+    });
+    
+    // Convert paragraphs (after lists and tables)
+    markdown = markdown.replace(/<p>(.*?)<\/p>/g, (_, content) => {
+      return content.trim() + '\n';
+    });
+    
+    // Convert line breaks
+    markdown = markdown.replace(/<br\s*\/?>/g, '\n');
+    
+    // Convert horizontal rules
+    markdown = markdown.replace(/<hr\s*\/?>/g, '\n---\n');
+    
+    // Remove any remaining HTML tags
+    markdown = markdown.replace(/<[^>]+>/g, ' ');
+    
+    // Clean up whitespace and HTML entities
+    markdown = markdown.replace(/&nbsp;/g, ' ');
+    markdown = markdown.replace(/&lt;/g, '<');
+    markdown = markdown.replace(/&gt;/g, '>');
+    markdown = markdown.replace(/&amp;/g, '&');
+    markdown = markdown.replace(/&quot;/g, '"');
+    
+    // Clean up extra whitespace
+    markdown = markdown.replace(/\n\s*\n\s*\n+/g, '\n\n');
+    markdown = markdown.replace(/[ \t]+/g, ' ');
+    markdown = markdown.trim();
+    
+    return markdown;
+  }
+
   /**
    * Create a new Confluence page
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "confluence-cli",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "A command-line interface for Atlassian Confluence with page creation and editing capabilities",
   "main": "index.js",
   "bin": {
@@ -19,7 +19,7 @@
     "wiki",
     "documentation"
   ],
-  "author": "Your Name",
+  "author": "pchuri",
   "license": "MIT",
   "dependencies": {
     "axios": "^1.6.2",

package/tests/confluence-client.test.js

@@ -28,14 +28,121 @@ describe('ConfluenceClient', () => {
   });
 
   describe('markdownToStorage', () => {
-    test('should convert markdown to Confluence storage format', () => {
-      const markdown = '# Hello World\n\nThis is a **test** page.';
+    test('should convert basic markdown to native Confluence storage format', () => {
+      const markdown = '# Hello World\n\nThis is a **test** page with *italic* text.';
       const result = client.markdownToStorage(markdown);
       
-      expect(result).toContain('<ac:structured-macro ac:name="markdown">');
-      expect(result).toContain('Hello World');
+      expect(result).toContain('<h1>Hello World</h1>');
+      expect(result).toContain('<p>This is a <strong>test</strong> page with <em>italic</em> text.</p>');
+      expect(result).not.toContain('<ac:structured-macro ac:name="html">');
+    });
+
+    test('should convert code blocks to Confluence code macro', () => {
+      const markdown = '```javascript\nconsole.log("Hello World");\n```';
+      const result = client.markdownToStorage(markdown);
+      
+      expect(result).toContain('<ac:structured-macro ac:name="code">');
+      expect(result).toContain('<ac:parameter ac:name="language">javascript</ac:parameter>');
+      expect(result).toContain('console.log(&quot;Hello World&quot;);');
+    });
+
+    test('should convert lists to native Confluence format', () => {
+      const markdown = '- Item 1\n- Item 2\n\n1. First\n2. Second';
+      const result = client.markdownToStorage(markdown);
+      
+      expect(result).toContain('<ul>');
+      expect(result).toContain('<li><p>Item 1</p></li>');
+      expect(result).toContain('<ol>');
+      expect(result).toContain('<li><p>First</p></li>');
+    });
+
+    test('should convert Confluence admonitions', () => {
+      const markdown = '[!info]\nThis is an info message';
+      const result = client.markdownToStorage(markdown);
+      
+      expect(result).toContain('<ac:structured-macro ac:name="info">');
+      expect(result).toContain('This is an info message');
+    });
+
+    test('should convert tables to native Confluence format', () => {
+      const markdown = '| Header 1 | Header 2 |\n|----------|----------|\n| Cell 1   | Cell 2   |';
+      const result = client.markdownToStorage(markdown);
+      
+      expect(result).toContain('<table>');
+      expect(result).toContain('<th><p>Header 1</p></th>');
+      expect(result).toContain('<td><p>Cell 1</p></td>');
+    });
+
+    test('should convert links to Confluence link format', () => {
+      const markdown = '[Example Link](https://example.com)';
+      const result = client.markdownToStorage(markdown);
+      
+      expect(result).toContain('<ac:link>');
+      expect(result).toContain('ri:value="https://example.com"');
+      expect(result).toContain('Example Link');
+    });
+  });
+
+  describe('storageToMarkdown', () => {
+    test('should convert Confluence storage format to markdown', () => {
+      const storage = '<h1>Hello World</h1><p>This is a <strong>test</strong> page.</p>';
+      const result = client.storageToMarkdown(storage);
+      
+      expect(result).toContain('# Hello World');
       expect(result).toContain('**test**');
     });
+
+    test('should convert Confluence code macro to markdown', () => {
+      const storage = '<ac:structured-macro ac:name="code"><ac:parameter ac:name="language">javascript</ac:parameter><ac:plain-text-body><![CDATA[console.log("Hello");]]></ac:plain-text-body></ac:structured-macro>';
+      const result = client.storageToMarkdown(storage);
+      
+      expect(result).toContain('```javascript');
+      expect(result).toContain('console.log("Hello");');
+      expect(result).toContain('```');
+    });
+
+    test('should convert Confluence macros to admonitions', () => {
+      const storage = '<ac:structured-macro ac:name="info"><ac:rich-text-body><p>This is info</p></ac:rich-text-body></ac:structured-macro>';
+      const result = client.storageToMarkdown(storage);
+      
+      expect(result).toContain('[!info]');
+      expect(result).toContain('This is info');
+    });
+
+    test('should convert Confluence links to markdown', () => {
+      const storage = '<ac:link><ri:url ri:value="https://example.com" /><ac:plain-text-link-body><![CDATA[Example]]></ac:plain-text-link-body></ac:link>';
+      const result = client.storageToMarkdown(storage);
+      
+      expect(result).toContain('[Example](https://example.com)');
+    });
+  });
+
+  describe('htmlToMarkdown', () => {
+    test('should convert basic HTML to markdown', () => {
+      const html = '<h2>Title</h2><p>Some <strong>bold</strong> and <em>italic</em> text.</p>';
+      const result = client.htmlToMarkdown(html);
+      
+      expect(result).toContain('## Title');
+      expect(result).toContain('**bold**');
+      expect(result).toContain('*italic*');
+    });
+
+    test('should convert HTML lists to markdown', () => {
+      const html = '<ul><li><p>Item 1</p></li><li><p>Item 2</p></li></ul>';
+      const result = client.htmlToMarkdown(html);
+      
+      expect(result).toContain('- Item 1');
+      expect(result).toContain('- Item 2');
+    });
+
+    test('should convert HTML tables to markdown', () => {
+      const html = '<table><tr><th><p>Header</p></th></tr><tr><td><p>Cell</p></td></tr></table>';
+      const result = client.htmlToMarkdown(html);
+      
+      expect(result).toContain('| Header |');
+      expect(result).toContain('| --- |');
+      expect(result).toContain('| Cell |');
+    });
   });
 
   describe('page creation and updates', () => {