vibecodingmachine-cli 2026.2.26-1739 → 2026.3.9-850

package/bin/auth/auth-compliance.js

@@ -103,7 +103,13 @@ async function setupInteractiveAuth(dependencies) {
  */
 async function setupCommandAuth(dependencies, command, args) {
   const authCommands = ['auth:login', 'auth:logout', 'auth:status'];
-  const skipAuthCheck = authCommands.includes(command);
+  // Commands that don't need database access
+  const localCommands = [
+    'auth:login', 'auth:logout', 'auth:status',
+    'list', 'get', 'enable', 'disable', 'en', 'di', 'agents',
+    'trui', 'help', '--help', '-h', 'version', '--version', '-v'
+  ];
+  const skipAuthCheck = authCommands.includes(command) || localCommands.includes(command);
   
   await checkAuthentication(dependencies, skipAuthCheck);
   await checkCompliance(dependencies, skipAuthCheck);

package/bin/commands/agent-commands.js

@@ -4,89 +4,116 @@
 
 const { program } = require('commander');
 const chalk = require('chalk');
+const { getProviderDefinitions, getProviderPreferences, saveProviderPreferences } = require('../../src/utils/provider-registry');
 
 /**
  * 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 };
+  // Using provider registry instead of old agent system
+  return {
+    async executeCommand(verb, resource, options = {}) {
+      const definitions = getProviderDefinitions();
+      const prefs = await getProviderPreferences();
+      
+      switch (verb) {
+        case 'LIST':
+          return await this.handleListAgents(options);
+        case 'GET':
+          return await this.handleGetAgent(resource, options);
+        case 'ENABLE':
+          return await this.handleEnableAgent(resource);
+        case 'DISABLE':
+          return await this.handleDisableAgent(resource);
+        default:
+          throw new Error(`Unknown command: ${verb} ${resource}`);
+        }
+    },
+    
+    async handleListAgents(options = {}) {
+      const definitions = getProviderDefinitions();
+      const prefs = await getProviderPreferences();
+      
+      const agents = definitions.map(def => ({
+        id: def.id,
+        name: def.name,
+        enabled: prefs.enabled[def.id] !== false,
+        type: def.type,
+        status: 'Not installed',
+        lastChecked: 'Never'
+      }));
+      
+      return { success: true, agents };
+    },
+    
+    async handleGetAgent(agentId, options = {}) {
+      const definitions = getProviderDefinitions();
+      const prefs = await getProviderPreferences();
+      const agent = definitions.find(d => d.id === agentId);
+      
+      if (!agent) {
+        return { success: false, error: `Agent '${agentId}' not found` };
+      }
+      
+      return {
+        success: true,
+        agent: {
+          ...agent,
+          enabled: prefs.enabled[agentId] !== false
+        }
+      };
+    },
+    
+    async handleEnableAgent(agentId) {
+      const definitions = getProviderDefinitions();
+      const prefs = await getProviderPreferences();
+      
+      if (!definitions.find(d => d.id === agentId)) {
+        return { success: false, error: `Agent '${agentId}' not found` };
+      }
+      
+      const newEnabled = { ...prefs.enabled, [agentId]: true };
+      await saveProviderPreferences(prefs.order, newEnabled);
+      
+      return { success: true, message: `Agent '${agentId}' enabled` };
+    },
+    
+    async handleDisableAgent(agentId) {
+      const definitions = getProviderDefinitions();
+      const prefs = await getProviderPreferences();
+      
+      if (!definitions.find(d => d.id === agentId)) {
+        return { success: false, error: `Agent '${agentId}' not found` };
+      }
+      
+      const newEnabled = { ...prefs.enabled, [agentId]: false };
+      await saveProviderPreferences(prefs.order, newEnabled);
+      
+      return { success: true, message: `Agent '${agentId}' disabled` };
+    }
+  };
 }
 
 /**
  * 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);
-      }
-    });
+  // Create agent commands once and reuse
+  const agentCommands = createAgentCommands();
 
   // 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);
+        const result = await agentCommands.executeCommand('ENABLE', agentId);
+        if (result.success) {
+          console.log(chalk.green(result.message));
+        } else {
+          console.error(chalk.red(result.error));
+          process.exit(1);
         }
       } catch (error) {
         console.error(`Error enabling agent ${agentId}:`, error.message);
@@ -99,14 +126,13 @@ function setupAgentCommands() {
     .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);
+        const result = await agentCommands.executeCommand('DISABLE', agentId);
+        if (result.success) {
+          console.log(chalk.green(result.message));
+        } else {
+          console.error(chalk.red(result.error));
+          process.exit(1);
         }
       } catch (error) {
         console.error(`Error disabling agent ${agentId}:`, error.message);
@@ -114,197 +140,93 @@ function setupAgentCommands() {
       }
     });
 
-  // Remove agent command
+  // Add aliases for agent commands
   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();
-
+    .command('en <agent-id>')
+    .description('Alias for enable agents')
+    .action(async (agentId) => {
       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}`);
-          });
+        const result = await agentCommands.executeCommand('ENABLE', agentId);
+        if (result.success) {
+          console.log(chalk.green(result.message));
         } else {
-          console.log(`No logs found for agent ${agentId}`);
+          console.error(chalk.red(result.error));
+          process.exit(1);
         }
       } catch (error) {
-        console.error(`Error getting logs for agent ${agentId}:`, error.message);
+        console.error(`Error enabling 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();
-
+    .command('di <agent-id>')
+    .description('Alias for disable agents')
+    .action(async (agentId) => {
       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));
+        const result = await agentCommands.executeCommand('DISABLE', agentId);
+        if (result.success) {
+          console.log(chalk.green(result.message));
         } else {
-          console.log(JSON.stringify(formattedResponse.data || formattedResponse, null, 2));
+          console.error(chalk.red(result.error));
+          process.exit(1);
         }
       } catch (error) {
-        console.error(`Error getting agent ${agentId}:`, error.message);
+        console.error(`Error disabling agent ${agentId}:`, error.message);
         process.exit(1);
       }
     });
 
-  // Enable alias
+  // Add agents subcommand structure
   program
-    .command('en <agent-id>')
-    .description('Alias for "enable agents"')
-    .action(async (agentId) => {
-      const { agentCommands } = createAgentCommands();
-
+    .command('agents <agent-id> <action>')
+    .description('Manage agent (enable/disable)')
+    .action(async (agentId, action) => {
       try {
-        const result = await agentCommands.executeCommand('PUT', agentId, { enabled: true });
-        console.log(`Agent ${agentId} enabled successfully`);
-        
-        if (!result.success) {
-          console.error('Error:', result.error);
+        let result;
+        if (action === 'enable') {
+          result = await agentCommands.executeCommand('ENABLE', agentId);
+        } else if (action === 'disable') {
+          result = await agentCommands.executeCommand('DISABLE', agentId);
+        } else {
+          console.error(chalk.red(`Unknown action: ${action}. Use 'enable' or 'disable'`));
+          process.exit(1);
         }
-      } 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);
+        if (result.success) {
+          console.log(chalk.green(result.message));
+        } else {
+          console.error(chalk.red(result.error));
+          process.exit(1);
         }
       } catch (error) {
-        console.error(`Error disabling agent ${agentId}:`, error.message);
+        console.error(`Error ${action}ing agent ${agentId}:`, error.message);
         process.exit(1);
       }
     });
 
-  // Remove alias
+  // Add agents list command
   program
-    .command('re <agent-id>')
-    .description('Alias for "remove agents"')
-    .option('--confirm', 'Confirm removal without prompting')
-    .action(async (agentId, options) => {
-      const { agentCommands } = createAgentCommands();
-
+    .command('agents list')
+    .description('List all agents')
+    .action(async () => {
       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);
+        const result = await agentCommands.executeCommand('LIST', 'agents');
+        if (result.success && result.agents) {
+          console.log(chalk.blue('=== AGENTS ==='));
+          result.agents.forEach(agent => {
+            const status = agent.enabled ? '✓' : '✗';
+            console.log(`${status} ${agent.id.padEnd(12)} ${agent.name}`);
+          });
+        } else {
+          console.error(chalk.red('Failed to list agents'));
+          process.exit(1);
         }
       } catch (error) {
-        console.error(`Error removing agent ${agentId}:`, error.message);
+        console.error('Error listing agents:', error.message);
         process.exit(1);
       }
     });
 }
 
-module.exports = {
-  setupAgentCommands,
-  setupAgentAliases,
-  createAgentCommands
-};
+module.exports = { setupAgentCommands, createAgentCommands };

package/bin/commands/command-aliases.js

@@ -111,6 +111,74 @@ function setupCommandAliases() {
 
       await agentCommands.disableAgent(agentId);
     });
+
+  // Spec enable alias
+  program
+    .command('se <spec-id>')
+    .description('Alias for "specs:enable"')
+    .action(async (specId) => {
+      const EnableSpecCommand = require('../../src/commands/specs/enable');
+      const enableCommand = new EnableSpecCommand();
+      const result = await enableCommand.execute([specId]);
+      
+      if (result.success) {
+        console.log(`✅ ${result.message}`);
+      } else {
+        console.error(`❌ ${result.error}`);
+        process.exit(1);
+      }
+    });
+
+  // Spec disable alias
+  program
+    .command('sd <spec-id>')
+    .description('Alias for "specs:disable"')
+    .action(async (specId) => {
+      const DisableSpecCommand = require('../../src/commands/specs/disable');
+      const disableCommand = new DisableSpecCommand();
+      const result = await disableCommand.execute([specId]);
+      
+      if (result.success) {
+        console.log(`✅ ${result.message}`);
+      } else {
+        console.error(`❌ ${result.error}`);
+        process.exit(1);
+      }
+    });
+
+  // Requirement enable alias
+  program
+    .command('re <requirement-text...>')
+    .description('Alias for "requirements:enable"')
+    .action(async (requirementText) => {
+      const EnableRequirementCommand = require('../../src/commands/requirements/enable');
+      const enableCommand = new EnableRequirementCommand();
+      const result = await enableCommand.execute(requirementText);
+      
+      if (result.success) {
+        console.log(`✅ ${result.message}`);
+      } else {
+        console.error(`❌ ${result.error}`);
+        process.exit(1);
+      }
+    });
+
+  // Requirement disable alias
+  program
+    .command('rd <requirement-text...>')
+    .description('Alias for "requirements:disable"')
+    .action(async (requirementText) => {
+      const DisableRequirementCommand = require('../../src/commands/requirements/disable');
+      const disableCommand = new DisableRequirementCommand();
+      const result = await disableCommand.execute(requirementText);
+      
+      if (result.success) {
+        console.log(`✅ ${result.message}`);
+      } else {
+        console.error(`❌ ${result.error}`);
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {

package/bin/vibecodingmachine.js

@@ -21,7 +21,7 @@ const { promptWithDefaultsOnce } = require('../src/utils/prompt-helper');
 // Import modular components
 const { initializeEnvironment } = require('./init/environment-setup');
 const { configureCli, setupBasicCommands, setupRequirementsCommands, setupFeatureAndIdeCommands, setupStatusCommands, setupAuthCommands, setupComputerCommands, setupSyncCommands } = require('./config/cli-config');
-const { setupAgentCommands, setupAgentAliases } = require('./commands/agent-commands');
+const { setupAgentCommands } = require('./commands/agent-commands');
 const { setupRuiCommands } = require('./commands/rui-commands');
 const { checkForUpdates } = require('./update/update-checker');
 const { setupInteractiveAuth, setupCommandAuth } = require('./auth/auth-compliance');
@@ -36,7 +36,6 @@ setupAuthCommands({ t });
 setupComputerCommands({ t });
 setupSyncCommands({ t });
 setupAgentCommands({ t });
-setupAgentAliases({ t });
 setupRuiCommands({ t });
 
 // Start interactive mode if no command provided (check BEFORE parsing)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibecodingmachine-cli",
-  "version": "2026.02.26-1739",
+  "version": "2026.03.09-0850",
   "description": "Command-line interface for Vibe Coding Machine - Autonomous development",
   "main": "src/index.js",
   "bin": {
@@ -59,7 +59,7 @@
     "react": "^19.2.0",
     "screenshot-desktop": "^1.15.3",
     "table": "^6.8.1",
-    "vibecodingmachine-core": "^2026.02.26-1739"
+    "vibecodingmachine-core": "^2026.03.09-0850"
   },
   "devDependencies": {
     "eslint": "^8.57.0",