myaidev-method 0.0.6 → 0.0.8

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm version:*)",
+      "Bash(node:*)",
+      "mcp__sequential-thinking__sequentialthinking",
+      "WebFetch(domain:github.com)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/README.md

@@ -1,14 +1,14 @@
 # MyAIDev Method
 
-> **🚀 The easiest way to supercharge your AI CLI with professional agents and WordPress integration**
+> **🚀 The easiest way to supercharge your AI CLI with professional agents and get real work done!**
 
-A comprehensive package for AI CLI tools (Claude Code, Gemini CLI, Codex CLI) that provides custom subagents and MCP integrations for enhanced development workflows. **Zero setup required** - just run one command and start creating professional content!
+A comprehensive package for AI CLI tools (Claude Code, Gemini CLI, Codex CLI) that provides custom subagents and MCP integrations for enhanced development workflows. **Zero code required** - just run one command and start creating professional content!
 
 **✨ What makes this special:**
 - **Instant setup**: One `npx` command and you're ready
 - **Professional agents**: Content writer and WordPress admin out-of-the-box
-- **Claude Code native**: Follows official standards for maximum compatibility
-- **No dependencies**: Works standalone, WordPress integration is optional
+- **Claude Code native**: Follows official standards for maximum compatibility, with Gemini and OpenAI Codex CLI too.
+- **No dependencies**: Works standalone, leverages MCPs for WordPress, Notion, Google Workspace integration is optional
 
 ## 📋 Table of Contents
 

package/bin/cli.js

@@ -99,10 +99,12 @@ async function setupClaude(projectDir) {
   const claudeDir = path.join(projectDir, '.claude');
   const commandsDir = path.join(claudeDir, 'commands');
   const agentsDir = path.join(claudeDir, 'agents');
+  const mcpDir = path.join(claudeDir, 'mcp');
   
   // Ensure directories exist
   await fs.ensureDir(commandsDir);
   await fs.ensureDir(agentsDir);
+  await fs.ensureDir(mcpDir);
   
   // Copy command markdown files
   const templateCommandsDir = path.join(__dirname, '..', 'src', 'templates', 'claude', 'commands');
@@ -132,6 +134,20 @@ async function setupClaude(projectDir) {
     }
   }
   
