hedgequantx 2.9.57 → 2.9.59

package/src/utils/prompts.js

@@ -1,42 +1,18 @@
 /**
- * @fileoverview Centralized prompts utility
+ * @fileoverview Centralized prompts utility with animated yellow spinner
  * @module utils/prompts
  * 
- * Uses native readline for reliable stdin handling
- * Yellow spinner shows activity while waiting for user input
+ * Custom readline-based prompts with animated spinner that runs
+ * while waiting for user input. Uses inquirer only for complex
+ * prompts (password, list selection).
  */
 
 const inquirer = require('inquirer');
 const readline = require('readline');
 const chalk = require('chalk');
 
-// Spinner characters for yellow waiting indicator
+// Spinner frames for yellow waiting indicator
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-let spinnerInterval = null;
-let spinnerFrame = 0;
-
-/**
- * Start yellow spinner to show we're waiting for user input
- */
-const startSpinner = () => {
-  if (spinnerInterval) return;
-  spinnerFrame = 0;
-  spinnerInterval = setInterval(() => {
-    spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
-    process.stdout.write(`\r${chalk.yellow(SPINNER_FRAMES[spinnerFrame])} `);
-  }, 80);
-};
-
-/**
- * Stop spinner and clear line
- */
-const stopSpinner = () => {
-  if (spinnerInterval) {
-    clearInterval(spinnerInterval);
-    spinnerInterval = null;
-    process.stdout.write('\r  \r'); // Clear spinner
-  }
-};
 
 /** @type {readline.Interface|null} */
 let rl = null;
@@ -72,64 +48,305 @@ const closeReadline = () => {
 };
 
 /**
- * Native readline prompt
+ * Animated spinner prompt using raw readline
+ * Spinner animates while waiting for user input
  * @param {string} message - Prompt message
  * @returns {Promise<string>}
  */
