myaidev-method 0.0.6 → 0.0.8

package/package.json

@@ -1,16 +1,27 @@
 {
   "name": "myaidev-method",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "AI CLI tools package with custom subagents and MCP integrations for Claude Code, Gemini CLI, and more",
+  "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
   "bin": {
-    "myaidev-method": "./bin/cli.js"
+    "myaidev-method": "./bin/cli.js",
+    "myaidev-mcp-server": "./.claude/mcp/wordpress-server.js",
+    "myaidev-mcp-launcher": "./src/mcp/mcp-launcher.js"
   },
   "scripts": {
     "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",
+    "test:mcp": "node test/test-enhanced-mcp-server.js",
+    "test:mcp:simple": "node test/test-simple-mcp.js",
+    "mcp:start": "node src/mcp/mcp-launcher.js start",
+    "mcp:start:direct": "node .claude/mcp/wordpress-server.js",
+    "mcp:start:simple": "node .claude/mcp/wordpress-server-simple.js",
+    "mcp:status": "node src/mcp/mcp-launcher.js status",
+    "mcp:health": "node src/mcp/mcp-launcher.js health",
+    "build:mcp": "mkdir -p dist/mcp && cp .claude/mcp/*.js .claude/mcp/*.json dist/mcp/",
+    "prepublishOnly": "npm install && npm test && npm run build:mcp",
     "postinstall": "echo \"MyAIDev Method installed successfully! Run 'npx myaidev-method init --claude' to get started.\"",
     "wordpress:troubleshoot": "node src/templates/docs/wordpress-troubleshoot.js"
   },
@@ -31,16 +42,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"
@@ -52,6 +64,8 @@
   "files": [
     "bin/",
     "src/",
+    ".claude/",
+    "dist/",
     "README.md",
     "USER_GUIDE.md",
     "LICENSE",

package/src/mcp/health-check.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server Health Check Script
+ * Validates MCP server configuration and connectivity
+ */
+
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default async function healthCheck() {
+  console.log('🔍 MyAIDev Method MCP Server Health Check');
+  console.log('==========================================\n');
+
+  const checks = [];
+  
+  // Check 1: Environment variables
+  console.log('📋 Checking environment configuration...');
+  const envChecks = {
+    'WORDPRESS_URL': process.env.WORDPRESS_URL,
+    'WORDPRESS_USERNAME': process.env.WORDPRESS_USERNAME,
+    'WORDPRESS_APP_PASSWORD': process.env.WORDPRESS_APP_PASSWORD
+  };
+
+  let envConfigured = true;
+  Object.entries(envChecks).forEach(([key, value]) => {
+    if (value) {
+      console.log(`  ✅ ${key}: configured`);
+    } else {
+      console.log(`  ❌ ${key}: missing`);
+      envConfigured = false;
+    }
+  });
+
+  checks.push({
+    name: 'Environment Configuration',
+    status: envConfigured ? 'passed' : 'failed'
+  });
+
+  // Check 2: MCP server files
+  console.log('\n📁 Checking MCP server files...');
+  const mcpServerPath = path.resolve(__dirname, '../../.claude/mcp/wordpress-server.js');
+  
+  try {
+    await fs.access(mcpServerPath);
+    console.log('  ✅ WordPress MCP server file exists');
+    checks.push({
+      name: 'MCP Server Files',
+      status: 'passed'
+    });
+  } catch (error) {
+    console.log('  ❌ WordPress MCP server file missing');
+    checks.push({
+      name: 'MCP Server Files',
+      status: 'failed'
+    });
+  }
+
+  // Check 3: Dependencies
+  console.log('\n📦 Checking dependencies...');
+  const requiredDeps = [
+    { name: '@modelcontextprotocol/sdk', path: '@modelcontextprotocol/sdk/server/mcp.js' },
+    { name: 'node-fetch', path: 'node-fetch' },
+    { name: 'dotenv', path: 'dotenv' },
+    { name: 'zod', path: 'zod' }
+  ];
+
+  let depsInstalled = true;
+  for (const dep of requiredDeps) {
+    try {
+      await import(dep.path);
+      console.log(`  ✅ ${dep.name}: installed`);
+    } catch (error) {
+      console.log(`  ❌ ${dep.name}: missing or failed to import`);
+      depsInstalled = false;
+    }
+  }
+
+  checks.push({
+    name: 'Dependencies',
+    status: depsInstalled ? 'passed' : 'failed'
+  });
+
+  // Check 4: MCP server startup test
+  if (envConfigured && depsInstalled) {
+    console.log('\n🚀 Testing MCP server startup...');
+    
+    try {
+      const startupTest = await testServerStartup(mcpServerPath);
+      console.log(`  ✅ MCP server starts successfully`);
+      checks.push({
+        name: 'MCP Server Startup',
+        status: 'passed'
+      });
+    } catch (error) {
+      console.log(`  ❌ MCP server startup failed: ${error.message}`);
+      checks.push({
+        name: 'MCP Server Startup',
+        status: 'failed'
+      });
+    }
+  } else {
+    console.log('\n⏭️ Skipping MCP server startup test (dependencies not met)');
+    checks.push({
+      name: 'MCP Server Startup',
+      status: 'skipped'
+    });
+  }
+
+  // Summary
+  console.log('\n📊 Health Check Summary:');
+  const passed = checks.filter(c => c.status === 'passed').length;
+  const failed = checks.filter(c => c.status === 'failed').length;
+  const skipped = checks.filter(c => c.status === 'skipped').length;
+
+  checks.forEach(check => {
+    const icon = check.status === 'passed' ? '✅' : 
+                 check.status === 'failed' ? '❌' : '⏭️';
+    console.log(`  ${icon} ${check.name}: ${check.status}`);
+  });
+
+  console.log(`\nResult: ${passed} passed, ${failed} failed, ${skipped} skipped`);
+
+  if (failed === 0) {
+    console.log('\n🎉 All checks passed! MCP server is ready to use.');
+    console.log('\n💡 Next steps:');
+    console.log('  • Run: npm run mcp:start');
+    console.log('  • Or use: /myai-wordpress-publish "your-file.md"');
+  } else {
+    console.log('\n⚠️  Some checks failed. Please address the issues above.');
+    console.log('\n💡 Common solutions:');
+    console.log('  • Set environment variables: /myai-configure wordpress');
+    console.log('  • Install dependencies: npm install');
+    console.log('  • Check file permissions and paths');
+  }
+
+  return {
+    passed,
+    failed,
+    skipped,
+    checks,
+    overall: failed === 0 ? 'healthy' : 'unhealthy'
+  };
+}
+
+async function testServerStartup(serverPath) {
+  return new Promise((resolve, reject) => {
+    const serverProcess = spawn('node', [serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: process.env
+    });
+
+    let startupOutput = '';
+    const timeout = setTimeout(() => {
+      serverProcess.kill();
+      reject(new Error('Server startup timeout'));
+    }, 5000);
+
+    serverProcess.stderr.on('data', (data) => {
+      startupOutput += data.toString();
+      if (startupOutput.includes('Enhanced WordPress MCP Server') || 
+          startupOutput.includes('running')) {
+        clearTimeout(timeout);
+        serverProcess.kill();
+        resolve(true);
+      }
+    });
+
+    serverProcess.on('error', (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+
+    serverProcess.on('exit', (code) => {
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Server exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  healthCheck().catch(console.error);
+}

package/src/mcp/mcp-launcher.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server Launcher Script
+ * Manages MCP server lifecycle with proper error handling and configuration
+ */
+
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+class MCPLauncher {
+  constructor() {
+    this.serverProcess = null;
+    this.serverPath = path.resolve(__dirname, '../../.claude/mcp/wordpress-server.js');
+    this.isShuttingDown = false;
+  }
+
+  log(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    const prefix = {
+      info: '🔧',
+      success: '✅',
+      error: '❌',
+      warn: '⚠️'
+    }[level] || 'ℹ️';
+    
+    console.log(`[${timestamp}] ${prefix} ${message}`);
+  }
+
+  async validateEnvironment() {
+    this.log('Validating environment configuration...');
+    
+    const required = ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'];
+    const missing = required.filter(key => !process.env[key]);
+    
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+    
+    this.log('Environment validation passed', 'success');
+  }
+
+  async validateServerFile() {
+    this.log('Checking MCP server file...');
+    
+    try {
+      await fs.access(this.serverPath);
+      this.log('MCP server file found', 'success');
+    } catch (error) {
+      throw new Error(`MCP server file not found: ${this.serverPath}`);
+    }
+  }
+
+  async startServer() {
+    if (this.serverProcess) {
+      this.log('Server is already running', 'warn');
+      return;
+    }
+
+    this.log('Starting Enhanced WordPress MCP Server...');
+    
+    this.serverProcess = spawn('node', [this.serverPath], {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      env: process.env
+    });
+
+    // Handle server output
+    this.serverProcess.stdout.on('data', (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        console.log(`[SERVER] ${output}`);
+      }
+    });
+
+    this.serverProcess.stderr.on('data', (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        if (output.includes('Enhanced WordPress MCP Server') && output.includes('running')) {
+          this.log('MCP Server started successfully', 'success');
+          this.log(`Server PID: ${this.serverProcess.pid}`);
+          this.log('MCP Server is ready to accept connections');
+        } else if (output.includes('ERROR') || output.includes('Error')) {
+          this.log(`Server error: ${output}`, 'error');
+        } else {
+          console.log(`[SERVER] ${output}`);
+        }
+      }
+    });
+
+    // Handle server exit
+    this.serverProcess.on('exit', (code, signal) => {
+      if (!this.isShuttingDown) {
+        if (code === 0) {
+          this.log('Server exited gracefully');
+        } else {
+          this.log(`Server exited with code ${code} (signal: ${signal})`, 'error');
+        }
+      }
+      this.serverProcess = null;
+    });
+
+    this.serverProcess.on('error', (error) => {
+      this.log(`Server startup error: ${error.message}`, 'error');
+      this.serverProcess = null;
+    });
+
+    // Setup graceful shutdown
+    this.setupShutdownHandlers();
+  }
+
+  setupShutdownHandlers() {
+    const shutdown = async (signal) => {
+      if (this.isShuttingDown) return;
+      
+      this.isShuttingDown = true;
+      this.log(`Received ${signal}, shutting down gracefully...`);
+      
+      if (this.serverProcess) {
+        this.log('Stopping MCP server...');
+        this.serverProcess.kill('SIGTERM');
+        
+        // Force kill after 10 seconds
+        setTimeout(() => {
+          if (this.serverProcess) {
+            this.log('Force killing server...', 'warn');
+            this.serverProcess.kill('SIGKILL');
+          }
+        }, 10000);
+        
+        // Wait for server to exit
+        await new Promise((resolve) => {
+          if (!this.serverProcess) {
+            resolve();
+            return;
+          }
+          
+          this.serverProcess.on('exit', () => {
+            resolve();
+          });
+        });
+      }
+      
+      this.log('Shutdown complete');
+      process.exit(0);
+    };
+
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGHUP', () => shutdown('SIGHUP'));
+  }
+
+  async launch() {
+    try {
+      this.log('🚀 MyAIDev Method MCP Server Launcher');
+      this.log('=====================================');
+      
+      await this.validateEnvironment();
+      await this.validateServerFile();
+      await this.startServer();
+      
+      // Keep the launcher running
+      this.log('Launcher is monitoring server...');
+      
+    } catch (error) {
+      this.log(`Launch failed: ${error.message}`, 'error');
+      process.exit(1);
+    }
+  }
+
+  async status() {
+    this.log('MCP Server Status Check');
+    this.log('======================');
+    
+    if (this.serverProcess) {
+      this.log(`Server is running (PID: ${this.serverProcess.pid})`, 'success');
+      this.log(`Server path: ${this.serverPath}`);
+    } else {
+      this.log('Server is not running', 'warn');
+    }
+    
+    // Environment status
+    const envVars = ['WORDPRESS_URL', 'WORDPRESS_USERNAME', 'WORDPRESS_APP_PASSWORD'];
+    this.log('\nEnvironment variables:');
+    envVars.forEach(key => {
+      const status = process.env[key] ? '✅' : '❌';
+      const value = process.env[key] ? 'configured' : 'missing';
+      console.log(`  ${status} ${key}: ${value}`);
+    });
+    
+    return {
+      running: !!this.serverProcess,
+      pid: this.serverProcess?.pid,
+      serverPath: this.serverPath
+    };
+  }
+}
+
+// CLI interface
+async function main() {
+  const launcher = new MCPLauncher();
+  const command = process.argv[2] || 'start';
+  
+  switch (command) {
+    case 'start':
+      await launcher.launch();
+      break;
+      
+    case 'status':
+      await launcher.status();
+      break;
+      
+    case 'health':
+      const { default: healthCheck } = await import('./health-check.js');
+      await healthCheck();
+      break;
+      
+    default:
+      console.log('Usage: node mcp-launcher.js [start|status|health]');
+      console.log('');
+      console.log('Commands:');
+      console.log('  start   - Start the MCP server (default)');
+      console.log('  status  - Show server status');
+      console.log('  health  - Run health check');
+      process.exit(1);
+  }
+}
+
+export { MCPLauncher };
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}

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);
+    });
+}