+  // Copy MCP server files
+  const templateMcpDir = path.join(__dirname, '..', '.claude', 'mcp');
+  if (await fs.pathExists(templateMcpDir)) {
+    const mcpFiles = await fs.readdir(templateMcpDir);
+    for (const file of mcpFiles) {
+      if (file.endsWith('.js') || file.endsWith('.json')) {
+        await fs.copy(
+          path.join(templateMcpDir, file),
+          path.join(mcpDir, file)
+        );
+      }
+    }
+  }
+  
   // Create CLAUDE.md configuration file
   const claudeMd = `# Claude Code Configuration
 
@@ -197,21 +213,8 @@ DEFAULT_TONE=professional
   
   await fs.writeFile(path.join(projectDir, '.env.example'), envExample);
   
-  // Create WordPress MCP server file
-  const mcpDir = path.join(claudeDir, 'mcp');
-  await fs.ensureDir(mcpDir);
-  
-  const wordpressMcpServer = path.join(__dirname, '..', 'src', 'mcp', 'wordpress-integration.js');
-  if (await fs.pathExists(wordpressMcpServer)) {
-    await fs.copy(wordpressMcpServer, path.join(mcpDir, 'wordpress-server.js'));
-  }
-  
-  // Copy Gutenberg converter
-  const gutenbergConverter = path.join(__dirname, '..', 'src', 'mcp', 'gutenberg-converter.js');
-  if (await fs.pathExists(gutenbergConverter)) {
-    await fs.copy(gutenbergConverter, path.join(mcpDir, 'gutenberg-converter.js'));
-  }
-  
+  // Note: MCP integration disabled for now - using native tools for WordPress REST API
+
   // Copy USER_GUIDE.md - Essential for users to understand customization
   const userGuide = path.join(__dirname, '..', 'USER_GUIDE.md');
   if (await fs.pathExists(userGuide)) {

package/dist/mcp/gutenberg-converter.js

@@ -0,0 +1,447 @@
+/**
+ * Gutenberg Block Converter
+ * Converts HTML/Markdown content to WordPress Gutenberg block format
+ * Following WordPress Block Editor Handbook specifications
+ */
+
+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}} -->
+<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 -->
+<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} -->
+<${tag} class="wp-block-list">${listItems}</${tag}>
+<!-- /wp:list -->`;
+  }
+
+  /**
+   * 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 -->
+<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>
+<!-- /wp:image -->`;
+    
+    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}"}} -->
+<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 -->
+<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>
+<!-- /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);
+  }
+}
+
+export default GutenbergConverter;

package/dist/mcp/mcp-config.json

@@ -0,0 +1,101 @@
+{
+  "server": {
+    "name": "myaidev-wordpress-mcp-server",
+    "version": "2.0.0",
+    "description": "Enhanced WordPress MCP Server with session management and memory persistence",
+    "mcpName": "io.github.myaione/myaidev-method",
+    "transport": "stdio"
+  },
+  "tools": [
+    {
+      "name": "wp_session_create",
+      "description": "Create a new session for tracking operations and maintaining context",
+      "category": "session_management"
+    },
+    {
+      "name": "wp_session_status", 
+      "description": "Get current session information and operation history",
+      "category": "session_management"
+    },
+    {
+      "name": "wp_memory_store",
+      "description": "Store data in memory for persistence across operations",
+      "category": "memory_management"
+    },
+    {
+      "name": "wp_memory_retrieve",
+      "description": "Retrieve stored data from memory",
+      "category": "memory_management"
+    },
+    {
+      "name": "wp_memory_list",
+      "description": "List all stored data in a namespace",
+      "category": "memory_management"
+    },
+    {
+      "name": "wp_health_check",
+      "description": "Comprehensive health check of WordPress site and MCP server",
+      "category": "health_monitoring"
+    },
+    {
+      "name": "wp_get_site_info",
+      "description": "Get WordPress site statistics, version, and health information",
+      "category": "wordpress_operations"
+    },
+    {
+      "name": "wp_create_post",
+      "description": "Create a new WordPress post or page with enhanced tracking and validation",
+      "category": "wordpress_operations"
+    },
+    {
+      "name": "wp_update_post",
+      "description": "Update an existing WordPress post",
+      "category": "wordpress_operations"
+    },
+    {
+      "name": "wp_delete_post",
+      "description": "Delete a WordPress post (move to trash)",
+      "category": "wordpress_operations"
+    },
+    {
+      "name": "wp_list_posts",
+      "description": "Get posts with filtering options",
+      "category": "wordpress_operations"
+    },
+    {
+      "name": "wp_batch_publish",
+      "description": "Publish multiple posts from markdown files with enhanced tracking",
+      "category": "batch_operations"
+    }
+  ],
+  "capabilities": [
+    "session_management",
+    "memory_persistence", 
+    "health_monitoring",
+    "wordpress_integration",
+    "batch_operations",
+    "gutenberg_support",
+    "error_tracking"
+  ],
+  "environment": {
+    "required": [
+      "WORDPRESS_URL",
+      "WORDPRESS_USERNAME", 
+      "WORDPRESS_APP_PASSWORD"
+    ],
+    "optional": [
+      "WORDPRESS_USE_GUTENBERG"
+    ]
+  },
+  "installation": {
+    "command": "npm install myaidev-method",
+    "global_command": "npm install -g myaidev-method",
+    "setup_command": "npx myaidev-method init --claude"
+  },
+  "usage": {
+    "start_server": "npm run mcp:start",
+    "health_check": "npm run mcp:health", 
+    "status_check": "npm run mcp:status",
+    "publish_command": "/myai-wordpress-publish \"your-file.md\" --status draft"
+  }
+}