@musashishao/agent-kit 1.2.2

package/bin/cli.js

@@ -0,0 +1,1267 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const VERSION = require('../package.json').version;
+const PACKAGE_NAME = '@musashishao/agent-kit';
+
+// Colors for terminal
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}ℹ${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}✔${colors.reset} ${msg}`),
+  warn: (msg) => console.log(`${colors.yellow}⚠${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}✖${colors.reset} ${msg}`),
+  title: (msg) => console.log(`\n${colors.bright}${colors.magenta}${msg}${colors.reset}\n`)
+};
+
+function showHelp() {
+  console.log(`
+${colors.bright}${colors.cyan}🚀 Musa Agent Kit${colors.reset} v${VERSION}
+
+${colors.bright}Usage:${colors.reset}
+  npx ${PACKAGE_NAME} <command> [options]
+
+${colors.bright}Commands:${colors.reset}
+  ${colors.cyan}init${colors.reset}          Install .agent folder into current project
+  ${colors.cyan}setup-codex${colors.reset}   Sync workflows with Codex CLI slash commands
+  ${colors.cyan}codex${colors.reset}         Generate AGENTS.md for Codex CLI (use --template)
+  ${colors.cyan}mcp${colors.reset}           MCP server management (setup, list, build)
+  ${colors.cyan}agents${colors.reset}        List all available agents
+  ${colors.cyan}skills${colors.reset}        List all available skills
+  ${colors.cyan}workflows${colors.reset}     List all available workflows
+  ${colors.cyan}doctor${colors.reset}        Check configuration and diagnose issues
+  ${colors.cyan}update${colors.reset}        Update .agent folder to latest version
+  ${colors.cyan}status${colors.reset}        Check installation status
+
+${colors.bright}MCP Subcommands:${colors.reset}
+  ${colors.cyan}mcp setup${colors.reset}     Configure MCP servers for Claude/Cursor
+  ${colors.cyan}mcp list${colors.reset}      List available MCP servers
+  ${colors.cyan}mcp build${colors.reset}     Build MCP servers
+
+${colors.bright}Options:${colors.reset}
+  --force       Overwrite existing files
+  --path <dir>  Install in specific directory
+  --prefix <str> Custom prefix for slash commands (default: kit-)
+  --template <type>  Template type: web, mobile, backend (for codex command)
+  --client <name>  MCP client: claude, cursor (for mcp setup)
+  --quiet       Suppress output
+  --help        Show this help message
+  --version     Show version
+
+${colors.bright}Examples:${colors.reset}
+  npx ${PACKAGE_NAME} init
+  npx ${PACKAGE_NAME} mcp setup --client claude
+  npx ${PACKAGE_NAME} codex --template web
+  npx ${PACKAGE_NAME} doctor
+  
+${colors.yellow}# To ensure you have the latest version from NPM:${colors.reset}
+  npx ${PACKAGE_NAME}@latest update
+`);
+}
+
+
+function showVersion() {
+  console.log(`${PACKAGE_NAME} v${VERSION}`);
+}
+
+function copyFolderRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyFolderRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function countItems(dir) {
+  let count = { files: 0, dirs: 0 };
+  
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      count.dirs++;
+      const subCount = countItems(path.join(dir, entry.name));
+      count.files += subCount.files;
+      count.dirs += subCount.dirs;
+    } else {
+      count.files++;
+    }
+  }
+  
+  return count;
+}
+
+function initCommand(options) {
+  const targetDir = options.path || process.cwd();
+  const agentDir = path.join(targetDir, '.agent');
+  const quiet = options.quiet;
+
+  if (!quiet) {
+    log.title('🚀 Musa Agent Kit - Installing...');
+  }
+
+  // Check if .agent exists
+  if (fs.existsSync(agentDir)) {
+    if (!options.force) {
+      log.warn('.agent folder already exists!');
+      log.info('Use --force to overwrite');
+      process.exit(1);
+    }
+    if (!quiet) log.info('Removing existing .agent folder...');
+    fs.rmSync(agentDir, { recursive: true, force: true });
+  }
+
+  // Find source .agent folder
+  const packageRoot = path.resolve(__dirname, '..');
+  const sourceAgent = path.join(packageRoot, '.agent');
+
+  if (!fs.existsSync(sourceAgent)) {
+    log.error('Source .agent folder not found in package!');
+    process.exit(1);
+  }
+
+  // Copy
+  if (!quiet) log.info('Copying .agent folder...');
+  copyFolderRecursive(sourceAgent, agentDir);
+
+  // Summary
+  const counts = countItems(agentDir);
+  
+  if (!quiet) {
+    log.success('Installation complete!');
+    console.log(`
+${colors.bright}📦 Installed:${colors.reset}
+   ${colors.cyan}${counts.dirs}${colors.reset} folders
+   ${colors.cyan}${counts.files}${colors.reset} files
+
+${colors.bright}📁 Location:${colors.reset} ${agentDir}
+
+${colors.bright}🎯 Quick Start:${colors.reset}
+   1. Open your project in Cursor/VS Code
+   2. Use slash commands: /brainstorm, /create, /debug
+   3. Mention agents: "Use security-auditor to review auth"
+
+${colors.bright}📚 Documentation:${colors.reset}
+   See .agent/ARCHITECTURE.md for full guide
+`);
+  }
+}
+
+function setupCodexCommand(options) {
+  const codexPromptDir = path.join(os.homedir(), '.codex', 'prompts');
+  const agentDir = path.join(process.cwd(), '.agent');
+  const workflowDir = path.join(agentDir, 'workflows');
+  const prefix = options.prefix || 'kit-';
+
+  log.title('🔗 Musa Agent Kit - Syncing with Codex CLI');
+
+  if (!fs.existsSync(agentDir)) {
+    log.error('.agent folder not found. Please run "init" first.');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(codexPromptDir)) {
+    log.info('Creating Codex prompt directory...');
+    fs.mkdirSync(codexPromptDir, { recursive: true });
+  }
+
+  const workflows = fs.readdirSync(workflowDir).filter(f => f.endsWith('.md'));
+  
+  log.info(`Found ${workflows.length} workflows. Linking to ${codexPromptDir}...`);
+
+  let successCount = 0;
+  for (const wf of workflows) {
+    const src = path.join(workflowDir, wf);
+    const destName = `${prefix}${wf}`;
+    const dest = path.join(codexPromptDir, destName);
+
+    try {
+      if (fs.existsSync(dest)) {
+        if (options.force) {
+          fs.unlinkSync(dest);
+        } else {
+          continue;
+        }
+      }
+      
+      // Use absolute path for symlink
+      fs.symlinkSync(src, dest, 'file');
+      successCount++;
+    } catch (err) {
+      // If symlink fails (e.g. on Windows without admin), copy instead
+      try {
+        fs.copyFileSync(src, dest);
+        successCount++;
+      } catch (copyErr) {
+        log.error(`Failed to sync ${wf}: ${copyErr.message}`);
+      }
+    }
+  }
+
+  log.success(`Successfully synced ${successCount} slash commands to Codex CLI!`);
+  log.info(`You can now use: /${prefix}${workflows[0].replace('.md', '')} in Codex CLI.`);
+}
+
+function statusCommand() {
+  const agentDir = path.join(process.cwd(), '.agent');
+  
+  log.title('📊 Musa Agent Kit - Status');
+  
+  if (!fs.existsSync(agentDir)) {
+    log.warn('.agent folder not found');
+    log.info(`Run: npx ${PACKAGE_NAME} init`);
+    return;
+  }
+
+  const counts = countItems(agentDir);
+  log.success('.agent folder found');
+  console.log(`
+${colors.bright}📦 Contents:${colors.reset}
+   ${colors.cyan}${counts.dirs}${colors.reset} folders
+   ${colors.cyan}${counts.files}${colors.reset} files
+
+${colors.bright}📁 Components:${colors.reset}`);
+
+  const components = ['agents', 'skills', 'workflows', 'rules'];
+  for (const comp of components) {
+    const compDir = path.join(agentDir, comp);
+    if (fs.existsSync(compDir)) {
+      const items = fs.readdirSync(compDir);
+      console.log(`   ${colors.green}✔${colors.reset} ${comp}: ${items.length} items`);
+    } else {
+      console.log(`   ${colors.yellow}○${colors.reset} ${comp}: not found`);
+    }
+  }
+}
+
+function updateCommand(options) {
+  log.title('🔄 Musa Agent Kit - Updating...');
+  
+  // Re-run init with force
+  initCommand({ ...options, force: true });
+  
+  log.success('Update complete!');
+}
+
+// ============ NEW COMMANDS ============
+
+function codexCommand(options) {
+  const targetDir = options.path || process.cwd();
+  const template = options.template || 'default';
+  
+  log.title('📝 Musa Agent Kit - Generating AGENTS.md for Codex CLI');
+  
+  const packageRoot = path.resolve(__dirname, '..');
+  const templatesDir = path.join(packageRoot, '.agent', 'templates');
+  
+  // Determine template file
+  let templateFile;
+  switch (template) {
+    case 'web':
+      templateFile = 'AGENTS.web.md';
+      break;
+    case 'mobile':
+      templateFile = 'AGENTS.mobile.md';
+      break;
+    case 'backend':
+      templateFile = 'AGENTS.backend.md';
+      break;
+    default:
+      templateFile = 'AGENTS.md';
+  }
+  
+  const templatePath = path.join(templatesDir, templateFile);
+  const destPath = path.join(targetDir, 'AGENTS.md');
+  
+  if (!fs.existsSync(templatePath)) {
+    log.error(`Template not found: ${templateFile}`);
+    log.info('Available templates: default, web, mobile, backend');
+    process.exit(1);
+  }
+  
+  if (fs.existsSync(destPath) && !options.force) {
+    log.warn('AGENTS.md already exists!');
+    log.info('Use --force to overwrite');
+    process.exit(1);
+  }
+  
+  fs.copyFileSync(templatePath, destPath);
+  
+  log.success(`AGENTS.md created with "${template}" template!`);
+  log.info('Edit the file to customize for your project.');
+  console.log(`
+${colors.bright}📄 File created:${colors.reset} ${destPath}
+
+${colors.bright}🎯 Next steps:${colors.reset}
+   1. Edit AGENTS.md with your project details
+   2. Replace [PROJECT_NAME] placeholders
+   3. Update tech stack section
+   4. Codex CLI will now use this config!
+`);
+}
+
+function agentsCommand() {
+  const agentDir = path.join(process.cwd(), '.agent', 'agents');
+  
+  log.title('🤖 Available Agents');
+  
+  if (!fs.existsSync(agentDir)) {
+    log.warn('.agent/agents folder not found. Run "init" first.');
+    return;
+  }
+  
+  const agents = fs.readdirSync(agentDir).filter(f => f.endsWith('.md'));
+  
+  console.log(`${colors.bright}Found ${agents.length} agents:${colors.reset}\n`);
+  
+  for (const agent of agents) {
+    const name = agent.replace('.md', '');
+    const content = fs.readFileSync(path.join(agentDir, agent), 'utf-8');
+    
+    // Extract description from frontmatter
+    const descMatch = content.match(/description:\s*(.+)/);
+    const desc = descMatch ? descMatch[1].substring(0, 60) + '...' : 'No description';
+    
+    console.log(`  ${colors.cyan}@${name}${colors.reset}`);
+    console.log(`    ${colors.yellow}${desc}${colors.reset}\n`);
+  }
+}
+
+function skillsCommand() {
+  const skillsDir = path.join(process.cwd(), '.agent', 'skills');
+  
+  log.title('🧠 Available Skills');
+  
+  if (!fs.existsSync(skillsDir)) {
+    log.warn('.agent/skills folder not found. Run "init" first.');
+    return;
+  }
+  
+  const skills = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory());
+  
+  console.log(`${colors.bright}Found ${skills.length} skills:${colors.reset}\n`);
+  
+  const categories = {
+    frontend: [],
+    backend: [],
+    security: [],
+    design: [],
+    debug: [],
+    other: []
+  };
+  
+  for (const skill of skills) {
+    const skillPath = path.join(skillsDir, skill.name, 'SKILL.md');
+    if (fs.existsSync(skillPath)) {
+      const content = fs.readFileSync(skillPath, 'utf-8');
+      const descMatch = content.match(/description:\s*(.+)/);
+      const desc = descMatch ? descMatch[1].substring(0, 50) : '';
+      
+      // Categorize
+      if (['react', 'next', 'tailwind', 'frontend'].some(k => skill.name.includes(k))) {
+        categories.frontend.push({ name: skill.name, desc });
+      } else if (['api', 'node', 'prisma', 'database', 'backend'].some(k => skill.name.includes(k))) {
+        categories.backend.push({ name: skill.name, desc });
+      } else if (['security', 'vulnerability', 'red-team'].some(k => skill.name.includes(k))) {
+        categories.security.push({ name: skill.name, desc });
+      } else if (['ui', 'design', 'mobile'].some(k => skill.name.includes(k))) {
+        categories.design.push({ name: skill.name, desc });
+      } else if (['debug', 'problem'].some(k => skill.name.includes(k))) {
+        categories.debug.push({ name: skill.name, desc });
+      } else {
+        categories.other.push({ name: skill.name, desc });
+      }
+    }
+  }
+  
+  for (const [category, items] of Object.entries(categories)) {
+    if (items.length > 0) {
+      console.log(`${colors.bright}${category.toUpperCase()}${colors.reset} (${items.length})`);
+      for (const item of items) {
+        console.log(`  ${colors.cyan}${item.name}${colors.reset}`);
+      }
+      console.log('');
+    }
+  }
+}
+
+function workflowsCommand() {
+  const workflowsDir = path.join(process.cwd(), '.agent', 'workflows');
+  
+  log.title('⚡ Available Workflows (Slash Commands)');
+  
+  if (!fs.existsSync(workflowsDir)) {
+    log.warn('.agent/workflows folder not found. Run "init" first.');
+    return;
+  }
+  
+  const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
+  
+  console.log(`${colors.bright}Found ${workflows.length} workflows:${colors.reset}\n`);
+  
+  for (const wf of workflows) {
+    const name = wf.replace('.md', '');
+    const content = fs.readFileSync(path.join(workflowsDir, wf), 'utf-8');
+    
+    const descMatch = content.match(/description:\s*(.+)/);
+    const desc = descMatch ? descMatch[1] : 'No description';
+    
+    console.log(`  ${colors.green}/${name}${colors.reset}`);
+    console.log(`    ${desc}\n`);
+  }
+}
+
+function doctorCommand() {
+  log.title('🩺 Agent Kit - Health Check');
+  
+  const cwd = process.cwd();
+  const checks = [];
+  
+  // Check 1: .agent folder
+  const agentDir = path.join(cwd, '.agent');
+  if (fs.existsSync(agentDir)) {
+    checks.push({ name: '.agent folder', status: '✅', message: 'Found' });
+  } else {
+    checks.push({ name: '.agent folder', status: '❌', message: 'Not found - run "init"' });
+  }
+  
+  // Check 2: AGENTS.md
+  const agentsMd = path.join(cwd, 'AGENTS.md');
+  if (fs.existsSync(agentsMd)) {
+    checks.push({ name: 'AGENTS.md', status: '✅', message: 'Found (Codex CLI ready)' });
+  } else {
+    checks.push({ name: 'AGENTS.md', status: '⚠️', message: 'Not found - run "codex"' });
+  }
+  
+  // Check 3: .codex folder
+  const codexDir = path.join(cwd, '.codex');
+  if (fs.existsSync(codexDir)) {
+    checks.push({ name: '.codex folder', status: '✅', message: 'Found' });
+  } else {
+    checks.push({ name: '.codex folder', status: '⚠️', message: 'Optional - not found' });
+  }
+  
+  // Check 4: Agents count
+  if (fs.existsSync(path.join(agentDir, 'agents'))) {
+    const count = fs.readdirSync(path.join(agentDir, 'agents')).length;
+    checks.push({ name: 'Agents', status: '✅', message: `${count} available` });
+  }
+  
+  // Check 5: Skills count
+  if (fs.existsSync(path.join(agentDir, 'skills'))) {
+    const count = fs.readdirSync(path.join(agentDir, 'skills')).length;
+    checks.push({ name: 'Skills', status: '✅', message: `${count} available` });
+  }
+  
+  // Check 6: Workflows count
+  if (fs.existsSync(path.join(agentDir, 'workflows'))) {
+    const count = fs.readdirSync(path.join(agentDir, 'workflows')).length;
+    checks.push({ name: 'Workflows', status: '✅', message: `${count} available` });
+  }
+  
+  // Check 7: Codex CLI global prompts
+  const codexPromptDir = path.join(os.homedir(), '.codex', 'prompts');
+  if (fs.existsSync(codexPromptDir)) {
+    const prompts = fs.readdirSync(codexPromptDir).filter(f => f.startsWith('kit-'));
+    if (prompts.length > 0) {
+      checks.push({ name: 'Codex slash commands', status: '✅', message: `${prompts.length} synced` });
+    } else {
+      checks.push({ name: 'Codex slash commands', status: '⚠️', message: 'Not synced - run "setup-codex"' });
+    }
+  } else {
+    checks.push({ name: 'Codex prompts dir', status: '⚠️', message: 'Not found' });
+  }
+  
+  // Display results
+  console.log(`${colors.bright}Diagnostic Results:${colors.reset}\n`);
+  
+  for (const check of checks) {
+    console.log(`  ${check.status} ${colors.cyan}${check.name}${colors.reset}: ${check.message}`);
+  }
+  
+  const hasErrors = checks.some(c => c.status === '❌');
+  const hasWarnings = checks.some(c => c.status === '⚠️');
+  
+  console.log('');
+  if (hasErrors) {
+    log.error('Some critical checks failed. Run suggested commands to fix.');
+  } else if (hasWarnings) {
+    log.warn('Some optional configurations missing. Consider running suggested commands.');
+  } else {
+    log.success('All checks passed! Agent Kit is ready.');
+  }
+}
+
+// ============================================================================
+// MCP Command
+// ============================================================================
+
+function mcpCommand(subArgs, options) {
+  const subCommand = subArgs[0];
+  const agentDir = path.join(process.cwd(), '.agent');
+  const mcpDir = path.join(agentDir, 'mcp');
+  const serversDir = path.join(mcpDir, 'servers');
+  
+  if (!fs.existsSync(agentDir)) {
+    log.error('.agent folder not found. Run: npx @musashishao/agent-kit init');
+    process.exit(1);
+  }
+
+  switch (subCommand) {
+    case 'setup':
+      mcpSetup(options);
+      break;
+    case 'list':
+      mcpList();
+      break;
+    case 'build':
+      mcpBuild();
+      break;
+    case 'status':
+      mcpStatus();
+      break;
+    case 'create':
+      mcpCreate(subArgs.slice(1), options);
+      break;
+    case 'templates':
+      mcpTemplates();
+      break;
+    case 'search':
+      mcpSearch(subArgs.slice(1));
+      break;
+    case 'install':
+      mcpInstall(subArgs.slice(1), options);
+      break;
+    case 'featured':
+      mcpFeatured();
+      break;
+    default:
+      console.log(`
+${colors.bright}${colors.cyan}🔌 Agent Kit MCP${colors.reset}
+
+${colors.bright}Subcommands:${colors.reset}
+  ${colors.cyan}mcp setup${colors.reset}       Configure MCP servers for your AI client
+  ${colors.cyan}mcp list${colors.reset}        List available MCP servers  
+  ${colors.cyan}mcp build${colors.reset}       Build all MCP servers
+  ${colors.cyan}mcp status${colors.reset}      Check MCP server status
+  ${colors.cyan}mcp create${colors.reset}      Create new MCP server from template
+  ${colors.cyan}mcp templates${colors.reset}   List available templates
+  ${colors.cyan}mcp search${colors.reset}      Search MCP servers on npm
+  ${colors.cyan}mcp install${colors.reset}     Install MCP server from npm
+  ${colors.cyan}mcp featured${colors.reset}    Show featured MCP servers
+
+${colors.bright}Options:${colors.reset}
+  --client <name>   AI client: claude, cursor (for setup)
+  --type <template> Template type: api, database, web-scraper, custom
+  --force           Overwrite existing
+
+${colors.bright}Examples:${colors.reset}
+  npx @musashishao/agent-kit mcp setup --client claude
+  npx @musashishao/agent-kit mcp create my-api --type api
+  npx @musashishao/agent-kit mcp search github
+  npx @musashishao/agent-kit mcp install @anthropic/mcp-server-github
+  npx @musashishao/agent-kit mcp featured
+`);
+  }
+}
+
+function mcpSetup(options) {
+  log.title('🔌 MCP Server Setup');
+  
+  const agentDir = path.join(process.cwd(), '.agent');
+  const mcpDir = path.join(agentDir, 'mcp');
+  const serversDir = path.join(mcpDir, 'servers');
+  
+  if (!fs.existsSync(serversDir)) {
+    log.error('MCP servers not found. Make sure Agent Kit is up to date.');
+    process.exit(1);
+  }
+  
+  const clientIndex = process.argv.indexOf('--client');
+  const client = clientIndex !== -1 ? process.argv[clientIndex + 1] : 'claude';
+  
+  const servers = fs.readdirSync(serversDir).filter(f => 
+    fs.statSync(path.join(serversDir, f)).isDirectory()
+  );
+  
+  log.info(`Found ${servers.length} MCP servers`);
+  
+  // Generate config based on client
+  const projectRoot = process.cwd();
+  
+  if (client === 'claude') {
+    const claudeConfigPath = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    
+    let existingConfig = {};
+    if (fs.existsSync(claudeConfigPath)) {
+      try {
+        existingConfig = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf-8'));
+      } catch {
+        existingConfig = {};
+      }
+    }
+    
+    if (!existingConfig.mcpServers) {
+      existingConfig.mcpServers = {};
+    }
+    
+    // Add each server
+    for (const server of servers) {
+      const serverPath = path.join(serversDir, server, 'dist', 'index.js');
+      existingConfig.mcpServers[server] = {
+        command: 'node',
+        args: [serverPath],
+        cwd: projectRoot
+      };
+      log.success(`Added ${server} to Claude config`);
+    }
+    
+    // Write config
+    const configDir = path.dirname(claudeConfigPath);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(claudeConfigPath, JSON.stringify(existingConfig, null, 2));
+    log.success(`Claude Desktop config updated: ${claudeConfigPath}`);
+    
+    console.log(`
+${colors.yellow}⚠️  Important:${colors.reset}
+  1. Build MCP servers first: ${colors.cyan}npx @musashishao/agent-kit mcp build${colors.reset}
+  2. Restart Claude Desktop to apply changes
+`);
+    
+  } else if (client === 'cursor') {
+    const cursorDir = path.join(projectRoot, '.cursor');
+    const cursorConfigPath = path.join(cursorDir, 'mcp.json');
+    
+    if (!fs.existsSync(cursorDir)) {
+      fs.mkdirSync(cursorDir, { recursive: true });
+    }
+    
+    const config = { mcpServers: {} };
+    
+    for (const server of servers) {
+      const serverPath = path.join(serversDir, server, 'dist', 'index.js');
+      config.mcpServers[server] = {
+        command: 'node',
+        args: [serverPath]
+      };
+      log.success(`Added ${server}`);
+    }
+    
+    fs.writeFileSync(cursorConfigPath, JSON.stringify(config, null, 2));
+    log.success(`Cursor config created: ${cursorConfigPath}`);
+    
+  } else {
+    log.error(`Unknown client: ${client}. Use 'claude' or 'cursor'`);
+    process.exit(1);
+  }
+}
+
+function mcpList() {
+  log.title('🔌 Available MCP Servers');
+  
+  const serversDir = path.join(process.cwd(), '.agent', 'mcp', 'servers');
+  
+  if (!fs.existsSync(serversDir)) {
+    log.warn('No MCP servers found');
+    return;
+  }
+  
+  const servers = fs.readdirSync(serversDir).filter(f => 
+    fs.statSync(path.join(serversDir, f)).isDirectory()
+  );
+  
+  console.log(`Found ${servers.length} servers:\n`);
+  
+  for (const server of servers) {
+    const packagePath = path.join(serversDir, server, 'package.json');
+    let description = 'No description';
+    
+    if (fs.existsSync(packagePath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+        description = pkg.description || description;
+      } catch {}
+    }
+    
+    const distExists = fs.existsSync(path.join(serversDir, server, 'dist'));
+    const status = distExists ? `${colors.green}✓ Built${colors.reset}` : `${colors.yellow}○ Not built${colors.reset}`;
+    
+    console.log(`  ${colors.cyan}${server}${colors.reset} ${status}`);
+    console.log(`    ${description}\n`);
+  }
+}
+
+function mcpBuild() {
+  log.title('🔨 Building MCP Servers');
+  
+  const serversDir = path.join(process.cwd(), '.agent', 'mcp', 'servers');
+  
+  if (!fs.existsSync(serversDir)) {
+    log.error('No MCP servers found');
+    process.exit(1);
+  }
+  
+  const servers = fs.readdirSync(serversDir).filter(f => 
+    fs.statSync(path.join(serversDir, f)).isDirectory()
+  );
+  
+  let successCount = 0;
+  
+  for (const server of servers) {
+    const serverPath = path.join(serversDir, server);
+    const packagePath = path.join(serverPath, 'package.json');
+    
+    if (!fs.existsSync(packagePath)) {
+      log.warn(`Skipping ${server}: no package.json`);
+      continue;
+    }
+    
+    log.info(`Building ${server}...`);
+    
+    try {
+      // Install dependencies
+      execSync('npm install', { 
+        cwd: serverPath, 
+        stdio: 'pipe',
+        timeout: 120000 
+      });
+      
+      // Build
+      execSync('npm run build', { 
+        cwd: serverPath, 
+        stdio: 'pipe',
+        timeout: 60000 
+      });
+      
+      log.success(`Built ${server}`);
+      successCount++;
+    } catch (error) {
+      log.error(`Failed to build ${server}: ${error.message}`);
+    }
+  }
+  
+  console.log('');
+  if (successCount === servers.length) {
+    log.success(`All ${successCount} servers built successfully!`);
+    console.log(`\n${colors.bright}Next:${colors.reset} Run ${colors.cyan}npx @musashishao/agent-kit mcp setup --client claude${colors.reset}`);
+  } else {
+    log.warn(`Built ${successCount}/${servers.length} servers`);
+  }
+}
+
+function mcpStatus() {
+  log.title('🔌 MCP Status');
+  
+  const serversDir = path.join(process.cwd(), '.agent', 'mcp', 'servers');
+  
+  if (!fs.existsSync(serversDir)) {
+    log.warn('MCP not configured');
+    return;
+  }
+  
+  const servers = fs.readdirSync(serversDir).filter(f => 
+    fs.statSync(path.join(serversDir, f)).isDirectory()
+  );
+  
+  console.log(`\n${colors.bright}Servers:${colors.reset}`);
+  for (const server of servers) {
+    const distExists = fs.existsSync(path.join(serversDir, server, 'dist'));
+    const status = distExists ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+    console.log(`  ${status} ${server}`);
+  }
+  
+  // Check Claude config
+  const claudeConfigPath = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  const claudeConfigured = fs.existsSync(claudeConfigPath);
+  
+  // Check Cursor config
+  const cursorConfigPath = path.join(process.cwd(), '.cursor', 'mcp.json');
+  const cursorConfigured = fs.existsSync(cursorConfigPath);
+  
+  console.log(`\n${colors.bright}Clients:${colors.reset}`);
+  console.log(`  ${claudeConfigured ? `${colors.green}✓${colors.reset}` : `${colors.yellow}○${colors.reset}`} Claude Desktop`);
+  console.log(`  ${cursorConfigured ? `${colors.green}✓${colors.reset}` : `${colors.yellow}○${colors.reset}`} Cursor`);
+}
+
+// ============================================================================
+// MCP Create Command
+// ============================================================================
+
+function mcpCreate(createArgs, options) {
+  const serverName = createArgs[0];
+  
+  if (!serverName) {
+    log.error('Please provide a server name: mcp create <name> --type <template>');
+    process.exit(1);
+  }
+  
+  // Get template type
+  const typeIndex = process.argv.indexOf('--type');
+  const templateType = typeIndex !== -1 ? process.argv[typeIndex + 1] : 'custom';
+  
+  const validTemplates = ['api', 'database', 'web-scraper', 'custom'];
+  if (!validTemplates.includes(templateType)) {
+    log.error(`Invalid template type: ${templateType}`);
+    log.info(`Valid types: ${validTemplates.join(', ')}`);
+    process.exit(1);
+  }
+  
+  log.title(`🔌 Creating MCP Server: ${serverName}`);
+  log.info(`Template: ${templateType}`);
+  
+  const agentDir = path.join(process.cwd(), '.agent');
+  const mcpDir = path.join(agentDir, 'mcp');
+  const templatesDir = path.join(mcpDir, 'templates');
+  const serversDir = path.join(mcpDir, 'servers');
+  const targetDir = path.join(serversDir, serverName);
+  
+  // Check if server already exists
+  if (fs.existsSync(targetDir)) {
+    if (!options.force) {
+      log.error(`Server '${serverName}' already exists. Use --force to overwrite.`);
+      process.exit(1);
+    }
+    fs.rmSync(targetDir, { recursive: true, force: true });
+  }
+  
+  // Create target directory
+  fs.mkdirSync(path.join(targetDir, 'src'), { recursive: true });
+  
+  // Copy and process template files
+  const templateDir = path.join(templatesDir, templateType);
+  const basePackage = path.join(templatesDir, 'base-package.json.template');
+  const baseTsconfig = path.join(templatesDir, 'base-tsconfig.json');
+  
+  // Process package.json
+  if (fs.existsSync(basePackage)) {
+    let packageContent = fs.readFileSync(basePackage, 'utf-8');
+    packageContent = packageContent
+      .replace(/\{\{SERVER_NAME\}\}/g, serverName)
+      .replace(/\{\{DESCRIPTION\}\}/g, `${templateType} integration`);
+    
+    // Add extra dependencies based on template
+    const pkg = JSON.parse(packageContent);
+    if (templateType === 'database') {
+      pkg.dependencies['better-sqlite3'] = '^11.0.0';
+      pkg.devDependencies['@types/better-sqlite3'] = '^7.6.0';
+    }
+    
+    fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2));
+    log.success('Created package.json');
+  }
+  
+  // Copy tsconfig
+  if (fs.existsSync(baseTsconfig)) {
+    fs.copyFileSync(baseTsconfig, path.join(targetDir, 'tsconfig.json'));
+    log.success('Created tsconfig.json');
+  }
+  
+  // Process main template file
+  const templateSrc = path.join(templateDir, 'src', 'index.ts.template');
+  if (fs.existsSync(templateSrc)) {
+    let srcContent = fs.readFileSync(templateSrc, 'utf-8');
+    srcContent = srcContent.replace(/\{\{SERVER_NAME\}\}/g, serverName);
+    fs.writeFileSync(path.join(targetDir, 'src', 'index.ts'), srcContent);
+    log.success('Created src/index.ts');
+  }
+  
+  // Copy README if exists
+  const templateReadme = path.join(templateDir, 'README.md.template');
+  if (fs.existsSync(templateReadme)) {
+    let readmeContent = fs.readFileSync(templateReadme, 'utf-8');
+    readmeContent = readmeContent.replace(/\{\{SERVER_NAME\}\}/g, serverName);
+    fs.writeFileSync(path.join(targetDir, 'README.md'), readmeContent);
+    log.success('Created README.md');
+  }
+  
+  console.log(`
+${colors.bright}${colors.green}✔ MCP Server created successfully!${colors.reset}
+
+${colors.bright}Location:${colors.reset} ${targetDir}
+
+${colors.bright}Next steps:${colors.reset}
+  1. ${colors.cyan}cd ${targetDir}${colors.reset}
+  2. ${colors.cyan}npm install${colors.reset}
+  3. Edit ${colors.cyan}src/index.ts${colors.reset} to customize your server
+  4. ${colors.cyan}npm run build${colors.reset}
+  5. ${colors.cyan}npx @musashishao/agent-kit mcp setup --client claude${colors.reset}
+`);
+}
+
+function mcpTemplates() {
+  log.title('🔌 Available MCP Templates');
+  
+  const templates = [
+    {
+      name: 'api',
+      description: 'REST API integration',
+      tools: ['api_get', 'api_post', 'api_list_endpoints'],
+      useCase: 'Connect to external REST APIs',
+    },
+    {
+      name: 'database',
+      description: 'SQLite database connector',
+      tools: ['db_query', 'db_schema', 'db_tables', 'db_describe'],
+      useCase: 'Query and analyze databases',
+    },
+    {
+      name: 'web-scraper',
+      description: 'Web page scraper',
+      tools: ['scrape_url', 'extract_links', 'extract_metadata'],
+      useCase: 'Extract data from websites',
+    },
+    {
+      name: 'custom',
+      description: 'Minimal template',
+      tools: ['hello', 'calculate'],
+      useCase: 'Build from scratch',
+    },
+  ];
+  
+  for (const t of templates) {
+    console.log(`
+  ${colors.cyan}${colors.bright}${t.name}${colors.reset}
+    ${t.description}
+    ${colors.yellow}Tools:${colors.reset} ${t.tools.join(', ')}
+    ${colors.yellow}Use case:${colors.reset} ${t.useCase}`);
+  }
+  
+  console.log(`
+
+${colors.bright}Usage:${colors.reset}
+  npx @musashishao/agent-kit mcp create <server-name> --type <template>
+
+${colors.bright}Example:${colors.reset}
+  npx @musashishao/agent-kit mcp create github-api --type api
+`);
+}
+
+// ============================================================================
+// MCP Registry Commands
+// ============================================================================
+
+async function mcpSearch(searchArgs) {
+  const query = searchArgs.join(' ');
+  
+  if (!query) {
+    log.error('Please provide a search query: mcp search <query>');
+    process.exit(1);
+  }
+  
+  log.title(`🔍 Searching MCP servers: "${query}"`);
+  
+  try {
+    // Search npm registry
+    const https = require('https');
+    
+    const searchUrl = `https://registry.npmjs.org/-/v1/search?text=mcp+${encodeURIComponent(query)}&size=15`;
+    
+    const data = await new Promise((resolve, reject) => {
+      https.get(searchUrl, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(body));
+          } catch (e) {
+            reject(new Error('Failed to parse response'));
+          }
+        });
+      }).on('error', reject);
+    });
+    
+    if (!data.objects || data.objects.length === 0) {
+      log.warn('No MCP servers found matching your query');
+      return;
+    }
+    
+    console.log(`\nFound ${data.objects.length} packages:\n`);
+    
+    for (const pkg of data.objects) {
+      const name = pkg.package.name;
+      const desc = pkg.package.description || 'No description';
+      const version = pkg.package.version;
+      
+      console.log(`  ${colors.cyan}${name}${colors.reset} ${colors.yellow}v${version}${colors.reset}`);
+      console.log(`    ${desc.slice(0, 80)}${desc.length > 80 ? '...' : ''}\n`);
+    }
+    
+    console.log(`${colors.bright}Install with:${colors.reset}`);
+    console.log(`  npx @musashishao/agent-kit mcp install <package-name>\n`);
+    
+  } catch (error) {
+    log.error(`Search failed: ${error.message}`);
+  }
+}
+
+async function mcpInstall(installArgs, options) {
+  const packageName = installArgs[0];
+  
+  if (!packageName) {
+    log.error('Please provide a package name: mcp install <package>');
+    process.exit(1);
+  }
+  
+  log.title(`📦 Installing MCP Server: ${packageName}`);
+  
+  const agentDir = path.join(process.cwd(), '.agent');
+  const mcpDir = path.join(agentDir, 'mcp');
+  const externalDir = path.join(mcpDir, 'external');
+  
+  // Create external directory if needed
+  if (!fs.existsSync(externalDir)) {
+    fs.mkdirSync(externalDir, { recursive: true });
+  }
+  
+  try {
+    // Install package globally or in external dir
+    log.info(`Installing ${packageName}...`);
+    
+    execSync(`npm install ${packageName}`, {
+      cwd: externalDir,
+      stdio: 'pipe',
+      timeout: 120000
+    });
+    
+    log.success(`Installed ${packageName}`);
+    
+    // Try to find the package and get its binary
+    const packagePath = path.join(externalDir, 'node_modules', packageName);
+    let binPath = null;
+    
+    if (fs.existsSync(path.join(packagePath, 'package.json'))) {
+      const pkg = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json'), 'utf-8'));
+      
+      if (pkg.bin) {
+        const binName = typeof pkg.bin === 'string' ? packageName : Object.keys(pkg.bin)[0];
+        const binFile = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin[binName];
+        binPath = path.join(packagePath, binFile);
+      } else if (pkg.main) {
+        binPath = path.join(packagePath, pkg.main);
+      }
+    }
+    
+    // Save to installed registry
+    const registryPath = path.join(mcpDir, 'config', 'registry.json');
+    let registry = { installed: [] };
+    
+    if (fs.existsSync(registryPath)) {
+      try {
+        registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+      } catch {}
+    }
+    
+    if (!registry.installed) registry.installed = [];
+    
+    // Add to installed list
+    const existing = registry.installed.findIndex(i => i.name === packageName);
+    const installInfo = {
+      name: packageName,
+      path: binPath || packagePath,
+      installedAt: new Date().toISOString()
+    };
+    
+    if (existing >= 0) {
+      registry.installed[existing] = installInfo;
+    } else {
+      registry.installed.push(installInfo);
+    }
+    
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+    
+    console.log(`
+${colors.bright}${colors.green}✔ Installation complete!${colors.reset}
+
+${colors.bright}Package:${colors.reset} ${packageName}
+${colors.bright}Location:${colors.reset} ${externalDir}/node_modules/${packageName}
+
+${colors.bright}Next steps:${colors.reset}
+  1. Run ${colors.cyan}npx @musashishao/agent-kit mcp setup --client claude${colors.reset}
+  2. Restart Claude Desktop
+`);
+    
+  } catch (error) {
+    log.error(`Installation failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function mcpFeatured() {
+  log.title('⭐ Featured MCP Servers');
+  
+  const featured = [
+    {
+      name: '@anthropic/mcp-server-filesystem',
+      description: 'Secure file system access for AI',
+      category: 'File Systems',
+      official: true
+    },
+    {
+      name: '@anthropic/mcp-server-sqlite',
+      description: 'SQLite database integration',
+      category: 'Databases',
+      official: true
+    },
+    {
+      name: '@anthropic/mcp-server-github',
+      description: 'GitHub API - repos, issues, PRs',
+      category: 'Developer Tools',
+      official: true
+    },
+    {
+      name: '@anthropic/mcp-server-memory',
+      description: 'Persistent memory/knowledge graph',
+      category: 'Knowledge',
+      official: true
+    },
+    {
+      name: 'playwright-mcp',
+      description: 'Browser automation with Playwright',
+      category: 'Browser Automation',
+      official: false
+    },
+    {
+      name: 'mcp-server-fetch',
+      description: 'HTTP requests and web fetching',
+      category: 'Web',
+      official: false
+    },
+    {
+      name: '@anthropic/mcp-server-postgres',
+      description: 'PostgreSQL database integration',
+      category: 'Databases',
+      official: true
+    },
+    {
+      name: 'mcp-server-slack',
+      description: 'Slack workspace integration',
+      category: 'Communication',
+      official: false
+    }
+  ];
+  
+  console.log('\n');
+  
+  for (const server of featured) {
+    const badge = server.official ? `${colors.green}[Official]${colors.reset}` : '';
+    console.log(`  ${colors.cyan}${colors.bright}${server.name}${colors.reset} ${badge}`);
+    console.log(`    ${server.description}`);
+    console.log(`    ${colors.yellow}Category:${colors.reset} ${server.category}\n`);
+  }
+  
+  console.log(`
+${colors.bright}Install with:${colors.reset}
+  npx @musashishao/agent-kit mcp install <package-name>
+
+${colors.bright}Example:${colors.reset}
+  npx @musashishao/agent-kit mcp install @anthropic/mcp-server-github
+
+${colors.bright}More servers:${colors.reset}
+  https://github.com/punkpeye/awesome-mcp-servers
+`);
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+const command = args[0];
+
+const options = {
+  force: args.includes('--force'),
+  quiet: args.includes('--quiet'),
+  path: null,
+  prefix: null,
+  template: null
+};
+
+// Parse --path
+const pathIndex = args.indexOf('--path');
+if (pathIndex !== -1 && args[pathIndex + 1]) {
+  options.path = path.resolve(args[pathIndex + 1]);
+}
+
+// Parse --prefix
+const prefixIndex = args.indexOf('--prefix');
+if (prefixIndex !== -1 && args[prefixIndex + 1]) {
+  options.prefix = args[prefixIndex + 1];
+}
+
+// Parse --template
+const templateIndex = args.indexOf('--template');
+if (templateIndex !== -1 && args[templateIndex + 1]) {
+  options.template = args[templateIndex + 1];
+}
+
+// Execute command
+switch (command) {
+  case 'init':
+    initCommand(options);
+    break;
+  case 'setup-codex':
+    setupCodexCommand(options);
+    break;
+  case 'codex':
+    codexCommand(options);
+    break;
+  case 'mcp':
+    mcpCommand(args.slice(1), options);
+    break;
+  case 'agents':
+    agentsCommand();
+    break;
+  case 'skills':
+    skillsCommand();
+    break;
+  case 'workflows':
+    workflowsCommand();
+    break;
+  case 'doctor':
+    doctorCommand();
+    break;
+  case 'update':
+    updateCommand(options);
+    break;
+  case 'status':
+    statusCommand();
+    break;
+  case '--version':
+  case '-v':
+    showVersion();
+    break;
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+  default:
+    log.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}