myaidev-method 0.0.5 → 0.0.7

package/bin/cli.js

@@ -78,11 +78,12 @@ 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('   • Publish content with /myai-wordpress-publish filename.md'));
-        console.log(chalk.gray('   • Check WORDPRESS_INTEGRATION.md for detailed workflow guide'));
+        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!`));
       
@@ -200,38 +201,33 @@ DEFAULT_TONE=professional
   const mcpDir = path.join(claudeDir, 'mcp');
   await fs.ensureDir(mcpDir);
   
-  const wordpressMcpServer = path.join(__dirname, '..', 'src', 'mcp', 'wordpress-integration.js');
+  const wordpressMcpServer = path.join(__dirname, '..', '.claude', 'mcp', 'wordpress-server.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');
+  const gutenbergConverter = path.join(__dirname, '..', '.claude', 'mcp', 'gutenberg-converter.js');
   if (await fs.pathExists(gutenbergConverter)) {
     await fs.copy(gutenbergConverter, path.join(mcpDir, 'gutenberg-converter.js'));
   }
   
-  // Copy USER_GUIDE.md
+  // Copy scripts directory
+  const scriptsTemplateDir = path.join(__dirname, '..', 'src', 'templates', 'scripts');
+  const scriptsDestDir = path.join(projectDir, 'scripts');
+  
+  if (await fs.pathExists(scriptsTemplateDir)) {
+    await fs.copy(scriptsTemplateDir, scriptsDestDir);
+  }
+
+  // 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'));
   }
   
-  // Copy WordPress documentation
-  const wordpressIntegrationDoc = path.join(__dirname, '..', 'src', 'templates', 'docs', 'WORDPRESS_INTEGRATION.md');
-  if (await fs.pathExists(wordpressIntegrationDoc)) {
-    await fs.copy(wordpressIntegrationDoc, path.join(projectDir, 'WORDPRESS_INTEGRATION.md'));
-  }
-  
-  const wordpressExamplesDoc = path.join(__dirname, '..', 'src', 'templates', 'docs', 'wordpress-api-examples.md');
-  if (await fs.pathExists(wordpressExamplesDoc)) {
-    await fs.copy(wordpressExamplesDoc, path.join(projectDir, 'wordpress-api-examples.md'));
-  }
-  
-  const wordpressTroubleshoot = path.join(__dirname, '..', 'src', 'templates', 'docs', 'wordpress-troubleshoot.js');
-  if (await fs.pathExists(wordpressTroubleshoot)) {
-    await fs.copy(wordpressTroubleshoot, path.join(projectDir, 'wordpress-troubleshoot.js'));
-  }
+  // 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,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "AI CLI tools package with custom subagents and MCP integrations for Claude Code, Gemini CLI, and more",
   "main": "src/index.js",
   "bin": {
@@ -31,16 +31,17 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "commander": "^12.0.0",
+    "@modelcontextprotocol/sdk": "^1.18.0",
     "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.1",
     "fs-extra": "^11.2.0",
     "inquirer": "^9.2.15",
-    "ora": "^8.0.1",
     "node-fetch": "^3.3.2",
-    "dotenv": "^16.4.1",
-    "ssh2": "^1.15.0"
+    "ora": "^8.0.1",
+    "ssh2": "^1.15.0",
+    "zod": "^3.23.8"
   },
-  "devDependencies": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/myaione/myaidev-method.git"

package/src/scripts/configure-wordpress-mcp.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Configure WordPress MCP integration for Claude Code
+ * This script creates the .mcp.json file required for Claude Code to recognize
+ * and use the WordPress MCP server
+ */
+export async function configureWordPressMCP(projectDir = process.cwd()) {
+  try {
+    console.log('🔧 Configuring WordPress MCP integration...');
+
+    // Load environment variables from .env file
+    const envPath = path.join(projectDir, '.env');
+    if (!fs.existsSync(envPath)) {
+      throw new Error('.env file not found. Please run WordPress configuration first.');
+    }
+
+    dotenv.config({ path: envPath });
+
+    // Validate required environment variables
+    const requiredVars = ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'];
+    const missing = requiredVars.filter(varName => !process.env[varName]);
+    
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+
+    // Check if MCP server files exist
+    const mcpServerPath = path.join(projectDir, '.claude/mcp/wordpress-server.js');
+    const gutenbergConverterPath = path.join(projectDir, '.claude/mcp/gutenberg-converter.js');
+
+    if (!fs.existsSync(mcpServerPath)) {
+      throw new Error(`WordPress MCP server not found at: ${mcpServerPath}`);
+    }
+
+    if (!fs.existsSync(gutenbergConverterPath)) {
+      throw new Error(`Gutenberg converter not found at: ${gutenbergConverterPath}`);
+    }
+
+    // Create MCP configuration
+    const mcpConfigPath = path.join(projectDir, '.mcp.json');
+    const mcpConfig = {
+      mcpServers: {
+        wordpress: {
+          command: "node",
+          args: [path.resolve(projectDir, ".claude/mcp/wordpress-server.js")],
+          env: {
+            WORDPRESS_URL: process.env.WORDPRESS_URL,
+            WORDPRESS_USERNAME: process.env.WORDPRESS_USERNAME,
+            WORDPRESS_APP_PASSWORD: process.env.WORDPRESS_APP_PASSWORD,
+            WORDPRESS_USE_GUTENBERG: process.env.WORDPRESS_USE_GUTENBERG || "false"
+          }
+        }
+      }
+    };
+
+    // If .mcp.json already exists, merge with existing configuration
+    let existingConfig = {};
+    if (fs.existsSync(mcpConfigPath)) {
+      try {
+        existingConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+        console.log('📝 Found existing .mcp.json file, merging configuration...');
+      } catch (error) {
+        console.warn('⚠️ Existing .mcp.json file is invalid, creating new one...');
+      }
+    }
+
+    // Merge configurations
+    const finalConfig = {
+      ...existingConfig,
+      mcpServers: {
+        ...existingConfig.mcpServers,
+        ...mcpConfig.mcpServers
+      }
+    };
+
+    // Write MCP configuration file
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
+    console.log('✅ Created .mcp.json configuration file');
+
+    // Set executable permissions on MCP server
+    try {
+      fs.chmodSync(mcpServerPath, 0o755);
+      console.log('✅ Set executable permissions on WordPress MCP server');
+    } catch (error) {
+      console.warn('⚠️ Could not set executable permissions:', error.message);
+    }
+
+    // Test MCP server startup
+    console.log('🧪 Testing MCP server startup...');
+    
+    try {
+      const { spawn } = await import('child_process');
+      
+      return new Promise((resolve, reject) => {
+        const testProcess = spawn('node', [mcpServerPath], {
+          env: { ...process.env, ...mcpConfig.mcpServers.wordpress.env },
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        let stderr = '';
+        testProcess.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        // Give the server 3 seconds to start up
+        setTimeout(() => {
+          testProcess.kill('SIGTERM');
+          
+          if (stderr.includes('WordPress MCP Server running') || stderr.includes('Server running')) {
+            console.log('✅ MCP server startup test successful');
+            resolve(true);
+          } else if (stderr.includes('Error') || stderr.includes('Missing required environment')) {
+            console.error('❌ MCP server startup failed:', stderr);
+            reject(new Error('MCP server failed to start'));
+          } else {
+            console.log('✅ MCP server appears to be working');
+            resolve(true);
+          }
+        }, 3000);
+
+        testProcess.on('error', (error) => {
+          reject(new Error(`Failed to start MCP server: ${error.message}`));
+        });
+      });
+    } catch (testError) {
+      console.warn('⚠️ Could not test MCP server startup:', testError.message);
+      console.log('   MCP configuration created, but please test manually if needed');
+    }
+
+    console.log('\n🎉 WordPress MCP integration configured successfully!');
+    console.log('\n📋 Configuration Summary:');
+    console.log(`   • WordPress URL: ${process.env.WORDPRESS_URL}`);
+    console.log(`   • Username: ${process.env.WORDPRESS_USERNAME}`);
+    console.log(`   • Gutenberg mode: ${process.env.WORDPRESS_USE_GUTENBERG || 'false'}`);
+    console.log(`   • MCP config: ${mcpConfigPath}`);
+    console.log(`   • MCP server: ${mcpServerPath}`);
+    
+    console.log('\n🔄 Next steps:');
+    console.log('   1. Restart Claude Code to load the new MCP configuration');
+    console.log('   2. Use WordPress MCP tools in your agents and commands');
+    console.log('   3. Test with: /myai-wordpress-admin or /myai-wordpress-publish');
+
+    return true;
+
+  } catch (error) {
+    console.error('❌ WordPress MCP configuration failed:', error.message);
+    console.log('\n🛠️ Troubleshooting:');
+    console.log('   • Ensure WordPress credentials are configured in .env');
+    console.log('   • Check that .claude/mcp/wordpress-server.js exists');
+    console.log('   • Verify Node.js version is 18+ (required for MCP SDK)');
+    console.log('   • Run: npm install to ensure dependencies are installed');
+    
+    return false;
+  }
+}
+
+// Allow running as standalone script
+if (import.meta.url === `file://${process.argv[1]}`) {
+  configureWordPressMCP()
+    .then((success) => {
+      process.exit(success ? 0 : 1);
+    })
+    .catch((error) => {
+      console.error('Configuration script error:', error);
+      process.exit(1);
+    });
+}

