vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/status-helpers.js

@@ -0,0 +1,107 @@
+const fs = require('fs-extra');
+const { getRepoPath, getRequirementsPath } = require('./config');
+
+/**
+ * Count project requirements statistics
+ * @returns {object|null} - Requirements stats or null if error
+ */
+async function countRequirements() {
+  try {
+    const { getProjectRequirementStats } = require('vibecodingmachine-core');
+    const repoPath = await getRepoPath() || process.cwd();
+    return await getProjectRequirementStats(repoPath);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get sync status for display
+ * @returns {string} - Formatted sync status
+ */
+async function getSyncStatus() {
+  try {
+    const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
+    const syncEngine = new SyncEngine();
+    await syncEngine.initialize();
+    const status = syncEngine.getStatus();
+    syncEngine.stop();
+
+    if (!status.isOnline && status.queuedChanges > 0) {
+      return `[Offline: ${status.queuedChanges} queued]`;
+    } else if (!status.isOnline) {
+      return '[Offline]';
+    } else if (status.isSyncing) {
+      return '[Syncing...]';
+    } else if (status.lastSyncTime) {
+      const timeSinceSync = Date.now() - status.lastSyncTime;
+      const minutesAgo = Math.floor(timeSinceSync / (1000 * 60));
+      if (minutesAgo < 1) {
+        return '[Sync: ✓ just now]';
+      } else if (minutesAgo < 60) {
+        return `[Sync: ✓ ${minutesAgo}m ago]`;
+      } else {
+        const hoursAgo = Math.floor(minutesAgo / 60);
+        return `[Sync: ✓ ${hoursAgo}h ago]`;
+      }
+    } else {
+      return '[Never synced]';
+    }
+  } catch (error) {
+    return '[Sync unavailable]';
+  }
+}
+
+/**
+ * Get current progress from requirements file
+ * @returns {object|null} - Current progress info or null if not found
+ */
+async function getCurrentProgress() {
+  try {
+    const reqPath = await getRequirementsPath();
+
+    if (!reqPath || !await fs.pathExists(reqPath)) {
+      return null;
+    }
+
+    const content = await fs.readFile(reqPath, 'utf8');
+    const lines = content.split('\n');
+
+    let requirement = null;
+    let inTodoSection = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Find TODO section
+      if (line.includes('## ⏳ Requirements not yet completed') || line.includes('## Requirements not yet completed')) {
+        inTodoSection = true;
+        continue;
+      }
+
+      // Exit TODO section when we hit another section
+      if (inTodoSection && line.trim().startsWith('##')) {
+        break;
+      }
+
+      // Find first TODO requirement
+      if (inTodoSection) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+          requirement = trimmed.substring(2); // Remove "- " or "* " prefix
+          break;
+        }
+      }
+    }
+
+    return requirement ? { status: 'PREPARE', requirement } : null;
+  } catch (error) {
+    return null;
+  }
+}
+
+module.exports = {
+  countRequirements,
+  getSyncStatus,
+  getCurrentProgress
+};

package/src/utils/trui-debug.js

