myaidev-method 0.3.2 → 0.3.4

package/dist/mcp/gutenberg-converter.js

@@ -5,443 +5,697 @@
  */
 
 export class GutenbergConverter {
-  /**
-   * Convert HTML content to Gutenberg blocks
-   * @param {string} html - HTML content to convert
-   * @returns {string} - Gutenberg block formatted content
-   */
-  static htmlToGutenberg(html) {
-    // Parse HTML and convert to blocks
-    let gutenbergContent = '';
-    
-    // Split content into sections for processing
-    const sections = this.parseHTMLSections(html);
-    
-    sections.forEach(section => {
-      const block = this.createBlock(section);
-      if (block) {
-        gutenbergContent += block + '\n\n';
-      }
-    });
-    
-    return gutenbergContent.trim();
-  }
-
-  /**
-   * Parse HTML into sections for block conversion
-   */
-  static parseHTMLSections(html) {
-    const sections = [];
-    
-    // Remove excess whitespace and normalize
-    const normalizedHtml = html.replace(/\n\s*\n/g, '\n').trim();
-    
-    // Regular expressions for different HTML elements
-    const patterns = {
-      heading: /<h([1-6])(?:\s[^>]*)?>(.+?)<\/h\1>/gi,
-      paragraph: /<p(?:\s[^>]*)?>(.+?)<\/p>/gi,
-      list: /<(ul|ol)(?:\s[^>]*)?>(.+?)<\/\1>/gis,
-      blockquote: /<blockquote(?:\s[^>]*)?>(.+?)<\/blockquote>/gis,
-      pre: /<pre(?:\s[^>]*)?><code(?:\s[^>]*)?>(.+?)<\/code><\/pre>/gis,
-      image: /<img\s+([^>]+)>/gi,
-      hr: /<hr(?:\s[^>]*)?>/gi
-    };
-    
-    // Process the HTML string sequentially
-    let lastIndex = 0;
-    const processedParts = [];
-    
-    // Create a combined pattern to find all blocks
-    const combinedPattern = new RegExp(
-      '(' +
-      '<h[1-6](?:\\s[^>]*)?>.*?</h[1-6]>|' +
-      '<p(?:\\s[^>]*)?>.*?</p>|' +
-      '<(?:ul|ol)(?:\\s[^>]*)?>.*?</(?:ul|ol)>|' +
-      '<blockquote(?:\\s[^>]*)?>.*?</blockquote>|' +
-      '<pre(?:\\s[^>]*)?><code(?:\\s[^>]*)?>.*?</code></pre>|' +
-      '<img\\s+[^>]+>|' +
-      '<hr(?:\\s[^>]*)?>' +
-      ')',
-      'gis'
-    );
-    
-    let match;
-    while ((match = combinedPattern.exec(normalizedHtml)) !== null) {
-      // Add any text between matches as a paragraph
-      if (match.index > lastIndex) {
-        const text = normalizedHtml.substring(lastIndex, match.index).trim();
-        if (text && !text.match(/^\s*$/)) {
-          sections.push({ type: 'paragraph', content: this.stripTags(text) });
-        }
-      }
-      
-      const fullMatch = match[0];
-      
-      // Determine block type and extract content
-      if (fullMatch.match(/<h([1-6])/i)) {
-        const level = fullMatch.match(/<h([1-6])/i)[1];
-        const content = fullMatch.replace(/<\/?h[1-6](?:\s[^>]*)?>/gi, '');
-        sections.push({ type: 'heading', level: parseInt(level), content: this.stripTags(content) });
-      }
-      else if (fullMatch.match(/<p(?:\s|>)/i)) {
-        const content = fullMatch.replace(/<\/?p(?:\s[^>]*)?>/gi, '');
-        sections.push({ type: 'paragraph', content: this.stripTags(content) });
-      }
-      else if (fullMatch.match(/<(ul|ol)/i)) {
-        const listType = fullMatch.match(/<(ul|ol)/i)[1];
-        const items = this.parseListItems(fullMatch);
-        sections.push({ type: 'list', ordered: listType === 'ol', items });
-      }
-      else if (fullMatch.match(/<blockquote/i)) {
-        const content = fullMatch.replace(/<\/?blockquote(?:\s[^>]*)?>/gi, '');
-        sections.push({ type: 'quote', content: this.stripTags(content) });
-      }
-      else if (fullMatch.match(/<pre/i)) {
-        const content = fullMatch.replace(/<\/?(?:pre|code)(?:\s[^>]*)?>/gi, '');
-        sections.push({ type: 'code', content: this.decodeHtml(content) });
-      }
-      else if (fullMatch.match(/<img/i)) {
-        const attrs = this.parseImageAttributes(fullMatch);
-        sections.push({ type: 'image', ...attrs });
-      }
-      else if (fullMatch.match(/<hr/i)) {
-        sections.push({ type: 'separator' });
-      }
-      
-      lastIndex = match.index + fullMatch.length;
-    }
-    
-    // Add any remaining content
-    if (lastIndex < normalizedHtml.length) {
-      const text = normalizedHtml.substring(lastIndex).trim();
-      if (text && !text.match(/^\s*$/)) {
-        sections.push({ type: 'paragraph', content: this.stripTags(text) });
-      }
-    }
-    
-    return sections;
-  }
-
-  /**
-   * Parse list items from HTML list
-   */
-  static parseListItems(listHtml) {
-    const items = [];
-    const itemPattern = /<li(?:\s[^>]*)?>(.+?)<\/li>/gis;
-    let match;
-    
-    while ((match = itemPattern.exec(listHtml)) !== null) {
-      items.push(this.stripTags(match[1].trim()));
-    }
-    
-    return items;
-  }
-
-  /**
-   * Parse image attributes from img tag
-   */
-  static parseImageAttributes(imgTag) {
-    const attrs = {};
-    
-    // Extract src
-    const srcMatch = imgTag.match(/src=["']([^"']+)["']/i);
-    if (srcMatch) attrs.url = srcMatch[1];
-    
-    // Extract alt text
-    const altMatch = imgTag.match(/alt=["']([^"']+)["']/i);
-    if (altMatch) attrs.alt = altMatch[1];
-    
-    // Extract title
-    const titleMatch = imgTag.match(/title=["']([^"']+)["']/i);
-    if (titleMatch) attrs.caption = titleMatch[1];
-    
-    return attrs;
-  }
-
-  /**
-   * Create a Gutenberg block from a section
-   */
-  static createBlock(section) {
-    switch (section.type) {
-      case 'heading':
-        return this.createHeadingBlock(section.level, section.content);
-      
-      case 'paragraph':
-        return this.createParagraphBlock(section.content);
-      
-      case 'list':
-        return this.createListBlock(section.items, section.ordered);
-      
-      case 'quote':
-        return this.createQuoteBlock(section.content);
-      
-      case 'code':
-        return this.createCodeBlock(section.content);
-      
-      case 'image':
-        return this.createImageBlock(section.url, section.alt, section.caption);
-      
-      case 'separator':
-        return this.createSeparatorBlock();
-      
-      default:
-        return this.createParagraphBlock(section.content || '');
-    }
-  }
-
-  /**
-   * Create heading block
-   */
-  static createHeadingBlock(level, content) {
-    return `<!-- wp:heading {"level":${level}} -->
+	/**
+	 * Convert HTML content to Gutenberg blocks
+	 * @param {string} html - HTML content to convert
+	 * @returns {string} - Gutenberg block formatted content
+	 */
+	static htmlToGutenberg(html) {
+		// Parse HTML and convert to blocks
+		let gutenbergContent = "";
+
+		// Split content into sections for processing
+		const sections = this.parseHTMLSections(html);
+
+		sections.forEach((section) => {
+			const block = this.createBlock(section);
+			if (block) {
+				gutenbergContent += block + "\n\n";
+			}
+		});
+
+		return gutenbergContent.trim();
+	}
+
+	/**
+	 * Parse HTML into sections for block conversion
+	 */
+	static parseHTMLSections(html) {
+		const sections = [];
+
+		// Remove excess whitespace and normalize
+		const normalizedHtml = html.replace(/\n\s*\n/g, "\n").trim();
+
+		// Regular expressions for different HTML elements
+		const patterns = {
+			heading: /<h([1-6])(?:\s[^>]*)?>(.+?)<\/h\1>/gi,
+			paragraph: /<p(?:\s[^>]*)?>(.+?)<\/p>/gi,
+			list: /<(ul|ol)(?:\s[^>]*)?>(.+?)<\/\1>/gis,
+			blockquote: /<blockquote(?:\s[^>]*)?>(.+?)<\/blockquote>/gis,
+			pre: /<pre(?:\s[^>]*)?><code(?:\s[^>]*)?>(.+?)<\/code><\/pre>/gis,
+			image: /<img\s+([^>]+)>/gi,
+			hr: /<hr(?:\s[^>]*)?>/gi,
+		};
+
+		// Process the HTML string sequentially
+		let lastIndex = 0;
+		const processedParts = [];
+
+		// Create a combined pattern to find all blocks
+		const combinedPattern = new RegExp(
+			"(" +
+				"<h[1-6](?:\\s[^>]*)?>.*?</h[1-6]>|" +
+				"<p(?:\\s[^>]*)?>.*?</p>|" +
+				"<(?:ul|ol)(?:\\s[^>]*)?>.*?</(?:ul|ol)>|" +
+				"<blockquote(?:\\s[^>]*)?>.*?</blockquote>|" +
+				"<pre(?:\\s[^>]*)?><code(?:\\s[^>]*)?>.*?</code></pre>|" +
+				"<img\\s+[^>]+>|" +
+				"<hr(?:\\s[^>]*)?>" +
+				")",
+			"gis",
+		);
+
+		let match;
+		while ((match = combinedPattern.exec(normalizedHtml)) !== null) {
+			// Add any text between matches as a paragraph
+			if (match.index > lastIndex) {
+				const text = normalizedHtml.substring(lastIndex, match.index).trim();
+				if (text && !text.match(/^\s*$/)) {
+					sections.push({ type: "paragraph", content: this.stripTags(text) });
+				}
+			}
+
+			const fullMatch = match[0];
+
+			// Determine block type and extract content
+			if (fullMatch.match(/<h([1-6])/i)) {
+				const level = fullMatch.match(/<h([1-6])/i)[1];
+				const content = fullMatch.replace(/<\/?h[1-6](?:\s[^>]*)?>/gi, "");
+				sections.push({
+					type: "heading",
+					level: parseInt(level),
+					content: this.stripTags(content),
+				});
+			} else if (fullMatch.match(/<p(?:\s|>)/i)) {
+				const content = fullMatch.replace(/<\/?p(?:\s[^>]*)?>/gi, "");
+				sections.push({ type: "paragraph", content: this.stripTags(content) });
+			} else if (fullMatch.match(/<(ul|ol)/i)) {
+				const listType = fullMatch.match(/<(ul|ol)/i)[1];
+				const items = this.parseListItems(fullMatch);
+				sections.push({ type: "list", ordered: listType === "ol", items });
+			} else if (fullMatch.match(/<blockquote/i)) {
+				const content = fullMatch.replace(/<\/?blockquote(?:\s[^>]*)?>/gi, "");
+				sections.push({ type: "quote", content: this.stripTags(content) });
+			} else if (fullMatch.match(/<pre/i)) {
+				const content = fullMatch.replace(
+					/<\/?(?:pre|code)(?:\s[^>]*)?>/gi,
+					"",
+				);
+				sections.push({ type: "code", content: this.decodeHtml(content) });
+			} else if (fullMatch.match(/<img/i)) {
+				const attrs = this.parseImageAttributes(fullMatch);
+				sections.push({ type: "image", ...attrs });
+			} else if (fullMatch.match(/<hr/i)) {
+				sections.push({ type: "separator" });
+			}
+
+			lastIndex = match.index + fullMatch.length;
+		}
+
+		// Add any remaining content
+		if (lastIndex < normalizedHtml.length) {
+			const text = normalizedHtml.substring(lastIndex).trim();
+			if (text && !text.match(/^\s*$/)) {
+				sections.push({ type: "paragraph", content: this.stripTags(text) });
+			}
+		}
+
+		return sections;
+	}
+
+	/**
+	 * Parse list items from HTML list
+	 */
+	static parseListItems(listHtml) {
+		const items = [];
+		const itemPattern = /<li(?:\s[^>]*)?>(.+?)<\/li>/gis;
+		let match;
+
+		while ((match = itemPattern.exec(listHtml)) !== null) {
+			items.push(this.stripTags(match[1].trim()));
+		}
+
+		return items;
+	}
+
+	/**
+	 * Parse image attributes from img tag
+	 */
+	static parseImageAttributes(imgTag) {
+		const attrs = {};
+
+		// Extract src
+		const srcMatch = imgTag.match(/src=["']([^"']+)["']/i);
+		if (srcMatch) attrs.url = srcMatch[1];
+
+		// Extract alt text
+		const altMatch = imgTag.match(/alt=["']([^"']+)["']/i);
+		if (altMatch) attrs.alt = altMatch[1];
+
+		// Extract title
+		const titleMatch = imgTag.match(/title=["']([^"']+)["']/i);
+		if (titleMatch) attrs.caption = titleMatch[1];
+
+		return attrs;
+	}
+
+	/**
+	 * Create a Gutenberg block from a section
+	 */
+	static createBlock(section) {
+		switch (section.type) {
+			case "heading":
+				return this.createHeadingBlock(section.level, section.content);
+
+			case "paragraph":
+				return this.createParagraphBlock(section.content);
+
+			case "list":
+				return this.createListBlock(section.items, section.ordered);
+
+			case "quote":
+				return this.createQuoteBlock(section.content);
+
+			case "code":
+				return this.createCodeBlock(section.content);
+
+			case "image":
+				return this.createImageBlock(section.url, section.alt, section.caption);
+
+			case "separator":
+				return this.createSeparatorBlock();
+
+			default:
+				return this.createParagraphBlock(section.content || "");
+		}
+	}
+
+	/**
+	 * Create heading block
+	 */
+	static createHeadingBlock(level, content) {
+		return `<!-- wp:heading {"level":${level}} -->
 <h${level} class="wp-block-heading">${this.escapeHtml(content)}</h${level}>
 <!-- /wp:heading -->`;
-  }
-
-  /**
-   * Create paragraph block
-   */
-  static createParagraphBlock(content) {
-    // Handle empty paragraphs
-    if (!content || content.trim() === '') {
-      return '';
-    }
-    
-    return `<!-- wp:paragraph -->
+	}
+
+	/**
+	 * Create paragraph block
+	 */
+	static createParagraphBlock(content) {
+		// Handle empty paragraphs
+		if (!content || content.trim() === "") {
+			return "";
+		}
+
+		return `<!-- wp:paragraph -->
 <p>${this.escapeHtml(content)}</p>
 <!-- /wp:paragraph -->`;
-  }
-
-  /**
-   * Create list block
-   */
-  static createListBlock(items, ordered = false) {
-    const tag = ordered ? 'ol' : 'ul';
-    const blockName = ordered ? 'list' : 'list';
-    const listItems = items.map(item => `<li>${this.escapeHtml(item)}</li>`).join('\n');
-    
-    const attributes = ordered ? ' {"ordered":true}' : '';
-    
-    return `<!-- wp:list${attributes} -->
+	}
+
+	/**
+	 * Create list block
+	 */
+	static createListBlock(items, ordered = false) {
+		const tag = ordered ? "ol" : "ul";
+		const blockName = ordered ? "list" : "list";
+		const listItems = items
+			.map((item) => `<li>${this.escapeHtml(item)}</li>`)
+			.join("\n");
+
+		const attributes = ordered ? ' {"ordered":true}' : "";
+
+		return `<!-- wp:list${attributes} -->
 <${tag} class="wp-block-list">${listItems}</${tag}>
 <!-- /wp:list -->`;
-  }
+	}
 
-  /**
-   * Create quote block
-   */
-  static createQuoteBlock(content) {
-    return `<!-- wp:quote -->
+	/**
+	 * Create quote block
+	 */
+	static createQuoteBlock(content) {
+		return `<!-- wp:quote -->
 <blockquote class="wp-block-quote">
 <p>${this.escapeHtml(content)}</p>
 </blockquote>
 <!-- /wp:quote -->`;
-  }
-
-  /**
-   * Create code block
-   */
-  static createCodeBlock(code) {
-    // Escape the code content for HTML
-    const escapedCode = this.escapeHtml(code);
-    
-    return `<!-- wp:code -->
+	}
+
+	/**
+	 * Create code block
+	 */
+	static createCodeBlock(code) {
+		// Escape the code content for HTML
+		const escapedCode = this.escapeHtml(code);
+
+		return `<!-- wp:code -->
 <pre class="wp-block-code"><code>${escapedCode}</code></pre>
 <!-- /wp:code -->`;
-  }
-
-  /**
-   * Create image block
-   */
-  static createImageBlock(url, alt = '', caption = '') {
-    let attributes = {};
-    if (alt) attributes.alt = alt;
-    
-    const attributesJson = Object.keys(attributes).length > 0 
-      ? ' ' + JSON.stringify(attributes) 
-      : '';
-    
-    let imageHtml = `<!-- wp:image${attributesJson} -->
-<figure class="wp-block-image"><img src="${url}"${alt ? ` alt="${this.escapeHtml(alt)}"` : ''}/>`;
-    
-    if (caption) {
-      imageHtml += `<figcaption class="wp-element-caption">${this.escapeHtml(caption)}</figcaption>`;
-    }
-    
-    imageHtml += `</figure>
+	}
+
+	/**
+	 * Create image block
+	 */
+	static createImageBlock(url, alt = "", caption = "") {
+		let attributes = {};
+		if (alt) attributes.alt = alt;
+
+		const attributesJson =
+			Object.keys(attributes).length > 0
+				? " " + JSON.stringify(attributes)
+				: "";
+
+		let imageHtml = `<!-- wp:image${attributesJson} -->
+<figure class="wp-block-image"><img src="${url}"${alt ? ` alt="${this.escapeHtml(alt)}"` : ""}/>`;
+
+		if (caption) {
+			imageHtml += `<figcaption class="wp-element-caption">${this.escapeHtml(caption)}</figcaption>`;
+		}
+
+		imageHtml += `</figure>
 <!-- /wp:image -->`;
-    
-    return imageHtml;
-  }
-
-  /**
-   * Create separator block
-   */
-  static createSeparatorBlock() {
-    return `<!-- wp:separator -->
+
+		return imageHtml;
+	}
+
+	/**
+	 * Create separator block
+	 */
+	static createSeparatorBlock() {
+		return `<!-- wp:separator -->
 <hr class="wp-block-separator has-alpha-channel-opacity"/>
 <!-- /wp:separator -->`;
-  }
-
-  /**
-   * Create columns block for advanced layouts
-   */
-  static createColumnsBlock(columns) {
-    const columnCount = columns.length;
-    let columnsHtml = `<!-- wp:columns {"columns":${columnCount}} -->\n<div class="wp-block-columns">`;
-    
-    columns.forEach(column => {
-      columnsHtml += `\n<!-- wp:column -->\n<div class="wp-block-column">`;
-      columnsHtml += `\n${column}`;
-      columnsHtml += `\n</div>\n<!-- /wp:column -->`;
-    });
-    
-    columnsHtml += `\n</div>\n<!-- /wp:columns -->`;
-    return columnsHtml;
-  }
-
-  /**
-   * Create button block
-   */
-  static createButtonBlock(text, url = '#', align = 'none') {
-    return `<!-- wp:buttons {"layout":{"type":"flex","justifyContent":"${align}"}} -->
+	}
+
+	/**
+	 * Create columns block for advanced layouts
+	 */
+	static createColumnsBlock(columns) {
+		const columnCount = columns.length;
+		let columnsHtml = `<!-- wp:columns {"columns":${columnCount}} -->\n<div class="wp-block-columns">`;
+
+		columns.forEach((column) => {
+			columnsHtml += `\n<!-- wp:column -->\n<div class="wp-block-column">`;
+			columnsHtml += `\n${column}`;
+			columnsHtml += `\n</div>\n<!-- /wp:column -->`;
+		});
+
+		columnsHtml += `\n</div>\n<!-- /wp:columns -->`;
+		return columnsHtml;
+	}
+
+	/**
+	 * Create button block
+	 */
+	static createButtonBlock(text, url = "#", align = "none") {
+		return `<!-- wp:buttons {"layout":{"type":"flex","justifyContent":"${align}"}} -->
 <div class="wp-block-buttons">
 <!-- wp:button -->
 <div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="${url}">${this.escapeHtml(text)}</a></div>
 <!-- /wp:button -->
 </div>
 <!-- /wp:buttons -->`;
-  }
+	}
 
-  /**
-   * Create table block
-   */
-  static createTableBlock(headers, rows) {
-    let tableHtml = `<!-- wp:table -->
+	/**
+	 * Create table block
+	 */
+	static createTableBlock(headers, rows) {
+		let tableHtml = `<!-- wp:table -->
 <figure class="wp-block-table"><table class="wp-block-table">`;
-    
-    // Add headers
-    if (headers && headers.length > 0) {
-      tableHtml += '\n<thead>\n<tr>';
-      headers.forEach(header => {
-        tableHtml += `<th>${this.escapeHtml(header)}</th>`;
-      });
-      tableHtml += '</tr>\n</thead>';
-    }
-    
-    // Add rows
-    tableHtml += '\n<tbody>';
-    rows.forEach(row => {
-      tableHtml += '\n<tr>';
-      row.forEach(cell => {
-        tableHtml += `<td>${this.escapeHtml(cell)}</td>`;
-      });
-      tableHtml += '</tr>';
-    });
-    tableHtml += '\n</tbody>';
-    
-    tableHtml += `\n</table></figure>
+
+		// Add headers
+		if (headers && headers.length > 0) {
+			tableHtml += "\n<thead>\n<tr>";
+			headers.forEach((header) => {
+				tableHtml += `<th>${this.escapeHtml(header)}</th>`;
+			});
+			tableHtml += "</tr>\n</thead>";
+		}
+
+		// Add rows
+		tableHtml += "\n<tbody>";
+		rows.forEach((row) => {
+			tableHtml += "\n<tr>";
+			row.forEach((cell) => {
+				tableHtml += `<td>${this.escapeHtml(cell)}</td>`;
+			});
+			tableHtml += "</tr>";
+		});
+		tableHtml += "\n</tbody>";
+
+		tableHtml += `\n</table></figure>
 <!-- /wp:table -->`;
-    
-    return tableHtml;
-  }
-
-  /**
-   * Utility: Strip HTML tags from text
-   */
-  static stripTags(text) {
-    return text.replace(/<[^>]+>/g, '').trim();
-  }
-
-  /**
-   * Utility: Escape HTML special characters
-   */
-  static escapeHtml(text) {
-    const map = {
-      '&': '&amp;',
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      "'": '&#x27;',
-      "/": '&#x2F;'
-    };
-    
-    return text.replace(/[&<>"'/]/g, char => map[char]);
-  }
-
-  /**
-   * Utility: Decode HTML entities
-   */
-  static decodeHtml(text) {
-    const entities = {
-      '&amp;': '&',
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&#x27;': "'",
-      '&#x2F;': '/',
-      '&#39;': "'",
-      '&nbsp;': ' '
-    };
-    
-    return text.replace(/&[#a-z0-9]+;/gi, entity => entities[entity] || entity);
-  }
-
-  /**
-   * Convert markdown to Gutenberg blocks (bonus feature)
-   */
-  static markdownToGutenberg(markdown) {
-    // First convert markdown to HTML (simplified version)
-    let html = markdown
-      // Headers
-      .replace(/^### (.+)$/gm, '<h3>$1</h3>')
-      .replace(/^## (.+)$/gm, '<h2>$1</h2>')
-      .replace(/^# (.+)$/gm, '<h1>$1</h1>')
-      // Bold
-      .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
-      // Italic
-      .replace(/\*(.+?)\*/g, '<em>$1</em>')
-      // Code blocks
-      .replace(/```[\s\S]*?```/g, match => {
-        const code = match.slice(3, -3).trim();
-        return `<pre><code>${code}</code></pre>`;
-      })
-      // Inline code
-      .replace(/`(.+?)`/g, '<code>$1</code>')
-      // Blockquotes
-      .replace(/^> (.+)$/gm, '<blockquote>$1</blockquote>')
-      // Horizontal rules
-      .replace(/^---$/gm, '<hr>')
-      // Lists (simplified)
-      .replace(/^- (.+)$/gm, '<li>$1</li>')
-      .replace(/^(\d+)\. (.+)$/gm, '<li>$2</li>');
-    
-    // Wrap consecutive li elements in ul/ol
-    html = html.replace(/(<li>.*<\/li>\n?)+/g, match => {
-      return `<ul>${match}</ul>`;
-    });
-    
-    // Convert paragraphs
-    const lines = html.split('\n');
-    const processedLines = [];
-    let inBlock = false;
-    
-    lines.forEach(line => {
-      const trimmed = line.trim();
-      if (trimmed === '') {
-        inBlock = false;
-      } else if (!trimmed.startsWith('<')) {
-        processedLines.push(`<p>${trimmed}</p>`);
-      } else {
-        processedLines.push(trimmed);
-      }
-    });
-    
-    html = processedLines.join('\n');
-    
-    // Now convert HTML to Gutenberg
-    return this.htmlToGutenberg(html);
-  }
+
+		return tableHtml;
+	}
+
+	/**
+	 * Utility: Strip HTML tags from text
+	 */
+	static stripTags(text) {
+		return text.replace(/<[^>]+>/g, "").trim();
+	}
+
+	/**
+	 * Utility: Escape HTML special characters
+	 */
+	static escapeHtml(text) {
+		const map = {
+			"&": "&amp;",
+			"<": "&lt;",
+			">": "&gt;",
+			'"': "&quot;",
+			"'": "&#x27;",
+			"/": "&#x2F;",
+		};
+
+		return text.replace(/[&<>"'/]/g, (char) => map[char]);
+	}
+
+	/**
+	 * Utility: Decode HTML entities
+	 */
+	static decodeHtml(text) {
+		const entities = {
+			"&amp;": "&",
+			"&lt;": "<",
+			"&gt;": ">",
+			"&quot;": '"',
+			"&#x27;": "'",
+			"&#x2F;": "/",
+			"&#39;": "'",
+			"&nbsp;": " ",
+		};
+
+		return text.replace(
+			/&[#a-z0-9]+;/gi,
+			(entity) => entities[entity] || entity,
+		);
+	}
+
+	/**
+	 * Strip YAML frontmatter from markdown content
+	 */
+	static stripFrontmatter(markdown) {
+		const frontmatterPattern = /^---\n[\s\S]*?\n---\n*/;
+		return markdown.replace(frontmatterPattern, "").trim();
+	}
+
+	/**
+	 * Detect whether content is markdown or HTML
+	 */
+	static isMarkdown(content) {
+		const trimmed = content.trim();
+		// If it starts with frontmatter, it's markdown
+		if (trimmed.startsWith("---\n")) return true;
+		// If first meaningful line starts with # heading
+		const firstLine = trimmed.split("\n").find((l) => l.trim() !== "");
+		if (firstLine && /^#{1,6}\s/.test(firstLine)) return true;
+		// If it has markdown links but no HTML tags
+		if (/\[.+?\]\(.+?\)/.test(trimmed) && !/<[a-z][\s\S]*>/i.test(trimmed))
+			return true;
+		// If it has markdown-style bold/italic but no HTML
+		if (
+			/\*\*.+?\*\*/.test(trimmed) &&
+			!/<(strong|b|em|i|p|div|h[1-6])[\s>]/i.test(trimmed)
+		)
+			return true;
+		return false;
+	}
+
+	/**
+	 * Convert content to Gutenberg blocks, auto-detecting markdown vs HTML
+	 */
+	static toGutenberg(content) {
+		if (this.isMarkdown(content)) {
+			return this.markdownToGutenberg(content);
+		}
+		return this.htmlToGutenberg(content);
+	}
+
+	/**
+	 * Convert inline markdown formatting to HTML (bold, italic, links, code)
+	 */
+	static convertInlineMarkdown(text) {
+		return (
+			text
+				// Links: [text](url)
+				.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+				// Bold: **text**
+				.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+				// Italic: *text* (but not inside URLs or already-converted tags)
+				.replace(/(?<!\w)\*(?!\*)(.+?)(?<!\*)\*(?!\w)/g, "<em>$1</em>")
+				// Inline code: `text`
+				.replace(/`([^`]+)`/g, "<code>$1</code>")
+		);
+	}
+
+	/**
+	 * Parse a markdown table into headers and rows
+	 */
+	static parseMarkdownTable(lines) {
+		if (lines.length < 2) return null;
+
+		const parseCells = (line) => {
+			return line
+				.replace(/^\|/, "")
+				.replace(/\|$/, "")
+				.split("|")
+				.map((cell) => cell.trim());
+		};
+
+		// Check if second line is a separator (|---|---|)
+		if (!/^\|?\s*[-:]+\s*\|/.test(lines[1])) return null;
+
+		const headers = parseCells(lines[0]);
+		const rows = [];
+
+		for (let i = 2; i < lines.length; i++) {
+			if (!lines[i].includes("|")) break;
+			rows.push(parseCells(lines[i]));
+		}
+
+		return { headers, rows, lineCount: 2 + rows.length };
+	}
+
+	/**
+	 * Build a Gutenberg block wrapper (inline HTML preserved, no escaping)
+	 */
+	static wrapBlock(blockType, innerHtml, attrs = {}) {
+		const attrStr =
+			Object.keys(attrs).length > 0 ? " " + JSON.stringify(attrs) : "";
+		return `<!-- wp:${blockType}${attrStr} -->\n${innerHtml}\n<!-- /wp:${blockType} -->`;
+	}
+
+	/**
+	 * Convert markdown to Gutenberg blocks
+	 * Builds block HTML directly to preserve inline formatting (links, bold, etc.)
+	 */
+	static markdownToGutenberg(markdown) {
+		// Strip frontmatter if present
+		const content = this.stripFrontmatter(markdown);
+		const lines = content.split("\n");
+		const blocks = [];
+		let i = 0;
+
+		while (i < lines.length) {
+			const line = lines[i];
+			const trimmed = line.trim();
+
+			// Skip empty lines
+			if (trimmed === "") {
+				i++;
+				continue;
+			}
+
+			// Headings: # through ######
+			const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+			if (headingMatch) {
+				const level = headingMatch[1].length;
+				const text = this.convertInlineMarkdown(headingMatch[2]);
+				blocks.push(
+					this.wrapBlock(
+						"heading",
+						`<h${level} class="wp-block-heading">${text}</h${level}>`,
+						{ level },
+					),
+				);
+				i++;
+				continue;
+			}
+
+			// Horizontal rule: --- or *** or ___
+			if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+				blocks.push(
+					this.wrapBlock(
+						"separator",
+						'<hr class="wp-block-separator has-alpha-channel-opacity"/>',
+					),
+				);
+				i++;
+				continue;
+			}
+
+			// Code blocks: ```
+			if (trimmed.startsWith("```")) {
+				const codeLines = [];
+				i++;
+				while (i < lines.length && !lines[i].trim().startsWith("```")) {
+					codeLines.push(lines[i]);
+					i++;
+				}
+				i++; // skip closing ```
+				const code = this.escapeHtml(codeLines.join("\n"));
+				blocks.push(
+					this.wrapBlock(
+						"code",
+						`<pre class="wp-block-code"><code>${code}</code></pre>`,
+					),
+				);
+				continue;
+			}
+
+			// Tables: | header | header |
+			if (
+				trimmed.startsWith("|") ||
+				(trimmed.includes("|") &&
+					i + 1 < lines.length &&
+					/^\|?\s*[-:]+/.test(lines[i + 1].trim()))
+			) {
+				const tableLines = [];
+				let j = i;
+				while (j < lines.length && lines[j].trim().includes("|")) {
+					tableLines.push(lines[j].trim());
+					j++;
+				}
+				const table = this.parseMarkdownTable(tableLines);
+				if (table) {
+					const headers = table.headers.map((h) =>
+						this.convertInlineMarkdown(h),
+					);
+					const rows = table.rows.map((row) =>
+						row.map((cell) => this.convertInlineMarkdown(cell)),
+					);
+					let tableHtml =
+						'<figure class="wp-block-table"><table class="wp-block-table">';
+					tableHtml += "\n<thead>\n<tr>";
+					headers.forEach((h) => {
+						tableHtml += `<th>${h}</th>`;
+					});
+					tableHtml += "</tr>\n</thead>";
+					tableHtml += "\n<tbody>";
+					rows.forEach((row) => {
+						tableHtml += "\n<tr>";
+						row.forEach((cell) => {
+							tableHtml += `<td>${cell}</td>`;
+						});
+						tableHtml += "</tr>";
+					});
+					tableHtml += "\n</tbody>\n</table></figure>";
+					blocks.push(this.wrapBlock("table", tableHtml));
+					i += table.lineCount;
+					continue;
+				}
+				// If table parsing failed, fall through to paragraph
+			}
+
+			// Blockquotes: > text
+			if (trimmed.startsWith("> ")) {
+				const quoteLines = [];
+				while (i < lines.length && lines[i].trim().startsWith("> ")) {
+					quoteLines.push(lines[i].trim().slice(2));
+					i++;
+				}
+				const quoteText = this.convertInlineMarkdown(quoteLines.join(" "));
+				blocks.push(
+					this.wrapBlock(
+						"quote",
+						`<blockquote class="wp-block-quote">\n<p>${quoteText}</p>\n</blockquote>`,
+					),
+				);
+				continue;
+			}
+
+			// Unordered lists: - item or * item
+			if (/^[-*]\s+/.test(trimmed)) {
+				const items = [];
+				while (i < lines.length && /^[-*]\s+/.test(lines[i].trim())) {
+					const itemText = lines[i].trim().replace(/^[-*]\s+/, "");
+					items.push(this.convertInlineMarkdown(itemText));
+					i++;
+				}
+				const listItems = items.map((item) => `<li>${item}</li>`).join("\n");
+				blocks.push(
+					this.wrapBlock("list", `<ul class="wp-block-list">${listItems}</ul>`),
+				);
+				continue;
+			}
+
+			// Ordered lists: 1. item
+			if (/^\d+\.\s+/.test(trimmed)) {
+				const items = [];
+				while (i < lines.length && /^\d+\.\s+/.test(lines[i].trim())) {
+					const itemText = lines[i].trim().replace(/^\d+\.\s+/, "");
+					items.push(this.convertInlineMarkdown(itemText));
+					i++;
+				}
+				const listItems = items.map((item) => `<li>${item}</li>`).join("\n");
+				blocks.push(
+					this.wrapBlock(
+						"list",
+						`<ol class="wp-block-list">${listItems}</ol>`,
+						{ ordered: true },
+					),
+				);
+				continue;
+			}
+
+			// Images: ![alt](url)
+			const imageMatch = trimmed.match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
+			if (imageMatch) {
+				const [, alt, url] = imageMatch;
+				const imgAttrs = alt ? ` alt="${this.escapeHtml(alt)}"` : "";
+				blocks.push(
+					this.wrapBlock(
+						"image",
+						`<figure class="wp-block-image"><img src="${url}"${imgAttrs}/></figure>`,
+					),
+				);
+				i++;
+				continue;
+			}
+
+			// Paragraph: everything else (collect consecutive non-empty lines)
+			const paraLines = [];
+			while (
+				i < lines.length &&
+				lines[i].trim() !== "" &&
+				!lines[i].trim().match(/^#{1,6}\s/) &&
+				!lines[i].trim().match(/^(-{3,}|\*{3,}|_{3,})$/) &&
+				!lines[i].trim().startsWith("```") &&
+				!lines[i].trim().startsWith("> ") &&
+				!lines[i].trim().match(/^[-*]\s+/) &&
+				!lines[i].trim().match(/^\d+\.\s+/) &&
+				!lines[i].trim().match(/^!\[/) &&
+				!(
+					lines[i].trim().startsWith("|") &&
+					i + 1 < lines.length &&
+					lines[i + 1] &&
+					/^\|?\s*[-:]/.test(lines[i + 1].trim())
+				)
+			) {
+				paraLines.push(lines[i].trim());
+				i++;
+			}
+			if (paraLines.length > 0) {
+				const paraText = this.convertInlineMarkdown(paraLines.join(" "));
+				blocks.push(this.wrapBlock("paragraph", `<p>${paraText}</p>`));
+			}
+		}
+
+		return blocks.join("\n\n");
+	}
 }
 
-export default GutenbergConverter;
+export default GutenbergConverter;