vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/interactive-menu.js

@@ -0,0 +1,1496 @@
+/**
+ * Interactive Menu System - Premium Terminal UI
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Beautiful arrow-key navigation menus for CLI applications
+ * No external dependencies - pure Node.js
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+"use strict";
+
+const readline = require("readline");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TERMINAL DETECTION
+// ═══════════════════════════════════════════════════════════════════════════════
+const SUPPORTS_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
+const SUPPORTS_TRUECOLOR = SUPPORTS_COLOR && (
+  process.env.COLORTERM === "truecolor" ||
+  process.env.TERM_PROGRAM === "iTerm.app" ||
+  process.env.TERM_PROGRAM === "Apple_Terminal" ||
+  process.env.WT_SESSION
+);
+const SUPPORTS_UNICODE = process.platform !== "win32" || process.env.WT_SESSION || process.env.TERM_PROGRAM;
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// ANSI ESCAPE CODES
+// ═══════════════════════════════════════════════════════════════════════════════
+const ESC = "\x1b";
+const CSI = `${ESC}[`;
+
+const ansi = {
+  // Cursor
+  hideCursor: `${CSI}?25l`,
+  showCursor: `${CSI}?25h`,
+  saveCursor: `${CSI}s`,
+  restoreCursor: `${CSI}u`,
+  moveTo: (row, col) => `${CSI}${row};${col}H`,
+  moveUp: (n = 1) => `${CSI}${n}A`,
+  moveDown: (n = 1) => `${CSI}${n}B`,
+  moveRight: (n = 1) => `${CSI}${n}C`,
+  moveLeft: (n = 1) => `${CSI}${n}D`,
+  moveToColumn: (col) => `${CSI}${col}G`,
+  
+  // Clear
+  clearLine: `${CSI}2K`,
+  clearToEnd: `${CSI}0K`,
+  clearToStart: `${CSI}1K`,
+  clearScreen: `${CSI}2J`,
+  clearDown: `${CSI}0J`,
+  
+  // Styles
+  reset: `${CSI}0m`,
+  bold: `${CSI}1m`,
+  dim: `${CSI}2m`,
+  italic: `${CSI}3m`,
+  underline: `${CSI}4m`,
+  blink: `${CSI}5m`,
+  inverse: `${CSI}7m`,
+  hidden: `${CSI}8m`,
+  strikethrough: `${CSI}9m`,
+  
+  // Colors
+  black: `${CSI}30m`,
+  red: `${CSI}31m`,
+  green: `${CSI}32m`,
+  yellow: `${CSI}33m`,
+  blue: `${CSI}34m`,
+  magenta: `${CSI}35m`,
+  cyan: `${CSI}36m`,
+  white: `${CSI}37m`,
+  gray: `${CSI}90m`,
+  
+  // Bright colors
+  brightRed: `${CSI}91m`,
+  brightGreen: `${CSI}92m`,
+  brightYellow: `${CSI}93m`,
+  brightBlue: `${CSI}94m`,
+  brightMagenta: `${CSI}95m`,
+  brightCyan: `${CSI}96m`,
+  brightWhite: `${CSI}97m`,
+  
+  // Background
+  bgBlack: `${CSI}40m`,
+  bgRed: `${CSI}41m`,
+  bgGreen: `${CSI}42m`,
+  bgYellow: `${CSI}43m`,
+  bgBlue: `${CSI}44m`,
+  bgMagenta: `${CSI}45m`,
+  bgCyan: `${CSI}46m`,
+  bgWhite: `${CSI}47m`,
+  bgGray: `${CSI}100m`,
+  
+  // True color
+  rgb: (r, g, b) => SUPPORTS_TRUECOLOR ? `${CSI}38;2;${r};${g};${b}m` : "",
+  bgRgb: (r, g, b) => SUPPORTS_TRUECOLOR ? `${CSI}48;2;${r};${g};${b}m` : "",
+};
+
+// Disable colors if not supported
+const c = SUPPORTS_COLOR ? ansi : Object.fromEntries(
+  Object.keys(ansi).map(k => [k, typeof ansi[k] === "function" ? () => "" : ""])
+);
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SYMBOLS
+// ═══════════════════════════════════════════════════════════════════════════════
+const sym = SUPPORTS_UNICODE ? {
+  // Selection
+  pointer: "❯",
+  pointerSmall: "›",
+  radio: {
+    on: "◉",
+    off: "○",
+  },
+  checkbox: {
+    on: "☑",
+    off: "☐",
+    disabled: "▫",
+  },
+  
+  // Status
+  success: "✓",
+  error: "✗",
+  warning: "⚠",
+  info: "ℹ",
+  active: "●",
+  pending: "○",
+  
+  // Decorative
+  star: "★",
+  heart: "♥",
+  lightning: "⚡",
+  fire: "🔥",
+  rocket: "🚀",
+  sparkles: "✨",
+  
+  // Arrows
+  arrowUp: "↑",
+  arrowDown: "↓",
+  arrowLeft: "←",
+  arrowRight: "→",
+  triangleUp: "▲",
+  triangleDown: "▼",
+  triangleLeft: "◀",
+  triangleRight: "▶",
+  
+  // Box drawing
+  boxTopLeft: "╭",
+  boxTopRight: "╮",
+  boxBottomLeft: "╰",
+  boxBottomRight: "╯",
+  boxHorizontal: "─",
+  boxVertical: "│",
+  boxHorizontalBold: "━",
+  boxVerticalBold: "┃",
+  
+  // Lines
+  line: "─",
+  lineBold: "━",
+  lineDashed: "┄",
+  lineDouble: "═",
+  
+  // Misc
+  bullet: "•",
+  dot: "·",
+  ellipsis: "…",
+  separator: "│",
+} : {
+  pointer: ">",
+  pointerSmall: ">",
+  radio: { on: "(*)", off: "( )" },
+  checkbox: { on: "[x]", off: "[ ]", disabled: "[-]" },
+  success: "√",
+  error: "×",
+  warning: "!",
+  info: "i",
+  active: "*",
+  pending: "o",
+  star: "*",
+  heart: "<3",
+  lightning: "!",
+  fire: "(!)",
+  rocket: ">>",
+  sparkles: "*",
+  arrowUp: "^",
+  arrowDown: "v",
+  arrowLeft: "<",
+  arrowRight: ">",
+  triangleUp: "^",
+  triangleDown: "v",
+  triangleLeft: "<",
+  triangleRight: ">",
+  boxTopLeft: "+",
+  boxTopRight: "+",
+  boxBottomLeft: "+",
+  boxBottomRight: "+",
+  boxHorizontal: "-",
+  boxVertical: "|",
+  boxHorizontalBold: "=",
+  boxVerticalBold: "|",
+  line: "-",
+  lineBold: "=",
+  lineDashed: "-",
+  lineDouble: "=",
+  bullet: "*",
+  dot: ".",
+  ellipsis: "...",
+  separator: "|",
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// COLOR THEMES
+// ═══════════════════════════════════════════════════════════════════════════════
+const themes = {
+  default: {
+    primary: c.cyan,
+    secondary: c.magenta,
+    accent: c.yellow,
+    success: c.green,
+    warning: c.yellow,
+    error: c.red,
+    muted: c.gray,
+    highlight: c.brightWhite,
+    pointer: c.cyan,
+    selected: c.rgb(0, 255, 200),
+    unselected: c.gray,
+    title: c.bold + c.brightWhite,
+    subtitle: c.dim,
+    border: c.dim,
+    search: c.yellow,
+  },
+  
+  vibecheck: {
+    primary: c.rgb(0, 255, 255),      // Cyan
+    secondary: c.rgb(138, 43, 226),   // Purple
+    accent: c.rgb(255, 200, 100),     // Gold
+    success: c.rgb(0, 255, 150),      // Green
+    warning: c.rgb(255, 200, 0),      // Yellow
+    error: c.rgb(255, 80, 80),        // Red
+    muted: c.rgb(120, 120, 120),      // Gray
+    highlight: c.rgb(255, 255, 255),  // White
+    pointer: c.rgb(0, 255, 255),      // Cyan
+    selected: c.rgb(0, 255, 200),     // Bright cyan-green
+    unselected: c.rgb(100, 100, 100), // Dark gray
+    title: c.bold + c.rgb(255, 255, 255),
+    subtitle: c.rgb(150, 150, 150),
+    border: c.rgb(60, 60, 80),
+    search: c.rgb(255, 200, 100),
+  },
+  
+  minimal: {
+    primary: c.white,
+    secondary: c.gray,
+    accent: c.white,
+    success: c.green,
+    warning: c.yellow,
+    error: c.red,
+    muted: c.dim,
+    highlight: c.bold,
+    pointer: c.white,
+    selected: c.white,
+    unselected: c.dim,
+    title: c.bold,
+    subtitle: c.dim,
+    border: c.dim,
+    search: c.white,
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+function truncate(str, maxLen, suffix = "…") {
+  const stripped = stripAnsi(str);
+  if (stripped.length <= maxLen) return str;
+  
+  // Simple truncation (doesn't preserve ANSI, but good enough for most cases)
+  return stripped.slice(0, maxLen - suffix.length) + suffix;
+}
+
+function padEnd(str, len, char = " ") {
+  const stripped = stripAnsi(str);
+  const padding = Math.max(0, len - stripped.length);
+  return str + char.repeat(padding);
+}
+
+function padStart(str, len, char = " ") {
+  const stripped = stripAnsi(str);
+  const padding = Math.max(0, len - stripped.length);
+  return char.repeat(padding) + str;
+}
+
+function centerText(str, width, char = " ") {
+  const stripped = stripAnsi(str);
+  const padding = Math.max(0, width - stripped.length);
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return char.repeat(left) + str + char.repeat(right);
+}
+
+function wrapText(str, width) {
+  const words = str.split(" ");
+  const lines = [];
+  let currentLine = "";
+  
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 <= width) {
+      currentLine += (currentLine ? " " : "") + word;
+    } else {
+      if (currentLine) lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  
+  return lines;
+}
+
+function getTerminalSize() {
+  return {
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GRADIENT TEXT
+// ═══════════════════════════════════════════════════════════════════════════════
+function gradient(text, colors = [[0, 255, 255], [138, 43, 226], [255, 20, 147]]) {
+  if (!SUPPORTS_TRUECOLOR) return `${c.cyan}${text}${c.reset}`;
+  
+  const chars = [...text];
+  const len = chars.length;
+  if (len === 0) return text;
+  
+  return chars.map((char, i) => {
+    const t = i / Math.max(len - 1, 1);
+    const segmentLen = colors.length - 1;
+    const segment = Math.min(Math.floor(t * segmentLen), segmentLen - 1);
+    const localT = (t * segmentLen) - segment;
+    const c1 = colors[segment];
+    const c2 = colors[segment + 1] || c1;
+    const r = Math.round(c1[0] + (c2[0] - c1[0]) * localT);
+    const g = Math.round(c1[1] + (c2[1] - c1[1]) * localT);
+    const b = Math.round(c1[2] + (c2[2] - c1[2]) * localT);
+    return `${c.rgb(r, g, b)}${char}`;
+  }).join("") + c.reset;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BOX DRAWING
+// ═══════════════════════════════════════════════════════════════════════════════
+function drawBox(content, options = {}) {
+  const {
+    title = "",
+    width = null,
+    padding = 1,
+    borderColor = c.dim,
+    titleColor = c.bold,
+    style = "rounded", // rounded, square, double, bold
+  } = options;
+  
+  const borders = {
+    rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" },
+    square: { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" },
+    double: { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" },
+    bold: { tl: "┏", tr: "┓", bl: "┗", br: "┛", h: "━", v: "┃" },
+  };
+  
+  const b = borders[style] || borders.rounded;
+  const lines = Array.isArray(content) ? content : content.split("\n");
+  const maxContentWidth = Math.max(...lines.map(l => stripAnsi(l).length));
+  const boxWidth = width || maxContentWidth + (padding * 2) + 2;
+  const innerWidth = boxWidth - 2;
+  
+  const output = [];
+  
+  // Top border with optional title
+  if (title) {
+    const titleStr = ` ${title} `;
+    const titleLen = stripAnsi(titleStr).length;
+    const leftBorder = Math.floor((innerWidth - titleLen) / 2);
+    const rightBorder = innerWidth - titleLen - leftBorder;
+    output.push(
+      `${borderColor}${b.tl}${b.h.repeat(leftBorder)}${c.reset}${titleColor}${titleStr}${c.reset}${borderColor}${b.h.repeat(rightBorder)}${b.tr}${c.reset}`
+    );
+  } else {
+    output.push(`${borderColor}${b.tl}${b.h.repeat(innerWidth)}${b.tr}${c.reset}`);
+  }
+  
+  // Padding top
+  for (let i = 0; i < padding; i++) {
+    output.push(`${borderColor}${b.v}${c.reset}${" ".repeat(innerWidth)}${borderColor}${b.v}${c.reset}`);
+  }
+  
+  // Content
+  for (const line of lines) {
+    const stripped = stripAnsi(line);
+    const contentPadding = " ".repeat(padding);
+    const rightPad = " ".repeat(Math.max(0, innerWidth - stripped.length - (padding * 2)));
+    output.push(`${borderColor}${b.v}${c.reset}${contentPadding}${line}${rightPad}${contentPadding}${borderColor}${b.v}${c.reset}`);
+  }
+  
+  // Padding bottom
+  for (let i = 0; i < padding; i++) {
+    output.push(`${borderColor}${b.v}${c.reset}${" ".repeat(innerWidth)}${borderColor}${b.v}${c.reset}`);
+  }
+  
+  // Bottom border
+  output.push(`${borderColor}${b.bl}${b.h.repeat(innerWidth)}${b.br}${c.reset}`);
+  
+  return output.join("\n");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// BASE PROMPT CLASS
+// ═══════════════════════════════════════════════════════════════════════════════
+class BasePrompt {
+  constructor(options = {}) {
+    this.theme = themes[options.theme] || themes.vibecheck;
+    this.stdin = options.stdin || process.stdin;
+    this.stdout = options.stdout || process.stdout;
+    this.rl = null;
+    this.closed = false;
+  }
+  
+  write(str) {
+    this.stdout.write(str);
+  }
+  
+  clearLines(count) {
+    for (let i = 0; i < count; i++) {
+      this.write(ansi.moveUp(1) + ansi.clearLine);
+    }
+  }
+  
+  hideCursor() {
+    this.write(ansi.hideCursor);
+  }
+  
+  showCursor() {
+    this.write(ansi.showCursor);
+  }
+  
+  setupReadline() {
+    if (this.rl) return;
+    
+    this.rl = readline.createInterface({
+      input: this.stdin,
+      output: this.stdout,
+      terminal: true,
+    });
+    
+    // Enable keypress events
+    readline.emitKeypressEvents(this.stdin, this.rl);
+    
+    if (this.stdin.isTTY) {
+      this.stdin.setRawMode(true);
+    }
+  }
+  
+  cleanup() {
+    if (this.closed) return;
+    this.closed = true;
+    
+    this.showCursor();
+    
+    if (this.stdin.isTTY) {
+      this.stdin.setRawMode(false);
+    }
+    
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// SELECT PROMPT - Single selection from list
+// ═══════════════════════════════════════════════════════════════════════════════
+class SelectPrompt extends BasePrompt {
+  constructor(options = {}) {
+    super(options);
+    
+    this.message = options.message || "Select an option";
+    this.choices = this.normalizeChoices(options.choices || []);
+    this.pageSize = options.pageSize || 10;
+    this.loop = options.loop !== false;
+    this.showSearch = options.search !== false;
+    this.hint = options.hint || "";
+    this.initialIndex = options.initial || 0;
+    
+    // State
+    this.selectedIndex = this.initialIndex;
+    this.searchQuery = "";
+    this.filteredChoices = [...this.choices];
+    this.scrollOffset = 0;
+    this.searching = false;
+    this.renderedLines = 0;
+  }
+  
+  normalizeChoices(choices) {
+    return choices.map((choice, index) => {
+      if (typeof choice === "string") {
+        return { value: choice, label: choice, index };
+      }
+      return {
+        value: choice.value ?? choice.label ?? choice.name,
+        label: choice.label ?? choice.name ?? choice.value,
+        description: choice.description || choice.desc || "",
+        disabled: choice.disabled || false,
+        group: choice.group || null,
+        icon: choice.icon || null,
+        hint: choice.hint || "",
+        index,
+      };
+    });
+  }
+  
+  filterChoices() {
+    if (!this.searchQuery) {
+      this.filteredChoices = [...this.choices];
+      return;
+    }
+    
+    const query = this.searchQuery.toLowerCase();
+    this.filteredChoices = this.choices.filter(choice => {
+      const label = (choice.label || "").toLowerCase();
+      const description = (choice.description || "").toLowerCase();
+      return label.includes(query) || description.includes(query);
+    });
+    
+    // Reset selection if current is out of bounds
+    if (this.selectedIndex >= this.filteredChoices.length) {
+      this.selectedIndex = Math.max(0, this.filteredChoices.length - 1);
+    }
+  }
+  
+  getVisibleChoices() {
+    const start = this.scrollOffset;
+    const end = Math.min(start + this.pageSize, this.filteredChoices.length);
+    return this.filteredChoices.slice(start, end);
+  }
+  
+  updateScroll() {
+    // Ensure selected item is visible
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + this.pageSize) {
+      this.scrollOffset = this.selectedIndex - this.pageSize + 1;
+    }
+  }
+  
+  renderChoice(choice, isSelected, index) {
+    const t = this.theme;
+    const pointer = isSelected ? `${t.pointer}${sym.pointer}${c.reset}` : "  ";
+    const icon = choice.icon ? `${choice.icon} ` : "";
+    
+    let label;
+    if (choice.disabled) {
+      label = `${t.muted}${icon}${choice.label} (disabled)${c.reset}`;
+    } else if (isSelected) {
+      label = `${t.selected}${c.bold}${icon}${choice.label}${c.reset}`;
+    } else {
+      label = `${t.unselected}${icon}${choice.label}${c.reset}`;
+    }
+    
+    let description = "";
+    if (choice.description && isSelected) {
+      description = ` ${t.muted}${sym.separator} ${choice.description}${c.reset}`;
+    }
+    
+    let hint = "";
+    if (choice.hint && isSelected) {
+      hint = ` ${t.accent}${choice.hint}${c.reset}`;
+    }
+    
+    return `${pointer} ${label}${description}${hint}`;
+  }
+  
+  renderHeader() {
+    const t = this.theme;
+    const lines = [];
+    
+    // Title
+    lines.push(`${t.title}${sym.pointer} ${this.message}${c.reset}`);
+    
+    // Search box
+    if (this.showSearch) {
+      const searchIcon = this.searching ? `${t.search}${sym.pointer}${c.reset}` : `${t.muted}/${c.reset}`;
+      const query = this.searchQuery || (this.searching ? "" : "type to search");
+      const queryStyle = this.searchQuery ? t.search : t.muted;
+      lines.push(`  ${searchIcon} ${queryStyle}${query}${c.reset}`);
+    }
+    
+    // Hint
+    if (this.hint && !this.searching) {
+      lines.push(`  ${t.muted}${this.hint}${c.reset}`);
+    }
+    
+    lines.push("");
+    
+    return lines;
+  }
+  
+  renderFooter() {
+    const t = this.theme;
+    const lines = [];
+    
+    // Scroll indicators
+    const total = this.filteredChoices.length;
+    const showing = Math.min(this.pageSize, total);
+    const hasMore = total > this.pageSize;
+    
+    if (hasMore) {
+      const scrollInfo = `${this.scrollOffset + 1}-${this.scrollOffset + showing} of ${total}`;
+      lines.push("");
+      lines.push(`  ${t.muted}${scrollInfo}${c.reset}`);
+    }
+    
+    // Navigation hints
+    lines.push("");
+    const navHints = [
+      `${t.muted}↑/↓${c.reset} navigate`,
+      `${t.muted}enter${c.reset} select`,
+    ];
+    if (this.showSearch) {
+      navHints.unshift(`${t.muted}/${c.reset} search`);
+    }
+    navHints.push(`${t.muted}esc${c.reset} cancel`);
+    lines.push(`  ${navHints.join("  ")}`);
+    
+    return lines;
+  }
+  
+  render() {
+    // Clear previous render
+    if (this.renderedLines > 0) {
+      this.clearLines(this.renderedLines);
+    }
+    
+    const lines = [];
+    
+    // Header
+    lines.push(...this.renderHeader());
+    
+    // Groups handling
+    let currentGroup = null;
+    const visibleChoices = this.getVisibleChoices();
+    
+    for (let i = 0; i < visibleChoices.length; i++) {
+      const choice = visibleChoices[i];
+      const globalIndex = this.scrollOffset + i;
+      const isSelected = globalIndex === this.selectedIndex;
+      
+      // Group header
+      if (choice.group && choice.group !== currentGroup) {
+        currentGroup = choice.group;
+        lines.push(`  ${this.theme.subtitle}${sym.bullet} ${currentGroup}${c.reset}`);
+      }
+      
+      lines.push(this.renderChoice(choice, isSelected, globalIndex));
+    }
+    
+    // Empty state
+    if (visibleChoices.length === 0) {
+      lines.push(`  ${this.theme.muted}No matches found${c.reset}`);
+    }
+    
+    // Footer
+    lines.push(...this.renderFooter());
+    
+    // Write output
+    this.write(lines.join("\n") + "\n");
+    this.renderedLines = lines.length;
+  }
+  
+  moveUp() {
+    if (this.filteredChoices.length === 0) return;
+    
+    let newIndex = this.selectedIndex - 1;
+    
+    // Skip disabled items
+    while (newIndex >= 0 && this.filteredChoices[newIndex]?.disabled) {
+      newIndex--;
+    }
+    
+    if (newIndex < 0) {
+      if (this.loop) {
+        newIndex = this.filteredChoices.length - 1;
+        while (newIndex > 0 && this.filteredChoices[newIndex]?.disabled) {
+          newIndex--;
+        }
+      } else {
+        return;
+      }
+    }
+    
+    this.selectedIndex = newIndex;
+    this.updateScroll();
+  }
+  
+  moveDown() {
+    if (this.filteredChoices.length === 0) return;
+    
+    let newIndex = this.selectedIndex + 1;
+    
+    // Skip disabled items
+    while (newIndex < this.filteredChoices.length && this.filteredChoices[newIndex]?.disabled) {
+      newIndex++;
+    }
+    
+    if (newIndex >= this.filteredChoices.length) {
+      if (this.loop) {
+        newIndex = 0;
+        while (newIndex < this.filteredChoices.length && this.filteredChoices[newIndex]?.disabled) {
+          newIndex++;
+        }
+      } else {
+        return;
+      }
+    }
+    
+    this.selectedIndex = newIndex;
+    this.updateScroll();
+  }
+  
+  handleKeypress(key, str) {
+    if (!key) return;
+    
+    const name = key.name || "";
+    const ctrl = key.ctrl || false;
+    
+    // Cancel
+    if (name === "escape" || (ctrl && name === "c")) {
+      this.cleanup();
+      return { action: "cancel" };
+    }
+    
+    // Submit
+    if (name === "return" || name === "enter") {
+      const selected = this.filteredChoices[this.selectedIndex];
+      if (selected && !selected.disabled) {
+        this.cleanup();
+        return { action: "submit", value: selected.value, choice: selected };
+      }
+    }
+    
+    // Navigation
+    if (name === "up" || (ctrl && name === "p")) {
+      this.moveUp();
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    if (name === "down" || (ctrl && name === "n")) {
+      this.moveDown();
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    // Page navigation
+    if (name === "pageup") {
+      this.selectedIndex = Math.max(0, this.selectedIndex - this.pageSize);
+      this.updateScroll();
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    if (name === "pagedown") {
+      this.selectedIndex = Math.min(this.filteredChoices.length - 1, this.selectedIndex + this.pageSize);
+      this.updateScroll();
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    // Home/End
+    if (name === "home") {
+      this.selectedIndex = 0;
+      this.scrollOffset = 0;
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    if (name === "end") {
+      this.selectedIndex = this.filteredChoices.length - 1;
+      this.updateScroll();
+      this.render();
+      return { action: "navigate" };
+    }
+    
+    // Search toggle
+    if (this.showSearch && str === "/" && !this.searching) {
+      this.searching = true;
+      this.render();
+      return { action: "search" };
+    }
+    
+    // Search input
+    if (this.searching || this.showSearch) {
+      if (name === "backspace") {
+        this.searchQuery = this.searchQuery.slice(0, -1);
+        this.filterChoices();
+        this.updateScroll();
+        this.render();
+        return { action: "search" };
+      }
+      
+      // Printable character
+      if (str && str.length === 1 && !ctrl && str !== "/") {
+        this.searchQuery += str;
+        this.searching = true;
+        this.filterChoices();
+        this.selectedIndex = 0;
+        this.scrollOffset = 0;
+        this.render();
+        return { action: "search" };
+      }
+    }
+    
+    return { action: "none" };
+  }
+  
+  async run() {
+    if (!this.stdin.isTTY) {
+      throw new Error("Interactive prompts require a TTY");
+    }
+    
+    this.setupReadline();
+    this.hideCursor();
+    this.render();
+    
+    return new Promise((resolve, reject) => {
+      const onKeypress = (str, key) => {
+        try {
+          const result = this.handleKeypress(key, str);
+          
+          if (result.action === "submit") {
+            resolve(result.value);
+          } else if (result.action === "cancel") {
+            resolve(null);
+          }
+        } catch (err) {
+          this.cleanup();
+          reject(err);
+        }
+      };
+      
+      this.stdin.on("keypress", onKeypress);
+      
+      // Cleanup handler
+      const cleanup = () => {
+        this.stdin.off("keypress", onKeypress);
+      };
+      
+      this.rl.once("close", () => {
+        cleanup();
+        resolve(null);
+      });
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MULTI-SELECT PROMPT
+// ═══════════════════════════════════════════════════════════════════════════════
+class MultiSelectPrompt extends SelectPrompt {
+  constructor(options = {}) {
+    super(options);
+    
+    this.selected = new Set(options.initial || []);
+    this.min = options.min || 0;
+    this.max = options.max || Infinity;
+    this.required = options.required || false;
+  }
+  
+  renderChoice(choice, isFocused, index) {
+    const t = this.theme;
+    const isSelected = this.selected.has(choice.value);
+    
+    const pointer = isFocused ? `${t.pointer}${sym.pointer}${c.reset}` : "  ";
+    const checkbox = choice.disabled
+      ? `${t.muted}${sym.checkbox.disabled}${c.reset}`
+      : isSelected
+        ? `${t.success}${sym.checkbox.on}${c.reset}`
+        : `${t.unselected}${sym.checkbox.off}${c.reset}`;
+    
+    const icon = choice.icon ? `${choice.icon} ` : "";
+    
+    let label;
+    if (choice.disabled) {
+      label = `${t.muted}${icon}${choice.label} (disabled)${c.reset}`;
+    } else if (isFocused) {
+      label = `${t.highlight}${icon}${choice.label}${c.reset}`;
+    } else if (isSelected) {
+      label = `${t.selected}${icon}${choice.label}${c.reset}`;
+    } else {
+      label = `${t.unselected}${icon}${choice.label}${c.reset}`;
+    }
+    
+    let description = "";
+    if (choice.description && isFocused) {
+      description = ` ${t.muted}${sym.separator} ${choice.description}${c.reset}`;
+    }
+    
+    return `${pointer} ${checkbox} ${label}${description}`;
+  }
+  
+  renderFooter() {
+    const t = this.theme;
+    const lines = [];
+    
+    // Selection count
+    const count = this.selected.size;
+    const countStr = count === 0 
+      ? "none selected" 
+      : `${count} selected`;
+    
+    lines.push("");
+    lines.push(`  ${t.muted}${countStr}${c.reset}`);
+    
+    // Navigation hints
+    lines.push("");
+    const navHints = [
+      `${t.muted}space${c.reset} toggle`,
+      `${t.muted}↑/↓${c.reset} navigate`,
+      `${t.muted}enter${c.reset} confirm`,
+      `${t.muted}a${c.reset} all`,
+      `${t.muted}esc${c.reset} cancel`,
+    ];
+    lines.push(`  ${navHints.join("  ")}`);
+    
+    return lines;
+  }
+  
+  toggleCurrent() {
+    const choice = this.filteredChoices[this.selectedIndex];
+    if (!choice || choice.disabled) return;
+    
+    if (this.selected.has(choice.value)) {
+      this.selected.delete(choice.value);
+    } else {
+      if (this.selected.size < this.max) {
+        this.selected.add(choice.value);
+      }
+    }
+  }
+  
+  selectAll() {
+    for (const choice of this.filteredChoices) {
+      if (!choice.disabled && this.selected.size < this.max) {
+        this.selected.add(choice.value);
+      }
+    }
+  }
+  
+  selectNone() {
+    this.selected.clear();
+  }
+  
+  handleKeypress(key, str) {
+    if (!key) return { action: "none" };
+    
+    const name = key.name || "";
+    const ctrl = key.ctrl || false;
+    
+    // Cancel
+    if (name === "escape" || (ctrl && name === "c")) {
+      this.cleanup();
+      return { action: "cancel" };
+    }
+    
+    // Submit
+    if (name === "return" || name === "enter") {
+      if (this.required && this.selected.size === 0) {
+        // Don't submit if required and nothing selected
+        return { action: "none" };
+      }
+      if (this.selected.size < this.min) {
+        return { action: "none" };
+      }
+      
+      this.cleanup();
+      const selectedChoices = this.choices.filter(c => this.selected.has(c.value));
+      return { 
+        action: "submit", 
+        value: Array.from(this.selected),
+        choices: selectedChoices,
+      };
+    }
+    
+    // Toggle selection
+    if (name === "space") {
+      this.toggleCurrent();
+      this.render();
+      return { action: "toggle" };
+    }
+    
+    // Select all
+    if (str === "a" && !this.searching) {
+      if (this.selected.size === this.filteredChoices.filter(c => !c.disabled).length) {
+        this.selectNone();
+      } else {
+        this.selectAll();
+      }
+      this.render();
+      return { action: "toggle" };
+    }
+    
+    // Inherit navigation from parent
+    return super.handleKeypress(key, str);
+  }
+  
+  async run() {
+    if (!this.stdin.isTTY) {
+      throw new Error("Interactive prompts require a TTY");
+    }
+    
+    this.setupReadline();
+    this.hideCursor();
+    this.render();
+    
+    return new Promise((resolve, reject) => {
+      const onKeypress = (str, key) => {
+        try {
+          const result = this.handleKeypress(key, str);
+          
+          if (result.action === "submit") {
+            resolve(result.value);
+          } else if (result.action === "cancel") {
+            resolve(null);
+          }
+        } catch (err) {
+          this.cleanup();
+          reject(err);
+        }
+      };
+      
+      this.stdin.on("keypress", onKeypress);
+      
+      this.rl.once("close", () => {
+        this.stdin.off("keypress", onKeypress);
+        resolve(null);
+      });
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIRM PROMPT
+// ═══════════════════════════════════════════════════════════════════════════════
+class ConfirmPrompt extends BasePrompt {
+  constructor(options = {}) {
+    super(options);
+    
+    this.message = options.message || "Are you sure?";
+    this.default = options.default !== false;
+    this.active = options.active || "Yes";
+    this.inactive = options.inactive || "No";
+    this.value = this.default;
+    this.renderedLines = 0;
+  }
+  
+  render() {
+    if (this.renderedLines > 0) {
+      this.clearLines(this.renderedLines);
+    }
+    
+    const t = this.theme;
+    const yes = this.value 
+      ? `${t.success}${c.bold}${c.underline}${this.active}${c.reset}`
+      : `${t.muted}${this.active}${c.reset}`;
+    const no = !this.value
+      ? `${t.error}${c.bold}${c.underline}${this.inactive}${c.reset}`
+      : `${t.muted}${this.inactive}${c.reset}`;
+    
+    const line = `${t.title}${sym.pointer} ${this.message}${c.reset} ${yes} / ${no}`;
+    
+    this.write(line + "\n");
+    this.renderedLines = 1;
+  }
+  
+  handleKeypress(key, str) {
+    if (!key) return { action: "none" };
+    
+    const name = key.name || "";
+    const ctrl = key.ctrl || false;
+    
+    // Cancel
+    if (name === "escape" || (ctrl && name === "c")) {
+      this.cleanup();
+      return { action: "cancel" };
+    }
+    
+    // Submit
+    if (name === "return" || name === "enter") {
+      this.cleanup();
+      return { action: "submit", value: this.value };
+    }
+    
+    // Toggle or direct selection
+    if (name === "left" || name === "right" || name === "tab") {
+      this.value = !this.value;
+      this.render();
+      return { action: "toggle" };
+    }
+    
+    // Direct yes/no
+    if (str === "y" || str === "Y") {
+      this.value = true;
+      this.render();
+      return { action: "toggle" };
+    }
+    
+    if (str === "n" || str === "N") {
+      this.value = false;
+      this.render();
+      return { action: "toggle" };
+    }
+    
+    return { action: "none" };
+  }
+  
+  async run() {
+    if (!this.stdin.isTTY) {
+      throw new Error("Interactive prompts require a TTY");
+    }
+    
+    this.setupReadline();
+    this.hideCursor();
+    this.render();
+    
+    return new Promise((resolve, reject) => {
+      const onKeypress = (str, key) => {
+        try {
+          const result = this.handleKeypress(key, str);
+          
+          if (result.action === "submit") {
+            resolve(result.value);
+          } else if (result.action === "cancel") {
+            resolve(null);
+          }
+        } catch (err) {
+          this.cleanup();
+          reject(err);
+        }
+      };
+      
+      this.stdin.on("keypress", onKeypress);
+      
+      this.rl.once("close", () => {
+        this.stdin.off("keypress", onKeypress);
+        resolve(null);
+      });
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// INPUT PROMPT
+// ═══════════════════════════════════════════════════════════════════════════════
+class InputPrompt extends BasePrompt {
+  constructor(options = {}) {
+    super(options);
+    
+    this.message = options.message || "Enter value";
+    this.default = options.default || "";
+    this.placeholder = options.placeholder || "";
+    this.validate = options.validate || (() => true);
+    this.transform = options.transform || ((v) => v);
+    this.mask = options.mask || null; // For password input
+    
+    this.value = "";
+    this.cursorPosition = 0;
+    this.error = null;
+    this.renderedLines = 0;
+  }
+  
+  render() {
+    if (this.renderedLines > 0) {
+      this.clearLines(this.renderedLines);
+    }
+    
+    const t = this.theme;
+    const lines = [];
+    
+    // Message
+    lines.push(`${t.title}${sym.pointer} ${this.message}${c.reset}`);
+    
+    // Input line
+    let displayValue = this.value;
+    if (this.mask && this.value) {
+      displayValue = this.mask.repeat(this.value.length);
+    }
+    
+    if (!displayValue && this.placeholder) {
+      displayValue = `${t.muted}${this.placeholder}${c.reset}`;
+    } else if (!displayValue && this.default) {
+      displayValue = `${t.muted}(${this.default})${c.reset}`;
+    }
+    
+    const cursor = `${t.primary}▌${c.reset}`;
+    lines.push(`  ${displayValue}${cursor}`);
+    
+    // Error
+    if (this.error) {
+      lines.push(`  ${t.error}${sym.error} ${this.error}${c.reset}`);
+    }
+    
+    this.write(lines.join("\n") + "\n");
+    this.renderedLines = lines.length;
+  }
+  
+  handleKeypress(key, str) {
+    if (!key) return { action: "none" };
+    
+    const name = key.name || "";
+    const ctrl = key.ctrl || false;
+    
+    // Cancel
+    if (name === "escape" || (ctrl && name === "c")) {
+      this.cleanup();
+      return { action: "cancel" };
+    }
+    
+    // Submit
+    if (name === "return" || name === "enter") {
+      const finalValue = this.value || this.default;
+      const validation = this.validate(finalValue);
+      
+      if (validation !== true) {
+        this.error = typeof validation === "string" ? validation : "Invalid input";
+        this.render();
+        return { action: "error" };
+      }
+      
+      this.cleanup();
+      return { action: "submit", value: this.transform(finalValue) };
+    }
+    
+    // Backspace
+    if (name === "backspace") {
+      this.value = this.value.slice(0, -1);
+      this.error = null;
+      this.render();
+      return { action: "input" };
+    }
+    
+    // Clear line
+    if (ctrl && name === "u") {
+      this.value = "";
+      this.error = null;
+      this.render();
+      return { action: "input" };
+    }
+    
+    // Printable character
+    if (str && str.length === 1 && !ctrl) {
+      this.value += str;
+      this.error = null;
+      this.render();
+      return { action: "input" };
+    }
+    
+    return { action: "none" };
+  }
+  
+  async run() {
+    if (!this.stdin.isTTY) {
+      throw new Error("Interactive prompts require a TTY");
+    }
+    
+    this.setupReadline();
+    this.hideCursor();
+    this.render();
+    
+    return new Promise((resolve, reject) => {
+      const onKeypress = (str, key) => {
+        try {
+          const result = this.handleKeypress(key, str);
+          
+          if (result.action === "submit") {
+            resolve(result.value);
+          } else if (result.action === "cancel") {
+            resolve(null);
+          }
+        } catch (err) {
+          this.cleanup();
+          reject(err);
+        }
+      };
+      
+      this.stdin.on("keypress", onKeypress);
+      
+      this.rl.once("close", () => {
+        this.stdin.off("keypress", onKeypress);
+        resolve(null);
+      });
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// WIZARD (Multi-step form)
+// ═══════════════════════════════════════════════════════════════════════════════
+class Wizard extends BasePrompt {
+  constructor(options = {}) {
+    super(options);
+    
+    this.title = options.title || "Setup Wizard";
+    this.steps = options.steps || [];
+    this.onCancel = options.onCancel || (() => {});
+    
+    this.currentStep = 0;
+    this.answers = {};
+  }
+  
+  renderProgress() {
+    const t = this.theme;
+    const total = this.steps.length;
+    const current = this.currentStep + 1;
+    
+    // Progress bar
+    const barWidth = 30;
+    const filled = Math.round((current / total) * barWidth);
+    const empty = barWidth - filled;
+    const bar = `${t.success}${"█".repeat(filled)}${c.reset}${t.muted}${"░".repeat(empty)}${c.reset}`;
+    
+    // Step indicators
+    const stepIndicators = this.steps.map((step, i) => {
+      if (i < this.currentStep) {
+        return `${t.success}${sym.success}${c.reset}`;
+      } else if (i === this.currentStep) {
+        return `${t.primary}${sym.active}${c.reset}`;
+      } else {
+        return `${t.muted}${sym.pending}${c.reset}`;
+      }
+    }).join(" ");
+    
+    console.log();
+    console.log(`  ${t.title}${this.title}${c.reset}`);
+    console.log(`  ${bar} ${t.muted}${current}/${total}${c.reset}`);
+    console.log(`  ${stepIndicators}`);
+    console.log();
+  }
+  
+  async runStep(step) {
+    const stepConfig = {
+      ...step,
+      theme: this.theme,
+    };
+    
+    let prompt;
+    switch (step.type) {
+      case "select":
+        prompt = new SelectPrompt(stepConfig);
+        break;
+      case "multiselect":
+        prompt = new MultiSelectPrompt(stepConfig);
+        break;
+      case "confirm":
+        prompt = new ConfirmPrompt(stepConfig);
+        break;
+      case "input":
+      case "text":
+        prompt = new InputPrompt(stepConfig);
+        break;
+      case "password":
+        prompt = new InputPrompt({ ...stepConfig, mask: "*" });
+        break;
+      default:
+        throw new Error(`Unknown step type: ${step.type}`);
+    }
+    
+    return await prompt.run();
+  }
+  
+  async run() {
+    console.clear();
+    
+    for (let i = 0; i < this.steps.length; i++) {
+      this.currentStep = i;
+      const step = this.steps[i];
+      
+      // Clear and show progress
+      console.clear();
+      this.renderProgress();
+      
+      // Run step
+      const answer = await this.runStep(step);
+      
+      if (answer === null) {
+        // Cancelled
+        this.onCancel();
+        return null;
+      }
+      
+      this.answers[step.name || `step_${i}`] = answer;
+      
+      // Run step callback if provided
+      if (step.onAnswer) {
+        await step.onAnswer(answer, this.answers);
+      }
+    }
+    
+    return this.answers;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONVENIENCE FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+async function select(options) {
+  const prompt = new SelectPrompt(options);
+  return await prompt.run();
+}
+
+async function multiselect(options) {
+  const prompt = new MultiSelectPrompt(options);
+  return await prompt.run();
+}
+
+async function confirm(options) {
+  if (typeof options === "string") {
+    options = { message: options };
+  }
+  const prompt = new ConfirmPrompt(options);
+  return await prompt.run();
+}
+
+async function input(options) {
+  if (typeof options === "string") {
+    options = { message: options };
+  }
+  const prompt = new InputPrompt(options);
+  return await prompt.run();
+}
+
+async function password(options) {
+  if (typeof options === "string") {
+    options = { message: options };
+  }
+  const prompt = new InputPrompt({ ...options, mask: "*" });
+  return await prompt.run();
+}
+
+async function wizard(options) {
+  const w = new Wizard(options);
+  return await w.run();
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+module.exports = {
+  // Prompts
+  SelectPrompt,
+  MultiSelectPrompt,
+  ConfirmPrompt,
+  InputPrompt,
+  Wizard,
+  
+  // Convenience functions
+  select,
+  multiselect,
+  confirm,
+  input,
+  password,
+  wizard,
+  
+  // Utilities
+  gradient,
+  drawBox,
+  truncate,
+  padEnd,
+  padStart,
+  centerText,
+  wrapText,
+  stripAnsi,
+  getTerminalSize,
+  
+  // Styling
+  ansi,
+  c,
+  sym,
+  themes,
+  
+  // Constants
+  SUPPORTS_COLOR,
+  SUPPORTS_TRUECOLOR,
+  SUPPORTS_UNICODE,
+};