grokcodecli 0.1.2 → 0.1.4

package/src/conversation/chat.ts

@@ -11,6 +11,7 @@ import { PermissionManager } from '../permissions/manager.js';
 import { HistoryManager, ConversationSession } from './history.js';
 import { ConfigManager } from '../config/manager.js';
 import { drawBox, randomTip, divider, formatCodeBlock, progressBar } from '../utils/ui.js';
+import { interactiveSelect, SelectorOption } from '../utils/selector.js';
 
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -76,12 +77,51 @@ export class GrokChat {
   private sessionStartTime: Date = new Date();
   private apiKey: string;
 
+  // All slash commands for autocomplete
+  private static SLASH_COMMANDS = [
+    '/help', '/h',
+    '/clear', '/c',
+    '/save', '/s',
+    '/exit', '/q',
+    '/history',
+    '/resume',
+    '/rename',
+    '/export',
+    '/compact',
+    '/config',
+    '/model',
+    '/stream',
+    '/permissions',
+    '/status',
+    '/context',
+    '/cost',
+    '/usage',
+    '/doctor',
+    '/version',
+    '/init',
+    '/review',
+    '/terminal-setup',
+    '/add-dir',
+    '/pwd',
+  ];
+
   constructor(options: ChatOptions) {
     this.apiKey = options.apiKey;
-    this.client = new GrokClient(options.apiKey, options.model || 'grok-4-0709');
+    this.client = new GrokClient(options.apiKey, options.model || 'grok-4-1-fast-reasoning');
+
+    // Autocomplete function for slash commands
+    const completer = (line: string): [string[], string] => {
+      if (line.startsWith('/')) {
+        const hits = GrokChat.SLASH_COMMANDS.filter(cmd => cmd.startsWith(line));
+        return [hits.length ? hits : GrokChat.SLASH_COMMANDS, line];
+      }
+      return [[], line];
+    };
+
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
+      completer,
     });
     this.permissions = new PermissionManager();
     this.permissions.setReadlineInterface(this.rl);
