vibecodingmachine-cli 1.0.0

package/src/utils/keyboard-handler.js

@@ -0,0 +1,152 @@
+const readline = require('readline');
+const chalk = require('chalk');
+
+/**
+ * Lightweight keyboard handler for Auto Mode
+ * Listens for 'x' key and Ctrl+C without interfering with child process stdin
+ */
+class KeyboardHandler {
+  constructor(options = {}) {
+    this.onExit = options.onExit;
+    this.isActive = false;
+    this.exitConfirmMode = false;
+    this.keypressHandler = null;
+  }
+
+  /**
+   * Start listening for keyboard input
+   */
+  start() {
+    if (this.isActive) return;
+    
+    this.isActive = true;
+
+    // Set up keypress events on stdin
+    readline.emitKeypressEvents(process.stdin);
+    
+    // Only set raw mode if stdin is a TTY
+    if (process.stdin.isTTY && !process.stdin.isRaw) {
+      process.stdin.setRawMode(true);
+    }
+
+    // Create keypress handler
+    this.keypressHandler = (str, key) => {
+      if (!key) return;
+
+      // Handle Ctrl+C - immediate exit
+      if (key.ctrl && key.name === 'c') {
+        this.handleImmediateExit();
+        return;
+      }
+
+      // Handle 'x' key - show confirmation
+      if (key.name === 'x' && !this.exitConfirmMode) {
+        this.showExitConfirmation();
+        return;
+      }
+
+      // In confirmation mode, handle y/n
+      if (this.exitConfirmMode) {
+        if (key.name === 'y') {
+          this.confirmExit();
+        } else if (key.name === 'n' || key.name === 'escape') {
+          this.cancelExit();
+        }
+      }
+    };
+
+    // Attach handler
+    process.stdin.on('keypress', this.keypressHandler);
+    process.stdin.resume();
+  }
+
+  /**
+   * Stop listening for keyboard input
+   */
+  stop() {
+    if (!this.isActive) return;
+
+    this.isActive = false;
+
+    // Remove keypress handler
+    if (this.keypressHandler) {
+      process.stdin.removeListener('keypress', this.keypressHandler);
+      this.keypressHandler = null;
+    }
+
+    // Restore stdin to normal mode
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+      process.stdin.setRawMode(false);
+    }
+
+    process.stdin.pause();
+  }
+
+  showExitConfirmation() {
+    this.exitConfirmMode = true;
+    console.log('\n' + chalk.yellow('─'.repeat(60)));
+    console.log(chalk.yellow.bold('  Exit Auto Mode?'));
+    console.log(chalk.yellow('  Press ') + chalk.white.bold('y') + chalk.yellow(' to exit, ') + chalk.white.bold('n') + chalk.yellow(' to cancel'));
+    console.log(chalk.yellow('─'.repeat(60)) + '\n');
+  }
+
+  cancelExit() {
+    this.exitConfirmMode = false;
+    console.log(chalk.gray('  Cancelled - continuing Auto Mode...\n'));
+  }
+
+  confirmExit() {
+    this.exitConfirmMode = false;
+    this.stop();
+    
+    console.log(chalk.green('  Exiting Auto Mode...\n'));
+    
+    if (this.onExit) {
+      this.onExit();
+    } else {
+      process.exit(0);
+    }
+  }
+
+  handleImmediateExit() {
+    console.log(chalk.yellow('\n  Ctrl+C detected - force exiting...\n'));
+
+    // Call onExit callback first if provided (for cleanup)
+    if (this.onExit) {
+      try {
+        this.onExit();
+      } catch (err) {
+        // Ignore errors during cleanup
+      }
+    }
+
+    // Force exit immediately - don't wait for async cleanup
+    // This is critical because the event loop may be blocked on child processes
+    this.stop();
+    process.exit(0);
+  }
+}
+
+/**
+ * Create a keyboard handler for Auto Mode
+ * @param {object} options - Configuration options
+ * @param {function} options.onExit - Callback when user exits
+ * @returns {KeyboardHandler}
+ */
+function createKeyboardHandler(options = {}) {
+  return new KeyboardHandler(options);
+}
+
+module.exports = {
+  KeyboardHandler,
+  createKeyboardHandler
+};
+
+
+
+
+
+
+
+
+

