vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/agents/list.js

@@ -0,0 +1,471 @@
+/**
+ * CLI Command: List Agents
+ * 
+ * Implements "app list agents" command for CLI interface.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentConfigManager = require('../../../../../packages/core/src/agents/config/AgentConfigManager');
+const AgentLogger = require('../../../../../packages/core/src/agents/logging/AgentLogger');
+const FileManager = require('../../../../../packages/core/src/agents/storage/FileManager');
+const { AgentStatus } = require('../../../../../packages/core/src/agents/AgentStatus');
+const AgentCommands = require('../../../../../packages/core/src/rui/commands/AgentCommands');
+const AgentResponseFormatter = require('../../../../../packages/core/src/rui/commands/AgentResponseFormatter');
+
+/**
+ * CLI list agents command implementation
+ */
+class ListAgentsCommand {
+  /**
+   * Create command instance
+   * @param {Object} options - Command 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: options.pretty !== false
+    });
+  }
+
+  /**
+   * Execute list agents command using RUI pattern
+   * @param {Object} args - Command arguments
+   * @param {Object} options - Command options
+   * @returns {Promise<Object>} - Command result
+   */
+  async execute(args = [], options = {}) {
+    const { 
+      includeDisabled = false, 
+      includeStatus = true,
+      format = 'table',
+      sortBy = 'name',
+      filterStatus = null
+    } = this.parseArguments(args, options);
+
+    try {
+      // Load configuration
+      await this.configManager.load();
+      
+      // Execute using RUI pattern
+      const ruiResult = await this.agentCommands.executeCommand('LIST', 'agents', {
+        includeDisabled,
+        includeStatus
+      });
+
+      // Format response for CLI
+      const formattedResponse = this.responseFormatter.format(ruiResult, 'cli', {
+        format,
+        sortBy,
+        filterStatus
+      });
+
+      // Apply additional filtering and sorting
+      let agents = formattedResponse.data?.agents || [];
+      
+      // Apply status filter
+      if (filterStatus) {
+        agents = agents.filter(agent => agent.status === filterStatus);
+      }
+
+      // Apply sorting
+      agents = this.sortAgents(agents, sortBy);
+
+      // Output results
+      this.outputResults(agents, format, includeStatus);
+
+      return {
+        success: ruiResult.success,
+        agents,
+        formatted: formattedResponse,
+        count: agents.length,
+        message: `Listed ${agents.length} agents`
+      };
+    } catch (error) {
+      const errorMessage = `List agents failed: ${error.message}`;
+      console.error(errorMessage);
+      
+      return {
+        success: false,
+        error: error.message,
+        message: errorMessage
+      };
+    }
+  }
+
+  /**
+   * Parse command line arguments
+   * @param {Array<string>} args - Command arguments
+   * @param {Object} options - Default options
+   * @returns {Object} - Parsed arguments
+   */
+  parseArguments(args, options = {}) {
+    const parsed = {
+      includeDisabled: options.includeDisabled || false,
+      includeStatus: options.includeStatus !== false,
+      format: options.format || 'table',
+      sortBy: options.sortBy || 'name',
+      filterStatus: options.filterStatus || null
+    };
+
+    // Parse command line arguments
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      
+      switch (arg) {
+        case '--all':
+        case '-a':
+          parsed.includeDisabled = true;
+          break;
+          
+        case '--no-status':
+          parsed.includeStatus = false;
+          break;
+          
+        case '--format':
+          if (i + 1 < args.length) {
+            const format = args[i + 1];
+            if (['table', 'json', 'csv'].includes(format)) {
+              parsed.format = format;
+              i++; // Skip the next argument (format value)
+            }
+          }
+          break;
+          
+        case '--sort':
+          if (i + 1 < args.length) {
+            const sortBy = args[i + 1];
+            if (['name', 'status', 'type', 'priority'].includes(sortBy)) {
+              parsed.sortBy = sortBy;
+              i++; // Skip the next argument (sort value)
+            }
+          }
+          break;
+          
+        case '--status':
+          if (i + 1 < args.length) {
+            const status = args[i + 1];
+            if (Object.values(AgentStatus).includes(status)) {
+              parsed.filterStatus = status;
+              i++; // Skip the next argument (status value)
+            }
+          }
+          break;
+          
+        default:
+          // Handle positional arguments (agent IDs)
+          if (!arg.startsWith('-')) {
+            // For list command, positional args are ignored
+            break;
+          }
+          break;
+      }
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Filter agents by status
+   * @param {Array<Object>} agents - Agents to filter
+   * @param {string} status - Status to filter by
+   * @returns {Promise<Array>} - Filtered agents
+   */
+  async filterAgentsByStatus(agents, status) {
+    const filteredAgents = [];
+    
+    for (const agent of agents) {
+      const agentStatus = await this.configManager.getAgentStatus(agent.id);
+      const currentStatus = agentStatus ? agentStatus.status : AgentStatus.NOT_INSTALLED;
+      
+      if (currentStatus === status) {
+        filteredAgents.push(agent);
+      }
+    }
+    
+    return filteredAgents;
+  }
+
+  /**
+   * Sort agents by specified criteria
+   * @param {Array<Object>} agents - Agents to sort
+   * @param {string} sortBy - Sort criteria
+   * @returns {Array<Object>} - Sorted agents
+   */
+  sortAgents(agents, sortBy) {
+    return agents.sort((a, b) => {
+      switch (sortBy) {
+        case 'name':
+          return a.name.localeCompare(b.name);
+        case 'status':
+          return (a.status || '').localeCompare(b.status || '');
+        case 'type':
+          return (a.type || '').localeCompare(b.type || '');
+        case 'priority':
+          return (a.priority || 999) - (b.priority || 999);
+        default:
+          return a.name.localeCompare(b.name);
+      }
+    });
+  }
+
+  /**
+   * Add status information to agents
+   * @param {Array<Object>} agents - Agents to enhance
+   * @returns {Promise<Array>} - Agents with status info
+   */
+  async addStatusInfo(agents) {
+    const agentsWithStatus = [];
+    
+    for (const agent of agents) {
+      const status = await this.configManager.getAgentStatus(agent.id);
+      
+      agentsWithStatus.push({
+        ...agent,
+        status: status ? status.status : AgentStatus.NOT_INSTALLED,
+        statusDescription: this.getStatusDescription(status ? status.status : AgentStatus.NOT_INSTALLED),
+        lastChecked: status ? status.lastChecked : null,
+        lastVerified: status ? status.lastVerified : null,
+        statusMessage: status ? status.message : '',
+        canInstall: agent.enabled && (!status || status.status === AgentStatus.NOT_INSTALLED),
+        canVerify: agent.enabled && status && [AgentStatus.INSTALLED, AgentStatus.VERIFIED].includes(status.status)
+      });
+    }
+    
+    return agentsWithStatus;
+  }
+
+  /**
+   * Get status description
+   * @param {string} status - Status code
+   * @returns {string} - Human-readable description
+   */
+  getStatusDescription(status) {
+    const descriptions = {
+      [AgentStatus.NOT_INSTALLED]: 'Not installed',
+      [AgentStatus.INSTALLING]: 'Installing...',
+      [AgentStatus.INSTALLED]: 'Installed (not verified)',
+      [AgentStatus.VERIFYING]: 'Verifying...',
+      [AgentStatus.VERIFIED]: 'Verified and ready',
+      [AgentStatus.ERROR]: 'Error occurred',
+      [AgentStatus.RATE_LIMITED]: 'Rate limited',
+      [AgentStatus.DISABLED]: 'Disabled'
+    };
+
+    return descriptions[status] || 'Unknown';
+  }
+
+  /**
+   * Output results in specified format
+   * @param {Array} agents - Agents to output
+   * @param {string} format - Output format
+   * @param {boolean} includeStatus - Include status information
+   */
+  outputResults(agents, format, includeStatus) {
+    if (agents.length === 0) {
+      console.log('No agents found.');
+      return;
+    }
+
+    switch (format) {
+      case 'json':
+        this.outputJson(agents, includeStatus);
+        break;
+      case 'csv':
+        this.outputCsv(agents, includeStatus);
+        break;
+      case 'table':
+      default:
+        this.outputTable(agents, includeStatus);
+        break;
+    }
+  }
+
+  /**
+   * Output results as JSON
+   * @param {Array<Object>} agents - Agents to output
+   * @param {boolean} includeStatus - Include status information
+   */
+  outputJson(agents, includeStatus) {
+    const output = includeStatus ? agents : agents.map(agent => ({
+      id: agent.id,
+      name: agent.name,
+      description: agent.description,
+      enabled: agent.enabled,
+      type: agent.type
+    }));
+
+    console.log(JSON.stringify(output, null, 2));
+  }
+
+  /**
+   * Output results as CSV
+   * @param {Array<Object>} agents - Agents to output
+   * @param {boolean} includeStatus - Include status information
+   */
+  outputCsv(agents, includeStatus) {
+    const headers = includeStatus 
+      ? ['ID', 'Name', 'Description', 'Enabled', 'Type', 'Status', 'Last Checked', 'Can Install', 'Can Verify']
+      : ['ID', 'Name', 'Description', 'Enabled', 'Type'];
+
+    console.log(headers.join(','));
+
+    for (const agent of agents) {
+      const row = includeStatus ? [
+        agent.id,
+        `"${agent.name}"`,
+        `"${agent.description}"`,
+        agent.enabled,
+        agent.type,
+        agent.statusDescription || 'Not installed',
+        agent.lastChecked || '',
+        agent.canInstall ? 'Yes' : 'No',
+        agent.canVerify ? 'Yes' : 'No'
+      ] : [
+        agent.id,
+        `"${agent.name}"`,
+        `"${agent.description}"`,
+        agent.enabled,
+        agent.type
+      ];
+
+      console.log(row.join(','));
+    }
+  }
+
+  /**
+   * Output results as table
+   * @param {Array<Object>} agents - Agents to output
+   * @param {boolean} includeStatus - Include status information
+   */
+  outputTable(agents, includeStatus) {
+    if (agents.length === 0) {
+      console.log('No agents found.');
+      return;
+    }
+
+    if (includeStatus) {
+      console.log('\n=== AGENTS ===');
+      console.log('ID'.padEnd(12) + '  ' + 'NAME'.padEnd(20) + '  ' + 'ENABLED'.padEnd(8) + '  ' + 'TYPE'.padEnd(12) + '  ' + 'STATUS'.padEnd(12) + '  ' + 'LAST CHECKED');
+      console.log('-'.repeat(80));
+      
+      for (const agent of agents) {
+        const id = agent.id.padEnd(12);
+        const name = agent.name.padEnd(20);
+        const enabled = agent.enabled ? 'Yes'.padEnd(8) : 'No'.padEnd(8);
+        const type = (agent.type || '').padEnd(12);
+        const status = agent.statusDescription.padEnd(12);
+        const lastChecked = (agent.lastChecked || 'Never').padEnd(12);
+        
+        console.log(`${id}  ${name}  ${enabled}  ${type}  ${status}  ${lastChecked}`);
+      }
+    } else {
+      console.log('\n=== AGENTS ===');
+      console.log('ID'.padEnd(12) + '  ' + 'NAME'.padEnd(20) + '  ' + 'ENABLED'.padEnd(8) + '  ' + 'TYPE'.padEnd(12));
+      console.log('-'.repeat(54));
+      
+      for (const agent of agents) {
+        const id = agent.id.padEnd(12);
+        const name = agent.name.padEnd(20);
+        const enabled = agent.enabled ? 'Yes'.padEnd(8) : 'No'.padEnd(8);
+        const type = (agent.type || '').padEnd(12);
+        
+        console.log(`${id}  ${name}  ${enabled}  ${type}`);
+      }
+    }
+  }
+
+  /**
+   * Show help information
+   */
+  showHelp() {
+    console.log('\n=== LIST AGENTS COMMAND ===');
+    console.log('Description: List all configured agents');
+    console.log('');
+    console.log('Usage: app list agents [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --all, -a               Include disabled agents');
+    console.log('  --no-status             Exclude status information');
+    console.log('  --format <format>      Output format: table, json, csv (default: table)');
+    console.log('  --sort <field>         Sort by: name, status, type, priority (default: name)');
+    console.log('  --status <status>       Filter by status (NOT_INSTALLED, INSTALLING, etc.)');
+    console.log('');
+    console.log('Examples:');
+    console.log('  app list agents');
+    console.log('  app list agents --all');
+    console.log('  app list agents --format json');
+    console.log('  app list agents --sort status');
+    console.log('  app list agents --status VERIFIED');
+  }
+
+  /**
+   * Get command information
+   * @returns {Object} - Command info
+   */
+  getCommandInfo() {
+    return {
+      name: 'list-agents',
+      description: 'List all configured agents',
+      usage: 'app list agents [options]',
+      examples: [
+        'app list agents',
+        'app list agents --all',
+        'app list agents --format json',
+        'app list agents --sort status',
+        'app list agents --status VERIFIED'
+      ],
+      options: [
+        {
+          flag: '--all, -a',
+          description: 'Include disabled agents'
+        },
+        {
+          flag: '--no-status',
+          description: 'Exclude status information'
+        },
+        {
+          flag: '--format <format>',
+          description: 'Output format: table, json, csv (default: table)'
+        },
+        {
+          flag: '--sort <field>',
+          description: 'Sort by: name, status, type, priority (default: name)'
+        },
+        {
+          flag: '--status <status>',
+          description: 'Filter by status (NOT_INSTALLED, INSTALLING, etc.)'
+        }
+      ]
+    };
+  }
+}
+
+/**
+ * Execute list agents command
+ * @param {Array<string>} args - Command line arguments
+ * @param {Object} options - Command options
+ * @returns {Promise<Object>} - Command result
+ */
+async function execute(args, options = {}) {
+  const command = new ListAgentsCommand(options);
+  return await command.execute(args, options);
+}
+
+module.exports = {
+  execute,
+  ListAgentsCommand
+};