-const nativePrompt = (message) => {
+const animatedPrompt = (message) => {
   return new Promise((resolve) => {
-    try {
-      prepareStdin();
-      closeReadline();
+    prepareStdin();
+    closeReadline();
 
-      rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-      });
+    let frameIndex = 0;
+    let userInput = '';
+    let cursorPos = 0;
 
-      let answered = false;
+    // Enable raw mode for character-by-character input
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
 
-      rl.question(`${message} `, (answer) => {
-        answered = true;
-        closeReadline();
-        resolve(answer || '');
-      });
+    const render = () => {
+      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
+      const line = `\r${spinner} ${message} ${userInput}`;
+      process.stdout.write('\r\x1b[K'); // Clear line
+      process.stdout.write(line);
+    };
+
+    // Animate spinner every 80ms
+    const spinnerInterval = setInterval(() => {
+      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+      render();
+    }, 80);
+
+    render();
 
-      rl.on('close', () => {
-        if (!answered) {
-          rl = null;
-          resolve('');
+    const onData = (key) => {
+      const char = key.toString();
+      
+      // Enter key
+      if (char === '\r' || char === '\n') {
+        clearInterval(spinnerInterval);
+        process.stdin.removeListener('data', onData);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
         }
-      });
-    } catch {
-      resolve('');
+        process.stdout.write('\n');
+        resolve(userInput);
+        return;
+      }
+      
+      // Ctrl+C
+      if (char === '\x03') {
+        clearInterval(spinnerInterval);
+        process.stdin.removeListener('data', onData);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdout.write('\n');
+        process.exit(0);
+      }
+      
+      // Backspace
+      if (char === '\x7f' || char === '\b') {
+        if (userInput.length > 0) {
+          userInput = userInput.slice(0, -1);
+          render();
+        }
+        return;
+      }
+      
+      // Regular printable character
+      if (char >= ' ' && char <= '~') {
+        userInput += char;
+        render();
+      }
+    };
+
+    process.stdin.on('data', onData);
+  });
+};
+
+/**
+ * Animated Y/N confirm prompt
+ * Shows [Y/n] or [y/N] based on default
+ * @param {string} message - Prompt message  
+ * @param {boolean} defaultVal - Default value
+ * @returns {Promise<boolean>}
+ */
+const animatedConfirm = (message, defaultVal = true) => {
+  return new Promise((resolve) => {
+    prepareStdin();
+    closeReadline();
+
+    let frameIndex = 0;
+    const hint = defaultVal ? '[Y/n]' : '[y/N]';
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const render = () => {
+      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
+      process.stdout.write('\r\x1b[K');
+      process.stdout.write(`${spinner} ${message} ${chalk.dim(hint)} `);
+    };
+
+    const spinnerInterval = setInterval(() => {
+      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+      render();
+    }, 80);
+
+    render();
+
+    const onData = (key) => {
+      const char = key.toString().toLowerCase();
+      
+      // Enter = use default
+      if (char === '\r' || char === '\n') {
+        cleanup();
+        process.stdout.write(defaultVal ? 'Yes' : 'No');
+        process.stdout.write('\n');
+        resolve(defaultVal);
+        return;
+      }
+      
+      // Y = yes
+      if (char === 'y') {
+        cleanup();
+        process.stdout.write('Yes');
+        process.stdout.write('\n');
+        resolve(true);
+        return;
+      }
+      
+      // N = no
+      if (char === 'n') {
+        cleanup();
+        process.stdout.write('No');
+        process.stdout.write('\n');
+        resolve(false);
+        return;
+      }
+      
+      // Ctrl+C
+      if (char === '\x03') {
+        cleanup();
+        process.stdout.write('\n');
+        process.exit(0);
+      }
+    };
+
+    const cleanup = () => {
+      clearInterval(spinnerInterval);
+      process.stdin.removeListener('data', onData);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    };
+
+    process.stdin.on('data', onData);
+  });
+};
+
+/**
+ * Animated list selection with arrow keys
+ * @param {string} message - Prompt message
+ * @param {Array<{name: string, value: any}>} choices - Options
+ * @returns {Promise<any>}
+ */
+const animatedSelect = (message, choices) => {
+  return new Promise((resolve) => {
+    prepareStdin();
+    closeReadline();
+
+    let frameIndex = 0;
+    let selectedIndex = 0;
+    const validChoices = choices.filter(c => !c.disabled);
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
     }
+    process.stdin.resume();
+
+    const render = () => {
+      const spinner = chalk.yellow(SPINNER_FRAMES[frameIndex]);
+      // Move cursor to start and clear down
+      process.stdout.write('\r\x1b[K');
+      process.stdout.write(`${spinner} ${message}\n`);
+      
+      validChoices.forEach((choice, i) => {
+        process.stdout.write('\x1b[K'); // Clear line
+        if (i === selectedIndex) {
+          process.stdout.write(`${chalk.cyan('❯')} ${chalk.cyan(choice.name)}\n`);
+        } else {
+          process.stdout.write(`  ${choice.name}\n`);
+        }
+      });
+      
+      // Move cursor back up
+      process.stdout.write(`\x1b[${validChoices.length + 1}A`);
+    };
+
+    const spinnerInterval = setInterval(() => {
+      frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+      render();
+    }, 80);
+
+    render();
+
+    let escapeSeq = '';
+    
+    const onData = (key) => {
+      const char = key.toString();
+      
+      // Handle escape sequences (arrow keys)
+      if (char === '\x1b') {
+        escapeSeq = char;
+        return;
+      }
+      
+      if (escapeSeq === '\x1b' && char === '[') {
+        escapeSeq += char;
+        return;
+      }
+      
+      if (escapeSeq === '\x1b[') {
+        escapeSeq = '';
+        // Up arrow
+        if (char === 'A') {
+          selectedIndex = Math.max(0, selectedIndex - 1);
+          render();
+          return;
+        }
+        // Down arrow
+        if (char === 'B') {
+          selectedIndex = Math.min(validChoices.length - 1, selectedIndex + 1);
+          render();
+          return;
+        }
+      }
+      
+      // Enter = select
+      if (char === '\r' || char === '\n') {
+        cleanup();
+        // Clear the menu lines
+        process.stdout.write('\r\x1b[K');
+        for (let i = 0; i < validChoices.length; i++) {
+          process.stdout.write('\x1b[B\x1b[K');
+        }
+        process.stdout.write(`\x1b[${validChoices.length}A`);
+        process.stdout.write(`${chalk.yellow('⠋')} ${message} ${chalk.cyan(validChoices[selectedIndex].name)}\n`);
+        resolve(validChoices[selectedIndex].value);
+        return;
+      }
+      
+      // Ctrl+C
+      if (char === '\x03') {
+        cleanup();
+        process.stdout.write('\n');
+        process.exit(0);
+      }
+    };
+
+    const cleanup = () => {
+      clearInterval(spinnerInterval);
+      process.stdin.removeListener('data', onData);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    };
+
+    process.stdin.on('data', onData);
   });
 };
 
 /**
- * Wait for Enter key + yellow spinner
+ * Wait for Enter key with animated spinner
  * @param {string} [message='Press Enter to continue...'] - Message to display
  * @returns {Promise<void>}
  */
 const waitForEnter = async (message = 'Press Enter to continue...') => {
-  await nativePrompt(`${chalk.yellow('⠋')} ${message}`);
+  await animatedPrompt(message);
 };
 
 /**
- * Text input + yellow spinner
+ * Text input with animated spinner
  * @param {string} message - Prompt message
  * @param {string} [defaultVal=''] - Default value
  * @returns {Promise<string>}
  */
 const textInput = async (message, defaultVal = '') => {
-  const value = await nativePrompt(`${chalk.yellow('⠋')} ${message}`);
+  const displayMsg = defaultVal ? `${message} (${defaultVal})` : message;
+  const value = await animatedPrompt(displayMsg);
   return value || defaultVal;
 };
 
 /**
- * Password input (masked) + yellow spinner
+ * Password input (masked) - uses inquirer for masking
  * @param {string} message - Prompt message
  * @returns {Promise<string>}
  */
