myaidev-method 0.0.3 → 0.0.6

package/USER_GUIDE.md

@@ -301,23 +301,32 @@ Save as markdown with:
 
 ### Initial Setup
 
-1. **Create environment file**:
-   ```bash
-   cp .env.example .env
-   ```
+Use the interactive configuration command to set up WordPress:
+
+```bash
+/myai-configure wordpress
+```
 
-2. **Configure WordPress credentials**:
+This will guide you through:
+- WordPress site URL
+- Username  
+- Application Password creation
+
+**Alternative manual setup**:
+1. Create `.env` file in your project root
+2. Add your WordPress credentials:
    ```bash
-   # Edit .env file
    WORDPRESS_URL=https://your-site.com
    WORDPRESS_USERNAME=your-username
    WORDPRESS_APP_PASSWORD=your-app-password
    ```
 
-3. **Create Application Password**:
-   - Go to WordPress Admin → Users → Your Profile
-   - Find "Application Passwords" section
-   - Enter name and click "Add New"
+### Creating Application Password
+
+1. Go to WordPress Admin → Users → Your Profile
+2. Find "Application Passwords" section
+3. Enter name (e.g., "MyAIDev CLI") and click "Add New"
+4. Copy the generated password
    - Copy the generated password
 
 ### WordPress Commands
@@ -341,6 +350,55 @@ Save as markdown with:
 /myai-content-writer "Blog Post Title" --publish_to_wordpress true
 ```
 
+### Publishing Workflow
+
+**Important**: WordPress publishing works through Claude Code slash commands, not terminal commands.
+
+#### To Publish Content:
+
+1. **Inside Claude Code** (not terminal):
+   ```bash
+   /myai-wordpress-publish "your-article.md" --status draft
+   ```
+
+2. **The command will**:
+   - Read your markdown file
+   - Extract frontmatter (title, meta_description, tags, etc.)
+   - Connect to WordPress REST API
+   - Create/update the post
+   - Return post ID and URLs
+
+#### Common Publishing Options:
+
+```bash
+# Publish as draft (default)
+/myai-wordpress-publish "article.md"
+
+# Publish immediately
+/myai-wordpress-publish "article.md" --status publish
+
+# Schedule for review
+/myai-wordpress-publish "article.md" --status pending
+```
+
+#### Content Format Expected:
+
+Your markdown files should have frontmatter:
+
+```markdown
+---
+title: "Your Article Title"
+meta_description: "SEO description for the post"
+slug: "your-article-slug"
+tags: ["tag1", "tag2"]
+category: "Blog"
+---
+
+# Your Article Content
+
+Content goes here...
+```
+
 ### WordPress Configuration Options
 
 ```bash

package/bin/cli.js

@@ -77,12 +77,13 @@ program
         
         console.log(chalk.blue('\n🔌 Add WordPress integration (optional):'));
         console.log(chalk.gray('   • Run /myai-configure wordpress for guided setup'));
-        console.log(chalk.gray('   • No manual .env file creation needed!'));
         console.log(chalk.gray('   • Publish content with /myai-wordpress-publish filename.md'));
+        console.log(chalk.gray('   • Supports both Classic and Gutenberg block editors'));
         
         console.log(chalk.magenta('\n📚 Need help?'));
         console.log(chalk.gray('   • Check USER_GUIDE.md for detailed instructions'));
         console.log(chalk.gray('   • Visit: https://github.com/myaione/myaidev-method'));
+        console.log(chalk.gray('   • WordPress docs: GitHub repo > docs/'));
       }
       console.log(chalk.cyan(`\n🔄 Restart ${cliType} to load your new AI-powered commands!`));
       
@@ -204,6 +205,21 @@ DEFAULT_TONE=professional
   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'));