package/src/templates/claude/agents/wordpress-admin.md

@@ -1,10 +1,43 @@
 ---
 name: wordpress-admin
 description: WordPress administrator for site management, security, performance, and health analysis
-tools: Read, Write, Edit, Bash, WebSearch, WebFetch, Task, Grep, Glob
+tools: Read, Write, Edit, Task, WebFetch
 ---
 
-You are a WordPress administrator with expertise in site management, security, performance optimization, and health monitoring. You have access to WordPress via MCP integration and can perform server-level operations through SSH when available.
+You are a WordPress administrator with expertise in site management, security, performance optimization, and health monitoring. You use the existing MyAIDev Method WordPress MCP integration and configuration.
+
+## WordPress Integration Setup
+
+### Prerequisites
+Before performing any WordPress operations, ensure configuration is complete:
+
+1. **Check Configuration**: Use `/myai-configure wordpress` if not already set up
+2. **Verify Credentials**: Ensure `.env` file contains:
+   ```
+   WORDPRESS_URL=https://your-site.com
+   WORDPRESS_USERNAME=your-username
+   WORDPRESS_APP_PASSWORD=your-app-password
+   ```
+3. **Use Existing MCP**: Leverage the WordPress MCP server in `.claude/mcp/wordpress-server.js`
+
+### WordPress Operations via MCP
+All WordPress operations MUST use our existing WordPress MCP integration. Never write new REST API code - use the provided MCP functions:
+
+**Available MCP Functions:**
+- `wp_get_site_info()` - Site statistics and information
+- `wp_list_posts(params)` - Get posts with filtering options
+- `wp_create_post(params)` - Create new posts/pages
+- `wp_update_post(id, params)` - Update existing content
+- `wp_delete_post(id)` - Delete posts/pages
+- `wp_list_users()` - Get user accounts
+- `wp_create_user(params)` - Add new users
+- `wp_update_user(id, params)` - Modify user settings
+- `wp_list_plugins()` - Get installed plugins
+- `wp_activate_plugin(slug)` - Enable plugins
+- `wp_deactivate_plugin(slug)` - Disable plugins
+- `wp_list_themes()` - Get available themes
+- `wp_get_media(params)` - Media library access
+- `wp_upload_media(file_data)` - Upload files
 
 ## Core Responsibilities
 
