superclaude-kiro 1.1.0 → 1.2.0

package/README.md

@@ -10,7 +10,13 @@ Easy installation of [SuperClaude Framework](https://superclaude.netlify.app/) f
 npx superclaude-kiro install
 ```
 
-That's it! SuperClaude is now installed and set as your default agent.
+The installer will guide you through selecting which MCP servers to install. By default, 4 core servers are pre-selected and ready to use immediately.
+
+**Want MorphLLM Fast Apply?** Select it during installation or add it later:
+
+```bash
+npx superclaude-kiro install --with-morph
+```
 
 ## Usage
 
@@ -55,17 +61,26 @@ Reference SuperClaude commands using `#sc-*` syntax:
 ## CLI Commands
 
 ```bash
-# Install SuperClaude
+# Install SuperClaude (interactive MCP server selection)
 npx superclaude-kiro install
 
 # Install with options
-npx superclaude-kiro install --force        # Overwrite existing
-npx superclaude-kiro install --no-mcp       # Skip MCP server config
-npx superclaude-kiro install --no-default   # Don't set as default agent
+npx superclaude-kiro install --force           # Overwrite existing
+npx superclaude-kiro install --minimal         # Core servers only, no prompts
+npx superclaude-kiro install --with-morph      # Include MorphLLM (prompts for API key)
+npx superclaude-kiro install --no-interactive  # Skip prompts, use defaults
+npx superclaude-kiro install --no-mcp          # Skip MCP server config entirely
+npx superclaude-kiro install --no-default      # Don't set as default agent
+
+# Install with MorphLLM API key (for CI/CD)
+npx superclaude-kiro install --morph-api-key "your-api-key"
 
-# Update to latest version
+# Update to latest version (preserves your MCP server selections)
 npx superclaude-kiro update
 
+# Add MorphLLM during update
+npx superclaude-kiro update --with-morph
+
 # Check installation status
 npx superclaude-kiro status
 
@@ -81,9 +96,44 @@ npx superclaude-kiro uninstall
   - `sc-pm` - Project Manager agent
   - `sc-implement` - Implementation agent
   - `sc-analyze` - Analysis agent
-- **MCP servers** - Pre-configured in `~/.kiro/settings/mcp.json`
+- **MCP servers** - Your selected servers in `~/.kiro/settings/mcp.json`
 - **Default agent** - Set to `superclaude` in `~/.kiro/settings/cli.json`
 
+## MCP Server Selection
+
+During installation, you can choose which MCP servers to install:
+
+| Server | Description | Default |
+|--------|-------------|---------|
+| `sequential-thinking` | Structured reasoning and problem-solving | Yes |
+| `context7` | Library documentation lookup | Yes |
+| `playwright` | Browser automation and testing | Yes |
+| `serena` | Semantic code analysis and editing | Yes |
+| `morphllm-fast-apply` | Ultra-fast file editing (requires API key) | No |
+
+### MorphLLM Fast Apply
+
+MorphLLM provides ultra-fast file editing at 10,500+ tokens/sec.
+
+**To install with MorphLLM:**
+
+```bash
+npx superclaude-kiro install --with-morph
+```
+
+The installer will guide you through:
+1. Creating a free account at [morphllm.com](https://www.morphllm.com)
+2. Getting your API key from [dashboard/api-keys](https://morphllm.com/dashboard/api-keys)
+3. Entering your API key securely
+
+**For CI/CD (non-interactive):**
+
+```bash
+npx superclaude-kiro install --morph-api-key "your-api-key"
+```
+
+**Pricing**: Free tier includes 500 requests/month. Paid usage is ~$1/million tokens.
+
 ## Configuration
 
 All agents are configured with:
@@ -156,46 +206,6 @@ npm version patch
 npm publish
 ```
 
-## MCP Server Setup
-
-SuperClaude includes 4 pre-configured MCP servers that work out of the box:
-
-| Server | Purpose |
-|--------|---------|
-| `sequential-thinking` | Structured reasoning and problem-solving |
-| `context7` | Library documentation lookup |
-| `playwright` | Browser automation and testing |
-| `serena` | Semantic code analysis and editing |
-
-### MorphLLM Fast Apply (Optional - Manual Setup Required)
-
-The `morphllm-fast-apply` MCP server provides ultra-fast file editing (10,500+ tokens/sec). **It is NOT included by default** due to Kiro CLI environment variable limitations.
-
-To add MorphLLM support:
-
-1. **Create a free account** at [morphllm.com](https://www.morphllm.com)
-2. **Get your API key** from [dashboard/api-keys](https://www.morphllm.com/dashboard/api-keys)
-3. **Add to your mcp.json** (`~/.kiro/settings/mcp.json`):
-
-```json
-{
-  "mcpServers": {
-    "morphllm-fast-apply": {
-      "command": "npx",
-      "args": ["-y", "@morph-llm/morph-fast-apply"],
-      "env": {
-        "MORPH_API_KEY": "your-actual-api-key-here"
-      },
-      "autoApprove": ["edit_file"]
-    }
-  }
-}
-```
-
-**Important**: Replace `"your-actual-api-key-here"` with your actual API key. The `${MORPH_API_KEY}` environment variable syntax does not work reliably in Kiro CLI ([known issue](https://github.com/kirodotdev/Kiro/issues/3909)).
-
-**Pricing**: Free tier includes 500 requests/month. Paid usage is ~$1/million tokens.
-
 ## Requirements
 
 - Node.js 18+
@@ -221,14 +231,27 @@ kiro-cli mcp list
 
 # Check config
 cat ~/.kiro/settings/mcp.json
+
+# Check status
+npx superclaude-kiro status
 ```
 
 ### MorphLLM not working
 
-MorphLLM requires manual setup. See [MCP Server Setup](#mcp-server-setup) above.
+Run the installer with `--with-morph` to set up MorphLLM:
+
+```bash
+npx superclaude-kiro install --force --with-morph
+```
+
+Or check your current status:
+
+```bash
+npx superclaude-kiro status
+```
 
 **Common issues:**
-- API key must be hardcoded in mcp.json (environment variable expansion doesn't work reliably)
+- API key must be provided during installation (environment variable expansion doesn't work reliably in Kiro CLI)
 - Get your API key from [morphllm.com/dashboard/api-keys](https://www.morphllm.com/dashboard/api-keys)
 
 ### Reinstall from scratch

package/bin/superclaude-kiro.js

@@ -17,11 +17,18 @@ program
   .option('-f, --force', 'Overwrite existing installation')
   .option('--no-mcp', 'Skip MCP server configuration')
   .option('--no-default', 'Do not set superclaude as default agent')
+  .option('-i, --interactive', 'Force interactive mode for MCP selection')
+  .option('--no-interactive', 'Skip interactive prompts (use defaults)')
+  .option('--minimal', 'Install only core MCP servers (no prompts)')
+  .option('--with-morph', 'Include MorphLLM Fast Apply (prompts for API key)')
+  .option('--morph-api-key <key>', 'Include MorphLLM with this API key (for CI/CD)')
   .action(install);
 
 program
   .command('update')
   .description('Update SuperClaude to latest version')
+  .option('--with-morph', 'Add MorphLLM during update (prompts for API key)')
+  .option('--morph-api-key <key>', 'Add MorphLLM with this API key during update')
   .action(update);
 
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superclaude-kiro",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "SuperClaude Framework for Kiro CLI - Easy installation for teams",
   "type": "module",
   "bin": {
@@ -36,10 +36,11 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "commander": "^12.1.0",
     "chalk": "^5.3.0",
+    "commander": "^12.1.0",
     "fs-extra": "^11.2.0",
-    "ora": "^8.1.0"
+    "ora": "^8.1.0",
+    "prompts": "^2.4.2"
   },
   "files": [
     "bin/",

package/src/cli.js

@@ -4,12 +4,19 @@ export async function install(options) {
   await installSuperClaude({
     force: options.force || false,
     mcp: options.mcp !== false,
-    default: options.default !== false
+    default: options.default !== false,
+    interactive: options.interactive,
+    minimal: options.minimal || false,
+    withMorph: options.withMorph || false,
+    morphApiKey: options.morphApiKey || null
   });
 }
 
 export async function update(options) {
-  await updateSuperClaude();
+  await updateSuperClaude({
+    withMorph: options.withMorph || false,
+    morphApiKey: options.morphApiKey || null
+  });
 }
 
 export async function uninstall(options) {

package/src/installer.js

@@ -5,6 +5,19 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import {
+  MCP_SERVERS,
+  CORE_SERVERS,
+  MANAGED_SERVERS,
+  buildServerConfig
+} from './mcp-servers.js';
+import {
+  isInteractive,
+  selectMcpServers,
+  promptMorphLLMSetup,
+  promptMorphApiKeyQuick,
+  confirmInstallation
+} from './prompts.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -15,51 +28,107 @@ const KIRO_DIR = path.join(os.homedir(), '.kiro');
 const DIST_DIR = path.join(__dirname, '..', 'dist');
 
 export async function installSuperClaude(options = {}) {
-  const spinner = ora('Installing SuperClaude for Kiro...').start();
-
   try {
-    // 1. Verify Kiro CLI directory exists
+    // 1. Verify Kiro CLI directory exists (before any prompts)
     if (!await fs.pathExists(KIRO_DIR)) {
-      spinner.fail(chalk.red('Kiro CLI not found.'));
-      console.log(chalk.yellow('\nPlease install Kiro CLI first:'));
-      console.log(chalk.cyan('  npm install -g @anthropic-ai/kiro-cli'));
-      console.log(chalk.yellow('  or visit: https://kiro.dev/docs/cli/'));
+      console.log(chalk.red('\n  Kiro CLI not found.'));
+      console.log(chalk.yellow('\n  Please install Kiro CLI first:'));
+      console.log(chalk.cyan('    npm install -g @anthropic-ai/kiro-cli'));
+      console.log(chalk.yellow('    or visit: https://kiro.dev/docs/cli/'));
       process.exit(1);
     }
 
-    // 2. Check for existing installation
+    // 2. Check for existing installation (before any prompts)
     const steeringDir = path.join(KIRO_DIR, 'steering', 'superclaude');
     if (await fs.pathExists(steeringDir) && !options.force) {
-      spinner.fail(chalk.red('SuperClaude already installed.'));
-      console.log(chalk.yellow('\nTo overwrite, run:'));
-      console.log(chalk.cyan('  npx superclaude-kiro install --force'));
+      console.log(chalk.red('\n  SuperClaude already installed.'));
+      console.log(chalk.yellow('\n  To overwrite, run:'));
+      console.log(chalk.cyan('    npx superclaude-kiro install --force'));
       process.exit(1);
     }
 
     // 3. Verify dist directory exists
     if (!await fs.pathExists(DIST_DIR)) {
-      spinner.fail(chalk.red('Distribution files not found.'));
-      console.log(chalk.yellow('\nPackage may be corrupted. Try reinstalling:'));
-      console.log(chalk.cyan('  npm cache clean --force'));
-      console.log(chalk.cyan('  npx superclaude-kiro@latest install'));
+      console.log(chalk.red('\n  Distribution files not found.'));
+      console.log(chalk.yellow('\n  Package may be corrupted. Try reinstalling:'));
+      console.log(chalk.cyan('    npm cache clean --force'));
+      console.log(chalk.cyan('    npx superclaude-kiro@latest install'));
       process.exit(1);
     }
 
-    // 4. Create directories
+    // 4. Determine MCP server selection and API keys
+    let selectedServers = options.servers || null;
+    let apiKeys = options.apiKeys || {};
+
+    // Handle MCP configuration based on options
+    if (options.mcp !== false) {
+      // If --minimal flag, use only core servers
+      if (options.minimal) {
+        selectedServers = CORE_SERVERS;
+      }
+      // If --morph-api-key provided via CLI
+      else if (options.morphApiKey) {
+        selectedServers = [...CORE_SERVERS, 'morphllm-fast-apply'];
+        apiKeys['morphllm-fast-apply'] = options.morphApiKey;
+      }
+      // If --with-morph flag, prompt for API key
+      else if (options.withMorph) {
+        selectedServers = [...CORE_SERVERS, 'morphllm-fast-apply'];
+        if (isInteractive()) {
+          const morphKey = await promptMorphApiKeyQuick();
+          if (morphKey) {
+            apiKeys['morphllm-fast-apply'] = morphKey;
+          } else {
+            // User didn't provide key, remove morphllm from selection
+            selectedServers = CORE_SERVERS;
+            console.log(chalk.gray('\n  Skipping MorphLLM (no API key provided).\n'));
+          }
+        } else {
+          console.log(chalk.yellow('\n  Warning: --with-morph requires interactive mode or --morph-api-key'));
+          selectedServers = CORE_SERVERS;
+        }
+      }
+      // If interactive and no specific flags, show selection UI
+      else if (options.interactive !== false && isInteractive()) {
+        selectedServers = await selectMcpServers();
+
+        // If morphllm was selected, prompt for API key
+        if (selectedServers.includes('morphllm-fast-apply')) {
+          const morphKey = await promptMorphLLMSetup();
+          if (morphKey) {
+            apiKeys['morphllm-fast-apply'] = morphKey;
+          } else {
+            // User didn't provide key, remove morphllm from selection
+            selectedServers = selectedServers.filter(s => s !== 'morphllm-fast-apply');
+          }
+        }
+
+        await confirmInstallation(selectedServers, !!apiKeys['morphllm-fast-apply']);
+      }
+      // Non-interactive default: core servers only
+      else {
+        selectedServers = CORE_SERVERS;
+      }
+    }
+
+    // Start the spinner after all prompts are done
+    const spinner = ora('Installing SuperClaude for Kiro...').start();
+
+    // 5. Create directories
     spinner.text = 'Creating directories...';
     await fs.ensureDir(path.join(KIRO_DIR, 'steering', 'superclaude'));
     await fs.ensureDir(path.join(KIRO_DIR, 'agents'));
     await fs.ensureDir(path.join(KIRO_DIR, 'settings'));
     await fs.ensureDir(path.join(KIRO_DIR, 'docs'));
 
-    // 5. Copy steering files
+    // 6. Copy steering files
     spinner.text = 'Installing steering files...';
     const steeringSrc = path.join(DIST_DIR, 'steering', 'superclaude');
     if (await fs.pathExists(steeringSrc)) {
       await fs.copy(steeringSrc, path.join(KIRO_DIR, 'steering', 'superclaude'));
     }
 
-    // 6. Copy agents
+    // 7. Copy agents
     spinner.text = 'Installing agents...';
     const agentsSrc = path.join(DIST_DIR, 'agents');
     if (await fs.pathExists(agentsSrc)) {
@@ -74,19 +143,19 @@ export async function installSuperClaude(options = {}) {
       }
     }
 
-    // 7. Configure MCP servers (optional)
-    if (options.mcp !== false) {
+    // 8. Configure MCP servers (with selected servers)
+    if (options.mcp !== false && selectedServers) {
       spinner.text = 'Configuring MCP servers...';
-      await configureMcpServers();
+      await configureMcpServers(selectedServers, apiKeys);
     }
 
-    // 8. Set default agent (optional)
+    // 9. Set default agent (optional)
     if (options.default !== false) {
       spinner.text = 'Setting default agent...';
       await setDefaultAgent();
     }
 
-    // 9. Create version file
+    // 10. Create version file
     spinner.text = 'Finalizing installation...';
     const pkg = require('../package.json');
     await fs.writeJson(
@@ -94,7 +163,8 @@ export async function installSuperClaude(options = {}) {
       {
         version: pkg.version,
         installedAt: new Date().toISOString(),
-        source: 'npm:superclaude-kiro'
+        source: 'npm:superclaude-kiro',
+        mcpServers: selectedServers || []
       },
       { spaces: 2 }
     );
@@ -109,6 +179,9 @@ export async function installSuperClaude(options = {}) {
     console.log(chalk.gray('  Installed:'));
     console.log(chalk.gray(`    - ${steeringFiles} steering files`));
     console.log(chalk.gray(`    - ${agentFiles + 1} agents`));
+    if (selectedServers) {
+      console.log(chalk.gray(`    - ${selectedServers.length} MCP servers`));
+    }
     console.log('');
     console.log(chalk.cyan('Quick Start:'));
     console.log('  1. Run: ' + chalk.yellow('kiro-cli chat'));
@@ -116,12 +189,12 @@ export async function installSuperClaude(options = {}) {
     console.log('');
 
   } catch (error) {
-    spinner.fail(chalk.red('Installation failed: ' + error.message));
+    console.log(chalk.red('\n  Installation failed: ' + error.message));
     process.exit(1);
   }
 }
 
-export async function updateSuperClaude() {
+export async function updateSuperClaude(options = {}) {
   const spinner = ora('Checking for updates...').start();
 
   try {
@@ -134,11 +207,22 @@ export async function updateSuperClaude() {
       process.exit(1);
     }
 
+    // Read existing version info to preserve MCP server selections
+    const versionInfo = await fs.readJson(versionFile);
+    const existingServers = versionInfo.mcpServers || CORE_SERVERS;
+
     // Stop this spinner before installSuperClaude starts its own
     spinner.stop();
 
-    // Perform fresh install with force
-    await installSuperClaude({ force: true, mcp: true, default: true });
+    // Perform fresh install with force, preserving server selection
+    await installSuperClaude({
+      force: true,
+      mcp: true,
+      default: true,
+      servers: existingServers,
+      interactive: false, // Don't re-prompt during update
+      ...options
+    });
 
   } catch (error) {
     spinner.fail(chalk.red('Update failed: ' + error.message));
@@ -238,12 +322,34 @@ export async function getStatus() {
   console.log(chalk.green(`    ✔ Steering files (${steeringFiles})`));
   console.log(chalk.green(`    ✔ Agents (${agentFiles + 1})`));
 
-  // Check MCP
+  // Check MCP servers
   const mcpPath = path.join(KIRO_DIR, 'settings', 'mcp.json');
   if (await fs.pathExists(mcpPath)) {
     const mcpConfig = await fs.readJson(mcpPath);
     const mcpCount = Object.keys(mcpConfig.mcpServers || {}).length;
+    const installedServers = versionInfo.mcpServers || [];
+
     console.log(chalk.green(`    ✔ MCP servers (${mcpCount})`));
+
+    // Show which servers are installed
+    if (installedServers.length > 0) {
+      console.log(chalk.gray('      Installed:'));
+      for (const serverName of installedServers) {
+        const server = MCP_SERVERS[serverName];
+        const displayName = server?.displayName || serverName;
+        console.log(chalk.gray(`        - ${displayName}`));
+      }
+    }
+
+    // Check if morphllm is configured
+    if (mcpConfig.mcpServers?.['morphllm-fast-apply']) {
+      const hasApiKey = mcpConfig.mcpServers['morphllm-fast-apply']?.env?.MORPH_API_KEY;
+      if (hasApiKey && !hasApiKey.startsWith('${')) {
+        console.log(chalk.green('    ✔ MorphLLM API key configured'));
+      } else {
+        console.log(chalk.yellow('    ○ MorphLLM needs API key'));
+      }
+    }
   } else {
     console.log(chalk.yellow('    ○ MCP servers (not configured)'));
   }
@@ -264,48 +370,61 @@ export async function getStatus() {
 
 // Helper functions
 
-async function configureMcpServers() {
+async function configureMcpServers(selectedServers, apiKeys = {}) {
   const mcpPath = path.join(KIRO_DIR, 'settings', 'mcp.json');
-  const templatePath = path.join(DIST_DIR, 'mcp', 'mcp-servers.json');
 
+  // Read existing config to preserve user's custom servers
   let existingConfig = { mcpServers: {} };
   if (await fs.pathExists(mcpPath)) {
     existingConfig = await fs.readJson(mcpPath);
   }
 
-  let newServers = { mcpServers: {} };
-  if (await fs.pathExists(templatePath)) {
-    newServers = await fs.readJson(templatePath);
+  // Build new config from selected servers
+  const newServers = {};
+  for (const serverName of selectedServers) {
+    const apiKey = apiKeys[serverName] || null;
+    const config = buildServerConfig(serverName, apiKey);
+    if (config) {
+      newServers[serverName] = config;
+    }
   }
 
-  // Deep merge MCP servers - add autoApprove from template while preserving user settings
+  // Merge: preserve user's custom servers, update managed servers
   const mergedServers = {};
 
-  // Start with all servers from both configs
-  const allServerNames = new Set([
-    ...Object.keys(newServers.mcpServers || {}),
-    ...Object.keys(existingConfig.mcpServers || {})
-  ]);
-
-  for (const serverName of allServerNames) {
-    const templateServer = newServers.mcpServers?.[serverName] || {};
-    const existingServer = existingConfig.mcpServers?.[serverName] || {};
-
-    // Deep merge: template provides base, existing settings override (except autoApprove)
-    // Preserve user's env settings (API keys etc) if they have real values
-    const mergedEnv = {
-      ...(templateServer.env || {}),
-      ...(existingServer.env || {})
-    };
-
-    mergedServers[serverName] = {
-      ...templateServer,
-      ...existingServer,
-      // Always use template's autoApprove (the whole point of this update)
-      ...(templateServer.autoApprove ? { autoApprove: templateServer.autoApprove } : {}),
-      // Preserve merged env if either had env settings
-      ...(Object.keys(mergedEnv).length > 0 ? { env: mergedEnv } : {})
-    };
+  // First, add all user's non-managed servers
+  for (const [name, config] of Object.entries(existingConfig.mcpServers || {})) {
+    if (!MANAGED_SERVERS.includes(name)) {
+      mergedServers[name] = config;
+    }
+  }
+
+  // Then add/update selected managed servers
+  for (const [name, config] of Object.entries(newServers)) {
+    const existingServer = existingConfig.mcpServers?.[name];
+
+    if (existingServer) {
+      // Preserve user's env settings (especially API keys) if they exist
+      const mergedEnv = {
+        ...(config.env || {}),
+        ...(existingServer.env || {})
+      };
+
+      // But if we have a new API key from this install, use it
+      if (apiKeys[name]) {
+        const server = MCP_SERVERS[name];
+        if (server?.apiKeyEnvVar) {
+          mergedEnv[server.apiKeyEnvVar] = apiKeys[name];
+        }
+      }
+
+      mergedServers[name] = {
+        ...config,
+        ...(Object.keys(mergedEnv).length > 0 ? { env: mergedEnv } : {})
+      };
+    } else {
+      mergedServers[name] = config;
+    }
   }
 
   const mergedConfig = { mcpServers: mergedServers };

package/src/mcp-servers.js

@@ -0,0 +1,157 @@
+/**
+ * MCP Server Definitions for SuperClaude
+ *
+ * Each server has metadata for the interactive installer:
+ * - displayName: Human-readable name
+ * - description: Short description for selection UI
+ * - requiresApiKey: Whether user needs to provide an API key
+ * - defaultEnabled: Pre-selected in interactive mode
+ * - config: The actual MCP server configuration
+ */
+
+export const MCP_SERVERS = {
+  'sequential-thinking': {
+    name: 'sequential-thinking',
+    displayName: 'Sequential Thinking',
+    description: 'Structured reasoning and problem-solving',
+    requiresApiKey: false,
+    defaultEnabled: true,
+    config: {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+      autoApprove: ['sequentialthinking']
+    }
+  },
+
+  'context7': {
+    name: 'context7',
+    displayName: 'Context7',
+    description: 'Library documentation lookup',
+    requiresApiKey: false,
+    defaultEnabled: true,
+    config: {
+      command: 'npx',
+      args: ['-y', '@upstash/context7-mcp'],
+      autoApprove: ['resolve-library-id', 'get-library-docs']
+    }
+  },
+
+  'playwright': {
+    name: 'playwright',
+    displayName: 'Playwright',
+    description: 'Browser automation and testing',
+    requiresApiKey: false,
+    defaultEnabled: true,
+    config: {
+      command: 'npx',
+      args: ['-y', '@playwright/mcp@latest'],
+      autoApprove: [
+        'browser_close', 'browser_resize', 'browser_console_messages',
+        'browser_handle_dialog', 'browser_evaluate', 'browser_file_upload',
+        'browser_fill_form', 'browser_install', 'browser_press_key',
+        'browser_type', 'browser_navigate', 'browser_navigate_back',
+        'browser_network_requests', 'browser_run_code', 'browser_take_screenshot',
+        'browser_snapshot', 'browser_click', 'browser_drag', 'browser_hover',
+        'browser_select_option', 'browser_tabs', 'browser_wait_for'
+      ]
+    }
+  },
+
+  'serena': {
+    name: 'serena',
+    displayName: 'Serena',
+    description: 'Semantic code analysis and editing',
+    requiresApiKey: false,
+    defaultEnabled: true,
+    config: {
+      command: 'uvx',
+      args: [
+        '--from', 'git+https://github.com/oraios/serena',
+        'serena', 'start-mcp-server',
+        '--context', 'ide-assistant',
+        '--enable-web-dashboard', 'false',
+        '--enable-gui-log-window', 'false'
+      ],
+      autoApprove: [
+        'list_dir', 'find_file', 'search_for_pattern', 'get_symbols_overview',
+        'find_symbol', 'find_referencing_symbols', 'replace_symbol_body',
+        'insert_after_symbol', 'insert_before_symbol', 'rename_symbol',
+        'write_memory', 'read_memory', 'list_memories', 'delete_memory',
+        'edit_memory', 'activate_project', 'get_current_config',
+        'check_onboarding_performed', 'onboarding', 'think_about_collected_information',
+        'think_about_task_adherence', 'think_about_whether_you_are_done', 'initial_instructions'
+      ]
+    }
+  },
+
+  'morphllm-fast-apply': {
+    name: 'morphllm-fast-apply',
+    displayName: 'MorphLLM Fast Apply',
+    description: 'Ultra-fast file editing (10,500+ tokens/sec) - requires API key',
+    requiresApiKey: true,
+    apiKeyEnvVar: 'MORPH_API_KEY',
+    defaultEnabled: false,
+    signupUrl: 'https://www.morphllm.com',
+    apiKeyUrl: 'https://morphllm.com/dashboard/api-keys',
+    pricing: 'Free tier: 500 requests/month. Paid: ~$1/million tokens.',
+    setupInstructions: [
+      '1. Create a free account at https://www.morphllm.com',
+      '2. Get your API key at https://morphllm.com/dashboard/api-keys',
+      '3. Paste your API key when prompted'
+    ],
+    config: {
+      command: 'npx',
+      args: ['-y', '@morph-llm/morph-fast-apply'],
+      autoApprove: ['edit_file']
+    }
+  }
+};
+
+// List of server names that are managed by SuperClaude installer
+export const MANAGED_SERVERS = Object.keys(MCP_SERVERS);
+
+// Get core servers (no API key required)
+export const CORE_SERVERS = Object.entries(MCP_SERVERS)
+  .filter(([_, server]) => !server.requiresApiKey)
+  .map(([name]) => name);
+
+// Get servers that require API keys
+export const API_KEY_SERVERS = Object.entries(MCP_SERVERS)
+  .filter(([_, server]) => server.requiresApiKey)
+  .map(([name]) => name);
+
+/**
+ * Build MCP config for a server, optionally with API key
+ */
+export function buildServerConfig(serverName, apiKey = null) {
+  const server = MCP_SERVERS[serverName];
+  if (!server) return null;
+
+  const config = { ...server.config };
+
+  // Add API key to env if provided
+  if (apiKey && server.requiresApiKey) {
+    config.env = {
+      [server.apiKeyEnvVar]: apiKey
+    };
+  }
+
+  return config;
+}
+
+/**
+ * Build complete MCP config from selected servers
+ */
+export function buildMcpConfig(selectedServers, apiKeys = {}) {
+  const mcpServers = {};
+
+  for (const serverName of selectedServers) {
+    const apiKey = apiKeys[serverName] || null;
+    const config = buildServerConfig(serverName, apiKey);
+    if (config) {
+      mcpServers[serverName] = config;
+    }
+  }
+
+  return { mcpServers };
+}

package/src/prompts.js

@@ -0,0 +1,182 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { MCP_SERVERS, CORE_SERVERS } from './mcp-servers.js';
+
+/**
+ * Check if running in interactive TTY
+ */
+export function isInteractive() {
+  return process.stdin.isTTY && process.stdout.isTTY;
+}
+
+/**
+ * Display a header box
+ */
+function showHeader(title) {
+  const line = '─'.repeat(title.length + 4);
+  console.log('');
+  console.log(chalk.cyan(`┌${line}┐`));
+  console.log(chalk.cyan(`│  ${chalk.bold(title)}  │`));
+  console.log(chalk.cyan(`└${line}┘`));
+  console.log('');
+}
+
+/**
+ * Prompt user to select which MCP servers to install
+ */
+export async function selectMcpServers() {
+  showHeader('MCP Server Setup');
+
+  const choices = Object.entries(MCP_SERVERS).map(([name, server]) => {
+    const apiKeyNote = server.requiresApiKey ? chalk.yellow(' (requires API key)') : '';
+    return {
+      title: `${server.displayName}${apiKeyNote}`,
+      description: server.description,
+      value: name,
+      selected: server.defaultEnabled
+    };
+  });
+
+  const response = await prompts({
+    type: 'multiselect',
+    name: 'servers',
+    message: 'Select MCP servers to install',
+    choices,
+    hint: '- Space to toggle, Enter to confirm',
+    instructions: false
+  }, {
+    onCancel: () => {
+      console.log(chalk.yellow('\nInstallation cancelled.'));
+      process.exit(0);
+    }
+  });
+
+  return response.servers || CORE_SERVERS;
+}
+
+/**
+ * Prompt for MorphLLM API key setup
+ */
+export async function promptMorphLLMSetup() {
+  const server = MCP_SERVERS['morphllm-fast-apply'];
+
+  showHeader('MorphLLM Fast Apply Setup');
+
+  console.log(chalk.white('MorphLLM provides ultra-fast file editing (10,500+ tokens/sec).'));
+  console.log(chalk.gray(server.pricing));
+  console.log('');
+  console.log(chalk.white('Setup steps:'));
+  server.setupInstructions.forEach(step => {
+    console.log(chalk.gray(`  ${step}`));
+  });
+  console.log('');
+
+  // Ask if user has an API key
+  const hasKey = await prompts({
+    type: 'confirm',
+    name: 'value',
+    message: 'Do you have a MorphLLM API key?',
+    initial: false
+  }, {
+    onCancel: () => {
+      return { value: false };
+    }
+  });
+
+  if (!hasKey.value) {
+    console.log('');
+    console.log(chalk.cyan('To get your free API key:'));
+    console.log(chalk.white(`  1. Sign up at: ${chalk.underline(server.signupUrl)}`));
+    console.log(chalk.white(`  2. Get key at: ${chalk.underline(server.apiKeyUrl)}`));
+    console.log('');
+
+    const wannaWait = await prompts({
+      type: 'confirm',
+      name: 'value',
+      message: 'Would you like to enter an API key now? (open the URL above first)',
+      initial: true
+    });
+
+    if (!wannaWait.value) {
+      console.log('');
+      console.log(chalk.gray('No worries! You can add MorphLLM later by running:'));
+      console.log(chalk.cyan('  npx superclaude-kiro install --with-morph'));
+      console.log('');
+      return null;
+    }
+  }
+
+  // Prompt for the API key
+  const apiKeyResponse = await prompts({
+    type: 'password',
+    name: 'apiKey',
+    message: 'Enter your MorphLLM API key',
+    validate: value => {
+      if (!value || value.trim().length === 0) {
+        return 'API key cannot be empty';
+      }
+      if (value.trim().length < 10) {
+        return 'API key seems too short';
+      }
+      return true;
+    }
+  }, {
+    onCancel: () => {
+      return { apiKey: null };
+    }
+  });
+
+  if (apiKeyResponse.apiKey) {
+    console.log(chalk.green('  API key saved.'));
+    return apiKeyResponse.apiKey.trim();
+  }
+
+  return null;
+}
+
+/**
+ * Quick prompt for MorphLLM key when using --with-morph flag
+ */
+export async function promptMorphApiKeyQuick() {
+  const server = MCP_SERVERS['morphllm-fast-apply'];
+
+  console.log('');
+  console.log(chalk.cyan.bold('MorphLLM Fast Apply'));
+  console.log(chalk.gray(server.pricing));
+  console.log('');
+  console.log(chalk.white(`Sign up: ${chalk.underline(server.signupUrl)}`));
+  console.log(chalk.white(`Get key: ${chalk.underline(server.apiKeyUrl)}`));
+  console.log('');
+
+  const response = await prompts({
+    type: 'password',
+    name: 'apiKey',
+    message: 'Enter your MorphLLM API key (or press Enter to skip)',
+  });
+
+  if (response.apiKey && response.apiKey.trim().length > 0) {
+    return response.apiKey.trim();
+  }
+
+  return null;
+}
+
+/**
+ * Confirm installation with selected servers
+ */
+export async function confirmInstallation(servers, hasMorph) {
+  console.log('');
+  console.log(chalk.white('Will install the following MCP servers:'));
+  servers.forEach(name => {
+    const server = MCP_SERVERS[name];
+    const icon = server?.requiresApiKey ? chalk.yellow('*') : chalk.green('✓');
+    console.log(`  ${icon} ${server?.displayName || name}`);
+  });
+
+  if (hasMorph) {
+    console.log(chalk.gray('  * requires API key'));
+  }
+  console.log('');
+
+  return true; // Auto-confirm for now, can add prompt if needed
+}