@@ -90,28 +130,11 @@ export class GrokChat {
   }
 
   async start(): Promise<void> {
-    // Beautiful welcome screen
-    console.log(chalk.cyan(`
-   ██████╗ ██████╗  ██████╗ ██╗  ██╗     ██████╗ ██████╗ ██████╗ ███████╗
-  ██╔════╝ ██╔══██╗██╔═══██╗██║ ██╔╝    ██╔════╝██╔═══██╗██╔══██╗██╔════╝
-  ██║  ███╗██████╔╝██║   ██║█████╔╝     ██║     ██║   ██║██║  ██║█████╗
-  ██║   ██║██╔══██╗██║   ██║██╔═██╗     ██║     ██║   ██║██║  ██║██╔══╝
-  ╚██████╔╝██║  ██║╚██████╔╝██║  ██╗    ╚██████╗╚██████╔╝██████╔╝███████╗
-   ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝`));
-
-    console.log();
-    console.log(drawBox([
-      `${chalk.bold('Grok Code CLI')} ${chalk.gray(`v${VERSION}`)}`,
-      '',
-      `${chalk.gray('Model:')}    ${chalk.green(this.client.model)}`,
-      `${chalk.gray('CWD:')}      ${chalk.blue(process.cwd())}`,
-      `${chalk.gray('Tools:')}    ${chalk.cyan('8 available')} ${chalk.gray('(Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch)')}`,
-      '',
-      `${chalk.gray('Commands:')} ${chalk.cyan('/help')} ${chalk.gray('•')} ${chalk.cyan('/model')} ${chalk.gray('•')} ${chalk.cyan('/doctor')} ${chalk.gray('•')} ${chalk.yellow('exit')}`,
-    ], { borderColor: chalk.cyan, padding: 0 }));
-
+    // Clean welcome like Claude Code
     console.log();
-    console.log(randomTip());
+    console.log(chalk.bold.cyan(' Grok Code') + chalk.dim(` v${VERSION}`));
+    console.log(chalk.dim(` ${this.client.model} • ${process.cwd()}`));
+    console.log(chalk.dim(' Type /help for commands, Tab for autocomplete'));
     console.log();
 
     // Create new session
@@ -465,8 +488,8 @@ export class GrokChat {
   }
 
   private async handleModel(modelName?: string): Promise<void> {
-    // Fetch latest models from xAI API dynamically
-    console.log(chalk.gray('Fetching available models...\n'));
+    // Fetch latest models from xAI API
+    process.stdout.write(chalk.dim('  Fetching models...'));
 
     let availableModels: string[] = [];
     try {
@@ -478,175 +501,87 @@ export class GrokChat {
         const data = await response.json() as { data: { id: string }[] };
         availableModels = data.data.map(m => m.id).sort();
       } else {
-        // Fallback to known models if API fails
         availableModels = [
-          'grok-4-0709', 'grok-4-fast-reasoning', 'grok-4-fast-non-reasoning',
           'grok-4-1-fast-reasoning', 'grok-4-1-fast-non-reasoning',
-          'grok-3', 'grok-3-mini', 'grok-code-fast-1',
-          'grok-2-vision-1212', 'grok-2-image-1212',
+          'grok-4-0709', 'grok-4-fast-reasoning', 'grok-4-fast-non-reasoning',
+          'grok-3', 'grok-3-mini',
         ];
       }
     } catch {
-      // Fallback to known models
       availableModels = [
-        'grok-4-0709', 'grok-4-fast-reasoning', 'grok-4-fast-non-reasoning',
-        'grok-3', 'grok-3-mini', 'grok-code-fast-1',
+        'grok-4-1-fast-reasoning', 'grok-4-1-fast-non-reasoning',
+        'grok-4-0709', 'grok-3', 'grok-3-mini',
       ];
     }
 
-    if (!modelName) {
-      console.log();
-      console.log(chalk.cyan('╭──────────────────────────────────────────────────────────────────────╮'));
-      console.log(chalk.cyan('│') + chalk.bold.cyan('  🤖 Model Selection                                                   ') + chalk.cyan('│'));
-      console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
-      console.log();
-      console.log(`  ${chalk.gray('Current Model:')} ${chalk.bold.green(this.client.model)}`);
-      console.log();
+    process.stdout.write('\r\x1B[K'); // Clear the "Fetching" line
 
-      // Better categorization
-      const grok41Reasoning: string[] = [];
-      const grok41NonReasoning: string[] = [];
-      const grok4Reasoning: string[] = [];
-      const grok4NonReasoning: string[] = [];
-      const grok4Other: string[] = [];
-      const grok3: string[] = [];
-      const grok2: string[] = [];
-      const specialized: string[] = [];
-
-      for (const model of availableModels) {
-        if (model.startsWith('grok-4-1')) {
-          if (model.includes('non-reasoning')) {
-            grok41NonReasoning.push(model);
-          } else if (model.includes('reasoning')) {
-            grok41Reasoning.push(model);
-          }
-        } else if (model.startsWith('grok-4')) {
-          if (model.includes('non-reasoning')) {
-            grok4NonReasoning.push(model);
-          } else if (model.includes('reasoning')) {
-            grok4Reasoning.push(model);
-          } else {
-            grok4Other.push(model);
-          }
-        } else if (model.startsWith('grok-3')) {
-          grok3.push(model);
-        } else if (model.startsWith('grok-2')) {
-          grok2.push(model);
-        } else if (model.includes('code') || model.includes('vision') || model.includes('image')) {
-          specialized.push(model);
-        }
-      }
+    // If model name provided directly, switch to it
+    if (modelName) {
+      let matchedModel = modelName;
+      if (!availableModels.includes(modelName)) {
+        // Normalize: "grok41" → "grok-4-1", "4.1" → "4-1"
+        const normalized = modelName.toLowerCase()
+          .replace(/grok\s*(\d)(\d)?/g, (_, d1, d2) => d2 ? `grok-${d1}-${d2}` : `grok-${d1}`)
+          .replace(/(\d+)\.(\d+)/g, '$1-$2')
+          .replace(/\s+/g, '-');
 
-      // Display Grok 4.1 (Latest)
-      if (grok41Reasoning.length > 0 || grok41NonReasoning.length > 0) {
-        console.log(chalk.bold.magenta('  ⭐ Grok 4.1 (Latest)'));
-        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
-        for (const model of grok41Reasoning) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.green('🧠')} ${chalk.green(model)}${current} ${chalk.yellow('[REASONING]')}`);
-        }
-        for (const model of grok41NonReasoning) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('⚡')} ${model}${current} ${chalk.gray('[FAST]')}`);
-        }
-        console.log();
-      }
+        const partialMatch = availableModels.find(m => m.toLowerCase().includes(normalized)) ||
+          availableModels.find(m => m.toLowerCase().includes(modelName.toLowerCase()));
 
-      // Display Grok 4
-      if (grok4Reasoning.length > 0 || grok4NonReasoning.length > 0 || grok4Other.length > 0) {
-        console.log(chalk.bold.cyan('  🚀 Grok 4'));
-        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
-        for (const model of grok4Other) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('•')} ${model}${current} ${chalk.gray('(recommended)')}`);
-        }
-        for (const model of grok4Reasoning) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.green('🧠')} ${chalk.green(model)}${current} ${chalk.yellow('[REASONING]')}`);
-        }
-        for (const model of grok4NonReasoning) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('⚡')} ${model}${current} ${chalk.gray('[FAST]')}`);
+        if (partialMatch) {
+          matchedModel = partialMatch;
+        } else {
+          console.log(chalk.red(`  Unknown model: ${modelName}`));
+          return;
         }
-        console.log();
       }
 
-      // Display Grok 3
-      if (grok3.length > 0) {
-        console.log(chalk.bold.blue('  📦 Grok 3'));
-        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
-        for (const model of grok3) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('•')} ${model}${current}`);
-        }
-        console.log();
-      }
+      this.client = new GrokClient(this.apiKey, matchedModel);
+      console.log(chalk.green(`  ✓ Switched to ${matchedModel}`));
+      return;
+    }
 