@@ -0,0 +1,261 @@
+/**
+ * TRUI Debug and State Tracking System
+ *
+ * Provides comprehensive debugging, state tracking, and performance monitoring
+ * for all TRUI menu operations. Used throughout the TRUI system.
+ */
+
+const fs = require('fs');
+const chalk = require('chalk');
+
+/**
+ * Debug logging utility with file and console output
+ */
+class DebugLogger {
+  constructor() {
+    this.enabled = process.env.VCM_DEBUG_MENU === '1';
+    this.logFile = '/tmp/vcm-menu-debug.log';
+  }
+
+  log(message, data = null, level = 'INFO') {
+    if (!this.enabled) return;
+
+    const timestamp = new Date().toISOString();
+    const caller = this.getCaller();
+    const dataStr = data ? ' ' + JSON.stringify(data) : '';
+    const logEntry = `[${level}-MENU ${timestamp}] [${caller}] ${message}${dataStr}\n`;
+
+    // Console output with colors
+    const colorFn = level === 'ERROR' ? chalk.red :
+                   level === 'WARN' ? chalk.yellow :
+                   level === 'PERF' ? chalk.magenta : chalk.gray;
+    console.log(colorFn(logEntry));
+
+    // File output (no colors)
+    try {
+      fs.appendFileSync(this.logFile, logEntry.replace(/\x1b\[[0-9;]*m/g, ''));
+    } catch (e) {
+      // Ignore file write errors
+    }
+  }
+
+  getCaller() {
+    const stack = new Error().stack.split('\n');
+    // Find first TRUI-related caller
+    for (let i = 3; i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes('trui-') || line.includes('showQuickMenu')) {
+        const match = line.match(/at.*\(.*\/(.*?):(\d+):/);
+        return match ? `${match[1]}:${match[2]}` : 'unknown';
+      }
+    }
+    return 'unknown';
+  }
+
+  error(message, data) { this.log(message, data, 'ERROR'); }
+  warn(message, data) { this.log(message, data, 'WARN'); }
+  perf(message, data) { this.log(message, data, 'PERF'); }
+  info(message, data) { this.log(message, data, 'INFO'); }
+}
+
+/**
+ * Performance monitoring for menu operations
+ */
+class PerformanceMonitor {
+  constructor() {
+    this.operations = new Map();
+    this.stack = [];
+  }
+
+  start(operation, context = {}) {
+    const startTime = process.hrtime.bigint();
+    this.stack.push({ operation, startTime, context });
+    debugLogger.perf(`Starting ${operation}`, context);
+  }
+
+  end(operation, result = null) {
+    const endTime = process.hrtime.bigint();
+    const lastOp = this.stack.pop();
+
+    if (!lastOp || lastOp.operation !== operation) {
+      debugLogger.warn(`Performance mismatch: expected ${operation}, got ${lastOp ? lastOp.operation : 'none'}`);
+      return 0;
+    }
+
+    const duration = Number(endTime - lastOp.startTime) / 1000000; // Convert to milliseconds
+    this.operations.set(operation, {
+      duration,
+      timestamp: Date.now(),
+      context: lastOp.context,
+      result
+    });
+
+    debugLogger.perf(`Completed ${operation}`, {
+      duration: `${duration.toFixed(2)}ms`,
+      context: lastOp.context
+    });
+
+    return duration;
+  }
+
+  getMetrics() {
+    const metrics = {};
+    for (const [op, data] of this.operations) {
+      metrics[op] = {
+        duration: data.duration,
+        timestamp: data.timestamp,
+        context: data.context
+      };
+    }
+    return metrics;
+  }
+
+  getAverage(operation) {
+    const ops = Array.from(this.operations.entries())
+      .filter(([op]) => op === operation)
+      .map(([, data]) => data.duration);
+
+    if (ops.length === 0) return 0;
+    return ops.reduce((sum, dur) => sum + dur, 0) / ops.length;
+  }
+
+  reset() {
+    this.operations.clear();
+    this.stack = [];
+  }
+}
+
+/**
+ * Menu state tracking for debugging and recovery
+ */
+class MenuStateTracker {
+  constructor() {
+    this.states = [];
+    this.currentState = null;
+  }
+
+  push(state) {
+    this.currentState = {
+      ...state,
+      timestamp: Date.now(),
+      id: this.states.length
+    };
+    this.states.push(this.currentState);
+    debugLogger.info('Menu state pushed', this.currentState);
+  }
+
+  pop() {
+    if (this.states.length > 0) {
+      const state = this.states.pop();
+      debugLogger.info('Menu state popped', state);
+      this.currentState = this.states.length > 0 ? this.states[this.states.length - 1] : null;
+      return state;
+    }
+    return null;
+  }
+
+  update(updates) {
+    if (this.currentState) {
+      Object.assign(this.currentState, updates);
+      debugLogger.info('Menu state updated', { updates, currentState: this.currentState });
+    }
+  }
+
+  getCurrent() {
+    return this.currentState;
+  }
+
+  getHistory() {
+    return this.states.slice();
+  }
+
+  reset() {
+    this.states = [];
+    this.currentState = null;
+    debugLogger.info('Menu state tracker reset');
+  }
+}
+
+/**
+ * Error handling and recovery system
+ */
+class ErrorHandler {
+  constructor() {
+    this.errors = [];
+    this.recoveryStrategies = new Map();
+  }
+
+  registerStrategy(errorType, strategy) {
+    this.recoveryStrategies.set(errorType, strategy);
+    debugLogger.info(`Recovery strategy registered for ${errorType}`);
+  }
+
+  handle(error, context = {}) {
+    const errorInfo = {
+      message: error.message,
+      stack: error.stack,
+      timestamp: Date.now(),
+      context
+    };
+
+    this.errors.push(errorInfo);
+    debugLogger.error('Error handled', errorInfo);
+
+    // Try recovery strategy
+    const strategy = this.recoveryStrategies.get(error.name);
+    if (strategy) {
+      debugLogger.info(`Attempting recovery for ${error.name}`);
+      try {
+        return strategy(error, context);
+      } catch (recoveryError) {
+        debugLogger.error('Recovery strategy failed', {
+          originalError: error.message,
+          recoveryError: recoveryError.message
+        });
+      }
+    }
+
+    // Default recovery: rethrow with context
+    error.context = context;
+    throw error;
+  }
+
+  getErrors() {
+    return this.errors.slice();
+  }
+
+  clearErrors() {
+    this.errors = [];
+    debugLogger.info('Error history cleared');
+  }
+}
+
+// Global instances
+const debugLogger = new DebugLogger();
+const perfMonitor = new PerformanceMonitor();
+const stateTracker = new MenuStateTracker();
+const errorHandler = new ErrorHandler();
+
+// Register default recovery strategies
+errorHandler.registerStrategy('TypeError', (error, context) => {
+  debugLogger.warn('TypeError recovery: checking for undefined/null values');
+  // Add recovery logic here
+  return null;
+});
+
+errorHandler.registerStrategy('RangeError', (error, context) => {
+  debugLogger.warn('RangeError recovery: checking array bounds');
+  // Add recovery logic here
+  return null;
+});
+
+module.exports = {
+  debugLogger,
+  perfMonitor,
+  stateTracker,
+  errorHandler,
+  DebugLogger,
+  PerformanceMonitor,
+  MenuStateTracker,
+  ErrorHandler
+};

package/src/utils/trui-feedback.js

@@ -0,0 +1,133 @@
+/**
+ * TRUI Feedback Submission System
+ *
+ * Handles F key feedback submission with category selection and multi-line text.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { debugLogger } = require('./trui-debug');
+
+/**
+ * Show feedback submission interface
+ */
+async function showFeedbackSubmission() {
+  debugLogger.info('Opening feedback submission');
+
+  console.clear();
+  console.log(chalk.cyan('\n💬 Feedback Submission\n'));
+  console.log(chalk.gray('Help us improve VCM by sharing your feedback.\n'));
+
+  try {
+    // Category selection
+    const { category } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'category',
+        message: 'What type of feedback would you like to share?',
+        choices: [
+          { name: '🐛 Bug Report', value: 'bug' },
+          { name: '💡 Feature Request', value: 'feature' },
+          { name: '📝 Documentation Issue', value: 'documentation' },
+          { name: '🎨 UI/UX Feedback', value: 'ui-ux' },
+          { name: '⚡ Performance Issue', value: 'performance' },
+          { name: '💭 General Feedback', value: 'general' }
+        ]
+      }
+    ]);
+
+    // Multi-line feedback text
+    const { feedback } = await inquirer.prompt([
+      {
+        type: 'editor',
+        name: 'feedback',
+        message: 'Please describe your feedback in detail:',
+        default: ''
+      }
+    ]);
+
+    if (!feedback || feedback.trim().length === 0) {
+      console.log(chalk.yellow('\n⚠ No feedback provided. Cancelled.'));
+      return;
+    }
+
+    // Email (optional)
+    const { email } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'email',
+        message: 'Email (optional, for follow-up questions):',
+        validate: (input) => {
+          if (!input) return true;
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          return emailRegex.test(input) || 'Please enter a valid email address';
+        }
+      }
+    ]);
+
+    // Confirmation
+    const { confirmed } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmed',
+        message: 'Submit this feedback?',
+        default: true
+      }
+    ]);
+
+    if (!confirmed) {
+      console.log(chalk.yellow('\n⚠ Feedback submission cancelled.'));
+      return;
+    }
+
+    // Submit feedback
+    await submitFeedback({ category, feedback, email });
+
+    console.log(chalk.green('\n✓ Thank you! Your feedback has been submitted.\n'));
+
+  } catch (error) {
+    debugLogger.error('Feedback submission error', { error: error.message });
+    console.log(chalk.red('\n❌ Error submitting feedback: ' + error.message));
+  }
+}
+
+/**
+ * Submit feedback to backend
+ */
+async function submitFeedback(feedbackData) {
+  debugLogger.info('Submitting feedback', { category: feedbackData.category });
+
+  try {
+    // Save feedback to local file for now
+    const fs = require('fs');
+    const path = require('path');
+    const feedbackDir = path.join(process.cwd(), '.vcm-feedback');
+
+    if (!fs.existsSync(feedbackDir)) {
+      fs.mkdirSync(feedbackDir, { recursive: true });
+    }
+
+    const feedbackFile = path.join(feedbackDir, `feedback-${Date.now()}.json`);
+    const feedbackWithMeta = {
+      ...feedbackData,
+      timestamp: new Date().toISOString(),
+      version: require('../../../package.json').version || 'unknown'
+    };
+
+    fs.writeFileSync(feedbackFile, JSON.stringify(feedbackWithMeta, null, 2));
+    debugLogger.info('Feedback saved locally', { file: feedbackFile });
+
+    // TODO: Send to backend API when available
+    // const response = await fetch('/api/feedback', {
+    //   method: 'POST',
+    //   headers: { 'Content-Type': 'application/json' },
+    //   body: JSON.stringify(feedbackWithMeta)
+    // });
+
+  } catch (error) {
+    debugLogger.error('Failed to submit feedback', { error: error.message });
+    throw error;
+  }
+}
+
+module.exports = { showFeedbackSubmission, submitFeedback };

