@vibecheckai/cli 3.3.0 → 3.5.0

package/bin/runners/lib/cli-prompts.js

@@ -0,0 +1,441 @@
+/**
+ * CLI Prompts - Interactive terminal prompts for Vibecheck CLI
+ * 
+ * Provides:
+ * - Confirmation prompts (y/n)
+ * - Selection prompts (single/multi)
+ * - Input prompts with validation
+ * - Password/secret input
+ * - Progress wizards
+ */
+
+"use strict";
+
+const readline = require("readline");
+const {
+  ansi,
+  sym,
+  box,
+  padRight,
+  SUPPORTS_UNICODE,
+} = require("./unified-cli-output");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// READLINE INTERFACE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BASIC INPUT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Simple text input
+ * @param {string} question - Prompt text
+ * @param {Object} options
+ */
+async function input(question, options = {}) {
+  const { defaultValue, required = false, validate } = options;
+  
+  const rl = createInterface();
+  const defaultHint = defaultValue ? ` ${ansi.dim}(${defaultValue})${ansi.reset}` : '';
+  const prompt = `  ${ansi.cyan}${sym.pointer}${ansi.reset} ${question}${defaultHint}: `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, async (answer) => {
+      rl.close();
+      
+      const value = answer.trim() || defaultValue || '';
+      
+      if (required && !value) {
+        console.log(`  ${ansi.red}${sym.cross}${ansi.reset} This field is required`);
+        return resolve(await input(question, options));
+      }
+      
+      if (validate) {
+        const error = validate(value);
+        if (error) {
+          console.log(`  ${ansi.red}${sym.cross}${ansi.reset} ${error}`);
+          return resolve(await input(question, options));
+        }
+      }
+      
+      resolve(value);
+    });
+  });
+}
+
+/**
+ * Password/secret input (masked)
+ * @param {string} question - Prompt text
+ */
+async function secret(question) {
+  const rl = createInterface();
+  const prompt = `  ${ansi.cyan}${sym.lock}${ansi.reset} ${question}: `;
+
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    
+    // Mask input
+    const stdin = process.stdin;
+    const originalRawMode = stdin.isRaw;
+    
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    
+    let value = '';
+    const onData = (char) => {
+      char = char.toString();
+      
+      switch (char) {
+        case '\n':
+        case '\r':
+        case '\u0004': // Ctrl+D
+          stdin.removeListener('data', onData);
+          if (stdin.isTTY) {
+            stdin.setRawMode(originalRawMode);
+          }
+          console.log();
+          rl.close();
+          resolve(value);
+          break;
+        case '\u0003': // Ctrl+C
+          process.exit(1);
+          break;
+        case '\u007F': // Backspace
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            process.stdout.write('\b \b');
+          }
+          break;
+        default:
+          value += char;
+          process.stdout.write('*');
+      }
+    };
+    
+    stdin.on('data', onData);
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIRMATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Yes/No confirmation
+ * @param {string} question - Prompt text
+ * @param {Object} options
+ */
+async function confirm(question, options = {}) {
+  const { defaultValue = false } = options;
+  
+  const rl = createInterface();
+  const hint = defaultValue ? 'Y/n' : 'y/N';
+  const prompt = `  ${ansi.cyan}${sym.pointer}${ansi.reset} ${question} ${ansi.dim}(${hint})${ansi.reset}: `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      
+      const value = answer.trim().toLowerCase();
+      
+      if (value === '') {
+        resolve(defaultValue);
+      } else if (value === 'y' || value === 'yes') {
+        resolve(true);
+      } else if (value === 'n' || value === 'no') {
+        resolve(false);
+      } else {
+        console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} Please answer yes or no`);
+        resolve(confirm(question, options));
+      }
+    });
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SELECTION (Single Choice)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Single selection from list
+ * @param {string} question - Prompt text
+ * @param {Array<{value: string, label: string, hint?: string}>} choices
+ * @param {Object} options
+ */
+async function select(question, choices, options = {}) {
+  const { defaultValue } = options;
+  
+  console.log(`\n  ${ansi.cyan}${sym.pointer}${ansi.reset} ${question}\n`);
+  
+  // Display choices
+  choices.forEach((choice, index) => {
+    const isDefault = choice.value === defaultValue;
+    const marker = isDefault ? `${ansi.cyan}${sym.pointer}${ansi.reset}` : ' ';
+    const hint = choice.hint ? ` ${ansi.dim}${choice.hint}${ansi.reset}` : '';
+    const number = `${ansi.dim}${index + 1})${ansi.reset}`;
+    console.log(`  ${marker} ${number} ${choice.label}${hint}`);
+  });
+  
+  console.log();
+  
+  const rl = createInterface();
+  const defaultHint = defaultValue ? ` ${ansi.dim}(default: ${choices.findIndex(c => c.value === defaultValue) + 1})${ansi.reset}` : '';
+  const prompt = `  ${ansi.gray}Enter number${defaultHint}:${ansi.reset} `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      
+      const value = answer.trim();
+      
+      if (value === '' && defaultValue) {
+        const choice = choices.find(c => c.value === defaultValue);
+        console.log(`  ${ansi.green}${sym.check}${ansi.reset} Selected: ${choice.label}\n`);
+        return resolve(defaultValue);
+      }
+      
+      const index = parseInt(value, 10) - 1;
+      
+      if (isNaN(index) || index < 0 || index >= choices.length) {
+        console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} Please enter a number between 1 and ${choices.length}`);
+        return resolve(select(question, choices, options));
+      }
+      
+      const selected = choices[index];
+      console.log(`  ${ansi.green}${sym.check}${ansi.reset} Selected: ${selected.label}\n`);
+      resolve(selected.value);
+    });
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MULTI-SELECT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Multiple selection from list
+ * @param {string} question - Prompt text
+ * @param {Array<{value: string, label: string, checked?: boolean}>} choices
+ */
+async function multiSelect(question, choices, options = {}) {
+  const { min = 0, max = choices.length } = options;
+  
+  console.log(`\n  ${ansi.cyan}${sym.pointer}${ansi.reset} ${question}`);
+  console.log(`  ${ansi.dim}(Enter numbers separated by commas, e.g., 1,3,5)${ansi.reset}\n`);
+  
+  // Display choices
+  choices.forEach((choice, index) => {
+    const checked = choice.checked ? `${ansi.green}${sym.check}${ansi.reset}` : `${ansi.gray}○${ansi.reset}`;
+    const number = `${ansi.dim}${index + 1})${ansi.reset}`;
+    console.log(`  ${checked} ${number} ${choice.label}`);
+  });
+  
+  console.log();
+  
+  const rl = createInterface();
+  const prompt = `  ${ansi.gray}Enter numbers:${ansi.reset} `;
+
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      
+      const value = answer.trim();
+      
+      if (value === '') {
+        if (min === 0) {
+          console.log(`  ${ansi.green}${sym.check}${ansi.reset} No items selected\n`);
+          return resolve([]);
+        }
+        console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} Please select at least ${min} item(s)`);
+        return resolve(multiSelect(question, choices, options));
+      }
+      
+      const indices = value.split(',')
+        .map(s => parseInt(s.trim(), 10) - 1)
+        .filter(i => !isNaN(i) && i >= 0 && i < choices.length);
+      
+      if (indices.length < min) {
+        console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} Please select at least ${min} item(s)`);
+        return resolve(multiSelect(question, choices, options));
+      }
+      
+      if (indices.length > max) {
+        console.log(`  ${ansi.yellow}${sym.warning}${ansi.reset} Please select at most ${max} item(s)`);
+        return resolve(multiSelect(question, choices, options));
+      }
+      
+      const selected = indices.map(i => choices[i].value);
+      const labels = indices.map(i => choices[i].label).join(', ');
+      console.log(`  ${ansi.green}${sym.check}${ansi.reset} Selected: ${labels}\n`);
+      resolve(selected);
+    });
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// WIZARD / MULTI-STEP
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Multi-step wizard
+ * @param {Array<{id: string, type: string, ...}>} steps
+ */
+async function wizard(steps, options = {}) {
+  const { title, onStep } = options;
+  const results = {};
+  
+  if (title) {
+    console.log(`\n  ${ansi.bold}${title}${ansi.reset}`);
+    console.log(`  ${ansi.gray}${box.horizontal.repeat(50)}${ansi.reset}\n`);
+  }
+  
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const progress = `${ansi.dim}[${i + 1}/${steps.length}]${ansi.reset}`;
+    
+    if (onStep) {
+      onStep(step, i, steps.length);
+    }
+    
+    let value;
+    
+    switch (step.type) {
+      case 'input':
+        value = await input(`${progress} ${step.message}`, step);
+        break;
+      case 'secret':
+        value = await secret(`${progress} ${step.message}`);
+        break;
+      case 'confirm':
+        value = await confirm(`${progress} ${step.message}`, step);
+        break;
+      case 'select':
+        value = await select(`${progress} ${step.message}`, step.choices, step);
+        break;
+      case 'multiSelect':
+        value = await multiSelect(`${progress} ${step.message}`, step.choices, step);
+        break;
+      default:
+        throw new Error(`Unknown step type: ${step.type}`);
+    }
+    
+    results[step.id] = value;
+    
+    // Allow step to modify flow
+    if (step.when && !step.when(results)) {
+      continue;
+    }
+  }
+  
+  return results;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PROGRESS DISPLAY
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Display step progress
+ * @param {number} current - Current step (1-indexed)
+ * @param {number} total - Total steps
+ * @param {string} label - Step label
+ */
+function stepProgress(current, total, label) {
+  const dots = [];
+  for (let i = 1; i <= total; i++) {
+    if (i < current) {
+      dots.push(`${ansi.green}●${ansi.reset}`);
+    } else if (i === current) {
+      dots.push(`${ansi.cyan}●${ansi.reset}`);
+    } else {
+      dots.push(`${ansi.gray}○${ansi.reset}`);
+    }
+  }
+  
+  console.log(`\n  ${dots.join(' ')} ${ansi.dim}Step ${current} of ${total}${ansi.reset}`);
+  console.log(`  ${ansi.bold}${label}${ansi.reset}\n`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// NOTIFICATION BOXES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Display an info box
+ * @param {string} title - Box title
+ * @param {string|string[]} content - Box content
+ */
+function infoBox(title, content, options = {}) {
+  const { type = 'info', width = 60 } = options;
+  
+  const typeConfig = {
+    info: { color: ansi.cyan, icon: sym.info },
+    success: { color: ansi.green, icon: sym.check },
+    warning: { color: ansi.yellow, icon: sym.warning },
+    error: { color: ansi.red, icon: sym.cross },
+  };
+  
+  const config = typeConfig[type] || typeConfig.info;
+  const lines = Array.isArray(content) ? content : [content];
+  
+  console.log();
+  console.log(`  ${config.color}${box.topLeft}${box.horizontal.repeat(width - 2)}${box.topRight}${ansi.reset}`);
+  console.log(`  ${config.color}${box.vertical}${ansi.reset} ${config.icon} ${ansi.bold}${title}${ansi.reset}${' '.repeat(width - title.length - 5)}${config.color}${box.vertical}${ansi.reset}`);
+  console.log(`  ${config.color}${box.vertical}${box.horizontal.repeat(width - 2)}${box.vertical}${ansi.reset}`);
+  
+  for (const line of lines) {
+    const paddedLine = padRight(line, width - 4);
+    console.log(`  ${config.color}${box.vertical}${ansi.reset} ${paddedLine} ${config.color}${box.vertical}${ansi.reset}`);
+  }
+  
+  console.log(`  ${config.color}${box.bottomLeft}${box.horizontal.repeat(width - 2)}${box.bottomRight}${ansi.reset}`);
+  console.log();
+}
+
+/**
+ * Display a tip/hint
+ * @param {string} text - Tip text
+ */
+function tip(text) {
+  console.log(`  ${ansi.cyan}${sym.info}${ansi.reset} ${ansi.dim}Tip:${ansi.reset} ${text}`);
+}
+
+/**
+ * Display a keyboard shortcut hint
+ * @param {string} key - Key combination
+ * @param {string} action - Action description
+ */
+function keyHint(key, action) {
+  console.log(`  ${ansi.dim}Press ${ansi.reset}${ansi.cyan}${key}${ansi.reset}${ansi.dim} to ${action}${ansi.reset}`);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Basic prompts
+  input,
+  secret,
+  confirm,
+  select,
+  multiSelect,
+  
+  // Wizard
+  wizard,
+  stepProgress,
+  
+  // UI helpers
+  infoBox,
+  tip,
+  keyHint,
+};