vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/rui-trui-adapter.js

@@ -0,0 +1,311 @@
+/**
+ * RUI TRUI Adapter
+ * Adapts the TRUI interface to use the RUI pattern
+ */
+
+const { RUICommandRegistry, RUICommandResolver, ListAgentsCommand, ListRequirementsCommand, ListSettingsCommand } = require('vibecodingmachine-core');
+
+class RUITRUIAdapter {
+  constructor() {
+    this.resolver = null;
+  }
+
+  /**
+   * Initialize the adapter
+   */
+  initialize() {
+    // Create registry and register commands
+    const registry = new RUICommandRegistry();
+    const agentsCmd = new ListAgentsCommand();
+    const reqsCmd = new ListRequirementsCommand();
+    const settingsCmd = new ListSettingsCommand();
+
+    registry.register(agentsCmd);
+    registry.register(reqsCmd);
+    registry.register(settingsCmd);
+
+    // Store registry on the adapter — RUICommandResolver uses a module-level
+    // singleton registry internally, so this.resolver.registry is undefined.
+    this.registry = registry;
+    this.resolver = new RUICommandResolver(registry);
+  }
+
+  /**
+   * Build menu items based on RUI commands
+   * @returns {Promise<Array>} Array of menu items
+   */
+  async buildMenuItems() {
+    if (!this.resolver) {
+      this.initialize();
+    }
+
+    const items = [];
+
+    // Get all available verbs and resources
+    const verbs = ['GET', 'POST', 'PUT', 'DELETE'];
+    const resources = ['agents', 'requirements', 'settings'];
+
+    // Add status information (similar to existing implementation)
+    await this.addStatusItems(items);
+
+    // Add separator
+    items.push({ type: 'blank', name: '', value: 'blank' });
+
+    // Build RUI-based menu structure
+    for (const verb of verbs) {
+      const verbItem = {
+        type: 'category',
+        name: this.getVerbDisplayName(verb),
+        value: `category:${verb}`,
+        children: []
+      };
+
+      for (const resource of resources) {
+        const command = `${verb} ${resource}`;
+        const resolution = this.resolver.resolve(command);
+        
+        if (resolution.success) {
+          verbItem.children.push({
+            type: 'action',
+            name: this.getResourceDisplayName(resource),
+            value: command,
+            description: resolution.command.description,
+            shortcuts: resolution.command.shortcuts
+          });
+        }
+      }
+
+      if (verbItem.children.length > 0) {
+        items.push(verbItem);
+      }
+    }
+
+    // Add system commands
+    items.push({ type: 'blank', name: '', value: 'blank' });
+    items.push({ type: 'action', name: 'Help', value: 'help' });
+    items.push({ type: 'action', name: 'Exit', value: 'exit' });
+
+    return items;
+  }
+
+  /**
+   * Add status items to menu
+   * @param {Array} items - Menu items array to modify
+   */
+  async addStatusItems(items) {
+    // Auto Mode status
+    let autoStatus = { running: false };
+    try {
+      const { checkAutoModeStatus } = require('./auto-mode');
+      autoStatus = await checkAutoModeStatus();
+    } catch (_) {}
+
+    if (autoStatus.running) {
+      items.push({ 
+        type: 'setting', 
+        name: `Auto Mode: Running ✓`, 
+        value: 'setting:auto' 
+      });
+    } else {
+      items.push({ 
+        type: 'setting', 
+        name: `Auto Mode: Stopped ○`, 
+        value: 'setting:auto' 
+      });
+    }
+
+    // Requirements summary
+    try {
+      const { countRequirements, getSyncStatus, getAgentConnectivityStatus } = 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;
+        
+        const reqLine = `Requirements: ${counts.todoCount} (${pct(counts.todoCount)}% todo), ` +
+                      `${counts.toVerifyCount} (${pct(counts.toVerifyCount)}% verify), ` +
+                      `${counts.verifiedCount} (${pct(counts.verifiedCount)}% done)`;
+        
+        items.push({ type: 'setting', name: reqLine, value: 'setting:requirements' });
+      }
+    } catch (_) {}
+  }
+
+  /**
+   * Get display name for verb
+   * @param {string} verb - Verb name
+   * @returns {string} Display name
+   */
+  getVerbDisplayName(verb) {
+    const displayNames = {
+      'GET': 'Lists (GET)',
+      'POST': 'Create (POST)',
+      'PUT': 'Update (PUT)',
+      'DELETE': 'Delete (DELETE)'
+    };
+    return displayNames[verb] || verb;
+  }
+
+  /**
+   * Get display name for resource
+   * @param {string} resource - Resource name
+   * @returns {string} Display name
+   */
+  getResourceDisplayName(resource) {
+    const displayNames = {
+      'agents': 'Agents',
+      'requirements': 'Requirements (reqs)',
+      'settings': 'Settings'
+    };
+    return displayNames[resource] || resource;
+  }
+
+  /**
+   * Handle menu action using RUI pattern
+   * @param {string} action - Action value from menu
+   * @returns {Promise<Object>} Action result
+   */
+  async handleAction(action) {
+    if (!this.resolver) {
+      this.initialize();
+    }
+
+    // Handle special actions
+    if (action === 'help') {
+      return await this.showHelp();
+    }
+
+    if (action === 'exit') {
+      return { action: 'exit' };
+    }
+
+    if (action.startsWith('setting:')) {
+      return await this.handleSettingAction(action);
+    }
+
+    if (action.startsWith('category:')) {
+      return await this.handleCategoryAction(action);
+    }
+
+    // Handle RUI commands
+    const resolution = this.resolver.resolve(action);
+    
+    if (!resolution.success) {
+      return {
+        success: false,
+        error: resolution.error,
+        suggestions: resolution.suggestions
+      };
+    }
+
+    try {
+      const result = await resolution.command.execute();
+      return {
+        success: true,
+        data: result.data,
+        command: action,
+        executionTime: result.executionTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        command: action
+      };
+    }
+  }
+
+  /**
+   * Show help information
+   * @returns {Promise<Object>} Help result
+   */
+  async showHelp() {
+    const commands = (this.registry.getAll || this.registry.getAllCommands).call(this.registry);
+    const helpText = commands.map(cmd => {
+      const shortcuts = cmd.shortcuts.length > 0 ? ` (${cmd.shortcuts.join(', ')})` : '';
+      return `${cmd.verb} ${cmd.resource}${shortcuts} - ${cmd.description}`;
+    }).join('\n');
+
+    return {
+      success: true,
+      data: {
+        type: 'help',
+        content: helpText
+      }
+    };
+  }
+
+  /**
+   * Handle setting actions
+   * @param {string} action - Setting action
+   * @returns {Promise<Object>} Setting result
+   */
+  async handleSettingAction(action) {
+    switch (action) {
+      case 'setting:auto':
+        try {
+          const { checkAutoModeStatus, stopAutoMode } = require('./auto-mode');
+          const status = await checkAutoModeStatus();
+          if (status.running) {
+            await stopAutoMode('manual');
+            return {
+              success: true,
+              message: 'Auto mode stopped'
+            };
+          } else {
+            return {
+              success: true,
+              message: 'To start auto mode, use: app POST auto-mode'
+            };
+          }
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+
+      default:
+        return {
+          success: false,
+          error: `Unknown setting action: ${action}`
+        };
+    }
+  }
+
+  /**
+   * Handle category actions (show category details)
+   * @param {string} action - Category action
+   * @returns {Promise<Object>} Category result
+   */
+  async handleCategoryAction(action) {
+    const verb = action.replace('category:', '');
+    // getByVerb returns full command objects; extract resource names
+    const commands = this.registry.getByVerb ? this.registry.getByVerb(verb) : [];
+    const resources = commands.map(c => c.resource);
+    
+    return {
+      success: true,
+      data: {
+        type: 'category',
+        verb: verb,
+        resources: resources
+      }
+    };
+  }
+
+  /**
+   * Get equivalent command for display
+   * @param {string} action - Action value
+   * @returns {string} Equivalent command
+   */
+  getEquivalentCommand(action) {
+    if (action.startsWith('setting:') || action.startsWith('category:') || 
+        action === 'help' || action === 'exit') {
+      return action;
+    }
+    return action;
+  }
+}
+
+module.exports = RUITRUIAdapter;