@@ -44,30 +77,59 @@ You are a WordPress administrator with expertise in site management, security, p
 ## Available Operations
 
 ### WordPress MCP Operations
-- Site information and statistics
-- Plugin/theme management
-- User administration
-- Content management
-- Database operations
-- Media library management
-- Settings configuration
-
-### SSH Server Operations (when available)
-- File system access and permissions
-- Log file analysis
-- Server resource monitoring
-- Database direct access
-- Web server configuration
-- System updates and maintenance
+Use the following MCP functions for all WordPress operations:
+
+**Site Management:**
+- `wp_get_site_info()` - Get site statistics, version, and health
+- `wp_list_posts({status: 'any', per_page: 100})` - Audit content
+- `wp_list_users()` - Review user accounts and roles
+
+**Security Operations:**
+- `wp_list_plugins()` - Check plugin versions and security
+- `wp_list_users()` - Audit user permissions and roles
+- `wp_get_site_info()` - Check WordPress version for updates
+
+**Content Management:**
+- `wp_list_posts({status: 'draft'})` - Find draft content
+- `wp_list_posts({status: 'trash'})` - Review deleted content
+- `wp_update_post(id, {status: 'trash'})` - Clean up spam content
+
+**User Administration:**
+- `wp_create_user({username, email, password, role})` - Add users
+- `wp_update_user(id, {role, password})` - Modify permissions
+- `wp_delete_user(id)` - Remove accounts
+
+**Plugin/Theme Management:**
+- `wp_activate_plugin(slug)` / `wp_deactivate_plugin(slug)` - Control plugins
+- `wp_list_themes()` - Review installed themes
+
+### SSH Server Operations (optional, when available)
+- File system access and permissions (use when MCP functions insufficient)
+- Log file analysis (`/var/log/apache2/`, `/var/log/nginx/`)
+- Server resource monitoring (`htop`, `df -h`)
+- Direct database access (only for complex queries)
+- Web server configuration (when MCP cannot modify settings)
 
 ## Security Assessment Workflow
 
 ### 1. Initial Security Scan
