@musashishao/agent-kit 1.9.0 → 1.9.1

package/bin/cli.js

@@ -28,62 +28,182 @@ const log = {
   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}ai${colors.reset}            AI Infrastructure management (init, sync, status)
-  ${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.cyan}set-lang${colors.reset}      Set Agent language (vi/en)
-
-${colors.bright}AI Subcommands:${colors.reset}
-  ${colors.cyan}ai init${colors.reset}       Initialize AI infrastructure (AGENTS.md, Graph, RAG)
-  ${colors.cyan}ai status${colors.reset}     Show AI infrastructure status
-  ${colors.cyan}ai config${colors.reset}     Auto-configure AI hosts (Claude, Cursor, etc.)
-  ${colors.cyan}ai memory${colors.reset}     Manage JSON memory (session, user, brain)
-  ${colors.cyan}ai autofix${colors.reset}    Autonomous repair loop (Run-Analyze-Fix)
-  ${colors.cyan}ai dashboard${colors.reset}  Open visual AI brain dashboard
+// ============ TRANSLATIONS ============
+const translations = {
+  en: {
+    title: '🚀 Musa Agent Kit',
+    usage: 'Usage:',
+    usageText: `  npx ${PACKAGE_NAME} <command> [options]`,
+    commands: 'Commands:',
+    init: 'Install .agent folder into current project',
+    ai: 'AI Infrastructure management (init, sync, status)',
+    setupCodex: 'Sync workflows with Codex CLI slash commands',
+    codex: 'Generate AGENTS.md for Codex CLI (use --template)',
+    mcp: 'MCP server management (setup, list, build)',
+    agents: 'List all available agents',
+    skills: 'List all available skills',
+    workflows: 'List all available workflows',
+    doctor: 'Check configuration and diagnose issues',
+    update: 'Update .agent folder to latest version',
+    status: 'Check installation status',
+    setLang: 'Set Agent language (vi/en)',
+    aiSubcommands: 'AI Subcommands:',
+    aiInit: 'Initialize AI infrastructure (AGENTS.md, Graph, RAG)',
+    aiStatus: 'Show AI infrastructure status',
+    aiConfig: 'Auto-configure AI hosts (Claude, Cursor, etc.)',
+    aiMemory: 'Manage JSON memory (session, user, brain)',
+    aiAutofix: 'Autonomous repair loop (Run-Analyze-Fix)',
+    aiDashboard: 'Open visual AI brain dashboard',
+    mcpSubcommands: 'MCP Subcommands:',
+    mcpSetup: 'Configure MCP servers for Claude/Cursor',
+    mcpList: 'List available MCP servers',
+    mcpBuild: 'Build MCP servers',
+    options: 'Options:',
+    optForce: 'Overwrite existing files',
+    optPath: 'Install in specific directory',
+    optPrefix: 'Custom prefix for slash commands (default: kit-)',
+    optTemplate: 'Template type: web, mobile, backend (for codex command)',
+    optClient: 'MCP client: claude, cursor (for mcp setup)',
+    optQuiet: 'Suppress output',
+    optHelp: 'Show this help message',
+    optVersion: 'Show version',
+    examples: 'Examples:',
+    exInit: 'npx @musashishao/agent-kit init',
+    exAiInit: 'Setup AI infrastructure',
+    exAiSync: 'Update after code changes',
+    exAiMemory: 'View session status',
+    exAiAutofix: 'Run autonomous fix',
+    exMcpSetup: 'npx @musashishao/agent-kit mcp setup --client claude',
+    exCodex: 'npx @musashishao/agent-kit codex --template web',
+    exDoctor: 'npx @musashishao/agent-kit doctor',
+    exSetLang: 'Switch to Vietnamese',
+    latestVersion: 'To ensure you have the latest version from NPM:'
+  },
+  vi: {
+    title: '🚀 Musa Agent Kit',
+    usage: 'Cách dùng:',
+    usageText: `  npx ${PACKAGE_NAME} <lệnh> [tùy chọn]`,
+    commands: 'Danh sách lệnh:',
+    init: 'Cài đặt thư mục .agent vào project hiện tại',
+    ai: 'Quản lý hạ tầng AI (init, sync, status)',
+    setupCodex: 'Đồng bộ workflow với slash commands của Codex CLI',
+    codex: 'Tạo file AGENTS.md cho Codex CLI (dùng --template)',
+    mcp: 'Quản lý MCP server (setup, list, build)',
+    agents: 'Liệt kê danh sách Agent hiện có',
+    skills: 'Liệt kê danh sách Skill hiện có',
+    workflows: 'Liệt kê danh sách Workflow hiện có',
+    doctor: 'Kiểm tra cấu hình và chẩn đoán lỗi',
+    update: 'Cập nhật thư mục .agent lên phiên bản mới nhất',
+    status: 'Kiểm tra trạng thái cài đặt',
+    setLang: 'Thiết lập ngôn ngữ Agent (vi/en)',
+    aiSubcommands: 'Các lệnh AI phụ:',
+    aiInit: 'Khởi tạo hạ tầng AI (AGENTS.md, Graph, RAG)',
+    aiStatus: 'Hiển thị trạng thái hạ tầng AI',
+    aiConfig: 'Tự động cấu hình AI hosts (Claude, Cursor, v.v.)',
+    aiMemory: 'Quản lý bộ nhớ JSON (session, user, brain)',
+    aiAutofix: 'Vòng lặp sửa lỗi tự động (Run-Analyze-Fix)',
+    aiDashboard: 'Mở dashboard trực quan cho AI brain',
+    mcpSubcommands: 'Các lệnh MCP phụ:',
+    mcpSetup: 'Cấu hình MCP servers cho Claude/Cursor',
+    mcpList: 'Liệt kê các MCP servers hiện có',
+    mcpBuild: 'Build các MCP servers',
+    options: 'Tùy chọn:',
+    optForce: 'Ghi đè lên các file hiện có',
+    optPath: 'Cài đặt vào một thư mục cụ thể',
+    optPrefix: 'Tiền tố tùy chỉnh cho slash commands (mặc định: kit-)',
+    optTemplate: 'Loại template: web, mobile, backend (cho lệnh codex)',
+    optClient: 'MCP client: claude, cursor (cho mcp setup)',
+    optQuiet: 'Tắt các thông báo đầu ra',
+    optHelp: 'Hiển thị thông tin trợ giúp này',
+    optVersion: 'Hiển thị phiên bản',
+    examples: 'Ví dụ:',
+    exInit: 'npx @musashishao/agent-kit init',
+    exAiInit: 'Thiết lập hạ tầng AI',
+    exAiSync: 'Cập nhật sau khi thay đổi code',
+    exAiMemory: 'Xem trạng thái session hiện tại',
+    exAiAutofix: 'Chạy vòng lặp sửa lỗi tự động',
+    exMcpSetup: 'npx @musashishao/agent-kit mcp setup --client claude',
+    exCodex: 'npx @musashishao/agent-kit codex --template web',
+    exDoctor: 'npx @musashishao/agent-kit doctor',
+    exSetLang: 'Chuyển sang tiếng Việt',
+    latestVersion: 'Đảm bảo bạn luôn có phiên bản mới nhất từ NPM:'
+  }
+};
 