package/src/utils/simple-trui.js

@@ -0,0 +1,204 @@
+/**
+ * Simple TRUI Interface
+ * Basic implementation for testing
+ */
+
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const boxen = require('boxen');
+
+class SimpleTRUI {
+  constructor() {
+    this.currentView = 'main';
+  }
+
+  async start() {
+    console.clear();
+    this.showWelcome();
+    await this.showMainMenu();
+  }
+
+  showWelcome() {
+    const welcome = boxen(
+      chalk.cyan.bold('🎯 Vibe Coding Machine - TRUI Interface\n\n') +
+      chalk.white('Text REST UI - Navigate with REST-based commands\n') +
+      chalk.gray('Type "help" for available commands or "quit" to exit\n'),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan'
+      }
+    );
+    console.log(welcome);
+  }
+
+  async showMainMenu() {
+    while (true) {
+      const { action } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'action',
+          message: chalk.cyan('📍 Navigate to:'),
+          choices: [
+            { name: '🤖 Agents', value: 'agents' },
+            { name: '📋 Requirements', value: 'requirements' },
+            { name: '⚙️  Settings', value: 'settings' },
+            { name: '❓ Help', value: 'help' },
+            { name: '🚪 Exit', value: 'quit' }
+          ],
+          pageSize: 10
+        }
+      ]);
+
+      if (action === 'quit') {
+        console.log(chalk.yellow('👋 Goodbye!'));
+        process.exit(0);
+      }
+
+      await this.handleAction(action);
+    }
+  }
+
+  async handleAction(action) {
+    switch (action) {
+      case 'agents':
+        await this.showAgentsMenu();
+        break;
+      case 'requirements':
+        await this.showRequirementsMenu();
+        break;
+      case 'settings':
+        await this.showSettingsMenu();
+        break;
+      case 'help':
+        this.showHelp();
+        break;
+    }
+  }
+
+  async showAgentsMenu() {
+    console.log(chalk.blue('\n🤖 Agents Management\n'));
+    
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Choose action:',
+        choices: [
+          { name: '📝 List Agents', value: 'list' },
+          { name: '⬅️  Back', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (action === 'list') {
+      this.showAgentsList();
+    }
+  }
+
+  async showRequirementsMenu() {
+    console.log(chalk.blue('\n📋 Requirements Management\n'));
+    
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Choose action:',
+        choices: [
+          { name: '📝 List Requirements', value: 'list' },
+          { name: '⬅️  Back', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (action === 'list') {
+      this.showRequirementsList();
+    }
+  }
+
+  async showSettingsMenu() {
+    console.log(chalk.blue('\n⚙️  Settings Management\n'));
+    
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'Choose action:',
+        choices: [
+          { name: '📝 List Settings', value: 'list' },
+          { name: '⬅️  Back', value: 'back' }
+        ]
+      }
+    ]);
+
+    if (action === 'list') {
+      this.showSettingsList();
+    }
+  }
+
+  showAgentsList() {
+    const agents = [
+      { id: 'cursor-cli', name: 'Cursor CLI Agent', status: 'enabled' },
+      { id: 'claude-code', name: 'Claude Code Agent', status: 'disabled' },
+      { id: 'vscode', name: 'VS Code Agent', status: 'enabled' }
+    ];
+
+    console.log(chalk.green('\n📋 Available Agents:\n'));
+    agents.forEach(agent => {
+      const status = agent.status === 'enabled' ? chalk.green('✓') : chalk.red('✗');
+      console.log(`  ${status} ${agent.name} (${agent.id})`);
+    });
+    console.log('');
+  }
+
+  showRequirementsList() {
+    const requirements = [
+      { id: 'REQ-001', title: 'Implement RUI Pattern', status: 'in-progress' },
+      { id: 'REQ-002', title: 'Fix Test Suite', status: 'pending' },
+      { id: 'REQ-003', title: 'Update Documentation', status: 'completed' }
+    ];
+
+    console.log(chalk.green('\n📋 Requirements:\n'));
+    requirements.forEach(req => {
+      const status = req.status === 'completed' ? chalk.green('✓') : 
+                   req.status === 'in-progress' ? chalk.yellow('⟳') : chalk.gray('○');
+      console.log(`  ${status} ${req.id}: ${req.title}`);
+    });
+    console.log('');
+  }
+
+  showSettingsList() {
+    const settings = [
+      { key: 'auto-start', value: 'enabled', description: 'Auto-start mode' },
+      { key: 'timeout', value: '30000', description: 'Command timeout (ms)' },
+      { key: 'debug', value: 'false', description: 'Debug mode' }
+    ];
+
+    console.log(chalk.green('\n⚙️  Current Settings:\n'));
+    settings.forEach(setting => {
+      console.log(`  ${setting.key}: ${setting.value} (${setting.description})`);
+    });
+    console.log('');
+  }
+
+  showHelp() {
+    const help = [
+      { command: 'list agents', description: 'List all available agents' },
+      { command: 'list requirements', description: 'List all requirements' },
+      { command: 'list settings', description: 'Show current settings' },
+      { command: 'help', description: 'Show this help message' },
+      { command: 'quit', description: 'Exit the application' }
+    ];
+
+    console.log(chalk.blue('\n❓ Available Commands:\n'));
+    help.forEach(cmd => {
+      console.log(`  ${chalk.cyan(cmd.command)} - ${cmd.description}`);
+    });
+    console.log('');
+    console.log(chalk.gray('💡 This is a simplified TRUI interface for testing purposes.'));
+    console.log('');
+  }
+}
+
+module.exports = { SimpleTRUI };