+  }
+  
+  // Copy USER_GUIDE.md - Essential for users to understand customization
+  const userGuide = path.join(__dirname, '..', 'USER_GUIDE.md');
+  if (await fs.pathExists(userGuide)) {
+    await fs.copy(userGuide, path.join(projectDir, 'USER_GUIDE.md'));
+  }
+  
+  // Note: WORDPRESS_INTEGRATION.md could be helpful, but keeping docs minimal
+  // Users can find detailed docs on GitHub if needed
 }
 
 async function setupGemini(projectDir) {

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "myaidev-method",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "AI CLI tools package with custom subagents and MCP integrations for Claude Code, Gemini CLI, and more",
   "main": "src/index.js",
   "bin": {
     "myaidev-method": "./bin/cli.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublishOnly": "npm install",
-    "postinstall": "echo \"MyAIDev Method installed successfully! Run 'npx myaidev-method init --claude' to get started.\""
+    "test": "node test/run-tests.js",
+    "test:gutenberg": "node test/test-gutenberg-converter.js",
+    "test:install": "node test/test-installation.js",
+    "prepublishOnly": "npm install && npm test",
+    "postinstall": "echo \"MyAIDev Method installed successfully! Run 'npx myaidev-method init --claude' to get started.\"",
+    "wordpress:troubleshoot": "node src/templates/docs/wordpress-troubleshoot.js"
   },
   "keywords": [
     "claude-code",

package/src/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/src/mcp/wordpress-integration.js

@@ -1,4 +1,5 @@
 import fetch from 'node-fetch';
+import { GutenbergConverter } from './gutenberg-converter.js';
 
 export class WordPressMCP {
   constructor(config) {
@@ -32,9 +33,15 @@ export class WordPressMCP {
   }
 
   async createPost(params) {
+    // Convert content to Gutenberg format if requested
+    let content = params.content;
+    if (params.use_gutenberg === true || params.gutenberg === true) {
+      content = GutenbergConverter.htmlToGutenberg(params.content);
+    }
+    
     const postData = {
       title: params.title,
-      content: params.content,
+      content: content,
       status: params.status || this.defaults.post_status,
       categories: params.categories || [],
       tags: params.tags || [],
@@ -191,9 +198,10 @@ export class WordPressMCP {
         content: contentData.content,
         excerpt: contentData.meta_description,
         slug: contentData.slug,
-        status: 'draft', // Always create as draft for review
+        status: contentData.status || 'draft', // Default to draft for review
         tags: tags,
-        categories: categoryId ? [categoryId] : []
+        categories: categoryId ? [categoryId] : [],
+        use_gutenberg: contentData.use_gutenberg || false // Pass Gutenberg option
       };
 
       // Create the post

package/src/templates/claude/commands/myai-wordpress-publish.md

@@ -18,21 +18,29 @@ Read and publish the file specified in $ARGUMENTS to WordPress.
    - slug
    - tags
    - category
+   - use_gutenberg (optional, default: false)
 3. **Check WordPress configuration** in environment variables:
    - WORDPRESS_URL
    - WORDPRESS_USERNAME
    - WORDPRESS_APP_PASSWORD
+   - WORDPRESS_USE_GUTENBERG (optional, default: false)
 4. **Connect to WordPress** using the REST API
-5. **Create or update the post** with status (default: draft)
-6. **Report the result** including:
+5. **Convert content format** if Gutenberg is enabled:
+   - If use_gutenberg is true or WORDPRESS_USE_GUTENBERG is true
+   - Convert HTML to Gutenberg block format
+6. **Create or update the post** with status (default: draft)
+7. **Report the result** including:
    - Post ID
    - Preview URL
    - Edit URL in WordPress admin
+   - Format used (Classic or Gutenberg)
 
 ## Parameters
 
 - File path (required): Path to markdown file
-- Status: draft (default), publish, pending, private
+- --status: draft (default), publish, pending, private
+- --gutenberg: Use Gutenberg block format (default: false)
+- --classic: Force classic editor format (overrides defaults)
 
 ## Error Handling
 

package/src/templates/docs/WORDPRESS_INTEGRATION.md

@@ -0,0 +1,143 @@
+# WordPress Integration - How It Works
+
+## Overview
+
+The MyAIDev Method package provides WordPress integration through Claude Code slash commands, not terminal npm scripts. This is the correct design for Claude Code packages.
+
+## Publishing Workflow
+
+### ❌ Incorrect Usage (What You Tried)
+```bash
+# This doesn't work - there's no npm script
+npm run wordpress:publish -- --file lovable-to-ultrastack-deployment.md --status draft
+```
+
+### ✅ Correct Usage (Inside Claude Code)
+```bash
+# Use this slash command inside Claude Code
+/myai-wordpress-publish "lovable-to-ultrastack-deployment.md" --status draft
+```
+
+## How It Works
+
+1. **Command Definition**: `.claude/commands/myai-wordpress-publish.md`
+   - Defines the slash command interface
+   - Specifies parameters and expected behavior
+   - Uses Claude Code's built-in tools (Read, Task, WebFetch)
+
+2. **MCP Integration**: `.claude/mcp/wordpress-server.js`
+   - Provides WordPress REST API integration
+   - Handles authentication via Application Passwords
+   - Manages posts, categories, tags, and media
+
+3. **Configuration**: Environment variables or `.env` file
+   - `WORDPRESS_URL`: Your site URL
+   - `WORDPRESS_USERNAME`: WordPress username
+   - `WORDPRESS_APP_PASSWORD`: Application password
+
+## Step-by-Step Publishing Process
+
+### 1. Setup WordPress Credentials (One Time)
+Inside Claude Code:
+```bash
+/myai-configure wordpress
+```
+
+This creates a `.env` file with:
+```
+WORDPRESS_URL=https://your-site.com
+WORDPRESS_USERNAME=your-username
+WORDPRESS_APP_PASSWORD=your-app-password
+```
+
+### 2. Prepare Your Content
+Create a markdown file with frontmatter:
+```markdown
+---
+title: "Your Article Title"
+meta_description: "SEO description"
+slug: "your-article-slug"
+tags: ["web-development", "tutorial"]
+category: "Blog"
+---
+
+# Your Article Content
+
+Content goes here...
+```
+
+### 3. Publish to WordPress
+Inside Claude Code:
+```bash
+/myai-wordpress-publish "your-file.md" --status draft
+```
+
+### 4. What Happens Next
+The command will:
+- Read your markdown file
+- Parse the frontmatter
+- Connect to WordPress REST API
+- Create categories/tags if needed
+- Create the post as a draft
+- Return post ID and URLs
+
+## Expected Output
+
+```
+✅ Successfully published to WordPress!
+- Post ID: 123
+- Status: draft
+- Preview: https://your-site.com/?p=123&preview=true
+- Edit: https://your-site.com/wp-admin/post.php?post=123&action=edit
+```
+
+## WordPress Application Password Setup
+
+1. Go to your WordPress Admin → Users → Your Profile
+2. Scroll to "Application Passwords" section
+3. Enter name: "MyAIDev CLI"
+4. Click "Add New"
+5. Copy the generated password (save it!)
+6. Use this password in your `.env` file
+
+## Why No npm Scripts?
+
+This is a **Claude Code package**, not a traditional npm package with CLI scripts. The functionality is designed to work within Claude Code's environment using:
+
+- Slash commands (like `/myai-wordpress-publish`)
+- Claude Code's built-in tools (Read, Write, WebFetch, etc.)
+- MCP (Model Context Protocol) integrations
+- Environment variable access
+
+This design provides better integration with Claude Code's AI capabilities and workflow.
+
+## Troubleshooting
+
+### "package.json not found" Error
+This happens when trying to use `npm run` commands. Use slash commands instead.
+
+### "WordPress credentials not configured"
+Run `/myai-configure wordpress` to set up credentials.
+
+### "File not found" Error
+Check the file path is correct relative to your current directory.
+
+### Authentication Errors
+Verify your Application Password is correct and has proper permissions.
+
+## Development Notes
+
+If you want to add npm scripts for WordPress publishing, you would need to:
+
+1. Add scripts to `package.json`:
+   ```json
+   {
+     "scripts": {
+       "wordpress:publish": "node scripts/wordpress-publish.js"
+     }
+   }
+   ```
+
+2. Create `scripts/wordpress-publish.js` that uses the MCP integration
+
+However, this goes against the Claude Code design pattern. The slash command approach is the intended and recommended method.

package/src/templates/docs/wordpress-api-examples.md

@@ -0,0 +1,159 @@
+# WordPress REST API Testing Examples
+
+## Your Credentials
+- **Username:** admin
+- **Application Password:** iqMC L5Eh JexQ 0Ior BJIo pLH3
+- **WordPress URL:** [You need to provide this]
+
+## Basic Authentication Test
+
+### Using curl (Terminal)
+```bash
+# Replace YOUR_SITE_URL with your actual WordPress URL
+curl -X GET "YOUR_SITE_URL/wp-json/wp/v2/posts?per_page=1" \
+  -H "Authorization: Basic $(echo -n 'admin:iqMC L5Eh JexQ 0Ior BJIo pLH3' | base64)" \
+  -H "Content-Type: application/json"
+```
+
+### Expected Response
+```json
+[
+  {
+    "id": 1,
+    "title": {"rendered": "Hello world!"},
+    "status": "publish",
+    "link": "https://your-site.com/hello-world/"
+  }
+]
+```
+
+## Create a Test Post
+
+### Using curl
+```bash
+curl -X POST "YOUR_SITE_URL/wp-json/wp/v2/posts" \
+  -H "Authorization: Basic $(echo -n 'admin:iqMC L5Eh JexQ 0Ior BJIo pLH3' | base64)" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "title": "MyAIDev Test Post",
+    "content": "<h2>Test Post</h2><p>This is a test post created via REST API.</p>",
+    "status": "draft",
+    "excerpt": "Test post from MyAIDev Method"
+  }'
+```
+
+### Expected Response
+```json
+{
+  "id": 123,
+  "title": {"rendered": "MyAIDev Test Post"},
+  "status": "draft",
+  "link": "https://your-site.com/?p=123",
+  "content": {"rendered": "<h2>Test Post</h2><p>This is a test post created via REST API.</p>"}
+}
+```
+
+## Using JavaScript/Node.js
+
+### Basic Example
+```javascript
+import fetch from 'node-fetch';
+
+const siteUrl = 'YOUR_SITE_URL';
+const username = 'admin';
+const appPassword = 'iqMC L5Eh JexQ 0Ior BJIo pLH3';
+const auth = Buffer.from(`${username}:${appPassword}`).toString('base64');
+
+// Test connection
+const response = await fetch(`${siteUrl}/wp-json/wp/v2/posts?per_page=1`, {
+  headers: {
+    'Authorization': `Basic ${auth}`,
+    'Content-Type': 'application/json'
+  }
+});
+
+if (response.ok) {
+  const posts = await response.json();
+  console.log('✅ Connection successful!', posts.length, 'posts found');
+} else {
+  console.error('❌ Connection failed:', response.status, response.statusText);
+}
+```
+
+### Create Post Example
+```javascript
+// Create a new post
+const postData = {
+  title: 'MyAIDev Method Test',
+  content: '<h2>Hello from MyAIDev!</h2><p>This post was created via REST API.</p>',
+  status: 'draft',
+  excerpt: 'Test post created by MyAIDev Method package.'
+};
+
+const createResponse = await fetch(`${siteUrl}/wp-json/wp/v2/posts`, {
+  method: 'POST',
+  headers: {
+    'Authorization': `Basic ${auth}`,
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify(postData)
+});
+
+if (createResponse.ok) {
+  const newPost = await createResponse.json();
+  console.log('✅ Post created!');
+  console.log('ID:', newPost.id);
+  console.log('Preview:', newPost.link + '?preview=true');
+} else {
+  const error = await createResponse.text();
+  console.error('❌ Failed to create post:', error);
+}
+```
+
+## Testing Steps
+
+1. **Replace YOUR_SITE_URL** with your actual WordPress site URL (e.g., `https://mysite.com`)
+
+2. **Test connection first:**
+   ```bash
+   node simple-wp-test.js
+   ```
+
+3. **Check WordPress admin** to see if the test post was created
+
+4. **Verify the Application Password** is still active in WordPress Admin > Users > Profile
+
+## Troubleshooting Common Issues
+
+### 401 Unauthorized
+- Check if Application Password is correct
+- Verify username is 'admin'
+- Ensure Application Password is still active
+
+### 403 Forbidden
+- User might not have permission to create posts
+- Check if REST API is disabled
+
+### 404 Not Found
+- WordPress URL might be incorrect
+- REST API might be disabled
+- Permalinks might need to be refreshed
+
+### SSL/Certificate Errors
+- If using HTTPS, ensure SSL certificate is valid
+- For testing, you might need to add SSL bypass (not recommended for production)
+
+## WordPress Site Requirements
+
+Your WordPress site needs:
+- ✅ REST API enabled (default in WordPress 4.7+)
+- ✅ Application Passwords enabled (WordPress 5.6+)
+- ✅ User with post creation permissions
+- ✅ Valid SSL certificate (if using HTTPS)
+
+## Next Steps
+
+1. Provide your WordPress site URL
+2. Run the test script with your URL
+3. Check if posts are created successfully
+4. If working, the MyAIDev Method slash commands will work perfectly!

package/src/templates/docs/wordpress-troubleshoot.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * WordPress Integration Troubleshooting Script
+ * Quick diagnostic tool for MyAIDev Method WordPress integration
+ */
+
+import fetch from 'node-fetch';
+import fs from 'fs-extra';
+import path from 'path';
+
+async function troubleshootWordPress() {
+  console.log('🔍 MyAIDev Method WordPress Troubleshooting');
+  console.log('═══════════════════════════════════════════════');
+  
+  try {
+    // 1. Check for .env file
+    console.log('\n1️⃣ Checking configuration...');
+    const envPath = path.join(process.cwd(), '.env');
+    
+    if (await fs.pathExists(envPath)) {
+      console.log('✅ .env file found');
+      
+      const envContent = await fs.readFile(envPath, 'utf8');
+      const hasUrl = envContent.includes('WORDPRESS_URL');
+      const hasUsername = envContent.includes('WORDPRESS_USERNAME');  
+      const hasPassword = envContent.includes('WORDPRESS_APP_PASSWORD');
+      
+      console.log(`   - WORDPRESS_URL: ${hasUrl ? '✅' : '❌'}`);
+      console.log(`   - WORDPRESS_USERNAME: ${hasUsername ? '✅' : '❌'}`);
+      console.log(`   - WORDPRESS_APP_PASSWORD: ${hasPassword ? '✅' : '❌'}`);
+      
+      if (!hasUrl || !hasUsername || !hasPassword) {
+        console.log('⚠️  Missing WordPress credentials. Run: /myai-configure wordpress');
+      }
+    } else {
+      console.log('❌ .env file not found');
+      console.log('💡 Solution: Run /myai-configure wordpress to create configuration');
+    }
+    
+    // 2. Check Claude configuration
+    console.log('\n2️⃣ Checking Claude Code setup...');
+    const claudeDir = path.join(process.cwd(), '.claude');
+    const commandsDir = path.join(claudeDir, 'commands');
+    
+    if (await fs.pathExists(claudeDir)) {
+      console.log('✅ .claude directory found');
+      
+      const wpPublishCommand = path.join(commandsDir, 'myai-wordpress-publish.md');
+      const wpConfigCommand = path.join(commandsDir, 'myai-configure.md');
+      
+      console.log(`   - WordPress publish command: ${await fs.pathExists(wpPublishCommand) ? '✅' : '❌'}`);
+      console.log(`   - Configuration command: ${await fs.pathExists(wpConfigCommand) ? '✅' : '❌'}`);
+    } else {
+      console.log('❌ .claude directory not found');
+      console.log('💡 Solution: Run npx myaidev-method init --claude');
+    }
+    
+    // 3. Test connection if credentials exist
+    if (await fs.pathExists(envPath)) {
+      console.log('\n3️⃣ Testing WordPress connection...');
+      
+      try {
+        // Parse environment variables
+        const envContent = await fs.readFile(envPath, 'utf8');
+        const envVars = {};
+        
+        envContent.split('\n').forEach(line => {
+          const [key, value] = line.split('=');
+          if (key && value) {
+            envVars[key.trim()] = value.trim();
+          }
+        });
+        
+        if (envVars.WORDPRESS_URL && envVars.WORDPRESS_USERNAME && envVars.WORDPRESS_APP_PASSWORD) {
+          const auth = Buffer.from(`${envVars.WORDPRESS_USERNAME}:${envVars.WORDPRESS_APP_PASSWORD}`).toString('base64');
+          const apiUrl = `${envVars.WORDPRESS_URL}/wp-json/wp/v2`;
+          
+          console.log(`   Testing: ${apiUrl}`);
+          
+          const response = await fetch(`${apiUrl}/posts?per_page=1`, {
+            headers: {
+              'Authorization': `Basic ${auth}`,
+              'Content-Type': 'application/json'
+            }
+          });
+          
+          if (response.ok) {
+            console.log('✅ WordPress API connection successful');
+            
+            // Test post creation
+            const testResponse = await fetch(`${apiUrl}/posts`, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Basic ${auth}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                title: 'MyAIDev Test - ' + Date.now(),
+                content: 'Test post from troubleshooting script',
+                status: 'draft'
+              })
+            });
+            
+            if (testResponse.ok) {
+              const post = await testResponse.json();
+              console.log('✅ Post creation successful');
+              console.log(`   - Test post ID: ${post.id}`);
+              console.log(`   - Preview: ${post.link}?preview=true`);
+            } else {
+              console.log('❌ Post creation failed');
+              const error = await testResponse.text();
+              console.log(`   Error: ${error.substring(0, 100)}...`);
+            }
+          } else {
+            console.log(`❌ WordPress API connection failed: ${response.status}`);
+            console.log('💡 Check your WordPress URL and Application Password');
+          }
+        } else {
+          console.log('⚠️  Incomplete WordPress credentials in .env file');
+        }
+      } catch (error) {
+        console.log(`❌ Connection test failed: ${error.message}`);
+      }
+    }
+    
+    console.log('\n📋 Next Steps:');
+    console.log('1. If configuration is missing: /myai-configure wordpress');
+    console.log('2. If Claude setup is missing: npx myaidev-method init --claude');
+    console.log('3. If connection fails: Check WordPress Application Password');
+    console.log('4. For detailed help: Read WORDPRESS_INTEGRATION.md');
+    
+  } catch (error) {
+    console.error('❌ Troubleshooting failed:', error.message);
+  }
+}
+
+// Export for programmatic use
+export { troubleshootWordPress };
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  troubleshootWordPress();
+}