package/src/utils/logger.js

@@ -0,0 +1,4 @@
+const { logger } = require('@vibecodingmachine/core');
+
+// Re-export the logger from core for CLI use
+module.exports = logger;

package/src/utils/persistent-header.js

@@ -0,0 +1,116 @@
+const chalk = require('chalk');
+
+/**
+ * Simple persistent header that stays at top while content scrolls below
+ * Uses ANSI terminal control codes instead of blessed
+ */
+class PersistentHeader {
+  constructor(lines = 10) {
+    this.headerLines = lines;
+    this.headerContent = '';
+    this.isActive = false;
+  }
+
+  /**
+   * Initialize the header by saving cursor and creating space
+   */
+  start() {
+    if (this.isActive) return;
+    this.isActive = true;
+
+    // Clear screen and move to top
+    process.stdout.write('\x1B[2J\x1B[H');
+
+    // Create space for header by printing empty lines
+    for (let i = 0; i < this.headerLines; i++) {
+      process.stdout.write('\n');
+    }
+  }
+
+  /**
+   * Update the header content
+   * @param {string} content - New header content
+   */
+  update(content) {
+    if (!this.isActive) return;
+
+    this.headerContent = content;
+
+    // Save current cursor position
+    process.stdout.write('\x1B[s');
+
+    // Move to top of screen
+    process.stdout.write('\x1B[H');
+
+    // Clear the header area
+    for (let i = 0; i < this.headerLines; i++) {
+      process.stdout.write('\x1B[2K'); // Clear line
+      if (i < this.headerLines - 1) process.stdout.write('\n');
+    }
+
+    // Move back to top
+    process.stdout.write('\x1B[H');
+
+    // Write header content
+    process.stdout.write(content);
+
+    // Restore cursor position
+    process.stdout.write('\x1B[u');
+  }
+
+  /**
+   * Stop the persistent header
+   */
+  stop() {
+    if (!this.isActive) return;
+    this.isActive = false;
+  }
+}
+
+/**
+ * Format auto mode header
+ */
+function formatAutoModeHeader(status) {
+  const {
+    requirement = 'No requirement',
+    step = 'PREPARE',
+    chatCount = 0,
+    maxChats = null,
+    progress = 0,
+    repoPath = '',
+    hostname = ''
+  } = status;
+
+  const stepColors = {
+    'PREPARE': chalk.cyan,
+    'ACT': chalk.yellow,
+    'CLEAN UP': chalk.magenta,
+    'VERIFY': chalk.blue,
+    'DONE': chalk.green,
+    'UNKNOWN': chalk.gray
+  };
+
+  const stepColor = stepColors[step] || chalk.gray;
+
+  const chatDisplay = maxChats
+    ? `Chat ${chatCount}/${maxChats}`
+    : `Chat ${chatCount} (unlimited)`;
+
+  const progressBar = chalk.green('█'.repeat(Math.floor(progress / 5))) +
+                      chalk.gray('░'.repeat(20 - Math.floor(progress / 5)));
+
+  return `${chalk.cyan('━'.repeat(80))}
+${chalk.bold.cyan('  VibeCodingMachine Auto Mode')} ${chalk.gray('- Press Ctrl+C to stop')}
+${chalk.cyan('━'.repeat(80))}
+${chalk.bold('  Requirement:')} ${requirement.substring(0, 60)}
+${chalk.bold('  Status:')} ${stepColor(step)}  ${chalk.bold('Progress:')} ${progressBar} ${progress}%
+${chalk.bold('  Chats:')} ${chatDisplay}
+${chalk.cyan('━'.repeat(80))}
+
+`;
+}
+
+module.exports = {
+  PersistentHeader,
+  formatAutoModeHeader
+};

package/src/utils/provider-registry.js