package/src/utils/status-helpers-extracted.js

@@ -0,0 +1,125 @@
+const fs = require('fs-extra');
+const { getRepoPath, getRequirementsPath } = require('vibecodingmachine-core');
+
+async function countRequirements() {
+  try {
+    const { getProjectRequirementStats } = require('vibecodingmachine-core');
+    const repoPath = await getRepoPath();
+    return await getProjectRequirementStats(repoPath);
+  } catch (error) {
+    return null;
+  }
+}
+
+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]';
+  }
+}
+
+async function getCurrentProgress() {
+  try {
+    const { getRequirementsPath } = require('vibecodingmachine-core');
+    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;
+  }
+}
+
+/**
+ * Get agent connectivity status for display
+ * @returns {string} - Formatted agent connectivity status
+ */
+async function getAgentConnectivityStatus() {
+  try {
+    const { checkAllProviders } = require('./provider-checker');
+    const result = await checkAllProviders();
+    
+    if (!result || !result.results) {
+      return '[Agents unavailable]';
+    }
+    
+    const total = Object.keys(result.results).length;
+    const reachable = Object.values(result.results).filter(r => r.status === 'success').length;
+    
+    if (reachable === total) {
+      return `[Agents: ✓ ${reachable}/${total}]`;
+    } else if (reachable > 0) {
+      return `[Agents: ⚠️ ${reachable}/${total}]`;
+    } else {
+      return `[Agents: ✗ 0/${total}]`;
+    }
+  } catch (error) {
+    return '[Agents unavailable]';
+  }
+}
+
+module.exports = {
+  countRequirements,
+  getSyncStatus,
+  getCurrentProgress,
+  getAgentConnectivityStatus
+};