@@ -149,33 +366,17 @@ const passwordInput = async (message) => {
 };
 
 /**
- * Confirm prompt with arrow keys + yellow spinner
+ * Confirm prompt with animated spinner (Y/n)
  * @param {string} message - Prompt message
  * @param {boolean} [defaultVal=true] - Default value
  * @returns {Promise<boolean>}
  */
 const confirmPrompt = async (message, defaultVal = true) => {
-  closeReadline();
-  prepareStdin();
-
-  const choices = defaultVal
-    ? [{ name: 'Yes', value: true }, { name: 'No', value: false }]
-    : [{ name: 'No', value: false }, { name: 'Yes', value: true }];
-
-  const { value } = await inquirer.prompt([{
-    type: 'list',
-    name: 'value',
-    message: `${chalk.yellow('⠋')} ${message}`,
-    choices,
-    prefix: '',
-    loop: false,
-  }]);
-
-  return value;
+  return animatedConfirm(message, defaultVal);
 };
 
 /**
- * Number input with validation + yellow spinner
+ * Number input with animated spinner and validation
  * @param {string} message - Prompt message
  * @param {number} [defaultVal=1] - Default value
  * @param {number} [min=1] - Minimum value
@@ -183,55 +384,40 @@ const confirmPrompt = async (message, defaultVal = true) => {
  * @returns {Promise<number>}
  */
 const numberInput = async (message, defaultVal = 1, min = 1, max = 1000) => {
-  closeReadline();
-  prepareStdin();
-
-  const { value } = await inquirer.prompt([{
-    type: 'input',
-    name: 'value',
-    message: `${chalk.yellow('⠋')} ${message}`,
-    default: String(defaultVal),
-    prefix: '',
-    validate: (v) => {
-      const n = parseInt(v, 10);
-      if (isNaN(n)) return 'Enter a number';
-      if (n < min) return `Min: ${min}`;
-      if (n > max) return `Max: ${max}`;
-      return true;
-    },
-  }]);
-
-  return parseInt(value, 10) || defaultVal;
+  const displayMsg = `${message} (${min}-${max}, default: ${defaultVal})`;
+  
+  while (true) {
+    const value = await animatedPrompt(displayMsg);
+    
+    if (!value) return defaultVal;
+    
+    const num = parseInt(value, 10);
+    if (isNaN(num)) {
+      console.log(chalk.red('Please enter a valid number'));
+      continue;
+    }
+    if (num < min || num > max) {
+      console.log(chalk.red(`Please enter a number between ${min} and ${max}`));
+      continue;
+    }
+    return num;
+  }
 };
 
 /**
- * Select from options with arrow keys + yellow spinner
+ * Select from options with animated spinner and arrow keys
  * @param {string} message - Prompt message
  * @param {Array<{label: string, value: any, disabled?: boolean}>} options - Options
  * @returns {Promise<any>}
  */
 const selectOption = async (message, options) => {
-  closeReadline();
-  prepareStdin();
-
-  const choices = options.map(opt => {
-    if (opt.disabled) {
-      return new inquirer.Separator(opt.label);
-    }
-    return { name: opt.label, value: opt.value };
-  });
+  const choices = options.map(opt => ({
+    name: opt.label,
+    value: opt.value,
+    disabled: opt.disabled || false,
+  }));
 
-  const { value } = await inquirer.prompt([{
-    type: 'list',
-    name: 'value',
-    message: `${chalk.yellow('⠋')} ${message}`,
-    choices,
-    prefix: '',
-    loop: false,
-    pageSize: 20,
-  }]);
-
-  return value;
+  return animatedSelect(message, choices);
 };
 
 module.exports = {