vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/trui/TruiInterface.js

@@ -0,0 +1,108 @@
+/**
+ * TRUI Interface Integration
+ * 
+ * Integrates TRUI agent interface with main CLI.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentInterface = require('./agents/AgentInterface');
+const { AgentConfigManager } = require('../../../../core/src/agents/config/AgentConfigManager');
+const AgentLogger = require('../../../../core/src/agents/logging/AgentLogger');
+const FileManager = require('../../../../core/src/agents/storage/FileManager');
+
+/**
+ * TRUI Interface Integration class
+ */
+class TruiInterface {
+  /**
+   * Create TRUI interface instance
+   * @param {Object} options - Interface options
+   */
+  constructor(options = {}) {
+    this.configManager = options.configManager || new AgentConfigManager();
+    this.logger = options.logger || new AgentLogger({
+      fileManager: new FileManager()
+    });
+    this.fileManager = options.fileManager || new FileManager();
+    
+    // Initialize agent interface
+    this.agentInterface = new AgentInterface({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager,
+      ...options
+    });
+  }
+
+  /**
+   * Start TRUI interface
+   * @returns {Promise<void>}
+   */
+  async start() {
+    try {
+      await this.agentInterface.start();
+    } catch (error) {
+      console.error(`Failed to start TRUI interface: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Stop TRUI interface
+   */
+  stop() {
+    this.agentInterface.stop();
+  }
+
+  /**
+   * Execute command in TRUI context
+   * @param {string} command - Command to execute
+   * @returns {Promise<Object>} - Command result
+   */
+  async executeCommand(command) {
+    try {
+      await this.agentInterface.executeCommand(command);
+      return {
+        success: true,
+        interface: 'trui',
+        command,
+        message: 'Command executed in TRUI'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        interface: 'trui',
+        command,
+        error: error.message,
+        message: `TRUI command failed: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * Get interface information
+   * @returns {Object} - Interface info
+   */
+  getInfo() {
+    return {
+      name: 'TRUI Interface Integration',
+      version: '1.0.0',
+      interface: 'trui',
+      features: [
+        'interactive command line',
+        'RUI pattern support',
+        'command history',
+        'context awareness',
+        'navigation hints',
+        'auto-completion',
+        'error handling',
+        'integration with CLI'
+      ],
+      components: {
+        'AgentInterface': this.agentInterface.getInfo()
+      }
+    };
+  }
+}
+
+module.exports = TruiInterface;

package/src/trui/agents/AgentInterface.js

@@ -0,0 +1,580 @@
+/**
+ * TRUI Agents Interface
+ * 
+ * Text-based REST UI interface for agent management.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const readline = require('readline');
+const AgentCommands = require('../../../../core/src/rui/commands/AgentCommands');
+const AgentResponseFormatter = require('../../../../core/src/rui/commands/AgentResponseFormatter');
+const AgentConfigManager = require('../../../../core/src/agents/config/AgentConfigManager');
+const AgentLogger = require('../../../../core/src/agents/logging/AgentLogger');
+const FileManager = require('../../../../core/src/agents/storage/FileManager');
+
+/**
+ * TRUI Agent Interface class
+ */
+class AgentInterface {
+  /**
+   * Create TRUI agent interface instance
+   * @param {Object} options - Interface options
+   */
+  constructor(options = {}) {
+    this.configManager = options.configManager || new AgentConfigManager();
+    this.logger = options.logger || new AgentLogger({
+      fileManager: new FileManager()
+    });
+    this.fileManager = options.fileManager || new FileManager();
+    
+    // Initialize RUI components
+    this.agentCommands = new AgentCommands({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager
+    });
+
+    this.responseFormatter = new AgentResponseFormatter({
+      defaultFormat: 'table',
+      includeTimestamp: true,
+      prettyPrint: false
+    });
+
+    // Interface state
+    this.context = 'agents';
+    this.currentAgent = null;
+    this.navigationHistory = [];
+    this.maxHistorySize = 50;
+
+    // Readline interface
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: this.getPrompt()
+    });
+
+    this.setupEventHandlers();
+  }
+
+  /**
+   * Start the TRUI interface
+   * @returns {Promise<void>}
+   */
+  async start() {
+    try {
+      await this.configManager.load();
+      
+      console.log('=== Vibe Coding Machine - Agent Management ===');
+      console.log('Type "help" for available commands or "exit" to quit');
+      console.log('');
+
+      // Show initial agent list
+      await this.executeCommand('list agents');
+
+      // Start command loop
+      this.rl.prompt();
+    } catch (error) {
+      console.error(`Failed to start TRUI interface: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Stop the TRUI interface
+   */
+  stop() {
+    if (this.rl) {
+      this.rl.close();
+    }
+  }
+
+  /**
+   * Setup event handlers for readline interface
+   */
+  setupEventHandlers() {
+    this.rl.on('line', async (input) => {
+      await this.handleInput(input);
+    });
+
+    this.rl.on('close', () => {
+      console.log('\nGoodbye!');
+      process.exit(0);
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      console.log('\nUse "exit" to quit');
+      this.rl.prompt();
+    });
+  }
+
+  /**
+   * Handle user input
+   * @param {string} input - User input
+   * @returns {Promise<void>}
+   */
+  async handleInput(input) {
+    const trimmedInput = input.trim();
+    
+    if (!trimmedInput) {
+      this.rl.prompt();
+      return;
+    }
+
+    // Add to history
+    this.addToHistory(trimmedInput);
+
+    // Handle special commands
+    if (trimmedInput.toLowerCase() === 'exit' || trimmedInput.toLowerCase() === 'quit') {
+      this.stop();
+      return;
+    }
+
+    if (trimmedInput.toLowerCase() === 'help') {
+      this.showHelp();
+      this.rl.prompt();
+      return;
+    }
+
+    if (trimmedInput.toLowerCase() === 'clear') {
+      console.clear();
+      this.rl.prompt();
+      return;
+    }
+
+    if (trimmedInput.toLowerCase() === 'history') {
+      this.showHistory();
+      this.rl.prompt();
+      return;
+    }
+
+    // Execute agent command
+    await this.executeCommand(trimmedInput);
+    this.rl.prompt();
+  }
+
+  /**
+   * Execute command using RUI pattern
+   * @param {string} commandString - Command string
+   * @returns {Promise<void>}
+   */
+  async executeCommand(commandString) {
+    try {
+      // Parse command
+      const parsed = this.parseCommand(commandString);
+      
+      if (!parsed.success) {
+        console.error(`Error: ${parsed.error}`);
+        return;
+      }
+
+      // Update context
+      this.updateContext(parsed);
+
+      // Execute command
+      const result = await this.agentCommands.executeCommand(
+        parsed.verb,
+        parsed.resource,
+        parsed.params
+      );
+
+      // Format and display result
+      await this.displayResult(result, parsed);
+
+    } catch (error) {
+      console.error(`Command execution failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Parse command string
+   * @param {string} commandString - Command string
+   * @returns {Object} - Parsed command
+   */
+  parseCommand(commandString) {
+    const tokens = commandString.trim().split(/\s+/);
+    
+    if (tokens.length === 0) {
+      return { success: false, error: 'Empty command' };
+    }
+
+    // Simple command parsing for TRUI
+    const verb = tokens[0].toUpperCase();
+    const resource = tokens[1] || '';
+    const params = {};
+
+    // Parse parameters
+    for (let i = 2; i < tokens.length; i++) {
+      const token = tokens[i];
+      
+      if (token.startsWith('--')) {
+        const param = token.substring(2);
+        if (param.includes('=')) {
+          const [key, value] = param.split('=', 2);
+          params[key] = value;
+        } else {
+          params[param] = true;
+        }
+      } else if (token.startsWith('-')) {
+        const flag = token.substring(1);
+        params[flag] = true;
+      }
+    }
+
+    return {
+      success: true,
+      verb,
+      resource,
+      params
+    };
+  }
+
+  /**
+   * Update interface context
+   * @param {Object} parsedCommand - Parsed command
+   */
+  updateContext(parsedCommand) {
+    this.navigationHistory.push({
+      command: `${parsedCommand.verb} ${parsedCommand.resource}`,
+      timestamp: new Date().toISOString()
+    });
+
+    // Keep history size limited
+    if (this.navigationHistory.length > this.maxHistorySize) {
+      this.navigationHistory.shift();
+    }
+
+    // Update current context
+    if (parsedCommand.resource === 'agents' || parsedCommand.resource === 'agent') {
+      this.context = 'agents';
+    } else if (parsedCommand.resource && parsedCommand.resource !== 'agents') {
+      this.context = 'agent-details';
+      this.currentAgent = parsedCommand.resource;
+    } else {
+      this.context = 'unknown';
+    }
+
+    // Update prompt
+    this.rl.setPrompt(this.getPrompt());
+  }
+
+  /**
+   * Get prompt based on current context
+   * @returns {string} - Prompt string
+   */
+  getPrompt() {
+    switch (this.context) {
+      case 'agents':
+        return 'agents> ';
+      case 'agent-details':
+        return `agents/${this.currentAgent}> `;
+      default:
+        return 'vibe> ';
+    }
+  }
+
+  /**
+   * Display command result
+   * @param {Object} result - Command result
+   * @param {Object} parsedCommand - Parsed command
+   * @returns {Promise<void>}
+   */
+  async displayResult(result, parsedCommand) {
+    const formattedResponse = this.responseFormatter.format(result, 'trui', {
+      verbose: parsedCommand.params.verbose
+    });
+
+    if (formattedResponse.success) {
+      await this.displaySuccessResult(formattedResponse, parsedCommand);
+    } else {
+      await this.displayErrorResult(formattedResponse, parsedCommand);
+    }
+  }
+
+  /**
+   * Display successful result
+   * @param {Object} response - Formatted response
+   * @param {Object} parsedCommand - Parsed command
+   * @returns {Promise<void>}
+   */
+  async displaySuccessResult(response, parsedCommand) {
+    if (response.data && response.data.agents) {
+      await this.displayAgentList(response.data);
+    } else if (response.data && response.data.id) {
+      await this.displayAgentDetails(response.data);
+    } else if (response.data && response.data.summary) {
+      await this.displayOperationSummary(response.data);
+    } else {
+      console.log('Command completed successfully');
+    }
+
+    // Show navigation hints
+    if (response.navigation) {
+      this.showNavigationHints(response.navigation);
+    }
+  }
+
+  /**
+   * Display error result
+   * @param {Object} response - Formatted response
+   * @param {Object} parsedCommand - Parsed command
+   * @returns {Promise<void>}
+   */
+  async displayErrorResult(response, parsedCommand) {
+    console.error(`Error: ${response.error}`);
+    
+    if (response.navigation && response.navigation.suggestions) {
+      console.log('\nSuggestions:');
+      response.navigation.suggestions.forEach(suggestion => {
+        console.log(`  ${suggestion}`);
+      });
+    }
+  }
+
+  /**
+   * Display agent list
+   * @param {Object} data - Agent data
+   * @returns {Promise<void>}
+   */
+  async displayAgentList(data) {
+    console.log('\n=== AGENTS ===');
+    
+    if (!data.agents || data.agents.length === 0) {
+      console.log('No agents found.');
+      return;
+    }
+
+    // Display agents with navigation hints
+    data.agents.forEach((agent, agentIndex) => {
+      const status = agent.status || 'UNKNOWN';
+      const statusIcon = this.getStatusIcon(status);
+      const displayIndex = (agentIndex + 1).toString().padStart(2);
+      
+      console.log(`${displayIndex}. ${statusIcon} ${agent.id.padEnd(15)} - ${agent.name}`);
+      
+      if (agent.statusDescription) {
+        console.log(`     Status: ${agent.statusDescription}`);
+      }
+    });
+
+    console.log(`\nTotal: ${data.agents.length} agents`);
+    this.showAgentListActions();
+  }
+
+  /**
+   * Display agent details
+   * @param {Object} data - Agent data
+   * @returns {Promise<void>}
+   */
+  async displayAgentDetails(data) {
+    console.log(`\n=== AGENT: ${data.id.toUpperCase()} ===`);
+    console.log(`Name: ${data.name}`);
+    console.log(`Description: ${data.description || 'No description'}`);
+    console.log(`Enabled: ${data.enabled ? 'Yes' : 'No'}`);
+    console.log(`Status: ${data.status || 'UNKNOWN'}`);
+    
+    if (data.statusDescription) {
+      console.log(`Status Description: ${data.statusDescription}`);
+    }
+    
+    if (data.lastChecked) {
+      console.log(`Last Checked: ${new Date(data.lastChecked).toLocaleString()}`);
+    }
+    
+    if (data.lastVerified) {
+      console.log(`Last Verified: ${new Date(data.lastVerified).toLocaleString()}`);
+    }
+
+    // Show sections if available
+    if (data.sections) {
+      data.sections.forEach(section => {
+        console.log(`\n--- ${section.title.toUpperCase()} ---`);
+        section.fields.forEach(field => {
+          const value = data[field];
+          if (value !== undefined && value !== null) {
+            console.log(`${field}: ${JSON.stringify(value, null, 2)}`);
+          }
+        });
+      });
+    }
+
+    this.showAgentDetailActions(data);
+  }
+
+  /**
+   * Display operation summary
+   * @param {Object} data - Summary data
+   * @returns {Promise<void>}
+   */
+  async displayOperationSummary(data) {
+    console.log('\n=== OPERATION SUMMARY ===');
+    console.log(`Success: ${data.allSuccessful ? 'Yes' : 'No'}`);
+    console.log(`Total: ${data.total || 0}`);
+    console.log(`Successful: ${data.successful || 0}`);
+    console.log(`Failed: ${data.failed || 0}`);
+    console.log(`Skipped: ${data.skipped || 0}`);
+    
+    if (data.duration) {
+      console.log(`Duration: ${(data.duration / 1000).toFixed(2)}s`);
+    }
+
+    // Show breakdown if available
+    if (data.breakdown) {
+      console.log('\n--- BREAKDOWN ---');
+      Object.entries(data.breakdown).forEach(([key, value]) => {
+        console.log(`${key}: ${JSON.stringify(value, null, 2)}`);
+      });
+    }
+  }
+
+  /**
+   * Show agent list actions
+   */
+  showAgentListActions() {
+    console.log('\nAvailable actions:');
+    console.log('  <index> - View agent details (e.g., "1")');
+    console.log('  get <agent-id> - Get specific agent');
+    console.log('  check <agent-id> - Check specific agent');
+    console.log('  check agents - Check all agents');
+    console.log('  help - Show this help');
+    console.log('  exit - Exit interface');
+  }
+
+  /**
+   * Show agent detail actions
+   * @param {Object} agent - Agent data
+   */
+  showAgentDetailActions(agent) {
+    console.log('\nAvailable actions:');
+    console.log(`  enable ${agent.id} - Enable agent`);
+    console.log(`  disable ${agent.id} - Disable agent`);
+    console.log(`  check ${agent.id} - Check agent`);
+    console.log(`  remove ${agent.id} - Remove agent`);
+    console.log(`  logs ${agent.id} - View agent logs`);
+    console.log('  back - Return to agent list');
+    console.log('  help - Show this help');
+    console.log('  exit - Exit interface');
+  }
+
+  /**
+   * Show navigation hints
+   * @param {Object} navigation - Navigation data
+   */
+  showNavigationHints(navigation) {
+    if (navigation.context) {
+      console.log(`\nContext: ${navigation.context}`);
+    }
+    
+    if (navigation.availableActions && navigation.availableActions.length > 0) {
+      console.log('Available commands:', navigation.availableActions.join(', '));
+    }
+    
+    if (navigation.shortcuts && navigation.shortcuts.length > 0) {
+      console.log('Shortcuts:', navigation.shortcuts.join(', '));
+    }
+  }
+
+  /**
+   * Show help information
+   */
+  showHelp() {
+    console.log('\n=== HELP ===');
+    console.log('Available commands:');
+    console.log('  list agents - List all agents');
+    console.log('  get <agent-id> - Get agent details');
+    console.log('  check agents - Check all agents');
+    console.log('  check <agent-id> - Check specific agent');
+    console.log('  enable <agent-id> - Enable agent');
+    console.log('  disable <agent-id> - Disable agent');
+    console.log('  remove <agent-id> - Remove agent');
+    console.log('  logs <agent-id> - View agent logs');
+    console.log('');
+    console.log('Options:');
+    console.log('  --includeDisabled - Include disabled agents in list');
+    console.log('  --format <format> - Output format (table, json, csv)');
+    console.log('  --verbose - Show detailed output');
+    console.log('  --force - Force reinstall');
+    console.log('  --skip-verification - Skip verification step');
+    console.log('');
+    console.log('Navigation:');
+    console.log('  <number> - Quick select agent from list');
+    console.log('  back - Return to agent list');
+    console.log('  history - Show command history');
+    console.log('  clear - Clear screen');
+    console.log('  help - Show this help');
+    console.log('  exit - Exit interface');
+  }
+
+  /**
+   * Show command history
+   */
+  showHistory() {
+    console.log('\n=== COMMAND HISTORY ===');
+    this.navigationHistory.forEach((entry, index) => {
+      const timestamp = new Date(entry.timestamp).toLocaleString();
+      console.log(`${(index + 1).toString().padStart(2)}. ${entry.command} (${timestamp})`);
+    });
+  }
+
+  /**
+   * Add command to history
+   * @param {string} command - Command to add
+   */
+  addToHistory(command) {
+    // Avoid duplicates
+    const lastCommand = this.navigationHistory[this.navigationHistory.length - 1];
+    if (lastCommand && lastCommand.command === command) {
+      return;
+    }
+
+    this.navigationHistory.push({
+      command,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get status icon
+   * @param {string} status - Agent status
+   * @returns {string} - Status icon
+   */
+  getStatusIcon(status) {
+    const icons = {
+      'VERIFIED': '✅',
+      'INSTALLED': '📦',
+      'INSTALLING': '⏳',
+      'VERIFYING': '🔍',
+      'NOT_INSTALLED': '❌',
+      'ERROR': '🚫',
+      'RATE_LIMITED': '⏱️',
+      'DISABLED': '🚫'
+    };
+
+    return icons[status] || '❓';
+  }
+
+  /**
+   * Get interface information
+   * @returns {Object} - Interface info
+   */
+  getInfo() {
+    return {
+      name: 'TRUI Agent Interface',
+      version: '1.0.0',
+      context: this.context,
+      currentAgent: this.currentAgent,
+      historySize: this.navigationHistory.length,
+      features: [
+        'interactive command line',
+        'RUI pattern support',
+        'command history',
+        'context awareness',
+        'navigation hints',
+        'auto-completion',
+        'error handling'
+      ]
+    };
+  }
+}
+
+module.exports = AgentInterface;