@@ -0,0 +1,128 @@
+const path = require('path');
+const os = require('os');
+const { getAutoConfig, setAutoConfig } = require('./config');
+
+const PROVIDER_DEFINITIONS = [
+  {
+    id: 'groq',
+    name: 'Groq (Cloud - Very Fast)',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'llama-3.3-70b-versatile',
+    configKeys: { apiKey: 'groqApiKey', model: 'groqModel' },
+    estimatedSpeed: 15000
+  },
+  {
+    id: 'anthropic',
+    name: 'Anthropic (Claude Sonnet 4)',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'claude-sonnet-4-20250514',
+    configKeys: { apiKey: 'anthropicApiKey', model: 'anthropicModel' },
+    estimatedSpeed: 25000
+  },
+  {
+    id: 'bedrock',
+    name: 'AWS Bedrock (Claude)',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'anthropic.claude-sonnet-4-v1',
+    configKeys: { region: 'awsRegion', accessKeyId: 'awsAccessKeyId', secretAccessKey: 'awsSecretAccessKey' },
+    estimatedSpeed: 40000
+  },
+  {
+    id: 'claude-code',
+    name: 'Claude Code CLI (Sonnet 4.5)',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'claude-code-cli',
+    estimatedSpeed: 35000
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor IDE Agent',
+    type: 'ide',
+    category: 'ide',
+    ide: 'cursor',
+    estimatedSpeed: 60000
+  },
+  {
+    id: 'windsurf',
+    name: 'Windsurf IDE Agent',
+    type: 'ide',
+    category: 'ide',
+    ide: 'windsurf',
+    estimatedSpeed: 90000
+  },
+  {
+    id: 'antigravity',
+    name: 'Google Antigravity IDE Agent',
+    type: 'ide',
+    category: 'ide',
+    ide: 'antigravity',
+    estimatedSpeed: 90000
+  },
+  {
+    id: 'ollama',
+    name: 'Ollama (Local)',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'qwen2.5-coder:32b',
+    estimatedSpeed: 200000
+  }
+];
+
+function getProviderDefinitions() {
+  return PROVIDER_DEFINITIONS.map(def => ({ ...def }));
+}
+
+function getProviderDefinition(id) {
+  return PROVIDER_DEFINITIONS.find(def => def.id === id);
+}
+
+function getDefaultProviderOrder() {
+  return PROVIDER_DEFINITIONS.map(def => def.id);
+}
+
+function mergeProviderPreferences(autoConfig) {
+  const prefs = (autoConfig && autoConfig.providerPreferences) || {};
+  const order = Array.isArray(prefs.order) ? prefs.order.slice() : [];
+  const enabled = (prefs.enabled && typeof prefs.enabled === 'object') ? { ...prefs.enabled } : {};
+
+  const defaultOrder = getDefaultProviderOrder();
+  const cleanedOrder = order.filter(id => getProviderDefinition(id));
+  defaultOrder.forEach(id => {
+    if (!cleanedOrder.includes(id)) {
+      cleanedOrder.push(id);
+    }
+    if (enabled[id] === undefined) {
+      enabled[id] = true;
+    }
+  });
+
+  return { order: cleanedOrder, enabled };
+}
+
+async function getProviderPreferences() {
+  const autoConfig = await getAutoConfig();
+  return mergeProviderPreferences(autoConfig);
+}
+
+async function saveProviderPreferences(order, enabled) {
+  await setAutoConfig({
+    providerPreferences: {
+      order: order.slice(),
+      enabled: { ...enabled }
+    }
+  });
+}
+
+module.exports = {
+  getProviderDefinitions,
+  getProviderDefinition,
+  getDefaultProviderOrder,
+  mergeProviderPreferences,
+  getProviderPreferences,
+  saveProviderPreferences
+};
+

package/src/utils/status-card.js

