vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/rui/commands/AgentResponseFormatter.js

@@ -0,0 +1,832 @@
+/**
+ * RUI Agent Response Formatter
+ * 
+ * Formats agent command responses for different interfaces.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * RUI Agent Response Formatter class
+ */
+class AgentResponseFormatter {
+  /**
+   * Create response formatter instance
+   * @param {Object} options - Formatter options
+   */
+  constructor(options = {}) {
+    this.defaultFormat = options.defaultFormat || 'json';
+    this.includeTimestamp = options.includeTimestamp !== false;
+    this.includeMetadata = options.includeMetadata !== false;
+    this.prettyPrint = options.prettyPrint !== false;
+    this.colorize = options.colorize || false;
+  }
+
+  /**
+   * Format response for specified interface
+   * @param {Object} response - Response object
+   * @param {string} interfaceType - Interface type (cli, trui, grui)
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted response
+   */
+  format(response, interfaceType = 'cli', options = {}) {
+    const format = options.format || this.defaultFormat;
+    
+    // Add metadata
+    const enhancedResponse = this.addMetadata(response, interfaceType);
+    
+    switch (interfaceType) {
+      case 'cli':
+        return this.formatForCLI(enhancedResponse, format, options);
+      case 'trui':
+        return this.formatForTRUI(enhancedResponse, format, options);
+      case 'grui':
+        return this.formatForGRUI(enhancedResponse, format, options);
+      default:
+        return enhancedResponse;
+    }
+  }
+
+  /**
+   * Format response for CLI interface
+   * @param {Object} response - Response object
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted response
+   */
+  formatForCLI(response, format = 'table', options = {}) {
+    const formatted = {
+      success: response.success,
+      data: response.data,
+      error: response.error,
+      timestamp: response.timestamp,
+      interface: 'cli'
+    };
+
+    // Format data based on command type
+    if (response.data) {
+      if (response.data.agents) {
+        formatted.data = this.formatAgentList(response.data.agents, format, options);
+      } else if (response.data.summary) {
+        formatted.data = this.formatSummary(response.data, format, options);
+      } else if (response.data.id) {
+        formatted.data = this.formatAgentDetails(response.data, format, options);
+      }
+    }
+
+    // Add CLI-specific formatting
+    if (options.verbose) {
+      formatted.verbose = this.formatVerboseOutput(response);
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Format response for TRUI interface
+   * @param {Object} response - Response object
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted response
+   */
+  formatForTRUI(response, format = 'json', options = {}) {
+    const formatted = {
+      success: response.success,
+      data: response.data,
+      error: response.error,
+      timestamp: response.timestamp,
+      interface: 'trui'
+    };
+
+    // TRUI-specific formatting
+    if (response.data) {
+      if (response.data.agents) {
+        formatted.data = {
+          agents: this.formatAgentListForTRUI(response.data.agents, options),
+          navigation: this.generateNavigationOptions('agent-list', response.data.agents)
+        };
+      } else if (response.data.id) {
+        formatted.data = {
+          agent: this.formatAgentDetailsForTRUI(response.data, options),
+          actions: this.generateActionOptions('agent-details', response.data)
+        };
+      }
+    }
+
+    // Add TRUI navigation hints
+    formatted.navigation = {
+      available: this.getAvailableCommands(),
+      context: this.getCurrentContext(response)
+    };
+
+    return formatted;
+  }
+
+  /**
+   * Format response for GRUI interface
+   * @param {Object} response - Response object
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted response
+   */
+  formatForGRUI(response, format = 'json', options = {}) {
+    const formatted = {
+      success: response.success,
+      data: response.data,
+      error: response.error,
+      timestamp: response.timestamp,
+      interface: 'grui'
+    };
+
+    // GRUI-specific formatting
+    if (response.data) {
+      if (response.data.agents) {
+        formatted.data = {
+          agents: this.formatAgentListForGRUI(response.data.agents, options),
+          ui: {
+            component: 'AgentList',
+            props: {
+              agents: response.data.agents,
+              selectable: true,
+              actions: ['enable', 'disable', 'check', 'details']
+            }
+          }
+        };
+      } else if (response.data.id) {
+        formatted.data = {
+          agent: this.formatAgentDetailsForGRUI(response.data, options),
+          ui: {
+            component: 'AgentDetails',
+            props: {
+              agent: response.data,
+              editable: true,
+              actions: ['enable', 'disable', 'check', 'remove', 'logs']
+            }
+          }
+        };
+      }
+    }
+
+    // Add GRUI event handling
+    formatted.events = this.generateUIEvents(response);
+    formatted.state = this.generateUIState(response);
+
+    return formatted;
+  }
+
+  /**
+   * Format agent list for CLI
+   * @param {Array} agents - Agent list
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {*} - Formatted agent list
+   */
+  formatAgentList(agents, format = 'table', options = {}) {
+    switch (format) {
+      case 'table':
+        return this.formatAgentListAsTable(agents, options);
+      case 'json':
+        return agents;
+      case 'csv':
+        return this.formatAgentListAsCSV(agents, options);
+      default:
+        return agents;
+    }
+  }
+
+  /**
+   * Format agent list as table
+   * @param {Array} agents - Agent list
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Table formatted data
+   */
+  formatAgentListAsTable(agents, options = {}) {
+    const includeStatus = options.includeStatus !== false;
+    const headers = ['ID', 'Name', 'Enabled'];
+    
+    if (includeStatus) {
+      headers.push('Status', 'Last Checked');
+    }
+
+    const rows = agents.map(agent => {
+      const row = [
+        agent.id,
+        agent.name,
+        agent.enabled ? 'Yes' : 'No'
+      ];
+      
+      if (includeStatus) {
+        row.push(
+          agent.status || 'Unknown',
+          agent.lastChecked || 'Never'
+        );
+      }
+      
+      return row;
+    });
+
+    return {
+      type: 'table',
+      headers,
+      rows,
+      count: agents.length
+    };
+  }
+
+  /**
+   * Format agent list as CSV
+   * @param {Array} agents - Agent list
+   * @param {Object} options - Formatting options
+   * @returns {Object} - CSV formatted data
+   */
+  formatAgentListAsCSV(agents, options = {}) {
+    const includeStatus = options.includeStatus !== false;
+    const headers = ['ID', 'Name', 'Enabled'];
+    
+    if (includeStatus) {
+      headers.push('Status', 'Last Checked');
+    }
+
+    const rows = agents.map(agent => {
+      const row = [
+        agent.id,
+        `"${agent.name}"`,
+        agent.enabled
+      ];
+      
+      if (includeStatus) {
+        row.push(
+          agent.status || 'Unknown',
+          agent.lastChecked || 'Never'
+        );
+      }
+      
+      return row.join(',');
+    });
+
+    return {
+      type: 'csv',
+      headers: headers.join(','),
+      rows,
+      count: agents.length
+    };
+  }
+
+  /**
+   * Format agent list for TRUI
+   * @param {Array} agents - Agent list
+   * @param {Object} options - Formatting options
+   * @returns {Array} - TRUI formatted agents
+   */
+  formatAgentListForTRUI(agents, options = {}) {
+    return agents.map((agent, index) => ({
+      ...agent,
+      displayIndex: index + 1,
+      statusIcon: this.getStatusIcon(agent.status),
+      canSelect: true,
+      quickActions: this.getQuickActions(agent)
+    }));
+  }
+
+  /**
+   * Format agent list for GRUI
+   * @param {Array} agents - Agent list
+   * @param {Object} options - Formatting options
+   * @returns {Array} - GRUI formatted agents
+   */
+  formatAgentListForGRUI(agents, options = {}) {
+    return agents.map(agent => ({
+      ...agent,
+      ui: {
+        status: {
+          type: 'badge',
+          value: agent.status,
+          variant: this.getStatusVariant(agent.status)
+        },
+        actions: {
+          primary: this.getPrimaryAction(agent),
+          secondary: this.getSecondaryActions(agent)
+        },
+        selectable: true,
+        editable: ['enabled'].includes(agent.enabled)
+      }
+    }));
+  }
+
+  /**
+   * Format agent details
+   * @param {Object} agent - Agent object
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted agent details
+   */
+  formatAgentDetails(agent, format = 'json', options = {}) {
+    const formatted = { ...agent };
+
+    // Add computed properties
+    formatted.statusDescription = this.getStatusDescription(agent.status);
+    formatted.canInstall = agent.enabled && (!agent.status || agent.status === 'NOT_INSTALLED');
+    formatted.canVerify = agent.enabled && ['INSTALLED', 'VERIFIED'].includes(agent.status);
+
+    if (format === 'detailed') {
+      formatted.installationMethods = this.formatInstallationMethods(agent.installationMethods);
+      formatted.verificationTests = this.formatVerificationTests(agent.verificationTests);
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Format agent details for TRUI
+   * @param {Object} agent - Agent object
+   * @param {Object} options - Formatting options
+   * @returns {Object} - TRUI formatted agent
+   */
+  formatAgentDetailsForTRUI(agent, options = {}) {
+    const formatted = this.formatAgentDetails(agent, 'detailed', options);
+
+    return {
+      ...formatted,
+      sections: this.generateAgentSections(agent),
+      navigation: {
+        back: 'list agents',
+        related: ['check ' + agent.id, 'logs ' + agent.id]
+      }
+    };
+  }
+
+  /**
+   * Format agent details for GRUI
+   * @param {Object} agent - Agent object
+   * @param {Object} options - Formatting options
+   * @returns {Object} - GRUI formatted agent
+   */
+  formatAgentDetailsForGRUI(agent, options = {}) {
+    const formatted = this.formatAgentDetails(agent, 'detailed', options);
+
+    return {
+      ...formatted,
+      ui: {
+        sections: this.generateAgentSections(agent),
+        tabs: this.generateAgentTabs(agent),
+        panels: this.generateAgentPanels(agent),
+        actions: this.generateAgentActions(agent)
+      }
+    };
+  }
+
+  /**
+   * Format summary information
+   * @param {Object} summary - Summary object
+   * @param {string} format - Output format
+   * @param {Object} options - Formatting options
+   * @returns {Object} - Formatted summary
+   */
+  formatSummary(summary, format = 'json', options = {}) {
+    const formatted = { ...summary };
+
+    // Add computed properties
+    formatted.successRate = summary.total > 0 ? (summary.successful / summary.total) * 100 : 0;
+    formatted.durationFormatted = this.formatDuration(summary.duration);
+
+    if (format === 'detailed') {
+      formatted.breakdown = this.generateSummaryBreakdown(summary);
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Add metadata to response
+   * @param {Object} response - Original response
+   * @param {string} interfaceType - Interface type
+   * @returns {Object} - Enhanced response
+   */
+  addMetadata(response, interfaceType) {
+    const enhanced = { ...response };
+
+    if (this.includeTimestamp) {
+      enhanced.timestamp = enhanced.timestamp || new Date().toISOString();
+    }
+
+    if (this.includeMetadata) {
+      enhanced.metadata = {
+        interface: interfaceType,
+        version: '1.0.0',
+        formatter: 'AgentResponseFormatter'
+      };
+    }
+
+    return enhanced;
+  }
+
+  /**
+   * 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 status variant for UI
+   * @param {string} status - Agent status
+   * @returns {string} - Status variant
+   */
+  getStatusVariant(status) {
+    const variants = {
+      'VERIFIED': 'success',
+      'INSTALLED': 'info',
+      'INSTALLING': 'warning',
+      'VERIFYING': 'warning',
+      'NOT_INSTALLED': 'danger',
+      'ERROR': 'danger',
+      'RATE_LIMITED': 'warning',
+      'DISABLED': 'secondary'
+    };
+
+    return variants[status] || 'secondary';
+  }
+
+  /**
+   * Get status description
+   * @param {string} status - Agent status
+   * @returns {string} - Status description
+   */
+  getStatusDescription(status) {
+    const descriptions = {
+      'VERIFIED': 'Verified and ready',
+      'INSTALLED': 'Installed (not verified)',
+      'INSTALLING': 'Installing...',
+      'VERIFYING': 'Verifying...',
+      'NOT_INSTALLED': 'Not installed',
+      'ERROR': 'Error occurred',
+      'RATE_LIMITED': 'Rate limited',
+      'DISABLED': 'Disabled'
+    };
+
+    return descriptions[status] || 'Unknown';
+  }
+
+  /**
+   * Get quick actions for agent
+   * @param {Object} agent - Agent object
+   * @returns {Array} - Quick actions
+   */
+  getQuickActions(agent) {
+    const actions = [];
+
+    if (agent.enabled) {
+      actions.push({ key: 'check', label: 'Check', shortcut: 'ch' });
+    }
+
+    if (agent.status === 'VERIFIED') {
+      actions.push({ key: 'logs', label: 'Logs', shortcut: 'lg' });
+    }
+
+    actions.push({ key: 'details', label: 'Details', shortcut: 'ge' });
+
+    return actions;
+  }
+
+  /**
+   * Get primary action for agent
+   * @param {Object} agent - Agent object
+   * @returns {Object} - Primary action
+   */
+  getPrimaryAction(agent) {
+    if (agent.enabled && agent.status !== 'VERIFIED') {
+      return { key: 'check', label: 'Check Agent', icon: 'play' };
+    } else if (agent.status === 'VERIFIED') {
+      return { key: 'logs', label: 'View Logs', icon: 'file-text' };
+    }
+
+    return { key: 'details', label: 'View Details', icon: 'info' };
+  }
+
+  /**
+   * Get secondary actions for agent
+   * @param {Object} agent - Agent object
+   * @returns {Array} - Secondary actions
+   */
+  getSecondaryActions(agent) {
+    const actions = [];
+
+    if (agent.enabled) {
+      actions.push({ key: 'disable', label: 'Disable', icon: 'pause' });
+    } else {
+      actions.push({ key: 'enable', label: 'Enable', icon: 'play' });
+    }
+
+    actions.push({ key: 'remove', label: 'Remove', icon: 'trash', danger: true });
+
+    return actions;
+  }
+
+  /**
+   * Generate navigation options
+   * @param {string} context - Current context
+   * @param {Array} items - Available items
+   * @returns {Object} - Navigation options
+   */
+  generateNavigationOptions(context, items) {
+    return {
+      context,
+      itemCount: items.length,
+      availableActions: this.getAvailableCommands(),
+      shortcuts: this.getAvailableShortcuts()
+    };
+  }
+
+  /**
+   * Generate action options
+   * @param {string} context - Current context
+   * @param {Object} item - Current item
+   * @returns {Array} - Action options
+   */
+  generateActionOptions(context, item) {
+    return this.getQuickActions(item);
+  }
+
+  /**
+   * Generate agent sections
+   * @param {Object} agent - Agent object
+   * @returns {Array} - Agent sections
+   */
+  generateAgentSections(agent) {
+    return [
+      {
+        id: 'basic',
+        title: 'Basic Information',
+        fields: ['id', 'name', 'description', 'enabled', 'status']
+      },
+      {
+        id: 'installation',
+        title: 'Installation',
+        fields: ['installationMethods', 'lastChecked']
+      },
+      {
+        id: 'verification',
+        title: 'Verification',
+        fields: ['verificationTests', 'lastVerified']
+      }
+    ];
+  }
+
+  /**
+   * Generate agent tabs
+   * @param {Object} agent - Agent object
+   * @returns {Array} - Agent tabs
+   */
+  generateAgentTabs(agent) {
+    return [
+      { id: 'overview', label: 'Overview', active: true },
+      { id: 'installation', label: 'Installation' },
+      { id: 'verification', label: 'Verification' },
+      { id: 'logs', label: 'Logs', disabled: !agent.status || agent.status === 'NOT_INSTALLED' }
+    ];
+  }
+
+  /**
+   * Generate agent panels
+   * @param {Object} agent - Agent object
+   * @returns {Array} - Agent panels
+   */
+  generateAgentPanels(agent) {
+    return [
+      {
+        id: 'status',
+        title: 'Status',
+        type: 'status-panel',
+        data: agent.status
+      },
+      {
+        id: 'actions',
+        title: 'Actions',
+        type: 'action-panel',
+        data: this.generateAgentActions(agent)
+      }
+    ];
+  }
+
+  /**
+   * Generate agent actions
+   * @param {Object} agent - Agent object
+   * @returns {Object} - Agent actions
+   */
+  generateAgentActions(agent) {
+    return {
+      primary: this.getPrimaryAction(agent),
+      secondary: this.getSecondaryActions(agent)
+    };
+  }
+
+  /**
+   * Generate UI events
+   * @param {Object} response - Response object
+   * @returns {Array} - UI events
+   */
+  generateUIEvents(response) {
+    return [
+      'agent-selected',
+      'agent-status-changed',
+      'agent-action-triggered',
+      'refresh-required'
+    ];
+  }
+
+  /**
+   * Generate UI state
+   * @param {Object} response - Response object
+   * @returns {Object} - UI state
+   */
+  generateUIState(response) {
+    return {
+      loading: false,
+      error: !response.success,
+      data: response.data,
+      lastUpdated: response.timestamp
+    };
+  }
+
+  /**
+   * Generate summary breakdown
+   * @param {Object} summary - Summary object
+   * @returns {Object} - Summary breakdown
+   */
+  generateSummaryBreakdown(summary) {
+    return {
+      byStatus: this.groupByStatus(summary.results || {}),
+      byDuration: this.groupByDuration(summary.results || {}),
+      performance: {
+        average: summary.duration / (summary.total || 1),
+        min: Math.min(...(summary.durations || [])),
+        max: Math.max(...(summary.durations || []))
+      }
+    };
+  }
+
+  /**
+   * Format duration
+   * @param {number} duration - Duration in milliseconds
+   * @returns {string} - Formatted duration
+   */
+  formatDuration(duration) {
+    if (!duration) return '0s';
+    
+    const seconds = Math.floor(duration / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+
+  /**
+   * Get available commands
+   * @returns {Array} - Available commands
+   */
+  getAvailableCommands() {
+    return [
+      'list agents', 'get agent', 'check agents', 'enable agent', 
+      'disable agent', 'remove agent', 'help'
+    ];
+  }
+
+  /**
+   * Get available shortcuts
+   * @returns {Array} - Available shortcuts
+   */
+  getAvailableShortcuts() {
+    return [
+      'la', 'li', 'ge', 'ch', 'en', 'di', 're', 'rm'
+    ];
+  }
+
+  /**
+   * Get current context
+   * @param {Object} response - Response object
+   * @returns {string} - Current context
+   */
+  getCurrentContext(response) {
+    if (response.data && response.data.agents) {
+      return 'agent-list';
+    } else if (response.data && response.data.id) {
+      return 'agent-details';
+    } else if (response.data && response.data.summary) {
+      return 'operation-summary';
+    }
+    return 'unknown';
+  }
+
+  /**
+   * Format verbose output
+   * @param {Object} response - Response object
+   * @returns {Object} - Verbose output
+   */
+  formatVerboseOutput(response) {
+    return {
+      debug: response.debug || {},
+      performance: response.performance || {},
+      metadata: response.metadata || {},
+      raw: response
+    };
+  }
+
+  /**
+   * Format installation methods
+   * @param {Array} methods - Installation methods
+   * @returns {Array} - Formatted methods
+   */
+  formatInstallationMethods(methods) {
+    return (methods || []).map(method => ({
+      ...method,
+      priorityDescription: this.getPriorityDescription(method.priority)
+    }));
+  }
+
+  /**
+   * Format verification tests
+   * @param {Array} tests - Verification tests
+   * @returns {Array} - Formatted tests
+   */
+  formatVerificationTests(tests) {
+    return (tests || []).map(test => ({
+      ...test,
+      typeDescription: this.getTestTypeDescription(test.type)
+    }));
+  }
+
+  /**
+   * Get priority description
+   * @param {number} priority - Priority number
+   * @returns {string} - Priority description
+   */
+  getPriorityDescription(priority) {
+    if (priority === 1) return 'Highest';
+    if (priority <= 3) return 'High';
+    if (priority <= 5) return 'Medium';
+    return 'Low';
+  }
+
+  /**
+   * Get test type description
+   * @param {string} type - Test type
+   * @returns {string} - Test type description
+   */
+  getTestTypeDescription(type) {
+    const descriptions = {
+      'FILE_OPERATION': 'File Operation Test',
+      'COMMAND_EXECUTION': 'Command Execution Test',
+      'API_CALL': 'API Call Test',
+      'NETWORK_TEST': 'Network Test'
+    };
+
+    return descriptions[type] || 'Unknown Test';
+  }
+
+  /**
+   * Get formatter information
+   * @returns {Object} - Formatter info
+   */
+  getInfo() {
+    return {
+      name: 'RUI Agent Response Formatter',
+      version: '1.0.0',
+      defaultFormat: this.defaultFormat,
+      includeTimestamp: this.includeTimestamp,
+      includeMetadata: this.includeMetadata,
+      prettyPrint: this.prettyPrint,
+      colorize: this.colorize,
+      supportedInterfaces: ['cli', 'trui', 'grui'],
+      supportedFormats: ['json', 'table', 'csv', 'detailed'],
+      features: [
+        'multi-interface formatting',
+        'response metadata',
+        'status formatting',
+        'action generation',
+        'navigation support',
+        'error handling',
+        'verbose output'
+      ]
+    };
+  }
+}
+
+module.exports = AgentResponseFormatter;