package/src/utils/trui-nav-agents.js

@@ -0,0 +1,119 @@
+/**
+ * TRUI Agents Section
+ * Exposes loadAgentsData / buildAgentChoices / handleAgentSelection
+ * for inline accordion display in the main navigation menu.
+ */
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+/**
+ * Load agents data via the RUI command resolver + provider preferences
+ * @param {Object} navigation - TRUINavigation instance
+ * @returns {Promise<{agents: Array, enabledMap: Object, prefs: Object}|null>}
+ */
+async function loadAgentsData(navigation) {
+  try {
+    const result = navigation.resolver.resolve('list agents');
+    if (!result.success) return null;
+
+    const commandResult = await result.command.execute();
+    if (!commandResult.success || !commandResult.data) return null;
+
+    const { getProviderPreferences } = require('./provider-registry');
+    const prefs = await getProviderPreferences();
+    const enabledMap = { ...(prefs.enabled || {}) };
+
+    return {
+      agents: commandResult.data.agents || [],
+      enabledMap,
+      prefs,
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Build inline accordion choice objects for the agents section
+ * @param {{agents: Array, enabledMap: Object}} data
+ * @returns {Array} inquirer choice objects
+ */
+function buildAgentChoices(data) {
+  if (!data || !data.agents || !data.agents.length) {
+    return [
+      { name: chalk.gray('  (no agents found)'), value: 'noop' },
+    ];
+  }
+
+  return data.agents.map((agent, index) => {
+    const isEnabled = data.enabledMap[agent.id] !== false;
+    const icon = isEnabled ? '🟢' : '🔴';
+    const label = agent.name || agent.type || agent.id || 'Unknown';
+    return {
+      name: `  ${icon} ${chalk.white(label)}`,
+      value: `agent:${index}`,
+    };
+  });
+}
+
+/**
+ * Handle selection of an agent item — shows an enable/disable sub-prompt
+ * @param {number} index - Index into data.agents
+ * @param {{agents: Array, enabledMap: Object, prefs: Object}} data
+ * @param {Object} navigation - TRUINavigation instance
+ * @returns {Promise<boolean>} true if prefs were changed (caller should reload)
+ */
+async function handleAgentSelection(index, data, navigation) {
+  if (!data || !data.agents || !data.agents[index]) return false;
+
+  const agent = data.agents[index];
+  const isEnabled = data.enabledMap[agent.id] !== false;
+  const label = agent.name || agent.type || agent.id || 'Unknown';
+  const statusText = isEnabled ? chalk.green('ENABLED') : chalk.red('DISABLED');
+
+  if (agent.description) {
+    console.log(chalk.gray(`\n  ${label}: ${agent.description}`));
+  }
+
+  const { agentAction } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'agentAction',
+      message: `${label} [${statusText}]`,
+      choices: [
+        {
+          name: isEnabled ? chalk.red('Disable') : chalk.green('Enable'),
+          value: 'toggle',
+        },
+        { name: chalk.gray('Cancel'), value: 'cancel' },
+      ],
+    },
+  ]);
+
+  if (agentAction !== 'toggle') return false;
+
+  try {
+    const { getProviderPreferences, saveProviderPreferences } = require('./provider-registry');
+    const prefs = await getProviderPreferences();
+    prefs.enabled = prefs.enabled || {};
+    prefs.enabled[agent.id] = !isEnabled;
+    await saveProviderPreferences(prefs);
+
+    const verb = !isEnabled ? 'enable' : 'disable';
+    console.log(chalk.green(`\n✓ ${label} ${verb}d`));
+    console.log(chalk.gray(`  Equivalent: app agents ${label} ${verb}`));
+    await navigation.promptContinue();
+    return true;
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+    await navigation.promptContinue();
+    return false;
+  }
+}
+
+module.exports = {
+  loadAgentsData,
+  buildAgentChoices,
+  handleAgentSelection,
+};