-- Check WordPress version and update status
-- Audit installed plugins and themes for vulnerabilities
-- Review user accounts and permissions
-- Scan for malware and suspicious files
-- Check file permissions and ownership
+**Using MCP Functions:**
+```javascript
+// Check WordPress version and site health
+const siteInfo = await wp_get_site_info();
+
+// Audit user accounts and permissions
+const users = await wp_list_users();
+
+// Review installed plugins for vulnerabilities
+const plugins = await wp_list_plugins();
+
+// Check themes for updates
+const themes = await wp_list_themes();
+
+// Review content for spam/malicious posts
+const allPosts = await wp_list_posts({status: 'any', per_page: 100});
+```
 
 ### 2. Configuration Review
 - WordPress security settings audit
@@ -92,11 +154,19 @@ You are a WordPress administrator with expertise in site management, security, p
 ## Performance Analysis Workflow
 
 ### 1. Site Speed Analysis
-- Page load time measurement
-- Core Web Vitals assessment
-- Resource loading analysis
-- Database query performance
-- Server response time evaluation
+**Using MCP Functions:**
+```javascript
+// Get site information for performance baseline
+const siteInfo = await wp_get_site_info();
+
+// Analyze content structure for optimization
+const posts = await wp_list_posts({per_page: 100});
+const media = await wp_get_media({per_page: 100});
+
+// Review active plugins for performance impact
+const plugins = await wp_list_plugins();
+```
+**Additional Analysis:** Page load time measurement, Core Web Vitals assessment, database query performance (use SSH access for detailed server metrics when needed)
 
 ### 2. Resource Optimization
 - Image compression recommendations
@@ -201,16 +271,30 @@ For each operation, provide:
 ## Error Handling
 
 ### WordPress MCP Failures
-- Provide fallback procedures
-- Document connection issues
-- Suggest alternative approaches
-- Report specific error details
+**When MCP functions fail:**
+1. **Check Configuration**: Verify `/myai-configure wordpress` setup
+2. **Validate Credentials**: Ensure `.env` variables are correct
+3. **Test Connection**: Use `wp_get_site_info()` to test basic connectivity
+4. **Fallback Options**: Document specific MCP errors and suggest SSH alternatives
+5. **Error Reporting**: Provide exact error messages for troubleshooting
+
+**Example Error Handling:**
+```javascript
+try {
+  const siteInfo = await wp_get_site_info();
+  console.log('WordPress connection successful');
+} catch (error) {
+  console.error('MCP Connection failed:', error.message);
+  // Suggest checking .env configuration
+  // Recommend running /myai-configure wordpress
+}
+```
 
 ### SSH Access Issues
-- Gracefully handle connection failures
-- Provide WordPress-only alternatives
-- Document permission requirements
-- Suggest credential verification steps
+- Use SSH only when MCP functions are insufficient
+- Document when SSH is required vs optional
+- Always try MCP functions first before SSH alternatives
+- Provide WordPress-admin-only alternatives when SSH unavailable
 
 ## Integration Guidelines
 

package/src/templates/claude/commands/myai-configure.md

@@ -39,7 +39,14 @@ Interactive WordPress setup - no manual .env file creation needed!
    - Set proper file permissions (600)
    - Show confirmation of saved settings
 
-6. **Optional SSH setup**
+6. **Configure MCP integration**
+   - Run the MCP configuration script: `node scripts/configure-wordpress-mcp.js`
+   - Create/update `.mcp.json` file for Claude Code MCP integration
+   - Configure WordPress MCP server with proper paths and environment
+   - Enable WordPress MCP tools in Claude Code
+   - Test MCP server connectivity
+
+7. **Optional SSH setup**
    - Ask: "Do you want to set up SSH for advanced WordPress administration? (y/n)"
    - If yes, prompt for SSH details:
      * SSH host/IP
@@ -77,7 +84,71 @@ List and manage available agents:
 2. Interactive prompts for required values
 3. Validate configuration
 4. Save to appropriate location (.env or .claude/config/)
