vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/trui-navigation.js

@@ -0,0 +1,303 @@
+/**
+ * TRUI Navigation — Main Menu
+ *
+ * Renders the status-rich main menu using showQuickMenu (raw keypress).
+ * Status/settings lines shown in gray at top; action items in white below.
+ * Dispatches to: Requirements tree, Provider manager, Settings, Spec creation.
+ * Now using RUI pattern for consistent command structure.
+ */
+
+const chalk = require('chalk');
+const { showQuickMenu } = require('./trui-quick-menu');
+const { initializeWindsurfIntegration, getWindsurfStatus } = require('./trui-windsurf');
+const { debugLogger } = require('./trui-debug');
+const RUITRUIAdapter = require('./rui-trui-adapter');
+
+/**
+ * Build main-menu items array with live status at top
+ */
+async function buildMainMenuItems() {
+  const items = [];
+
+  // Auto Mode status
+  let autoStatus = { running: false };
+  try {
+    const { checkAutoModeStatus } = require('./auto-mode');
+    autoStatus = await checkAutoModeStatus();
+  } catch (_) {}
+
+  items.push({
+    type: 'setting',
+    name: `Auto Mode: ${autoStatus.running ? chalk.green('Running ✓') : chalk.yellow('Stopped ○')}`,
+    value: 'setting:auto',
+  });
+
+  // Requirements summary
+  try {
+    const { countRequirements } = require('./status-helpers-extracted');
+    const counts = await countRequirements();
+    if (counts) {
+      const total = (counts.todoCount || 0) + (counts.toVerifyCount || 0) + (counts.verifiedCount || 0);
+      const pct = n => total > 0 ? Math.round((n / total) * 100) : 0;
+      items.push({
+        type: 'setting',
+        name: `Requirements: ${chalk.yellow(counts.todoCount + ' todo')}, ${chalk.cyan(counts.toVerifyCount + ' verify')}, ${chalk.green(counts.verifiedCount + ' done')} (${pct(counts.verifiedCount)}% complete)`,
+        value: 'setting:requirements',
+      });
+    }
+  } catch (_) {}
+
+  items.push({ type: 'blank', name: '', value: 'blank' });
+
+  // Action items
+  items.push({ type: 'action', name: '📋 Requirements', value: 'requirements' });
+  items.push({ type: 'action', name: '🤖 Agents / Providers', value: 'agents' });
+  items.push({ type: 'action', name: '⚙️  Settings', value: 'settings' });
+  items.push({ type: 'action', name: '[+ Add Requirement]', value: 'add-req' });
+  items.push({ type: 'action', name: '[+ Add Specification]', value: 'add-spec' });
+  items.push({ type: 'action', name: '💬 Send Continue to Windsurf', value: 'continue-windsurf' });
+  items.push({ type: 'action', name: '🔄 Sync Now', value: 'sync' });
+
+  return items;
+}
+
+/**
+ * TRUINavigation — main menu loop
+ */
+class TRUINavigation {
+  constructor() {
+    this._lastIndex = 0;
+    this.ruiAdapter = new RUITRUIAdapter();
+  }
+
+  async start() {
+    const { showWelcomeScreen } = require('./welcome-screen-extracted');
+    console.clear();
+    try { await showWelcomeScreen(); } catch (_) {}
+
+    // Initialize Windsurf integration with error handling
+    try {
+      initializeWindsurfIntegration();
+    } catch (error) {
+      console.log(chalk.yellow('⚠ Windsurf integration disabled: ' + error.message));
+    }
+
+    await this._loop();
+  }
+
+  async _loop() {
+    const {
+      showRequirementsTree,
+    } = require('./trui-req-tree');
+    const { showProviderManagerMenu } = require('./trui-provider-manager');
+    const { showSettings } = require('./trui-nav-settings');
+    const { addRequirementFlow } = require('./trui-req-actions');
+    const { addSpecificationFlow } = require('./trui-nav-specifications');
+    const { sendContinueToWindsurf } = require('./trui-windsurf');
+    const { showFeedbackSubmission } = require('./trui-feedback');
+    const { showSpecificationsList } = require('./trui-specifications');
+
+    while (true) {
+      try {
+        const items = await buildMainMenuItems();
+        const result = await showQuickMenu(items, this._lastIndex);
+        this._lastIndex = result.selectedIndex;
+        const action = result.value;
+
+        if (action === '__cancel__' || action === 'exit') {
+          await this._confirmExit();
+          continue;
+        }
+
+        // Dispatch to sub-modules
+        try {
+          if (action === 'setting:auto') {
+            try {
+              const { checkAutoModeStatus, stopAutoMode } = require('./auto-mode');
+              const s = await checkAutoModeStatus();
+              if (s.running) {
+                await stopAutoMode('manual');
+                console.log(chalk.yellow('\n⏹  Auto mode stopped\n'));
+                await this._pause();
+                console.clear();
+              } else {
+                console.log(chalk.bold.cyan('\n▶  Starting Auto Mode...\n'));
+                try {
+                  const { getAutoConfig } = require('./config');
+                  const currentConfig = await getAutoConfig();
+                  // Pick first enabled provider
+                  const { getProviderPreferences } = require('./provider-registry');
+                  const prefs = await getProviderPreferences();
+                  let agentToUse = currentConfig.ide || currentConfig.agent || 'cline';
+                  for (const agentId of (prefs.order || [])) {
+                    if (prefs.enabled[agentId] !== false) { agentToUse = agentId; break; }
+                  }
+                  // Release raw mode before running auto (so Ctrl+C works)
+                  if (process.stdin.isTTY && process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                  }
+                  const options = { ide: agentToUse };
+                  if (currentConfig.neverStop) {
+                    options.neverStop = true;
+                  } else if (currentConfig.maxChats) {
+                    options.maxChats = currentConfig.maxChats;
+                  } else {
+                    options.neverStop = true;
+                  }
+                  const { handleAutoStart } = require('../commands/auto-direct');
+                  await handleAutoStart(options);
+                } catch (startErr) {
+                  if (startErr.message && startErr.message.includes('User force closed')) {
+                    console.log(chalk.yellow('\nCancelled\n'));
+                  } else {
+                    console.log(chalk.red(`\n✗ Error: ${startErr.message}`));
+                    if (startErr.stack) console.log(chalk.gray(startErr.stack.split('\n').slice(0, 8).join('\n')));
+                    console.log(chalk.yellow('\nReturning to menu in 5 seconds...'));
+                    await new Promise(r => setTimeout(r, 5000));
+                  }
+                }
+                await this._pause();
+                console.clear();
+              }
+            } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); console.clear(); }
+            continue;
+          }
+
+          if (action === 'requirements' || action === 'setting:requirements') {
+            try { await showRequirementsTree(); } catch (err) { console.log(chalk.red('Requirements error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'agents') {
+            try { await showProviderManagerMenu(); } catch (err) { console.log(chalk.red('Agents error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'settings') {
+            try { await showSettings(); } catch (err) { console.log(chalk.red('Settings error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'add-req') {
+            try { await addRequirementFlow(); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'add-spec') {
+            try { await addSpecificationFlow(); } catch (err) { console.log(chalk.red('Error: ' + err.message)); await this._pause(); }
+            console.clear();
+            continue;
+          }
+
+          if (action === 'continue-windsurf') {
+            try {
+              await sendContinueToWindsurf();
+              console.log(chalk.green('\n✓ Continue message sent to Windsurf Cascade\n'));
+            } catch (err) { console.log(chalk.red('Error: ' + err.message)); }
+            await this._pause();
+            console.clear();
+            continue;
+          }
+
+          if (action === 'sync') {
+            try {
+              const { execSync } = require('child_process');
+              console.log(chalk.cyan('\n🔄 Syncing...\n'));
+              execSync('vcm sync:now', { stdio: 'inherit' });
+            } catch (_) { console.log(chalk.gray('vcm sync:now: command unavailable')); }
+            await this._pause();
+            console.clear();
+            continue;
+          }
+
+          // Unknown action — show error
+          console.log(chalk.yellow('Unknown action: ' + action));
+          await this._pause();
+          console.clear();
+          continue;
+        } catch (err) {
+          console.log(chalk.red('Action error: ' + err.message));
+          await this._pause();
+          console.clear();
+          continue;
+        }
+
+      } catch (error) {
+        debugLogger.error('Menu loop error', { error: error.message, stack: error.stack });
+        console.log(chalk.red('Menu error: ' + error.message));
+        await this._pause();
+        continue;
+      }
+    }
+  }
+
+  async _confirmExit() {
+    console.clear();
+    console.log(chalk.yellow('\nExit Vibe Coding Machine? (Y/n/x)\n'));
+
+    return new Promise((resolve) => {
+      const readline = require('readline');
+
+      // Set up raw keypress handling
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY && process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+
+      const onKeypress = (str, key) => {
+        // Handle left arrow - exit without confirmation
+        if (key && key.name === 'left') {
+          cleanup();
+          console.log(chalk.yellow('\nGoodbye!\n'));
+          process.exit(0);
+          return;
+        }
+
+        // Handle Enter or 'y' or 'Y' or 'x' - confirm exit
+        if (key && (key.name === 'return' || (str && (str === 'y' || str === 'Y' || str === 'x' || str === 'X')))) {
+          cleanup();
+          console.log(chalk.yellow('\nGoodbye!\n'));
+          process.exit(0);
+          return;
+        }
+
+        // Handle 'n' or 'N' or ESC or right arrow - cancel exit
+        if (key && (key.name === 'escape' || key.name === 'right' || (str && (str === 'n' || str === 'N')))) {
+          cleanup();
+          resolve();
+          return;
+        }
+      };
+
+      const cleanup = () => {
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdin.removeListener('keypress', onKeypress);
+        process.stdin.pause();
+      };
+
+      process.stdin.on('keypress', onKeypress);
+      process.stdin.resume();
+    });
+  }
+
+  async _pause() {
+    const inquirer = require('inquirer');
+    await inquirer.prompt([{ type: 'input', name: 'c', message: chalk.gray('Press Enter to continue...') }]);
+  }
+
+  async promptContinue() {
+    await this._pause();
+  }
+}
+
+module.exports = { TRUINavigation, buildMainMenuItems };
+
+// Export a singleton instance for use by other modules
+const navigationInstance = new TRUINavigation();
+module.exports.promptContinue = () => navigationInstance.promptContinue();

package/src/utils/trui-provider-manager.js

@@ -0,0 +1,182 @@
+/**
+ * TRUI Provider / Agent Manager
+ *
+ * Lists all configured providers with letter shortcuts via showQuickMenu.
+ * Changes are saved immediately on every toggle or reorder.
+ *
+ * Consistent key scheme (all non-letter commands):
+ *   ↑ / ↓  — navigate
+ *   <  /,  — move item down (lower priority / higher index), NO SHIFT needed
+ *   >  /.  — move item up   (higher priority / lower index), NO SHIFT needed
+ *   Space  — toggle enable/disable
+ *   Enter  — set as active provider
+ *   ← / ESC — back
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Main provider manager menu — uses showQuickMenu for letter shortcuts + consistency
+ */
+async function showProviderManagerMenu() {
+  const { showQuickMenu } = require('./trui-quick-menu');
+  const {
+    getProviderDefinitions,
+    getProviderPreferences,
+    saveProviderPreferences,
+  } = require('./provider-registry');
+  const { IDEHealthTracker, HealthReporter } = require('vibecodingmachine-core');
+
+  const definitions = getProviderDefinitions();
+  const defMap = new Map(definitions.map(def => [def.id, def]));
+  const prefs = await getProviderPreferences();
+  let order = prefs.order.slice();
+  let enabled = { ...prefs.enabled };
+  let lastIndex = 0;
+
+  // Ensure all definitions are present in order
+  for (const def of definitions) {
+    if (!order.includes(def.id)) order.push(def.id);
+  }
+
+  // Load health metrics (best-effort — empty map if unavailable)
+  let allMetrics = new Map();
+  try {
+    const tracker = new IDEHealthTracker();
+    allMetrics = await tracker.getAllHealthMetrics();
+  } catch (_) {}
+
+  const printHeader = () => {
+    console.clear();
+    process.stdout.write(chalk.bold.cyan('🤖 Agents & Providers\n\n'));
+    process.stdout.write(chalk.gray('  Interface types: 🖥️  GUI Automation  ⚡  Direct Automation\n'));
+    process.stdout.write(chalk.gray('  Provider type:   ☁️  Cloud  🏠  Local\n\n'));
+  };
+
+  const buildItems = () => {
+    return order.map((id, idx) => {
+      const def = defMap.get(id);
+      if (!def) return null;
+      const isEnabled = enabled[id] !== false;
+      const statusEmoji = isEnabled ? '🟢' : '🔴';
+      const interfaceIcon = def.type === 'ide' ? '🖥️ ' : '⚡';
+      const providerTypeIcon =
+        def.type === 'direct' && def.category === 'llm' && def.id === 'ollama'
+          ? '🏠'
+          : '☁️ ';
+      const nameStr = isEnabled ? def.name : chalk.gray(def.name);
+
+      // Health stats
+      const metrics = allMetrics.get(id);
+      let healthStr = '';
+      if (metrics && metrics.totalInteractions > 0) {
+        const healthIcon = metrics.consecutiveFailures === 0 ? '✅' : '⚠️ ';
+        const counters = HealthReporter.formatInlineCounters(metrics);
+        healthStr = ' ' + healthIcon + (counters ? ' ' + chalk.gray(counters) : '');
+      }
+
+      return {
+        type: 'action',
+        name: `${statusEmoji}  ${interfaceIcon} ${providerTypeIcon}  ${nameStr} ${chalk.gray('(' + id + ')')}${healthStr}`,
+        value: `provider:${idx}`,
+      };
+    }).filter(Boolean);
+  };
+
+  const hintText = '[< move item down  > move item up  Space toggle  Enter select  ← back, NO SHIFT needed]';
+
+  printHeader();
+
+  while (true) {
+    const items = buildItems();
+
+    const extraKeys = (str, key, selectedIndex, { resolveWith }) => {
+      const keyName = key && key.name;
+
+      // Space: toggle enable/disable
+      if (str === ' ' || keyName === 'space') {
+        const item = items[selectedIndex];
+        if (item && item.value && item.value.startsWith('provider:')) {
+          resolveWith(`toggle:${selectedIndex}`);
+        }
+        return true;
+      }
+
+      // < or , = move item down (no shift needed);  > or . = move item up
+      const isDown = str === ',' || str === '<' || keyName === ',' || keyName === '<';
+      const isUp   = str === '.' || str === '>' || keyName === '.' || keyName === '>';
+      if (isDown || isUp) {
+        const item = items[selectedIndex];
+        if (item && item.value && item.value.startsWith('provider:')) {
+          resolveWith(`reorder:${isDown ? 'down' : 'up'}:${selectedIndex}`);
+        }
+        return true;
+      }
+
+      return false;
+    };
+
+    const result = await showQuickMenu(items, lastIndex, { extraKeys, hintText });
+    lastIndex = result.selectedIndex;
+    const value = result.value;
+
+    // Back (← / ESC)
+    if (value === '__cancel__') break;
+
+    // Refresh health metrics on each action so stats stay current
+    try {
+      const tracker = new IDEHealthTracker();
+      allMetrics = await tracker.getAllHealthMetrics();
+    } catch (_) {}
+
+    // Toggle enable/disable — save immediately
+    if (value.startsWith('toggle:')) {
+      const itemIdx = parseInt(value.split(':')[1], 10);
+      const item = items[itemIdx];
+      if (item && item.value && item.value.startsWith('provider:')) {
+        const provIdx = parseInt(item.value.split(':')[1], 10);
+        const id = order[provIdx];
+        if (id) {
+          enabled[id] = enabled[id] === false ? true : false;
+          await saveProviderPreferences(order, enabled);
+        }
+      }
+      printHeader();
+      continue;
+    }
+
+    // Reorder — save immediately
+    if (value.startsWith('reorder:')) {
+      const parts = value.split(':');
+      const direction = parts[1];
+      const itemIdx = parseInt(parts[2], 10);
+      const item = items[itemIdx];
+      if (item && item.value && item.value.startsWith('provider:')) {
+        const provIdx = parseInt(item.value.split(':')[1], 10);
+        const target = direction === 'down' ? provIdx + 1 : provIdx - 1;
+        if (target >= 0 && target < order.length) {
+          const temp = order[provIdx];
+          order[provIdx] = order[target];
+          order[target] = temp;
+          await saveProviderPreferences(order, enabled);
+          // Cursor follows the moved item
+          lastIndex = direction === 'down'
+            ? Math.min(lastIndex + 1, items.length - 1)
+            : Math.max(lastIndex - 1, 0);
+        }
+      }
+      printHeader();
+      continue;
+    }
+
+    // Select/activate provider
+    if (value.startsWith('provider:')) {
+      const provIdx = parseInt(value.split(':')[1], 10);
+      return order[provIdx];
+    }
+  }
+
+  return null;
+}
+
+module.exports = { showProviderManagerMenu };