@@ -0,0 +1,120 @@
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+/**
+ * Render a status card showing current requirement progress
+ * Similar to the purple card in the GUI
+ * @param {object} status - Current status object
+ * @param {string} status.requirement - Current requirement being worked on
+ * @param {string} status.step - Current step (PREPARE, ACT, CLEAN UP, VERIFY, DONE)
+ * @param {number} status.chatCount - Current chat count
+ * @param {number|null} status.maxChats - Maximum chats or null for unlimited
+ * @param {number} status.progress - Progress percentage (0-100)
+ * @returns {string} Formatted status card
+ */
+function renderStatusCard(status) {
+  const {
+    requirement = 'No requirement loaded',
+    step = 'UNKNOWN',
+    chatCount = 0,
+    maxChats = null,
+    progress = 0
+  } = status;
+
+  // Step color mapping
+  const stepColors = {
+    'PREPARE': chalk.cyan,
+    'ACT': chalk.yellow,
+    'CLEAN UP': chalk.magenta,
+    'VERIFY': chalk.blue,
+    'DONE': chalk.green,
+    'UNKNOWN': chalk.gray
+  };
+
+  const stepColor = stepColors[step] || chalk.gray;
+
+  // Progress bar
+  const barWidth = 30;
+  const filledWidth = Math.round((progress / 100) * barWidth);
+  const emptyWidth = barWidth - filledWidth;
+  const progressBar = chalk.green('█'.repeat(filledWidth)) + chalk.gray('░'.repeat(emptyWidth));
+
+  // Chat counter
+  const chatDisplay = maxChats
+    ? `Chat ${chatCount}/${maxChats}`
+    : `Chat ${chatCount} (unlimited)`;
+
+  // Build card content
+  const content = [
+    chalk.bold('📋 Current Requirement'),
+    '',
+    chalk.white(requirement.length > 60 ? requirement.substring(0, 57) + '...' : requirement),
+    '',
+    chalk.bold('🚦 Status: ') + stepColor.bold(step),
+    '',
+    `${progressBar} ${progress}%`,
+    '',
+    chalk.gray(chatDisplay)
+  ].join('\n');
+
+  // Render with boxen (purple/magenta border like the GUI)
+  return boxen(content, {
+    padding: 1,
+    margin: { top: 0, right: 0, bottom: 1, left: 0 },
+    borderStyle: 'round',
+    borderColor: 'magenta',
+    title: 'Auto Mode Status',
+    titleAlignment: 'center'
+  });
+}
+
+/**
+ * Clear the terminal and move cursor to top
+ */
+function clearAndMoveToTop() {
+  // ANSI escape codes
+  process.stdout.write('\x1B[2J'); // Clear entire screen
+  process.stdout.write('\x1B[H');  // Move cursor to home (top-left)
+}
+
+/**
+ * Move cursor up N lines
+ * @param {number} lines - Number of lines to move up
+ */
+function moveCursorUp(lines) {
+  process.stdout.write(`\x1B[${lines}A`);
+}
+
+/**
+ * Save cursor position
+ */
+function saveCursor() {
+  process.stdout.write('\x1B[s');
+}
+
+/**
+ * Restore cursor position
+ */
+function restoreCursor() {
+  process.stdout.write('\x1B[u');
+}
+
+/**
+ * Render the menu header and status card together
+ * @param {string} menuContent - The menu content to display
+ * @param {object} status - Status object for the status card
+ */
+function renderHeaderWithStatus(menuContent, status) {
+  clearAndMoveToTop();
+  console.log(menuContent);
+  console.log(renderStatusCard(status));
+}
+
+module.exports = {
+  renderStatusCard,
+  clearAndMoveToTop,
+  moveCursorUp,
+  saveCursor,
+  restoreCursor,
+  renderHeaderWithStatus
+};

package/src/utils/stdout-interceptor.js