-5. Confirm successful configuration
+5. **For WordPress configuration**: Create `.mcp.json` file with WordPress MCP server configuration
+6. Confirm successful configuration
+
+## MCP Configuration Details
+
+When configuring WordPress, the command should:
+
+1. **Create `.mcp.json` file** in the project root with the following structure:
+```json
+{
+  "mcpServers": {
+    "wordpress": {
+      "command": "node",
+      "args": [".claude/mcp/wordpress-server.js"],
+      "env": {
+        "WORDPRESS_URL": "loaded from .env",
+        "WORDPRESS_USERNAME": "loaded from .env", 
+        "WORDPRESS_APP_PASSWORD": "loaded from .env",
+        "WORDPRESS_USE_GUTENBERG": "loaded from .env"
+      }
+    }
+  }
+}
+```
+
+2. **Verify MCP server executable** by checking:
+   - `.claude/mcp/wordpress-server.js` exists
+   - `.claude/mcp/gutenberg-converter.js` exists
+   - File permissions are correct (executable)
+
+3. **Test MCP server startup** by running:
+   - `node .claude/mcp/wordpress-server.js` to verify it starts without errors
+   - Check that all dependencies are installed
+
+4. **Environment integration** by:
+   - Reading existing `.env` values
+   - Populating MCP environment variables
+   - Ensuring `.env` file is properly formatted
+
+5. **Implementation steps**:
+   - Read the current `.env` file to get WordPress credentials
+   - Create the `.mcp.json` file with proper server configuration
+   - Use absolute paths for the MCP server script
+   - Set executable permissions on MCP server files
+   - Test that Claude Code can load the MCP configuration
+
+```javascript
+// Example implementation for creating .mcp.json:
+const mcpConfig = {
+  mcpServers: {
+    wordpress: {
+      command: "node",
+      args: [path.resolve(".claude/mcp/wordpress-server.js")],
+      env: {
+        WORDPRESS_URL: process.env.WORDPRESS_URL,
+        WORDPRESS_USERNAME: process.env.WORDPRESS_USERNAME,
+        WORDPRESS_APP_PASSWORD: process.env.WORDPRESS_APP_PASSWORD,
+        WORDPRESS_USE_GUTENBERG: process.env.WORDPRESS_USE_GUTENBERG || "false"
+      }
+    }
+  }
+};
+
+fs.writeFileSync('.mcp.json', JSON.stringify(mcpConfig, null, 2));
+```
 
 ## WordPress Setup Example
 
@@ -113,6 +184,8 @@ List and manage available agents:
 
 ✅ Configuration saved to .env
 ✅ File permissions set to 600 (secure)
+✅ MCP configuration saved to .mcp.json
+✅ WordPress MCP server configured
 
 WordPress integration ready! Available commands:
 • /myai-wordpress-admin health-check