-      // Display Grok 2
-      if (grok2.length > 0) {
-        console.log(chalk.bold.gray('  📷 Grok 2 (Vision/Image)'));
-        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
-        for (const model of grok2) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('•')} ${model}${current}`);
-        }
-        console.log();
-      }
+    // Build options for interactive selector - prioritize Grok 4.1
+    const options: SelectorOption[] = [];
 
-      // Display Specialized
-      if (specialized.length > 0) {
-        console.log(chalk.bold.yellow('  🔧 Specialized'));
-        console.log(chalk.gray('  ─────────────────────────────────────────────────────────────────'));
-        for (const model of specialized) {
-          const current = model === this.client.model ? chalk.green(' ← current') : '';
-          console.log(`    ${chalk.cyan('•')} ${model}${current}`);
-        }
-        console.log();
-      }
+    // Categorize models
+    const grok41 = availableModels.filter(m => m.startsWith('grok-4-1'));
+    const grok4 = availableModels.filter(m => m.startsWith('grok-4') && !m.startsWith('grok-4-1'));
+    const grok3 = availableModels.filter(m => m.startsWith('grok-3'));
+    const others = availableModels.filter(m => !m.startsWith('grok-4') && !m.startsWith('grok-3'));
 
-      console.log(chalk.gray(`  ${availableModels.length} models available • Use /model <name> to switch`));
-      console.log(chalk.gray('  🧠 = Reasoning (best for complex tasks) • ⚡ = Fast (quick responses)'));
-      console.log();
-      return;
+    // Add Grok 4.1 first (latest)
+    for (const model of grok41) {
+      const desc = model.includes('non-reasoning') ? 'fast' : model.includes('reasoning') ? 'reasoning' : '';
+      options.push({ label: model, value: model, description: desc });
     }
 
-    // Allow partial matching with normalization
-    let matchedModel = modelName;
-    if (!availableModels.includes(modelName)) {
-      // Normalize input:
-      // "grok41" → "grok-4-1", "grok4" → "grok-4", "grok 3" → "grok-3"
-      // "4.1" → "4-1", "grok 4 1" → "grok-4-1"
-      let normalized = modelName.toLowerCase()
-        .replace(/grok\s*(\d)(\d)?(\d)?/g, (_, d1, d2, d3) => {
-          if (d3) return `grok-${d1}-${d2}-${d3}`;
-          if (d2) return `grok-${d1}-${d2}`;
-          return `grok-${d1}`;
-        })
-        .replace(/(\d+)\.(\d+)/g, '$1-$2')  // "4.1" → "4-1"
-        .replace(/\s+/g, '-');  // spaces to hyphens
-
-      // Try to find a match
-      let partialMatch = availableModels.find(m => m.toLowerCase().includes(normalized));
-
-      // If no match, try the original input
-      if (!partialMatch) {
-        partialMatch = availableModels.find(m =>
-          m.toLowerCase().includes(modelName.toLowerCase())
-        );
-      }
+    // Add Grok 4
+    for (const model of grok4) {
+      const desc = model.includes('non-reasoning') ? 'fast' : model.includes('reasoning') ? 'reasoning' : '';
+      options.push({ label: model, value: model, description: desc });
+    }
 
-      if (partialMatch) {
-        matchedModel = partialMatch;
-        console.log(chalk.gray(`Matched: ${matchedModel}`));
-      } else {
-        console.log(chalk.red(`Unknown model: ${modelName}\n`));
-        console.log(chalk.gray('Use /model to see available models.\n'));
-        return;
-      }
+    // Add Grok 3
+    for (const model of grok3) {
+      options.push({ label: model, value: model });
     }
 
-    this.client = new GrokClient(this.apiKey, matchedModel);
-    console.log(chalk.green(`✓ Switched to model: ${matchedModel}\n`));
+    // Add others
+    for (const model of others) {
+      options.push({ label: model, value: model });
+    }
+
+    console.log();
+    const selected = await interactiveSelect('Select model:', options, this.client.model);
+
+    if (selected && selected !== this.client.model) {
+      this.client = new GrokClient(this.apiKey, selected);
+      console.log(chalk.green(`  ✓ Switched to ${selected}`));
+    } else if (!selected) {
+      console.log(chalk.dim('  Cancelled'));
+    }
   }
 
   private handlePermissions(): void {
@@ -1101,9 +1036,8 @@ Start by checking git status and recent changes, then provide specific, actionab
   }
 
   private async getStreamingResponse(): Promise<void> {
-    // Show thinking indicator
-    process.stdout.write(chalk.cyan('\n╭─ ') + chalk.bold.cyan('Grok') + chalk.cyan(' ─────────────────────────────────────────────────────────────╮\n'));
-    process.stdout.write(chalk.cyan('│ ') + chalk.gray('⠋ thinking...'));
+    // Simple thinking indicator like Claude Code
+    process.stdout.write('\n' + chalk.dim('  Thinking...'));
 
     let fullContent = '';
     let toolCalls: ToolCall[] = [];
@@ -1116,8 +1050,8 @@ Start by checking git status and recent changes, then provide specific, actionab
 
         if (delta?.content) {
           if (firstChunk) {
-            // Clear thinking indicator and start content
-            process.stdout.write('\r' + chalk.cyan('│ ') + ' '.repeat(50) + '\r' + chalk.cyan('│ '));
+            // Clear thinking indicator
+            process.stdout.write('\r' + ' '.repeat(20) + '\r\n');
             firstChunk = false;
           }
           process.stdout.write(delta.content);
@@ -1153,13 +1087,11 @@ Start by checking git status and recent changes, then provide specific, actionab
         toolCalls.push(currentToolCall as ToolCall);
       }
 
-      // Close the response box
+      // End response
       if (fullContent) {
-        console.log();
-        console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
-      } else if (toolCalls.length > 0) {
-        process.stdout.write('\r' + chalk.cyan('│ ') + chalk.gray('Using tools...') + ' '.repeat(40) + '\n');
-        console.log(chalk.cyan('╰──────────────────────────────────────────────────────────────────────╯'));
+        console.log('\n');
+      } else if (toolCalls.length > 0 && firstChunk) {
+        process.stdout.write('\r' + ' '.repeat(20) + '\r');
       }
 
       // Build the message for history
@@ -1223,59 +1155,35 @@ Start by checking git status and recent changes, then provide specific, actionab
       return;
     }
 
-    // Show execution with beautiful box
-    const toolIcons: Record<string, string> = {
-      Read: '📖', Write: '✏️', Edit: '🔧', Bash: '⚡',
-      Glob: '🔍', Grep: '🔎', WebFetch: '🌐', WebSearch: '🔍'
-    };
-    const toolColors: Record<string, typeof chalk> = {
-      Read: chalk.green, Write: chalk.yellow, Edit: chalk.yellow, Bash: chalk.red,
-      Glob: chalk.green, Grep: chalk.green, WebFetch: chalk.green, WebSearch: chalk.green
-    };
-
-    const icon = toolIcons[name] || '🔧';
-    const color = toolColors[name] || chalk.gray;
-
-    console.log();
-    console.log(color('┌─ ') + chalk.bold(`${icon} ${name}`) + color(' ─────────────────────────────────────────────────'));
-
-    // Show details based on tool type
+    // Simple tool display like Claude Code
+    let toolInfo = '';
     if (name === 'Bash') {
-      console.log(color('│ ') + chalk.gray('$') + ' ' + chalk.white(params.command));
-    } else if (name === 'Read' || name === 'Write' || name === 'Edit') {
-      console.log(color('│ ') + chalk.gray('File:') + ' ' + chalk.cyan(params.file_path as string));
-    } else if (name === 'Glob' || name === 'Grep') {
-      console.log(color('│ ') + chalk.gray('Pattern:') + ' ' + chalk.cyan(params.pattern as string));
+      toolInfo = chalk.dim('$ ') + (params.command as string).slice(0, 60);
+    } else if (name === 'Read') {
+      toolInfo = params.file_path as string;
+    } else if (name === 'Write') {
+      toolInfo = params.file_path as string;
+    } else if (name === 'Edit') {
+      toolInfo = params.file_path as string;
+    } else if (name === 'Glob') {
+      toolInfo = params.pattern as string;
+    } else if (name === 'Grep') {
+      toolInfo = params.pattern as string;
     } else if (name === 'WebFetch') {
-      console.log(color('│ ') + chalk.gray('URL:') + ' ' + chalk.cyan(params.url as string));
+      toolInfo = (params.url as string).slice(0, 50);
     } else if (name === 'WebSearch') {
-      console.log(color('│ ') + chalk.gray('Query:') + ' ' + chalk.cyan(params.query as string));
+      toolInfo = params.query as string;
     }
 
+    console.log(chalk.dim('  ● ') + chalk.cyan(name) + chalk.dim(' ' + toolInfo));
+
     // Execute
     const result = await executeTool(name, params);
 
-    if (result.success) {
-      console.log(color('│'));
-      console.log(color('│ ') + chalk.green('✓ Success'));
-      if (result.output && result.output.length < 500) {
-        const lines = result.output.split('\n').slice(0, 10);
-        for (const line of lines) {
-          console.log(color('│ ') + chalk.gray(line.slice(0, 80)));
-        }
-        if (result.output.split('\n').length > 10) {
-          console.log(color('│ ') + chalk.gray('... (truncated)'));
-        }
-      } else if (result.output) {
-        console.log(color('│ ') + chalk.gray(result.output.slice(0, 200) + '... (truncated)'));
-      }
-    } else {
-      console.log(color('│'));
-      console.log(color('│ ') + chalk.red('✗ Failed: ') + chalk.red(result.error || 'Unknown error'));
+    if (!result.success) {
+      console.log(chalk.red('    ✗ ') + chalk.red(result.error || 'Failed'));
     }
 
-    console.log(color('└──────────────────────────────────────────────────────────────────────'));
-
     this.messages.push({
       role: 'tool',
       tool_call_id: toolCall.id,

package/src/utils/selector.ts

@@ -0,0 +1,165 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+
+export interface SelectorOption {
+  label: string;
+  value: string;
+  description?: string;
+}
+
+export async function interactiveSelect(
+  title: string,
+  options: SelectorOption[],
+  currentValue?: string
+): Promise<string | null> {
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+
+    // Find current value index
+    if (currentValue) {
+      const idx = options.findIndex(o => o.value === currentValue);
+      if (idx >= 0) selectedIndex = idx;
+    }
+
+    const render = () => {
+      // Clear previous render
+      process.stdout.write('\x1B[?25l'); // Hide cursor
+
+      // Move up and clear lines if not first render
+      const totalLines = options.length + 2;
+      process.stdout.write(`\x1B[${totalLines}A`);
+
+      // Title
+      console.log(chalk.bold(title));
+      console.log(chalk.dim('↑↓/Tab to navigate, Enter to select, Esc to cancel'));
+
+      // Options
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const isSelected = i === selectedIndex;
+        const isCurrent = opt.value === currentValue;
+
+        const pointer = isSelected ? chalk.cyan('❯') : ' ';
+        const label = isSelected ? chalk.cyan.bold(opt.label) : opt.label;
+        const current = isCurrent ? chalk.green(' (current)') : '';
+        const desc = opt.description ? chalk.dim(` - ${opt.description}`) : '';
+
+        console.log(`${pointer} ${label}${current}${desc}`);
+      }
+    };
+
+    // Initial render with padding
+    console.log(chalk.bold(title));
+    console.log(chalk.dim('↑↓/Tab to navigate, Enter to select, Esc to cancel'));
+    for (const opt of options) {
+      const isCurrent = opt.value === currentValue;
+      const current = isCurrent ? chalk.green(' (current)') : '';
+      const desc = opt.description ? chalk.dim(` - ${opt.description}`) : '';
+      console.log(`  ${opt.label}${current}${desc}`);
+    }
+
+    // Now render with selection
+    render();
+
+    // Set up raw mode for key input
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const onKeypress = (key: Buffer) => {
+      const char = key.toString();
+
+      // Arrow up or k
+      if (char === '\x1B[A' || char === 'k') {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : options.length - 1;
+        render();
+      }
+      // Arrow down or j
+      else if (char === '\x1B[B' || char === 'j') {
+        selectedIndex = selectedIndex < options.length - 1 ? selectedIndex + 1 : 0;
+        render();
+      }
+      // Tab - cycle forward
+      else if (char === '\t') {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        render();
+      }
+      // Shift+Tab - cycle backward (usually \x1B[Z)
+      else if (char === '\x1B[Z') {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : options.length - 1;
+        render();
+      }
+      // Enter
+      else if (char === '\r' || char === '\n') {
+        cleanup();
+        resolve(options[selectedIndex].value);
+      }
+      // Escape or q
+      else if (char === '\x1B' || char === 'q') {
+        cleanup();
+        resolve(null);
+      }
+      // Ctrl+C
+      else if (char === '\x03') {
+        cleanup();
+        resolve(null);
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdout.write('\x1B[?25h'); // Show cursor
+      console.log(); // New line after selection
+    };
+
+    process.stdin.on('data', onKeypress);
+  });
+}
+
+// Simple yes/no confirmation
+export async function confirm(message: string, defaultYes = true): Promise<boolean> {
+  return new Promise((resolve) => {
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    process.stdout.write(`${message} ${chalk.dim(hint)} `);
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const onKeypress = (key: Buffer) => {
+      const char = key.toString().toLowerCase();
+
+      if (char === 'y') {
+        cleanup();
+        console.log(chalk.green('Yes'));
+        resolve(true);
+      } else if (char === 'n') {
+        cleanup();
+        console.log(chalk.red('No'));
+        resolve(false);
+      } else if (char === '\r' || char === '\n') {
+        cleanup();
+        console.log(defaultYes ? chalk.green('Yes') : chalk.red('No'));
+        resolve(defaultYes);
+      } else if (char === '\x03' || char === '\x1B') {
+        cleanup();
+        console.log(chalk.red('Cancelled'));
+        resolve(false);
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    };
+
+    process.stdin.on('data', onKeypress);
+  });
+}