vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/rui/commands/AgentCommandParser.js

@@ -1,10 +1,15 @@
 /**
  * RUI Agent Command Parser
  * 
- * Parses and validates REST-based agent commands.
+ * Orchestrates command parsing using modular components.
  * Follows constitutional requirements: <555 lines, test-first approach.
  */
 
+const TokenParser = require('./parsers/TokenParser');
+const ComponentExtractor = require('./parsers/ComponentExtractor');
+const CommandValidator = require('./parsers/CommandValidator');
+const CommandMapper = require('./parsers/CommandMapper');
+
 /**
  * RUI Agent Command Parser class
  */
@@ -18,10 +23,24 @@ class AgentCommandParser {
     this.allowShortcuts = options.allowShortcuts !== false;
     this.strictMode = options.strictMode || false;
     
-    // Define command mappings
-    this.commandMap = this.initializeCommandMap();
-    this.shortcutMap = this.initializeShortcutMap();
-    this.parameterDefinitions = this.initializeParameterDefinitions();
+    // Initialize component modules
+    this.tokenParser = new TokenParser();
+    this.componentExtractor = new ComponentExtractor({
+      allowShortcuts: this.allowShortcuts,
+      tokenParser: this.tokenParser
+    });
+    this.commandValidator = new CommandValidator({
+      strictMode: this.strictMode
+    });
+    this.commandMapper = new CommandMapper({
+      caseSensitive: this.caseSensitive,
+      allowShortcuts: this.allowShortcuts
+    });
+
+    // Legacy property access for backward compatibility
+    this.commandMap = this.commandMapper.commandMap;
+    this.shortcutMap = this.commandMapper.shortcutMap;
+    this.parameterDefinitions = this.commandValidator.parameterDefinitions;
   }
 
   /**
@@ -35,11 +54,11 @@ class AgentCommandParser {
     }
 
     try {
-      const tokens = this.tokenize(commandString);
-      const { verb, resource, params } = this.extractComponents(tokens);
+      const tokens = this.tokenParser.tokenize(commandString);
+      const { verb, resource, params } = this.componentExtractor.extractComponents(tokens);
       
-      const normalizedVerb = this.normalizeVerb(verb);
-      const validatedCommand = this.validateCommand(normalizedVerb, resource, params);
+      const normalizedVerb = this.commandMapper.normalizeVerb(verb);
+      const validatedCommand = this.commandValidator.validateCommand(normalizedVerb, resource, params);
       
       return {
         ...validatedCommand,
@@ -58,478 +77,150 @@ class AgentCommandParser {
   }
 
   /**
-   * Tokenize command string
+   * Tokenize command string (delegated to TokenParser)
    * @param {string} commandString - Command string to tokenize
    * @returns {Array} - Array of tokens
    */
   tokenize(commandString) {
-    // Handle quoted strings and parameters
-    const tokens = [];
-    let current = '';
-    let inQuotes = false;
-    let quoteChar = '';
-    
-    for (let i = 0; i < commandString.length; i++) {
-      const char = commandString[i];
-      
-      if ((char === '"' || char === "'") && !inQuotes) {
-        inQuotes = true;
-        quoteChar = char;
-      } else if (char === quoteChar && inQuotes) {
-        inQuotes = false;
-        quoteChar = '';
-      } else if (char === ' ' && !inQuotes) {
-        if (current.trim()) {
-          tokens.push(current.trim());
-          current = '';
-        }
-      } else {
-        current += char;
-      }
-    }
-    
-    if (current.trim()) {
-      tokens.push(current.trim());
-    }
-    
-    return tokens;
+    return this.tokenParser.tokenize(commandString);
   }
 
   /**
-   * Extract verb, resource, and parameters from tokens
+   * Extract verb, resource, and parameters from tokens (delegated to ComponentExtractor)
    * @param {Array} tokens - Command tokens
    * @returns {Object} - Extracted components
    */
   extractComponents(tokens) {
-    if (tokens.length === 0) {
-      throw new Error('Empty command');
-    }
-
-    let verb = tokens[0];
-    let resource = '';
-    let params = {};
-
-    // Handle shortcuts (2-character commands)
-    if (this.allowShortcuts && tokens.length >= 2 && tokens[0].length <= 3) {
-      verb = tokens[0];
-      resource = tokens[1];
-      
-      // Extract parameters from remaining tokens
-      for (let i = 2; i < tokens.length; i++) {
-        this.parseParameter(tokens[i], params);
-      }
-    } 
-    // Handle full commands
-    else if (tokens.length >= 2) {
-      verb = tokens[0];
-      resource = tokens[1];
-      
-      // Extract parameters from remaining tokens
-      for (let i = 2; i < tokens.length; i++) {
-        this.parseParameter(tokens[i], params);
-      }
-    } else {
-      // Single token - might be verb only or verb+resource
-      const parts = tokens[0].split(/\s+/);
-      if (parts.length >= 2) {
-        verb = parts[0];
-        resource = parts[1];
-      }
-    }
-
-    return { verb, resource, params };
+    return this.componentExtractor.extractComponents(tokens);
   }
 
   /**
-   * Parse parameter token
+   * Parse parameter token (delegated to ComponentExtractor)
    * @param {string} token - Parameter token
    * @param {Object} params - Parameters object to update
    */
   parseParameter(token, params) {
-    // Handle flag parameters (--flag)
-    if (token.startsWith('--')) {
-      const flag = token.substring(2);
-      params[flag] = true;
-    }
-    // Handle short flags (-f)
-    else if (token.startsWith('-') && !token.startsWith('--')) {
-      const flag = token.substring(1);
-      params[flag] = true;
-    }
-    // Handle key=value parameters (--key=value)
-    else if (token.includes('=')) {
-      const [key, value] = token.split('=', 2);
-      const cleanKey = key.startsWith('--') ? key.substring(2) : key.startsWith('-') ? key.substring(1) : key;
-      params[cleanKey] = this.parseValue(value);
-    }
-    // Handle key value parameters (--key value)
-    else if (token.startsWith('--')) {
-      const key = token.substring(2);
-      params[key] = true; // Will be updated with next token if it's a value
-    }
-    // Positional parameter
-    else {
-      if (!params.positional) {
-        params.positional = [];
-      }
-      params.positional.push(this.parseValue(token));
-    }
+    return this.componentExtractor.parseParameter(token, params);
   }
 
   /**
-   * Parse parameter value
+   * Parse parameter value (delegated to TokenParser)
    * @param {string} value - Raw value
    * @returns {*} - Parsed value
    */
   parseValue(value) {
-    // Remove quotes if present
-    if ((value.startsWith('"') && value.endsWith('"')) || 
-        (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-
-    // Parse as JSON if possible
-    try {
-      return JSON.parse(value);
-    } catch {
-      // Return as string if not valid JSON
-      return value;
-    }
+    return this.tokenParser.parseValue(value);
   }
 
   /**
-   * Normalize verb using command map
+   * Normalize verb using command map (delegated to CommandMapper)
    * @param {string} verb - Raw verb
    * @returns {string} - Normalized verb
    */
   normalizeVerb(verb) {
-    if (!verb) return verb;
-
-    const normalized = this.caseSensitive ? verb : verb.toUpperCase();
-    
-    // Check shortcuts first
-    if (this.allowShortcuts && this.shortcutMap[normalized]) {
-      return this.shortcutMap[normalized];
-    }
-    
-    // Check full commands
-    if (this.commandMap[normalized]) {
-      return this.commandMap[normalized];
-    }
-    
-    return normalized;
+    return this.commandMapper.normalizeVerb(verb);
   }
 
   /**
-   * Validate command components
+   * Validate command components (delegated to CommandValidator)
    * @param {string} verb - Command verb
    * @param {string} resource - Command resource
    * @param {Object} params - Command parameters
    * @returns {Object} - Validation result
    */
   validateCommand(verb, resource, params) {
-    const validation = {
-      success: true,
-      verb,
-      resource,
-      params,
-      errors: [],
-      warnings: []
-    };
-
-    // Validate verb
-    if (!this.isValidVerb(verb)) {
-      validation.success = false;
-      validation.errors.push(`Unknown command: ${verb}`);
-      return validation;
-    }
-
-    // Validate resource based on verb
-    const resourceValidation = this.validateResource(verb, resource);
-    if (!resourceValidation.valid) {
-      validation.success = false;
-      validation.errors.push(...resourceValidation.errors);
-    }
-
-    // Validate parameters
-    const paramValidation = this.validateParameters(verb, resource, params);
-    if (!paramValidation.valid) {
-      validation.success = false;
-      validation.errors.push(...paramValidation.errors);
-    }
-
-    validation.warnings.push(...paramValidation.warnings);
-
-    return validation;
+    return this.commandValidator.validateCommand(verb, resource, params);
   }
 
   /**
-   * Check if verb is valid
+   * Check if verb is valid (delegated to CommandValidator)
    * @param {string} verb - Verb to check
    * @returns {boolean} - Whether verb is valid
    */
   isValidVerb(verb) {
-    const validVerbs = new Set([
-      'GET', 'LIST', 'POST', 'CHECK', 'PUT', 'UPDATE', 'DELETE', 'REMOVE',
-      'ENABLE', 'DISABLE', 'STATUS', 'HELP'
-    ]);
-    
-    return validVerbs.has(verb);
+    return this.commandValidator.isValidVerb(verb);
   }
 
   /**
-   * Validate resource for given verb
+   * Validate resource for given verb (delegated to CommandValidator)
    * @param {string} verb - Command verb
    * @param {string} resource - Resource to validate
    * @returns {Object} - Validation result
    */
   validateResource(verb, resource) {
-    const validation = { valid: true, errors: [] };
-
-    // Verbs that require resource
-    const resourceRequiredVerbs = new Set(['GET', 'PUT', 'UPDATE', 'DELETE', 'REMOVE', 'ENABLE', 'DISABLE']);
-    
-    if (resourceRequiredVerbs.has(verb) && !resource) {
-      validation.valid = false;
-      validation.errors.push('Resource is required for this command');
-    }
-
-    // Validate resource format
-    if (resource && !this.isValidResource(resource)) {
-      validation.valid = false;
-      validation.errors.push(`Invalid resource: ${resource}`);
-    }
-
-    return validation;
+    return this.commandValidator.validateResource(verb, resource);
   }
 
   /**
-   * Check if resource is valid
+   * Check if resource is valid (delegated to CommandValidator)
    * @param {string} resource - Resource to check
    * @returns {boolean} - Whether resource is valid
    */
   isValidResource(resource) {
-    const validResources = ['agents', 'agent'];
-    return validResources.includes(resource.toLowerCase()) || 
-           resource.toLowerCase().startsWith('agent-');
+    return this.commandValidator.isValidResource(resource);
   }
 
   /**
-   * Validate command parameters
+   * Validate command parameters (delegated to CommandValidator)
    * @param {string} verb - Command verb
    * @param {string} resource - Command resource
    * @param {Object} params - Parameters to validate
    * @returns {Object} - Validation result
    */
   validateParameters(verb, resource, params) {
-    const validation = { valid: true, errors: [], warnings: [] };
-
-    // Get parameter definitions for this verb
-    const paramDefs = this.parameterDefinitions[verb] || {};
-    
-    // Validate each parameter
-    for (const [paramName, paramValue] of Object.entries(params)) {
-      if (paramName === 'positional') continue;
-
-      const paramDef = paramDefs[paramName];
-      if (!paramDef) {
-        if (this.strictMode) {
-          validation.valid = false;
-          validation.errors.push(`Unknown parameter: ${paramName}`);
-        }
-        continue;
-      }
-
-      // Type validation
-      if (paramDef.type && !this.validateParameterType(paramValue, paramDef.type)) {
-        validation.valid = false;
-        validation.errors.push(`Invalid type for parameter ${paramName}: expected ${paramDef.type}`);
-      }
-
-      // Value validation
-      if (paramDef.validValues && !paramDef.validValues.includes(paramValue)) {
-        validation.valid = false;
-        validation.errors.push(`Invalid value for parameter ${paramName}: ${paramValue}. Valid values: ${paramDef.validValues.join(', ')}`);
-      }
-    }
-
-    // Check for required parameters
-    for (const [paramName, paramDef] of Object.entries(paramDefs)) {
-      if (paramDef.required && !(paramName in params)) {
-        validation.valid = false;
-        validation.errors.push(`Required parameter missing: ${paramName}`);
-      }
-    }
-
-    // Add warnings for special cases
-    if (verb === 'DELETE' && !params.confirm) {
-      validation.warnings.push('DELETE command requires confirmation (confirm=true)');
-    }
-
-    if (verb === 'CHECK' && params.timeout && params.timeout < 0) {
-      validation.warnings.push('Timeout should be positive');
-    }
-
-    return validation;
+    return this.commandValidator.validateParameters(verb, resource, params);
   }
 
   /**
-   * Validate parameter type
+   * Validate parameter type (delegated to CommandValidator)
    * @param {*} value - Parameter value
    * @param {string} type - Expected type
    * @returns {boolean} - Whether type is valid
    */
   validateParameterType(value, type) {
-    switch (type) {
-      case 'boolean':
-        return typeof value === 'boolean' || value === true || value === false;
-      case 'number':
-        return !isNaN(Number(value));
-      case 'string':
-        return typeof value === 'string';
-      case 'array':
-        return Array.isArray(value);
-      default:
-        return true; // Unknown type, assume valid
-    }
+    return this.commandValidator.validateParameterType(value, type);
   }
 
   /**
-   * Initialize command mappings
+   * Initialize command mappings (delegated to CommandMapper)
    * @returns {Object} - Command map
    */
   initializeCommandMap() {
-    return {
-      'GET': 'GET',
-      'LIST': 'GET',
-      'POST': 'POST',
-      'CHECK': 'POST',
-      'PUT': 'PUT',
-      'UPDATE': 'PUT',
-      'DELETE': 'DELETE',
-      'REMOVE': 'DELETE',
-      'ENABLE': 'PUT',
-      'DISABLE': 'PUT',
-      'STATUS': 'GET',
-      'HELP': 'GET'
-    };
+    return this.commandMapper.initializeCommandMap();
   }
 
   /**
-   * Initialize shortcut mappings
+   * Initialize shortcut mappings (delegated to CommandMapper)
    * @returns {Object} - Shortcut map
    */
   initializeShortcutMap() {
-    return {
-      'LA': 'GET',      // List agents
-      'LI': 'GET',      // List agents
-      'CH': 'POST',     // Check agents
-      'CA': 'POST',     // Check agents
-      'GE': 'GET',      // Get agent
-      'UP': 'PUT',      // Update agent
-      'EN': 'PUT',      // Enable agent
-      'DI': 'PUT',      // Disable agent
-      'RE': 'DELETE',   // Remove agent
-      'RM': 'DELETE',   // Remove agent
-      'ST': 'GET',      // Status
-      'HE': 'GET'       // Help
-    };
+    return this.commandMapper.initializeShortcutMap();
   }
 
   /**
-   * Initialize parameter definitions
+   * Initialize parameter definitions (delegated to CommandValidator)
    * @returns {Object} - Parameter definitions
    */
   initializeParameterDefinitions() {
-    return {
-      'GET': {
-        'includeDisabled': { type: 'boolean', default: false },
-        'includeStatus': { type: 'boolean', default: true },
-        'includeLogs': { type: 'boolean', default: false },
-        'format': { type: 'string', validValues: ['table', 'json', 'csv'] },
-        'sort': { type: 'string', validValues: ['name', 'status', 'type', 'priority'] },
-        'status': { type: 'string' },
-        'limit': { type: 'number' },
-        'offset': { type: 'number' }
-      },
-      'POST': {
-        'agentIds': { type: 'array' },
-        'forceReinstall': { type: 'boolean', default: false },
-        'skipVerification': { type: 'boolean', default: false },
-        'timeout': { type: 'number', default: 300000 },
-        'parallel': { type: 'boolean', default: true },
-        'maxConcurrency': { type: 'number', default: 2 }
-      },
-      'PUT': {
-        'enabled': { type: 'boolean' },
-        'status': { type: 'string' },
-        'message': { type: 'string' }
-      },
-      'DELETE': {
-        'confirm': { type: 'boolean', required: true }
-      }
-    };
+    return this.commandValidator.initializeParameterDefinitions();
   }
 
   /**
-   * Get command suggestions
+   * Get command suggestions (delegated to CommandMapper)
    * @param {string} partial - Partial command
    * @returns {Array} - Suggestions
    */
   getSuggestions(partial) {
-    if (!partial) return [];
-
-    const normalized = this.caseSensitive ? partial : partial.toUpperCase();
-    const suggestions = [];
-
-    // Command suggestions
-    for (const [command, normalizedCommand] of Object.entries(this.commandMap)) {
-      if (normalizedCommand.startsWith(normalized)) {
-        suggestions.push({
-          type: 'command',
-          value: command,
-          description: this.getCommandDescription(command)
-        });
-      }
-    }
-
-    // Shortcut suggestions
-    if (this.allowShortcuts) {
-      for (const [shortcut, command] of Object.entries(this.shortcutMap)) {
-        if (shortcut.startsWith(normalized)) {
-          suggestions.push({
-            type: 'shortcut',
-            value: shortcut,
-            description: this.getCommandDescription(command)
-          });
-        }
-      }
-    }
-
-    return suggestions;
+    return this.commandMapper.getSuggestions(partial);
   }
 
   /**
-   * Get command description
+   * Get command description (delegated to CommandMapper)
    * @param {string} command - Command
    * @returns {string} - Description
    */
   getCommandDescription(command) {
-    const descriptions = {
-      'GET': 'Get agent or list agents',
-      'POST': 'Check agents',
-      'PUT': 'Update agent (enable/disable)',
-      'DELETE': 'Remove agent',
-      'LIST': 'List agents',
-      'CHECK': 'Check agents',
-      'ENABLE': 'Enable agent',
-      'DISABLE': 'Disable agent',
-      'REMOVE': 'Remove agent',
-      'STATUS': 'Get agent status',
-      'HELP': 'Show help'
-    };
-
-    return descriptions[command] || 'Unknown command';
+    return this.commandMapper.getCommandDescription(command);
   }
 
   /**

package/src/rui/commands/AgentResponseFormatter.js

@@ -426,56 +426,26 @@ class AgentResponseFormatter {
    */
   getStatusIcon(status) {
     const icons = {
-      'VERIFIED': '✅',
-      'INSTALLED': '📦',
-      'INSTALLING': '⏳',
-      'VERIFYING': '🔍',
-      'NOT_INSTALLED': '❌',
-      'ERROR': '🚫',
-      'RATE_LIMITED': '⏱️',
-      'DISABLED': '🚫'
+      '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'
+      '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'
+      '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';
   }
 
@@ -486,32 +456,22 @@ class AgentResponseFormatter {
    */
   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' };
   }