vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-cli",
-  "version": "2026.02.20-0438",
+  "version": "2026.02.26-1739",
   "description": "Command-line interface for Vibe Coding Machine - Autonomous development",
   "main": "src/index.js",
   "bin": {
@@ -20,6 +20,12 @@
     "build": "echo 'CLI package - no build step needed'",
     "test": "jest",
     "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:unit": "jest --testPathPattern=unit",
+    "test:integration": "jest --testPathPattern=integration",
+    "test:ci": "jest --ci --coverage --watchAll=false",
+    "test:regression": "../../scripts/run-regression-tests.sh",
+    "test:package": "../../scripts/test-package.sh",
     "lint": "eslint src/ --ext .js",
     "format": "prettier --write \"src/**/*.js\""
   },
@@ -53,7 +59,7 @@
     "react": "^19.2.0",
     "screenshot-desktop": "^1.15.3",
     "table": "^6.8.1",
-    "vibecodingmachine-core": "^2026.02.20-0438"
+    "vibecodingmachine-core": "^2026.02.26-1739"
   },
   "devDependencies": {
     "eslint": "^8.57.0",

package/src/commands/agents/add.js

@@ -0,0 +1,277 @@
+/**
+ * CLI Command: Add Agent
+ * 
+ * Implements "app add agent" command for CLI interface.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentAdditionService = require('../../../core/src/agents/AgentAdditionService');
+const AgentConfigManager = require('../../../core/src/agents/config/AgentConfigManager');
+const AgentLogger = require('../../../core/src/agents/logging/AgentLogger');
+const FileManager = require('../../../core/src/agents/storage/FileManager');
+const AgentCommands = require('../../../core/src/rui/commands/AgentCommands');
+const AgentResponseFormatter = require('../../../core/src/rui/commands/AgentResponseFormatter');
+
+/**
+ * CLI add agent command implementation
+ */
+class AddAgentCommand {
+  /**
+   * 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 addition service
+    this.additionService = new AgentAdditionService({
+      configManager: this.configManager,
+      logger: this.logger
+    });
+
+    // Initialize RUI components
+    this.agentCommands = new AgentCommands({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager
+    });
+
+    this.responseFormatter = new AgentResponseFormatter({
+      defaultFormat: 'json',
+      includeTimestamp: true,
+      prettyPrint: options.pretty !== false
+    });
+  }
+
+  /**
+   * Execute add agent command
+   * @param {Object} args - Command arguments
+   * @param {Object} options - Command options
+   * @returns {Object} - Command result
+   */
+  async execute(args = {}, options = {}) {
+    try {
+      const { agentConfig } = args;
+      const { validateOnly = false, format = 'json' } = options;
+
+      this.logger.info(`Executing add agent command: ${agentConfig?.id || 'unknown'}`);
+
+      // Validate agent configuration
+      if (!agentConfig) {
+        const error = 'Agent configuration is required';
+        this.logger.error(error);
+        return this.formatResponse({
+          success: false,
+          error
+        }, format);
+      }
+
+      // Check required fields
+      const requiredFields = ['id', 'name', 'description', 'installationMethods'];
+      const missingFields = requiredFields.filter(field => !agentConfig[field]);
+      
+      if (missingFields.length > 0) {
+        const error = `Missing required fields: ${missingFields.join(', ')}`;
+        this.logger.error(error);
+        return this.formatResponse({
+          success: false,
+          error,
+          missingFields
+        }, format);
+      }
+
+      // Validate only mode
+      if (validateOnly) {
+        const validation = this.additionService.validateAgentConfig(agentConfig);
+        return this.formatResponse({
+          success: validation.valid,
+          validation,
+          message: validation.valid ? 'Agent configuration is valid' : 'Agent configuration validation failed'
+        }, format);
+      }
+
+      // Add agent
+      const result = await this.additionService.addAgent(agentConfig);
+
+      // Log result
+      if (result.success) {
+        this.logger.info(`Successfully added agent: ${result.agentId}`);
+      } else {
+        this.logger.error(`Failed to add agent: ${result.error}`);
+      }
+
+      return this.formatResponse(result, format);
+
+    } catch (error) {
+      this.logger.error(`Add agent command failed: ${error.message}`);
+      return this.formatResponse({
+        success: false,
+        error: error.message
+      }, options.format);
+    }
+  }
+
+  /**
+   * Add agent from file
+   * @param {string} filePath - Path to agent configuration file
+   * @param {Object} options - Command options
+   * @returns {Object} - Command result
+   */
+  async addFromFile(filePath, options = {}) {
+    try {
+      this.logger.info(`Adding agent from file: ${filePath}`);
+
+      // Read configuration file
+      const fileContent = await this.fileManager.readFile(filePath);
+      const agentConfig = JSON.parse(fileContent);
+
+      // Execute add command
+      return this.execute({ agentConfig }, options);
+
+    } catch (error) {
+      this.logger.error(`Failed to add agent from file: ${error.message}`);
+      return this.formatResponse({
+        success: false,
+        error: `Failed to read or parse file: ${error.message}`
+      }, options.format);
+    }
+  }
+
+  /**
+   * Add agent interactively
+   * @param {Object} options - Command options
+   * @returns {Object} - Command result
+   */
+  async addInteractive(options = {}) {
+    try {
+      this.logger.info('Starting interactive agent addition');
+
+      // For now, return a message indicating interactive mode
+      // In a full implementation, this would prompt the user for details
+      return this.formatResponse({
+        success: false,
+        error: 'Interactive mode not yet implemented. Please provide agent configuration via file or command line.',
+        message: 'Use --file option to add agent from configuration file'
+      }, options.format);
+
+    } catch (error) {
+      this.logger.error(`Interactive add agent failed: ${error.message}`);
+      return this.formatResponse({
+        success: false,
+        error: error.message
+      }, options.format);
+    }
+  }
+
+  /**
+   * Validate agent configuration
+   * @param {Object} agentConfig - Agent configuration to validate
+   * @param {Object} options - Command options
+   * @returns {Object} - Validation result
+   */
+  async validateConfig(agentConfig, options = {}) {
+    try {
+      this.logger.info('Validating agent configuration');
+
+      const validation = this.additionService.validateAgentConfig(agentConfig);
+
+      return this.formatResponse({
+        success: validation.valid,
+        validation,
+        message: validation.valid ? 'Configuration is valid' : 'Configuration validation failed'
+      }, options.format);
+
+    } catch (error) {
+      this.logger.error(`Validation failed: ${error.message}`);
+      return this.formatResponse({
+        success: false,
+        error: error.message
+      }, options.format);
+    }
+  }
+
+  /**
+   * Check if agent ID is available
+   * @param {string} agentId - Agent ID to check
+   * @param {Object} options - Command options
+   * @returns {Object} - Availability result
+   */
+  async checkAvailability(agentId, options = {}) {
+    try {
+      this.logger.info(`Checking agent ID availability: ${agentId}`);
+
+      const result = await this.additionService.isAgentIdAvailable(agentId);
+
+      return this.formatResponse({
+        ...result,
+        message: result.available ? 
+          `Agent ID '${agentId}' is available` : 
+          `Agent ID '${agentId}' is already in use`
+      }, options.format);
+
+    } catch (error) {
+      this.logger.error(`Availability check failed: ${error.message}`);
+      return this.formatResponse({
+        success: false,
+        error: error.message
+      }, options.format);
+    }
+  }
+
+  /**
+   * Format response according to specified format
+   * @param {Object} data - Response data
+   * @param {string} format - Response format (json, table, etc.)
+   * @returns {Object} - Formatted response
+   */
+  formatResponse(data, format = 'json') {
+    return this.responseFormatter.format(data, format);
+  }
+
+  /**
+   * Get command help
+   * @returns {Object} - Help information
+   */
+  getHelp() {
+    return {
+      name: 'add-agent',
+      description: 'Add a new agent to the system',
+      usage: [
+        'app add agent --config <json>',
+        'app add agent --file <path>',
+        'app add agent --interactive',
+        'app add agent --validate-only --config <json>',
+        'app add agent --check-availability <agent-id>'
+      ],
+      options: {
+        '--config': 'Agent configuration as JSON string',
+        '--file': 'Path to agent configuration file',
+        '--interactive': 'Interactive agent addition',
+        '--validate-only': 'Validate configuration without adding',
+        '--check-availability': 'Check if agent ID is available',
+        '--format': 'Output format (json, table)',
+        '--pretty': 'Pretty print JSON output'
+      },
+      examples: [
+        {
+          command: 'app add agent --config \'{"id":"new-agent","name":"New Agent","description":"A new AI agent","installationMethods":[{"type":"WINGET","command":"winget install NewAgent","priority":1]}}\'',
+          description: 'Add agent with inline configuration'
+        },
+        {
+          command: 'app add agent --file ./agent-config.json',
+          description: 'Add agent from configuration file'
+        },
+        {
+          command: 'app add agent --validate-only --config \'{"id":"test-agent","name":"Test Agent","description":"Test agent","installationMethods":[]}\'',
+          description: 'Validate agent configuration without adding'
+        }
+      ]
+    };
+  }
+}
+
+module.exports = AddAgentCommand;

package/src/commands/agents/check.js

@@ -0,0 +1,380 @@
+/**
+ * CLI Command: Check Agents
+ * 
+ * Implements "app check agents" command for CLI interface.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentCheckService = require('../../packages/core/src/agents/AgentCheckService');
+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 AgentCommands = require('../../packages/core/src/rui/commands/AgentCommands');
+const AgentResponseFormatter = require('../../packages/core/src/rui/commands/AgentResponseFormatter');
+
+/**
+ * CLI check agents command implementation
+ */
+class CheckAgentsCommand {
+  /**
+   * 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 check service
+    this.checkService = AgentCheckService.createDefault({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager
+    });
+
+    // Initialize RUI components
+    this.agentCommands = new AgentCommands({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager
+    });
+
+    this.responseFormatter = new AgentResponseFormatter({
+      defaultFormat: 'json',
+      includeTimestamp: true,
+      prettyPrint: options.pretty !== false
+    });
+  }
+
+  /**
+   * Execute check 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 { 
+      agentIds = null, 
+      force = false, 
+      skipVerification = false, 
+      timeout = 600000,
+      parallel = true,
+      maxConcurrency = 2,
+      verbose = false,
+      json = false,
+      format = 'table'
+    } = this.parseArguments(args, options);
+
+    try {
+      // Load configuration
+      await this.configManager.load();
+      
+      if (verbose) {
+        console.log('Starting agent check operation');
+        console.log('Options:', { agentIds, force, skipVerification, timeout, parallel, maxConcurrency });
+      }
+
+      // Execute using RUI pattern
+      const ruiResult = await this.agentCommands.executeCommand('CHECK', 'agents', {
+        agentIds,
+        forceReinstall: force,
+        skipVerification,
+        timeout,
+        parallel,
+        maxConcurrency
+      });
+
+      // Format response for CLI
+      const formattedResponse = this.responseFormatter.format(ruiResult, 'cli', {
+        format: json ? 'json' : format,
+        verbose
+      });
+
+      // Output results
+      if (json) {
+        console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, this.responseFormatter.prettyPrint ? 2 : 0));
+      } else {
+        this.outputResults(formattedResponse, verbose);
+      }
+
+      return {
+        success: ruiResult.success,
+        results: ruiResult.data,
+        formatted: formattedResponse,
+        message: ruiResult.success ? 'All agents checked successfully' : 'Some agent checks failed'
+      };
+    } catch (error) {
+      const errorMessage = `Agent check failed: ${error.message}`;
+      
+      if (verbose) {
+        console.error(errorMessage);
+        console.error(error.stack);
+      } else {
+        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 = {
+      agentIds: options.agentIds || null,
+      force: options.force || false,
+      skipVerification: options.skipVerification || false,
+      timeout: options.timeout || 600000,
+      parallel: options.parallel !== false,
+      maxConcurrency: options.maxConcurrency || 2,
+      verbose: options.verbose || false,
+      json: options.json || false
+    };
+
+    // Parse command line arguments
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      
+      switch (arg) {
+        case '--force':
+        case '-f':
+          parsed.force = true;
+          break;
+          
+        case '--skip-verification':
+        case '-s':
+          parsed.skipVerification = true;
+          break;
+          
+        case '--sequential':
+          parsed.parallel = false;
+          parsed.maxConcurrency = 1;
+          break;
+          
+        case '--verbose':
+        case '-v':
+          parsed.verbose = true;
+          break;
+          
+        case '--json':
+        case '-j':
+          parsed.json = true;
+          break;
+          
+        case '--timeout':
+          if (i + 1 < args.length) {
+            const timeout = parseInt(args[i + 1]);
+            if (!isNaN(timeout) && timeout > 0) {
+              parsed.timeout = timeout * 1000; // Convert seconds to milliseconds
+              i++; // Skip the next argument (timeout value)
+            }
+          }
+          break;
+          
+        case '--max-concurrency':
+          if (i + 1 < args.length) {
+            const concurrency = parseInt(args[i + 1]);
+            if (!isNaN(concurrency) && concurrency > 0) {
+              parsed.maxConcurrency = concurrency;
+              i++; // Skip the next argument (concurrency value)
+            }
+          }
+          break;
+          
+        case '--agents':
+          if (i + 1 < args.length) {
+            const agentList = args[i + 1].split(',').map(id => id.trim());
+            parsed.agentIds = agentList;
+            i++; // Skip the next argument (agent list)
+          }
+          break;
+          
+        default:
+          // Handle positional arguments (agent IDs)
+          if (!arg.startsWith('-')) {
+            if (!parsed.agentIds) {
+              parsed.agentIds = [];
+            }
+            parsed.agentIds.push(arg);
+          }
+          break;
+      }
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Output results to console
+   * @param {Object} formattedResponse - Formatted response object
+   * @param {boolean} verbose - Verbose output
+   */
+  outputResults(formattedResponse, verbose = false) {
+    const data = formattedResponse.data || formattedResponse;
+    
+    if (verbose) {
+      console.log('\n=== DETAILED RESULTS ===');
+      if (data.summary) {
+        console.log('Summary:', data.summary);
+      }
+      if (data.installationResults) {
+        console.log('Installation results:', Object.keys(data.installationResults).length);
+      }
+      if (data.verificationResults) {
+        console.log('Verification results:', Object.keys(data.verificationResults).length);
+      }
+      console.log('Overall success:', formattedResponse.success);
+      console.log('Duration:', data.duration ? `${(data.duration / 1000).toFixed(2)}s` : 'Unknown');
+    }
+
+    // Summary output
+    console.log('\n=== AGENT CHECK SUMMARY ===');
+    if (data.summary) {
+      console.log(`Total agents: ${data.summary.total || 0}`);
+      console.log(`Successful: ${data.summary.successful || 0}`);
+      console.log(`Failed: ${data.summary.failed || 0}`);
+      console.log(`Skipped: ${data.summary.skipped || 0}`);
+      console.log(`Duration: ${data.duration ? `${(data.duration / 1000).toFixed(2)}s` : 'Unknown'}`);
+    }
+
+    // Installation results
+    if (data.installationResults && Object.keys(data.installationResults).length > 0) {
+      console.log('\n=== INSTALLATION RESULTS ===');
+      for (const [agentId, result] of Object.entries(data.installationResults)) {
+        const status = result.success ? '✅' : '❌';
+        console.log(`${status} ${agentId}: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+        if (!result.success && result.error) {
+          console.log(`   Error: ${result.error}`);
+        }
+        if (result.duration) {
+          console.log(`   Duration: ${(result.duration / 1000).toFixed(2)}s`);
+        }
+      }
+    }
+
+    // Verification results
+    if (data.verificationResults && Object.keys(data.verificationResults).length > 0) {
+      console.log('\n=== VERIFICATION RESULTS ===');
+      for (const [agentId, result] of Object.entries(data.verificationResults)) {
+        const status = result.success ? '✅' : '❌';
+        console.log(`${status} ${agentId}: ${result.success ? 'VERIFIED' : 'FAILED'}`);
+        if (!result.success && result.error) {
+          console.log(`   Error: ${result.error}`);
+        }
+        if (result.duration) {
+          console.log(`   Duration: ${(result.duration / 1000).toFixed(2)}s`);
+        }
+        if (result.result && result.result.summary) {
+          console.log(`   Tests: ${result.result.summary.allPassed ? 'All passed' : 'Some failed'}`);
+          console.log(`   Passed: ${result.result.summary.allPassed ? result.result.summary.passed : result.result.summary.passed}/${result.result.summary.totalTests}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Show help information
+   */
+  showHelp() {
+    console.log('\n=== CHECK AGENTS COMMAND ===');
+    console.log('Description: Check and install/verify agents on Windows');
+    console.log('');
+    console.log('Usage: app check agents [options] [agent-ids...]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --force, -f              Force reinstall even if already installed');
+    console.log('  --skip-verification, -s  Skip verification step');
+    console.log('  --sequential              Run operations sequentially (default: parallel)');
+    console.log('  --max-concurrency <n>     Maximum concurrent operations (default: 2)');
+    console.log('  --timeout <seconds>       Timeout for entire operation (default: 600)');
+    console.log('  --agents <ids>           Specific agent IDs to check (comma-separated)');
+    console.log('  --verbose, -v            Show detailed output');
+    console.log('  --json, -j              Output results in JSON format');
+    console.log('');
+    console.log('Examples:');
+    console.log('  app check agents');
+    console.log('  app check agents --force');
+    console.log('  app check agents --agents claude-code,github-copilot');
+    console.log('  app check agents --sequential --timeout 300');
+    console.log('  app check agents --verbose --json');
+  }
+
+  /**
+   * Get command information
+   * @returns {Object} - Command info
+   */
+  getCommandInfo() {
+    return {
+      name: 'check-agents',
+      description: 'Check and install/verify agents on Windows',
+      usage: 'app check agents [options] [agent-ids...]',
+      examples: [
+        'app check agents',
+        'app check agents --force',
+        'app check agents --agents claude-code,github-copilot',
+        'app check agents --sequential --timeout 300',
+        'app check agents --verbose --json'
+      ],
+      options: [
+        {
+          flag: '--force, -f',
+          description: 'Force reinstall even if already installed'
+        },
+        {
+          flag: '--skip-verification, -s',
+          description: 'Skip verification step'
+        },
+        {
+          flag: '--sequential',
+          description: 'Run operations sequentially (default: parallel)'
+        },
+        {
+          flag: '--max-concurrency <n>',
+          description: 'Maximum concurrent operations (default: 2)'
+        },
+        {
+          flag: '--timeout <seconds>',
+          description: 'Timeout for entire operation (default: 600)'
+        },
+        {
+          flag: '--agents <ids>',
+          description: 'Specific agent IDs to check (comma-separated)'
+        },
+        {
+          flag: '--verbose, -v',
+          description: 'Show detailed output'
+        },
+        {
+          flag: '--json, -j',
+          description: 'Output results in JSON format'
+        }
+      ]
+    };
+  }
+}
+
+/**
+ * Execute check 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 CheckAgentsCommand(options);
+  return await command.execute(args, options);
+}
+
+module.exports = {
+  execute,
+  CheckAgentsCommand
+};