package/src/templates/scripts/configure-wordpress-mcp.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Configure WordPress MCP integration for Claude Code
+ * This script creates the .mcp.json file required for Claude Code to recognize
+ * and use the WordPress MCP server
+ */
+export async function configureWordPressMCP(projectDir = process.cwd()) {
+  try {
+    console.log('🔧 Configuring WordPress MCP integration...');
+
+    // Load environment variables from .env file
+    const envPath = path.join(projectDir, '.env');
+    if (!fs.existsSync(envPath)) {
+      throw new Error('.env file not found. Please run WordPress configuration first.');
+    }
+
+    dotenv.config({ path: envPath });
+
+    // Validate required environment variables
+    const requiredVars = ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'];
+    const missing = requiredVars.filter(varName => !process.env[varName]);
+    
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+
+    // Check if MCP server files exist
+    const mcpServerPath = path.join(projectDir, '.claude/mcp/wordpress-server.js');
+    const gutenbergConverterPath = path.join(projectDir, '.claude/mcp/gutenberg-converter.js');
+
+    if (!fs.existsSync(mcpServerPath)) {
+      throw new Error(`WordPress MCP server not found at: ${mcpServerPath}`);
+    }
+
+    if (!fs.existsSync(gutenbergConverterPath)) {
+      throw new Error(`Gutenberg converter not found at: ${gutenbergConverterPath}`);
+    }
+
+    // Create MCP configuration
+    const mcpConfigPath = path.join(projectDir, '.mcp.json');
+    
+    // Use relative path for portability across different environments
+    const relativeMcpServerPath = ".claude/mcp/wordpress-server.js";
+    
+    const mcpConfig = {
+      mcpServers: {
+        wordpress: {
+          command: "node",
+          args: [relativeMcpServerPath],
+          env: {
+            WORDPRESS_URL: process.env.WORDPRESS_URL,
+            WORDPRESS_USERNAME: process.env.WORDPRESS_USERNAME,
+            WORDPRESS_APP_PASSWORD: process.env.WORDPRESS_APP_PASSWORD,
+            WORDPRESS_USE_GUTENBERG: process.env.WORDPRESS_USE_GUTENBERG || "false"
+          }
+        }
+      }
+    };
+
+    // If .mcp.json already exists, merge with existing configuration
+    let existingConfig = {};
+    if (fs.existsSync(mcpConfigPath)) {
+      try {
+        existingConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+        console.log('📝 Found existing .mcp.json file, merging configuration...');
+      } catch (error) {
+        console.warn('⚠️ Existing .mcp.json file is invalid, creating new one...');
+      }
+    }
+
+    // Merge configurations
+    const finalConfig = {
+      ...existingConfig,
+      mcpServers: {
+        ...existingConfig.mcpServers,
+        ...mcpConfig.mcpServers
+      }
+    };
+
+    // Write MCP configuration file
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
+    console.log('✅ Created .mcp.json configuration file');
+
+    // Set executable permissions on MCP server
+    try {
+      fs.chmodSync(mcpServerPath, 0o755);
+      console.log('✅ Set executable permissions on WordPress MCP server');
+    } catch (error) {
+      console.warn('⚠️ Could not set executable permissions:', error.message);
+    }
+
+    // Test MCP server startup
+    console.log('🧪 Testing MCP server startup...');
+    
+    try {
+      const { spawn } = await import('child_process');
+      
+      return new Promise((resolve, reject) => {
+        const testProcess = spawn('node', [relativeMcpServerPath], {
+          cwd: projectDir, // Set working directory to project root
+          env: { ...process.env, ...mcpConfig.mcpServers.wordpress.env },
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        let stderr = '';
+        testProcess.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        // Give the server 3 seconds to start up
+        setTimeout(() => {
+          testProcess.kill('SIGTERM');
+          
+          if (stderr.includes('WordPress MCP Server running') || stderr.includes('Server running')) {
+            console.log('✅ MCP server startup test successful');
+            resolve(true);
+          } else if (stderr.includes('Error') || stderr.includes('Missing required environment')) {
+            console.error('❌ MCP server startup failed:', stderr);
+            reject(new Error('MCP server failed to start'));
+          } else {
+            console.log('✅ MCP server appears to be working');
+            resolve(true);
+          }
+        }, 3000);
+
+        testProcess.on('error', (error) => {
+          reject(new Error(`Failed to start MCP server: ${error.message}`));
+        });
+      });
+    } catch (testError) {
+      console.warn('⚠️ Could not test MCP server startup:', testError.message);
+      console.log('   MCP configuration created, but please test manually if needed');
+    }
+
+    console.log('\n🎉 WordPress MCP integration configured successfully!');
+    console.log('\n📋 Configuration Summary:');
+    console.log(`   • WordPress URL: ${process.env.WORDPRESS_URL}`);
+    console.log(`   • Username: ${process.env.WORDPRESS_USERNAME}`);
+    console.log(`   • Gutenberg mode: ${process.env.WORDPRESS_USE_GUTENBERG || 'false'}`);
+    console.log(`   • MCP config: ${mcpConfigPath}`);
+    console.log(`   • MCP server: ${relativeMcpServerPath}`);
+    
+    console.log('\n🔄 Next steps:');
+    console.log('   1. Restart Claude Code to load the new MCP configuration');
+    console.log('   2. Use WordPress MCP tools in your agents and commands');
+    console.log('   3. Test with: /myai-wordpress-admin or /myai-wordpress-publish');
+
+    return true;
+
+  } catch (error) {
+    console.error('❌ WordPress MCP configuration failed:', error.message);
+    console.log('\n🛠️ Troubleshooting:');
+    console.log('   • Ensure WordPress credentials are configured in .env');
+    console.log('   • Check that .claude/mcp/wordpress-server.js exists');
+    console.log('   • Verify Node.js version is 18+ (required for MCP SDK)');
+    console.log('   • Run: npm install to ensure dependencies are installed');
+    
+    return false;
+  }
+}
+
+// Allow running as standalone script
+if (import.meta.url === `file://${process.argv[1]}`) {
+  configureWordPressMCP()
+    .then((success) => {
+      process.exit(success ? 0 : 1);
+    })
+    .catch((error) => {
+      console.error('Configuration script error:', error);
+      process.exit(1);
+    });
+}