vibecodingmachine-cli 2026.2.20-436 → 2026.2.26-1642

package/bin/auth/auth-compliance.js

@@ -0,0 +1,126 @@
+/**
+ * Authentication and compliance checking
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Check authentication and handle login if needed
+ * @param {Object} dependencies - Dependencies for authentication
+ * @param {boolean} skipAuthCheck - Whether to skip authentication check
+ */
+async function checkAuthentication(dependencies, skipAuthCheck = false) {
+  const { t, errorReporter } = dependencies;
+  const auth = require('../../src/utils/auth');
+  
+  if (!skipAuthCheck) {
+    const isAuth = await auth.isAuthenticated();
+    
+    if (!isAuth) {
+      console.log(chalk.cyan(`\n🔐 ${t('cli.auth.opening.browser')}\n`));
+      try {
+        await auth.login();
+        console.log(chalk.green(`\n✓ ${t('cli.auth.success')}\n`));
+        
+        // Initialize error reporter with auth token
+        const token = await auth.getAuthToken();
+        if (token) {
+          errorReporter.setAuthToken(token);
+        }
+      } catch (error) {
+        console.log(chalk.red(`\n✗ ${t('cli.auth.failed')}:`), error.message);
+        process.exit(1);
+      }
+    } else {
+      // Initialize error reporter with existing auth token
+      const token = await auth.getAuthToken();
+      if (token) {
+        errorReporter.setAuthToken(token);
+      }
+    }
+  }
+}
+
+/**
+ * Check compliance and handle failure
+ * @param {Object} dependencies - Dependencies for compliance checking
+ * @param {boolean} skipComplianceCheck - Whether to skip compliance check
+ */
+async function checkCompliance(dependencies, skipComplianceCheck = false) {
+  const { t } = dependencies;
+  
+  if (!skipComplianceCheck) {
+    const { checkCompliance } = require('../../src/utils/compliance-check');
+    const isCompliant = await checkCompliance();
+    
+    if (!isCompliant) {
+      console.log(chalk.red(`\n✗ ${t('cli.compliance.failed')}\n`));
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Track CLI activity
+ * @param {string} activity - Activity type
+ * @param {Object} metadata - Additional metadata
+ */
+async function trackActivity(activity, metadata = {}) {
+  const auth = require('../../src/utils/auth');
+  try {
+    await auth.trackCLIActivity(activity, metadata);
+  } catch (error) {
+    // Don't block CLI if tracking fails
+    console.warn('Warning: Failed to track activity:', error.message);
+  }
+}
+
+/**
+ * Handle first run experience
+ * @param {Object} dependencies - Dependencies for first run
+ */
+async function handleFirstRun(dependencies) {
+  const { checkFirstRun } = require('../../src/utils/first-run');
+  await checkFirstRun();
+}
+
+/**
+ * Setup authentication and compliance for interactive mode
+ * @param {Object} dependencies - Dependencies for setup
+ */
+async function setupInteractiveAuth(dependencies) {
+  await checkAuthentication(dependencies);
+  await checkCompliance(dependencies);
+  await handleFirstRun(dependencies);
+  await trackActivity('interactive_mode_started');
+}
+
+/**
+ * Setup authentication and compliance for command execution
+ * @param {Object} dependencies - Dependencies for setup
+ * @param {string} command - Command being executed
+ * @param {Array} args - Command arguments
+ */
+async function setupCommandAuth(dependencies, command, args) {
+  const authCommands = ['auth:login', 'auth:logout', 'auth:status'];
+  const skipAuthCheck = authCommands.includes(command);
+  
+  await checkAuthentication(dependencies, skipAuthCheck);
+  await checkCompliance(dependencies, skipAuthCheck);
+  
+  if (!skipAuthCheck) {
+    await trackActivity('command_executed', {
+      command,
+      args: args.filter(arg => !arg.includes('password') && !arg.includes('token'))
+    });
+  }
+}
+
+module.exports = {
+  checkAuthentication,
+  checkCompliance,
+  trackActivity,
+  handleFirstRun,
+  setupInteractiveAuth,
+  setupCommandAuth
+};

package/bin/cli-program.js

@@ -0,0 +1,104 @@
+/**
+ * Main CLI program setup and configuration
+ */
+
+const { program } = require('commander');
+const path = require('path');
+const chalk = require('chalk');
+const { t, detectLocale, setLocale } = require('vibecodingmachine-core');
+const { promptWithDefaultsOnce } = require('../src/utils/prompt-helper');
+
+/**
+ * Setup main program configuration
+ */
+function setupProgram() {
+  // Detect which command was used (vcm or vibecodingmachine)
+  const commandName = path.basename(process.argv[1], '.js');
+  const packageJson = require('../package.json');
+
+  // Initialize locale detection
+  const detectedLocale = detectLocale();
+  setLocale(detectedLocale);
+
+  program
+    .name(commandName)
+    .usage(`[options] [command]\n\n  You can use '${commandName}' or '${altCommandName}'`)
+    .description(t('app.name') + ' CLI - Autonomous development')
+    .version(packageJson.version, '-v, --version', 'output the current version')
+    .helpOption('-h, --help', 'display help for command');
+
+  return { commandName, packageJson };
+}
+
+/**
+ * Setup remaining CLI commands (requirements, features, IDE, status)
+ */
+function setupOtherCommands() {
+  const reqCommands = require('../src/commands/requirements');
+  const featureCommands = require('../src/commands/feature');
+  const ideCommands = require('../src/commands/ide');
+  const statusCommands = require('../src/commands/status');
+
+  // Requirements commands
+  program
+    .command('requirements:add <requirement>')
+    .description('Add a new requirement')
+    .action(reqCommands.add);
+
+  program
+    .command('requirements:list')
+    .description('List all requirements')
+    .action(reqCommands.list);
+
+  program
+    .command('requirements:complete <requirement>')
+    .description('Mark requirement as complete')
+    .action(reqCommands.complete);
+
+  // Feature commands
+  program
+    .command('feature:create <name>')
+    .description('Create a new feature')
+    .action(featureCommands.create);
+
+  program
+    .command('feature:list')
+    .description('List all features')
+    .action(featureCommands.list);
+
+  // IDE commands
+  program
+    .command('ide:install <ide>')
+    .description('Install an IDE')
+    .action(ideCommands.install);
+
+  program
+    .command('ide:list')
+    .description('List available IDEs')
+    .action(ideCommands.list);
+
+  // Status commands
+  program
+    .command('status:show')
+    .description('Show current status')
+    .action(statusCommands.show);
+
+  program
+    .command('status:health')
+    .description('Check system health')
+    .action(statusCommands.health);
+}
+
+/**
+ * Parse and execute CLI arguments
+ */
+function runCLI() {
+  // Parse command line arguments
+  program.parse();
+}
+
+module.exports = {
+  setupProgram,
+  setupOtherCommands,
+  runCLI
+};

package/bin/cli-setup.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * CLI environment setup and initialization
+ */
+
+/**
+ * Auto-load .env.cognito from root
+ */
+function loadEnvironment() {
+  const rootDir = path.join(__dirname, '..', '..', '..');
+  const envCognitoPath = path.join(rootDir, '.env.cognito');
+
+  if (fs.existsSync(envCognitoPath)) {
+    const envContent = fs.readFileSync(envCognitoPath, 'utf8');
+    envContent.split('\n').forEach(line => {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#')) {
+        const [key, ...valueParts] = trimmed.split('=');
+        if (key && valueParts.length > 0) {
+          process.env[key.trim()] = valueParts.join('=').trim();
+        }
+      }
+    });
+  }
+}
+
+/**
+ * Setup CLI dependencies and cleanup
+ */
+async function setupCLI() {
+  // mitigate broken assets issue
+  const { cleanupBrokenAssets } = require('../src/utils/asset-cleanup');
+  await cleanupBrokenAssets();
+}
+
+/**
+ * Initialize CLI environment
+ */
+async function initializeCLI() {
+  loadEnvironment();
+  await setupCLI();
+}
+
+module.exports = {
+  loadEnvironment,
+  setupCLI,
+  initializeCLI
+};

package/bin/commands/agent-commands.js

@@ -0,0 +1,310 @@
+/**
+ * Agent management CLI commands
+ */
+
+const { program } = require('commander');
+const chalk = require('chalk');
+
+/**
+ * Create agent commands instance with required dependencies
+ * @returns {Object} Agent commands instance
+ */
+function createAgentCommands() {
+  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');
+
+  const agentCommands = new AgentCommands({
+    configManager: new AgentConfigManager(),
+    logger: new AgentLogger({ fileManager: new FileManager() }),
+    fileManager: new FileManager()
+  });
+
+  const responseFormatter = new AgentResponseFormatter({
+    defaultFormat: 'json',
+    includeTimestamp: true,
+    prettyPrint: true
+  });
+
+  return { agentCommands, responseFormatter };
+}
+
+/**
+ * Setup agent management commands
+ */
+function setupAgentCommands() {
+  // List agents command
+  program
+    .command('list agents')
+    .description('List all available agents')
+    .option('--format <format>', 'Output format (table, json, csv)')
+    .option('--include-disabled', 'Include disabled agents in list')
+    .option('--include-status', 'Include agent status information')
+    .option('--sort <field>', 'Sort by field (name, status, type)')
+    .option('--status <status>', 'Filter by agent status')
+    .action(async (options) => {
+      const { ListAgentsCommand } = require('../../src/commands/agents/list');
+      const listCommand = new ListAgentsCommand(options);
+      await listCommand.execute();
+    });
+
+  // Get agent details command
+  program
+    .command('get agents <agent-id>')
+    .description('Get detailed information about a specific agent')
+    .option('--include-status', 'Include agent status information')
+    .option('--include-logs', 'Include agent logs')
+    .action(async (agentId, options) => {
+      const { agentCommands, responseFormatter } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('GET', agentId, options);
+        const formattedResponse = responseFormatter.format(result, 'cli', options);
+        
+        if (options.format === 'json') {
+          console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, 2));
+        } else {
+          console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, 2));
+        }
+      } catch (error) {
+        console.error(`Error getting agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Enable agent command
+  program
+    .command('enable agents <agent-id>')
+    .description('Enable a specific agent')
+    .action(async (agentId) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('PUT', agentId, { enabled: true });
+        console.log(`Agent ${agentId} enabled successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error enabling agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Disable agent command
+  program
+    .command('disable agents <agent-id>')
+    .description('Disable a specific agent')
+    .action(async (agentId) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('PUT', agentId, { enabled: false });
+        console.log(`Agent ${agentId} disabled successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error disabling agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Remove agent command
+  program
+    .command('remove agents <agent-id>')
+    .description('Remove a specific agent')
+    .option('--confirm', 'Confirm removal without prompting')
+    .action(async (agentId, options) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('DELETE', agentId, { confirm: options.confirm });
+        console.log(`Agent ${agentId} removed successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error removing agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // View agent logs command
+  program
+    .command('logs agents <agent-id>')
+    .description('View logs for a specific agent')
+    .option('--limit <number>', 'Limit number of log entries')
+    .action(async (agentId, options) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('GET', agentId, { includeLogs: true, limit: options.limit });
+        
+        if (result.success && result.data && result.data.logs) {
+          console.log(`Logs for agent ${agentId}:`);
+          result.data.logs.forEach(log => {
+            console.log(`${log.timestamp} [${log.level.toUpperCase()}] ${log.message}`);
+          });
+        } else {
+          console.log(`No logs found for agent ${agentId}`);
+        }
+      } catch (error) {
+        console.error(`Error getting logs for agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Check agents command
+  program
+    .command('check agents')
+    .description('Ping all agents and show connection status')
+    .option('--provider <id>', 'Check a specific provider by ID')
+    .action(async (options) => {
+      const { checkAgents } = require('../../src/commands/agents-check');
+      await checkAgents(options);
+    });
+}
+
+/**
+ * Setup agent command aliases
+ */
+function setupAgentAliases() {
+  // List aliases
+  program
+    .command('la')
+    .description('Alias for "list agents"')
+    .action(async (options) => {
+      const { ListAgentsCommand } = require('../../src/commands/agents/list');
+      const listCommand = new ListAgentsCommand(options);
+      await listCommand.execute();
+    });
+
+  program
+    .command('li')
+    .description('Alias for "list agents"')
+    .action(async (options) => {
+      const { ListAgentsCommand } = require('../../src/commands/agents/list');
+      const listCommand = new ListAgentsCommand(options);
+      await listCommand.execute();
+    });
+
+  // Check aliases
+  program
+    .command('ch')
+    .description('Alias for "check agents"')
+    .action(async (options) => {
+      const { checkAgents } = require('../../src/commands/agents-check');
+      await checkAgents(options);
+    });
+
+  program
+    .command('ca')
+    .description('Alias for "check agents"')
+    .action(async (options) => {
+      const { checkAgents } = require('../../src/commands/agents-check');
+      await checkAgents(options);
+    });
+
+  program
+    .command('!/1')
+    .description('Check agents (shortcut for first agent)')
+    .action(async (options) => {
+      const { checkAgents } = require('../../src/commands/agents-check');
+      await checkAgents(options);
+    });
+
+  // Get alias
+  program
+    .command('ge <agent-id>')
+    .description('Alias for "get agents"')
+    .action(async (agentId, options) => {
+      const { agentCommands, responseFormatter } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('GET', agentId, options);
+        const formattedResponse = responseFormatter.format(result, 'cli', options);
+        
+        if (options.format === 'json') {
+          console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, 2));
+        } else {
+          console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, 2));
+        }
+      } catch (error) {
+        console.error(`Error getting agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Enable alias
+  program
+    .command('en <agent-id>')
+    .description('Alias for "enable agents"')
+    .action(async (agentId) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('PUT', agentId, { enabled: true });
+        console.log(`Agent ${agentId} enabled successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error enabling agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Disable alias
+  program
+    .command('di <agent-id>')
+    .description('Alias for "disable agents"')
+    .action(async (agentId) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('PUT', agentId, { enabled: false });
+        console.log(`Agent ${agentId} disabled successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error disabling agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+
+  // Remove alias
+  program
+    .command('re <agent-id>')
+    .description('Alias for "remove agents"')
+    .option('--confirm', 'Confirm removal without prompting')
+    .action(async (agentId, options) => {
+      const { agentCommands } = createAgentCommands();
+
+      try {
+        const result = await agentCommands.executeCommand('DELETE', agentId, { confirm: options.confirm });
+        console.log(`Agent ${agentId} removed successfully`);
+        
+        if (!result.success) {
+          console.error('Error:', result.error);
+        }
+      } catch (error) {
+        console.error(`Error removing agent ${agentId}:`, error.message);
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = {
+  setupAgentCommands,
+  setupAgentAliases,
+  createAgentCommands
+};

package/bin/commands/auto-commands.js

@@ -0,0 +1,70 @@
+/**
+ * Auto mode CLI commands
+ */
+
+const { program } = require('commander');
+const { t } = require('vibecodingmachine-core');
+
+/**
+ * Setup auto mode commands
+ * @param {Object} autoCommands - Auto command handlers
+ */
+function setupAutoCommands(autoCommands) {
+  // Auto mode commands
+  program
+    .command('auto:start')
+    .description(t('cli.auto.start'))
+    .option('-i, --ide <ide>', 'IDE to use (claude-code, aider, cursor, vscode, windsurf, cline)')
+    .option('--ide-model <model>', 'IDE agent/model to use (for IDE sub-agents like Windsurf/Antigravity)')
+    .option('--extension <extension>', 'VS Code extension to use (amazon-q, github-copilot, windsurf)')
+    .option('-m, --max-chats <number>', 'Maximum number of iterations', parseInt)
+    .option('-p, --provider <provider>', 'AI provider to use (claude, openai, groq, anthropic)')
+    .option('-n, --never-stop', 'Run indefinitely without stopping')
+    .option('-f, --force-provider-setup', 'Force provider selection even if already configured')
+    .option('--adaptive-timeout', 'Enable adaptive timeout calculation based on IDE performance')
+    .action(autoCommands.start);
+
+  // Direct LLM auto mode (new simplified implementation)
+  const { handleAutoStart: handleDirectAutoStart } = require('../../src/commands/auto-direct');
+  program
+    .command('auto:direct')
+    .description(t('cli.auto.direct'))
+    .option('-m, --max-chats <number>', 'Maximum number of iterations', parseInt)
+    .option('--provider <id>', 'Force a specific provider by ID (e.g. groq, anthropic, cursor)')
+    .action(handleDirectAutoStart);
+
+  program
+    .command('auto:stop')
+    .description(t('cli.auto.stop'))
+    .action(autoCommands.stop);
+
+  program
+    .command('auto:status')
+    .description(t('cli.auto.status'))
+    .action(autoCommands.status);
+
+  program
+    .command('auto:config')
+    .description(t('cli.auto.config'))
+    .option('--max-chats <number>', 'Set maximum chat iterations', parseInt)
+    .option('--never-stop', 'Enable never stop mode')
+    .option('--no-never-stop', 'Disable never stop mode')
+    .action(autoCommands.config);
+
+  program
+    .command('config:timeout [action] [key] [value]')
+    .description('Manage timeout configuration for adaptive timeouts')
+    .action((action, key, value) => {
+      const timeoutCommands = require('../../src/commands/timeout');
+      timeoutCommands.handleCommand([action, key, value]);
+    });
+
+  program
+    .command('auto:agents')
+    .description(t('cli.auto.agents'))
+    .action(autoCommands.listAgents);
+}
+
+module.exports = {
+  setupAutoCommands
+};