-${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
+function getSystemLanguage() {
+  const agentDir = path.join(process.cwd(), '.agent');
+  const userJson = path.join(agentDir, 'memory', 'user.json');
+  
+  if (fs.existsSync(userJson)) {
+    try {
+      const userData = JSON.parse(fs.readFileSync(userJson, 'utf-8'));
+      return (userData.preferences && userData.preferences.language) || 'en';
+    } catch (e) {
+      return 'en';
+    }
+  }
+  return 'en';
+}
 
-${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
+function showHelp() {
+  const lang = getSystemLanguage();
+  const t = translations[lang] || translations.en;
 
-${colors.bright}Examples:${colors.reset}
-  npx ${PACKAGE_NAME} init
-  npx ${PACKAGE_NAME} ai init              # Setup AI infrastructure
-  npx ${PACKAGE_NAME} ai sync              # Update after code changes
-  npx ${PACKAGE_NAME} ai memory get        # View session status
-  npx ${PACKAGE_NAME} ai autofix "npm test" # Run autonomous fix
-  npx ${PACKAGE_NAME} mcp setup --client claude
-  npx ${PACKAGE_NAME} codex --template web
-  npx ${PACKAGE_NAME} doctor
-  npx ${PACKAGE_NAME} set-lang vi          # Switch to Vietnamese
-  
-${colors.yellow}# To ensure you have the latest version from NPM:${colors.reset}
+  console.log(`
+${colors.bright}${colors.cyan}${t.title}${colors.reset} v${VERSION}
+
+${colors.bright}${t.usage}${colors.reset}
+${t.usageText}
+
+${colors.bright}${t.commands}${colors.reset}
+  ${colors.cyan}init${colors.reset}          ${t.init}
+  ${colors.cyan}ai${colors.reset}            ${t.ai}
+  ${colors.cyan}setup-codex${colors.reset}   ${t.setupCodex}
+  ${colors.cyan}codex${colors.reset}         ${t.codex}
+  ${colors.cyan}mcp${colors.reset}           ${t.mcp}
+  ${colors.cyan}agents${colors.reset}        ${t.agents}
+  ${colors.cyan}skills${colors.reset}        ${t.skills}
+  ${colors.cyan}workflows${colors.reset}     ${t.workflows}
+  ${colors.cyan}doctor${colors.reset}        ${t.doctor}
+  ${colors.cyan}update${colors.reset}        ${t.update}
+  ${colors.cyan}status${colors.reset}        ${t.status}
+  ${colors.cyan}set-lang${colors.reset}      ${t.setLang}
+
+${colors.bright}${t.aiSubcommands}${colors.reset}
+  ${colors.cyan}ai init${colors.reset}       ${t.aiInit}
+  ${colors.cyan}ai status${colors.reset}     ${t.aiStatus}
+  ${colors.cyan}ai config${colors.reset}     ${t.aiConfig}
+  ${colors.cyan}ai memory${colors.reset}     ${t.aiMemory}
+  ${colors.cyan}ai autofix${colors.reset}    ${t.aiAutofix}
+  ${colors.cyan}ai dashboard${colors.reset}  ${t.aiDashboard}
+
+${colors.bright}${t.mcpSubcommands}${colors.reset}
+  ${colors.cyan}mcp setup${colors.reset}     ${t.mcpSetup}
+  ${colors.cyan}mcp list${colors.reset}      ${t.mcpList}
+  ${colors.cyan}mcp build${colors.reset}     ${t.mcpBuild}
+
+${colors.bright}${t.options}${colors.reset}
+  --force       ${t.optForce}
+  --path <dir>  ${t.optPath}
+  --prefix <str> ${t.optPrefix}
+  --template <type>  ${t.optTemplate}
+  --client <name>  ${t.optClient}
+  --quiet       ${t.optQuiet}
+  --help        ${t.optHelp}
+  --version     ${t.optVersion}
+
+${colors.bright}${t.examples}${colors.reset}
+  ${t.exInit}
+  npx ${PACKAGE_NAME} ai init              # ${t.exAiInit}
+  npx ${PACKAGE_NAME} ai sync              # ${t.exAiSync}
+  npx ${PACKAGE_NAME} ai memory get        # ${t.exAiMemory}
+  npx ${PACKAGE_NAME} ai autofix "npm test" # ${t.exAiAutofix}
+  ${t.exMcpSetup}
+  ${t.exCodex}
+  ${t.exDoctor}
+  npx ${PACKAGE_NAME} set-lang vi          # ${t.exSetLang}
+  
+${colors.yellow}# ${t.latestVersion}${colors.reset}
   npx ${PACKAGE_NAME}@latest update
 `);
 }
@@ -426,10 +546,15 @@ function skillsCommand() {
 }
 
 function workflowsCommand() {
-  const agentDir = path.join(process.cwd(), '.agent');
+  const targetDir = process.env.AK_PROJECT_ROOT || process.cwd();
+  const agentDir = path.join(targetDir, '.agent');
   const workflowsDir = path.join(agentDir, 'workflows');
   const userJson = path.join(agentDir, 'memory', 'user.json');
   
+  // Find project root for docs
+  let projectRoot = targetDir;
+  const packageRoot = path.resolve(__dirname, '..');
+  
   let language = 'en';
   if (fs.existsSync(userJson)) {
     try {
@@ -437,6 +562,32 @@ function workflowsCommand() {
       language = (userData.preferences && userData.preferences.language) || 'en';
     } catch (e) {}
   }
+
+  // Try to find WORKFLOW_GUIDE.md with language suffix in internal folders
+  const guidePaths = [
+    path.join(agentDir, 'templates', 'docs', `WORKFLOW_GUIDE.${language}.md`),
+    path.join(packageRoot, '.agent', 'templates', 'docs', `WORKFLOW_GUIDE.${language}.md`),
+    path.join(agentDir, 'templates', 'docs', 'WORKFLOW_GUIDE.md'),
+    path.join(packageRoot, '.agent', 'templates', 'docs', 'WORKFLOW_GUIDE.md'),
+    path.join(projectRoot, 'docs', `WORKFLOW_GUIDE.${language}.md`),
+    path.join(packageRoot, 'docs', `WORKFLOW_GUIDE.${language}.md`),
+    path.join(projectRoot, 'docs', 'WORKFLOW_GUIDE.md'),
+    path.join(packageRoot, 'docs', 'WORKFLOW_GUIDE.md')
+  ];
+  
+  let guideContent = null;
+  for (const gp of guidePaths) {
+    if (fs.existsSync(gp)) {
+      guideContent = fs.readFileSync(gp, 'utf-8');
+      break;
+    }
+  }
+
+  if (guideContent) {
+    log.title('📚 AGENT KIT WORKFLOW GUIDE');
+    console.log(guideContent);
+    return;
+  }
   
   log.title('⚡ Available Workflows (Slash Commands)');
   
@@ -1183,11 +1334,59 @@ async function mcpSearch(searchArgs) {
   }
 }
 
+// Known MCP packages with special configurations
+const KNOWN_MCP_PACKAGES = {
+  'notebooklm-mcp': {
+    displayName: 'NotebookLM (Agent Kit Custom)',
+    serverName: 'notebooklm',
+    command: 'node',
+    args: ['.agent/mcp/servers/notebooklm/dist/index.js'],
+    description: 'Chrome OAuth, skill-linking, Agent Kit native integration',
+    authRequired: true,
+    authInstructions: 'Say "Log me in to NotebookLM" in Claude/Cursor to authenticate via Google.',
+    tools: [
+      'notebooklm_login', 
+      'notebooklm_query', 
+      'notebooklm_list_notebooks',
+      'notebooklm_library_add',
+      'notebooklm_library_search',
+      'notebooklm_skill_link'
+    ],
+    requiresBuild: true,
+    buildCommand: 'cd .agent/mcp/servers/notebooklm && npm install && npm run build',
+  },
+  '@anthropic/mcp-server-github': {
+    displayName: 'GitHub',
+    serverName: 'github',
+    command: 'npx',
+    args: ['-y', '@anthropic/mcp-server-github'],
+    description: 'GitHub API - repos, issues, PRs',
+    envRequired: ['GITHUB_TOKEN'],
+  },
+  '@anthropic/mcp-server-filesystem': {
+    displayName: 'Filesystem',
+    serverName: 'filesystem',
+    command: 'npx',
+    args: ['-y', '@anthropic/mcp-server-filesystem', process.cwd()],
+    description: 'Secure file system access',
+  },
+  'playwright-mcp': {
+    displayName: 'Playwright',
+    serverName: 'playwright',
+    command: 'npx',
+    args: ['-y', 'playwright-mcp'],
+    description: 'Browser automation with Playwright',
+  },
+};
+
 async function mcpInstall(installArgs, options) {
   const packageName = installArgs[0];
   
   if (!packageName) {
     log.error('Please provide a package name: mcp install <package>');
+    log.info('Examples:');
+    log.info('  mcp install notebooklm-mcp');
+    log.info('  mcp install @anthropic/mcp-server-github');
     process.exit(1);
   }
   
@@ -1195,84 +1394,185 @@ async function mcpInstall(installArgs, options) {
   
   const agentDir = path.join(process.cwd(), '.agent');
   const mcpDir = path.join(agentDir, 'mcp');
-  const externalDir = path.join(mcpDir, 'external');
+  const configDir = path.join(mcpDir, 'config');
   
-  // Create external directory if needed
-  if (!fs.existsSync(externalDir)) {
-    fs.mkdirSync(externalDir, { recursive: true });
+  // Create config directory if needed
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { 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}`);
+  // Check if this is a known package
+  const knownPackage = KNOWN_MCP_PACKAGES[packageName];
+  const serverName = knownPackage?.serverName || packageName.replace(/^@[^/]+\//, '').replace(/-mcp$/, '').replace(/^mcp-server-/, '');
+  
+  log.info(`Server name: ${serverName}`);
+  
+  // Build MCP config entry
+  let mcpConfig;
+  if (knownPackage) {
+    mcpConfig = {
+      command: knownPackage.command,
+      args: knownPackage.args,
+    };
+    if (knownPackage.envRequired) {
+      mcpConfig.env = {};
+      for (const envVar of knownPackage.envRequired) {
+        mcpConfig.env[envVar] = process.env[envVar] || `YOUR_${envVar}`;
+      }
+    }
     
-    // Try to find the package and get its binary
-    const packagePath = path.join(externalDir, 'node_modules', packageName);
-    let binPath = null;
+    // Auto-build if required
+    if (knownPackage.requiresBuild && knownPackage.buildCommand) {
+      log.info('Building server (this may take a moment)...');
+      try {
+        execSync(knownPackage.buildCommand, {
+          cwd: process.cwd(),
+          stdio: 'pipe',
+          timeout: 180000, // 3 minutes
+        });
+        log.success('Build completed');
+      } catch (buildError) {
+        log.error(`Build failed: ${buildError.message}`);
+        log.info('You may need to run the build manually:');
+        log.info(`  ${knownPackage.buildCommand}`);
+      }
+    }
+  } else {
+    // Generic npx config for unknown packages
+    mcpConfig = {
+      command: 'npx',
+      args: ['-y', `${packageName}@latest`],
+    };
+  }
+  
+  // ========== Auto-configure Claude Desktop ==========
+  const claudeConfigPath = path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  let claudeUpdated = false;
+  
+  try {
+    let claudeConfig = { mcpServers: {} };
     
-    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);
+    if (fs.existsSync(claudeConfigPath)) {
+      claudeConfig = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf-8'));
+      if (!claudeConfig.mcpServers) claudeConfig.mcpServers = {};
+    } else {
+      // Create directory if needed
+      const claudeDir = path.dirname(claudeConfigPath);
+      if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
       }
     }
     
-    // Save to installed registry
-    const registryPath = path.join(mcpDir, 'config', 'registry.json');
-    let registry = { installed: [] };
+    // Add/update server config
+    claudeConfig.mcpServers[serverName] = mcpConfig;
     
-    if (fs.existsSync(registryPath)) {
-      try {
-        registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
-      } catch {}
+    fs.writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2));
+    log.success(`Added "${serverName}" to Claude Desktop config`);
+    claudeUpdated = true;
+  } catch (err) {
+    log.warn(`Could not update Claude Desktop config: ${err.message}`);
+  }
+  
+  // ========== Auto-configure Cursor ==========
+  const cursorDir = path.join(process.cwd(), '.cursor');
+  const cursorConfigPath = path.join(cursorDir, 'mcp.json');
+  let cursorUpdated = false;
+  
+  try {
+    if (!fs.existsSync(cursorDir)) {
+      fs.mkdirSync(cursorDir, { recursive: true });
     }
     
-    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()
-    };
+    let cursorConfig = { mcpServers: {} };
     
-    if (existing >= 0) {
-      registry.installed[existing] = installInfo;
-    } else {
-      registry.installed.push(installInfo);
+    if (fs.existsSync(cursorConfigPath)) {
+      cursorConfig = JSON.parse(fs.readFileSync(cursorConfigPath, 'utf-8'));
+      if (!cursorConfig.mcpServers) cursorConfig.mcpServers = {};
     }
     
-    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+    // Add/update server config
+    cursorConfig.mcpServers[serverName] = mcpConfig;
     
-    console.log(`
-${colors.bright}${colors.green}✔ Installation complete!${colors.reset}
+    fs.writeFileSync(cursorConfigPath, JSON.stringify(cursorConfig, null, 2));
+    log.success(`Added "${serverName}" to Cursor config (.cursor/mcp.json)`);
+    cursorUpdated = true;
+  } catch (err) {
+    log.warn(`Could not update Cursor config: ${err.message}`);
+  }
+  
+  // ========== Save to registry ==========
+  const registryPath = path.join(configDir, 'registry.json');
+  let registry = { installed: [] };
+  
+  if (fs.existsSync(registryPath)) {
+    try {
+      registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+    } catch {}
+  }
+  
+  if (!registry.installed) registry.installed = [];
+  
+  const existing = registry.installed.findIndex(i => i.name === packageName);
+  const installInfo = {
+    name: packageName,
+    serverName,
+    config: mcpConfig,
+    installedAt: new Date().toISOString(),
+    claudeConfigured: claudeUpdated,
+    cursorConfigured: cursorUpdated,
+  };
+  
+  if (existing >= 0) {
+    registry.installed[existing] = installInfo;
+  } else {
+    registry.installed.push(installInfo);
+  }
+  
+  fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+  
+  // ========== Output ==========
+  console.log(`
+${colors.bright}${colors.green}✔ MCP Server installed and configured!${colors.reset}
 
 ${colors.bright}Package:${colors.reset} ${packageName}
-${colors.bright}Location:${colors.reset} ${externalDir}/node_modules/${packageName}
+${colors.bright}Server Name:${colors.reset} ${serverName}
+${colors.bright}Configuration:${colors.reset}
+  ${claudeUpdated ? `${colors.green}✓${colors.reset}` : `${colors.yellow}○${colors.reset}`} Claude Desktop
+  ${cursorUpdated ? `${colors.green}✓${colors.reset}` : `${colors.yellow}○${colors.reset}`} Cursor
+`);
 
-${colors.bright}Next steps:${colors.reset}
-  1. Run ${colors.cyan}npx @musashishao/agent-kit mcp setup --client claude${colors.reset}
-  2. Restart Claude Desktop
+  // Special instructions for known packages
+  if (knownPackage) {
+    console.log(`${colors.bright}Description:${colors.reset} ${knownPackage.description}`);
+    
+    if (knownPackage.authRequired) {
+      console.log(`
+${colors.yellow}⚠️  Authentication Required:${colors.reset}
+  ${knownPackage.authInstructions}
 `);
+    }
     
-  } catch (error) {
-    log.error(`Installation failed: ${error.message}`);
-    process.exit(1);
+    if (knownPackage.envRequired) {
+      console.log(`${colors.yellow}⚠️  Environment Variables Required:${colors.reset}`);
+      for (const envVar of knownPackage.envRequired) {
+        console.log(`  export ${envVar}="your-value"`);
+      }
+      console.log('');
+    }
+    
+    if (knownPackage.tools) {
+      console.log(`${colors.bright}Available Tools:${colors.reset}`);
+      for (const tool of knownPackage.tools) {
+        console.log(`  • ${colors.cyan}${tool}${colors.reset}`);
+      }
+      console.log('');
+    }
   }
+  
+  console.log(`${colors.bright}Next Steps:${colors.reset}
+  1. ${colors.cyan}Restart Claude Desktop${colors.reset} to load the new MCP server
+  2. ${knownPackage?.authRequired ? 'Authenticate when prompted' : 'Start using the new tools!'}
+`);
 }
 
 function mcpFeatured() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@musashishao/agent-kit",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "AI Agent templates - Skills, Agents, Workflows, and AI-Ready Data Infrastructure Gateway",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,6 @@
   },
   "files": [
     "bin",
-    "docs",
     ".agent/.shared",
     ".agent/adr",
     ".agent/agents",