@@ -0,0 +1,127 @@
+/**
+ * Intercept stdout and stderr to capture console output
+ * Allows routing output to custom handlers (like blessed UI) while optionally preserving original output
+ */
+class StdoutInterceptor {
+  constructor() {
+    this.originalStdoutWrite = null;
+    this.originalStderrWrite = null;
+    this.outputHandlers = [];
+    this.isIntercepting = false;
+    this.buffer = '<span style="color: white;">';
+  }
+
+  /**
+   * Add a handler that will receive output
+   * @param {function} handler - Function that receives output strings
+   */
+  addHandler(handler) {
+    this.outputHandlers.push(handler);
+  }
+
+  /**
+   * Remove a handler
+   * @param {function} handler - Handler to remove
+   */
+  removeHandler(handler) {
+    const index = this.outputHandlers.indexOf(handler);
+    if (index > -1) {
+      this.outputHandlers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Start intercepting stdout/stderr
+   * @param {boolean} passthrough - If true, still write to original stdout/stderr
+   */
+  start(passthrough = false) {
+    if (this.isIntercepting) {
+      return;
+    }
+
+    this.isIntercepting = true;
+
+    // Save original write functions
+    this.originalStdoutWrite = process.stdout.write;
+    this.originalStderrWrite = process.stderr.write;
+
+    // Intercept stdout
+    process.stdout.write = (chunk, encoding, callback) => {
+      const str = chunk.toString();
+
+      // Call all registered handlers
+      this.outputHandlers.forEach(handler => {
+        try {
+          handler(str);
+        } catch (error) {
+          // Silently ignore handler errors to prevent breaking the interceptor
+        }
+      });
+
+      // Optionally pass through to original stdout
+      if (passthrough && this.originalStdoutWrite) {
+        return this.originalStdoutWrite.call(process.stdout, chunk, encoding, callback);
+      }
+
+      // If not passing through, still call the callback if provided
+      if (typeof callback === 'function') {
+        callback();
+      }
+      return true;
+    };
+
+    // Intercept stderr
+    process.stderr.write = (chunk, encoding, callback) => {
+      const str = chunk.toString();
+
+      // Call all registered handlers
+      this.outputHandlers.forEach(handler => {
+        try {
+          handler(str);
+        } catch (error) {
+          // Silently ignore handler errors
+        }
+      });
+
+      // Optionally pass through to original stderr
+      if (passthrough && this.originalStderrWrite) {
+        return this.originalStderrWrite.call(process.stderr, chunk, encoding, callback);
+      }
+
+      // If not passing through, still call the callback if provided
+      if (typeof callback === 'function') {
+        callback();
+      }
+      return true;
+    };
+  }
+
+  /**
+   * Stop intercepting and restore original stdout/stderr
+   */
+  stop() {
+    if (!this.isIntercepting) {
+      return;
+    }
+
+    if (this.originalStdoutWrite) {
+      process.stdout.write = this.originalStdoutWrite;
+    }
+    if (this.originalStderrWrite) {
+      process.stderr.write = this.originalStderrWrite;
+    }
+
+    this.isIntercepting = false;
+  }
+
+  /**
+   * Clear all handlers
+   */
+  clearHandlers() {
+    this.outputHandlers = [];
+  }
+}
+
+module.exports = {
+  StdoutInterceptor
+};

package/tests/auto-mode.test.js

@@ -0,0 +1,37 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs-extra');
+
+describe('auto-mode utils', () => {
+  const tmpConfig = path.join(os.tmpdir(), `allnightai_test_config_${Date.now()}.json`);
+  const tmpRepo = path.join(os.tmpdir(), `allnightai_test_repo_${Date.now()}`);
+
+  beforeAll(async () => {
+    process.env.ALLNIGHTAI_CONFIG_PATH = tmpConfig;
+    await fs.ensureDir(path.join(tmpRepo, '.vibecodingmachine', 'temp'));
+    const { setRepoPath } = require('../src/utils/config');
+    await setRepoPath(tmpRepo);
+  });
+
+  afterAll(async () => {
+    delete process.env.ALLNIGHTAI_CONFIG_PATH;
+    await fs.remove(tmpConfig).catch(() => {});
+    await fs.remove(tmpRepo).catch(() => {});
+  });
+
+  test('start/stop and status', async () => {
+    const { startAutoMode, stopAutoMode, checkAutoModeStatus } = require('../src/utils/auto-mode');
+    const { getAutoConfig } = require('../src/utils/config');
+    await startAutoMode(tmpRepo, { ide: 'cursor' });
+    let status = await checkAutoModeStatus();
+    expect(status.running).toBe(true);
+    expect(status.ide).toBe('cursor');
+
+    await stopAutoMode();
+    status = await checkAutoModeStatus();
+    expect(status.running).toBe(false);
+  });
+});
+
+
+