vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/requirements.js

@@ -3,7 +3,7 @@ const fs = require('fs-extra');
 const chalk = require('chalk');
 const chokidar = require('chokidar');
 const { getRepoPath, setRepoPath } = require('../utils/config');
-const { getRequirementsPath } = require('vibecodingmachine-core');
+const { getRequirementsPath, DefaultRequirementManager, JSONStorage } = require('vibecodingmachine-core');
 
 async function getReqPathOrExit() {
   let repoPath = await getRepoPath();
@@ -478,6 +478,297 @@ async function numberAll() {
   }
 }
 
+// Default Requirement Management Functions
+
+/**
+ * Create a new default requirement
+ */
+async function createDefault(title, options = {}) {
+  const { description, maxIterations } = options;
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  if (!title) {
+    console.log(chalk.red('✗ Title is required'));
+    console.log(chalk.gray('Usage: vcm req:default create "Title" --description "Description" --max-iterations 10'));
+    return;
+  }
+
+  if (!description) {
+    console.log(chalk.red('✗ Description is required'));
+    console.log(chalk.gray('Usage: vcm req:default create "Title" --description "Description" --max-iterations 10'));
+    return;
+  }
+
+  const iterations = maxIterations || 10;
+  
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const requirement = await manager.create({
+      title: title.trim(),
+      description: description.trim(),
+      maxIterations: iterations
+    });
+
+    console.log(chalk.bold.green('✅ Default requirement created'));
+    console.log(chalk.cyan(`  Title: ${requirement.title}`));
+    console.log(chalk.cyan(`  Description: ${requirement.description}`));
+    console.log(chalk.cyan(`  Max Iterations: ${requirement.maxIterations}`));
+    console.log(chalk.cyan(`  Status: ${requirement.status}`));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to create default requirement:'), error.message);
+  }
+}
+
+/**
+ * Edit existing default requirement
+ */
+async function editDefault(options = {}) {
+  const { title, description, maxIterations } = options;
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  if (!title && !description && !maxIterations) {
+    console.log(chalk.red('✗ At least one field to update is required'));
+    console.log(chalk.gray('Usage: vcm req:default edit --title "New Title" --description "New Description" --max-iterations 20'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const updates = {};
+    if (title !== undefined) updates.title = title.trim();
+    if (description !== undefined) updates.description = description.trim();
+    if (maxIterations !== undefined) updates.maxIterations = maxIterations;
+    
+    const requirement = await manager.edit(updates);
+
+    console.log(chalk.bold.green('✅ Default requirement updated'));
+    console.log(chalk.cyan(`  Title: ${requirement.title}`));
+    console.log(chalk.cyan(`  Description: ${requirement.description}`));
+    console.log(chalk.cyan(`  Max Iterations: ${requirement.maxIterations}`));
+    console.log(chalk.cyan(`  Status: ${requirement.status}`));
+    if (requirement.updatedAt) {
+      console.log(chalk.gray(`  Updated: ${new Date(requirement.updatedAt).toLocaleString()}`));
+    }
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to edit default requirement:'), error.message);
+  }
+}
+
+/**
+ * Delete default requirement
+ */
+async function deleteDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const status = await manager.getStatus();
+    if (!status) {
+      console.log(chalk.yellow('⚠️  No default requirement exists'));
+      return;
+    }
+
+    console.log(chalk.bold.yellow(`Deleting default requirement: ${status.title}`));
+    
+    await manager.delete();
+
+    console.log(chalk.bold.green('✅ Default requirement deleted'));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to delete default requirement:'), error.message);
+  }
+}
+
+/**
+ * Show current default requirement status
+ */
+async function showDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const status = await manager.getStatus();
+    if (!status) {
+      console.log(chalk.yellow('⚠️  No default requirement exists'));
+      console.log(chalk.gray('Create one with: vcm req:default create "Title" --description "Description" --max-iterations 10'));
+      console.log();
+      return;
+    }
+
+    const statistics = await manager.getStatistics();
+    
+    console.log(chalk.bold.cyan('📋 Default Requirement Status'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.cyan(`Title: ${status.title}`));
+    console.log(chalk.cyan(`Description: ${status.description}`));
+    console.log(chalk.cyan(`Status: ${status.status}`));
+    console.log(chalk.cyan(`Iterations: ${status.iterationCount}/${status.maxIterations}`));
+    console.log(chalk.cyan(`Consecutive Failures: ${status.consecutiveFailures}`));
+    
+    if (statistics) {
+      console.log(chalk.cyan(`Completion: ${statistics.completionPercentage}%`));
+      console.log(chalk.cyan(`Age: ${statistics.ageHours}h`));
+      if (statistics.iterationsPerHour > 0) {
+        console.log(chalk.cyan(`Rate: ${statistics.iterationsPerHour} iterations/hour`));
+      }
+    }
+    
+    if (status.createdAt) {
+      console.log(chalk.gray(`Created: ${new Date(status.createdAt).toLocaleString()}`));
+    }
+    if (status.lastIterationAt) {
+      console.log(chalk.gray(`Last iteration: ${new Date(status.lastIterationAt).toLocaleString()}`));
+    }
+    if (status.pausedAt) {
+      console.log(chalk.yellow(`Paused: ${new Date(status.pausedAt).toLocaleString()}`));
+    }
+    if (status.resumedAt) {
+      console.log(chalk.green(`Resumed: ${new Date(status.resumedAt).toLocaleString()}`));
+    }
+    if (status.completedAt) {
+      console.log(chalk.green(`Completed: ${new Date(status.completedAt).toLocaleString()}`));
+      console.log(chalk.green(`Reason: ${status.completionReason}`));
+    }
+    
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to get default requirement status:'), error.message);
+  }
+}
+
+/**
+ * Pause default requirement
+ */
+async function pauseDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const status = await manager.getStatus();
+    if (!status) {
+      console.log(chalk.yellow('⚠️  No default requirement exists'));
+      return;
+    }
+
+    if (status.status === 'PAUSED') {
+      console.log(chalk.yellow('⚠️  Default requirement is already paused'));
+      return;
+    }
+
+    await manager.pause();
+
+    console.log(chalk.bold.green('✅ Default requirement paused'));
+    console.log(chalk.cyan(`  Title: ${status.title}`));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to pause default requirement:'), error.message);
+  }
+}
+
+/**
+ * Resume default requirement
+ */
+async function resumeDefault() {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const status = await manager.getStatus();
+    if (!status) {
+      console.log(chalk.yellow('⚠️  No default requirement exists'));
+      return;
+    }
+
+    if (status.status === 'ACTIVE') {
+      console.log(chalk.yellow('⚠️  Default requirement is already active'));
+      return;
+    }
+
+    await manager.resume();
+
+    console.log(chalk.bold.green('✅ Default requirement resumed'));
+    console.log(chalk.cyan(`  Title: ${status.title}`));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to resume default requirement:'), error.message);
+  }
+}
+
+/**
+ * Set max iterations for default requirement
+ */
+async function setMaxIterations(maxIterations) {
+  const repoPath = await getRepoPath();
+  
+  if (!repoPath) {
+    console.log(chalk.red('✗ No repository configured'));
+    return;
+  }
+
+  if (!maxIterations || maxIterations < 1 || maxIterations > 1000) {
+    console.log(chalk.red('✗ Max iterations must be between 1 and 1000'));
+    return;
+  }
+
+  try {
+    const storage = new JSONStorage();
+    const manager = new DefaultRequirementManager(storage);
+    
+    const requirement = await manager.edit({ maxIterations });
+
+    console.log(chalk.bold.green('✅ Max iterations updated'));
+    console.log(chalk.cyan(`  Max Iterations: ${requirement.maxIterations}`));
+    console.log(chalk.cyan(`  Current Iterations: ${requirement.iterationCount}`));
+    console.log();
+  } catch (error) {
+    console.log(chalk.red('✗ Failed to set max iterations:'), error.message);
+  }
+}
+
 module.exports = {
   list,
   add,
@@ -487,7 +778,15 @@ module.exports = {
   edit,
   watch,
   rename,
-  numberAll
+  numberAll,
+  // Default requirement commands
+  createDefault,
+  editDefault,
+  delete: deleteDefault,
+  showDefault,
+  pauseDefault,
+  resumeDefault,
+  setMaxIterations
 };
 
 

package/src/commands/timeout.js

@@ -0,0 +1,290 @@
+/**
+ * Timeout Configuration Command
+ * 
+ * Manages adaptive timeout settings for autonomous mode
+ * Part of User Story 3: Adaptive Timeout Management
+ */
+
+const chalk = require('chalk');
+const { getTimeoutConfig, setTimeoutConfig, resetTimeoutConfig, DEFAULT_TIMEOUT_CONFIG } = require('../utils/config');
+const { TimeoutCalculator } = require('vibecodingmachine-core');
+
+/**
+ * Display current timeout configuration
+ */
+async function showConfig() {
+  try {
+    const config = await getTimeoutConfig();
+    
+    console.log(chalk.cyan('\n🕐 Timeout Configuration\n'));
+    
+    // Mode
+    const modeIcon = config.mode === 'adaptive' ? '🔄' : '⏱️';
+    console.log(`${modeIcon} Mode: ${chalk.bold(config.mode)}`);
+    
+    // Timeouts
+    console.log(`⏱️  Default: ${chalk.bold(formatDuration(config.defaultTimeout))}`);
+    console.log(`⏱️  Minimum: ${chalk.bold(formatDuration(config.minTimeout))}`);
+    console.log(`⏱️  Maximum: ${chalk.bold(formatDuration(config.maxTimeout))}`);
+    
+    // Adaptive settings
+    if (config.mode === 'adaptive') {
+      console.log(`📊 Buffer: ${chalk.bold(config.bufferPercentage * 100)}%`);
+      console.log(`📈 EWMA Alpha: ${chalk.bold(config.ewmaAlpha)}`);
+      console.log(`📋 Min Samples: ${chalk.bold(config.minSamples)}`);
+    }
+    
+    console.log();
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to get timeout configuration:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Set timeout configuration
+ */
+async function setConfig(key, value) {
+  try {
+    const currentConfig = await getTimeoutConfig();
+    let newConfig = { ...currentConfig };
+    
+    switch (key) {
+      case 'mode':
+        if (!['fixed', 'adaptive'].includes(value)) {
+          console.error(chalk.red('✗ Invalid mode. Use: fixed or adaptive'));
+          process.exit(1);
+        }
+        newConfig.mode = value;
+        break;
+        
+      case 'default':
+        newConfig.defaultTimeout = parseDuration(value);
+        break;
+        
+      case 'minimum':
+        newConfig.minTimeout = parseDuration(value);
+        break;
+        
+      case 'maximum':
+        newConfig.maxTimeout = parseDuration(value);
+        break;
+        
+      case 'buffer':
+        const bufferPercent = parseFloat(value);
+        if (isNaN(bufferPercent) || bufferPercent < 0 || bufferPercent > 200) {
+          console.error(chalk.red('✗ Buffer percentage must be between 0 and 200'));
+          process.exit(1);
+        }
+        newConfig.bufferPercentage = bufferPercent / 100;
+        break;
+        
+      case 'ewma':
+        const alpha = parseFloat(value);
+        if (isNaN(alpha) || alpha < 0 || alpha > 1) {
+          console.error(chalk.red('✗ EWMA alpha must be between 0 and 1'));
+          process.exit(1);
+        }
+        newConfig.ewmaAlpha = alpha;
+        break;
+        
+      case 'samples':
+        const samples = parseInt(value);
+        if (isNaN(samples) || samples < 1) {
+          console.error(chalk.red('✗ Minimum samples must be a positive integer'));
+          process.exit(1);
+        }
+        newConfig.minSamples = samples;
+        break;
+        
+      default:
+        console.error(chalk.red(`✗ Unknown setting: ${key}`));
+        console.log(chalk.yellow('Available settings: mode, default, minimum, maximum, buffer, ewma, samples'));
+        process.exit(1);
+    }
+    
+    await setTimeoutConfig(newConfig);
+    console.log(chalk.green(`✓ Timeout configuration updated: ${key} = ${value}`));
+    
+    // Show updated config
+    await showConfig();
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to set timeout configuration:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Reset timeout configuration to defaults
+ */
+async function resetConfig() {
+  try {
+    await resetTimeoutConfig();
+    console.log(chalk.green('✓ Timeout configuration reset to defaults'));
+    await showConfig();
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to reset timeout configuration:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Test timeout calculation with sample data
+ */
+async function testConfig(ideId) {
+  try {
+    const config = await getTimeoutConfig();
+    
+    console.log(chalk.cyan(`\n🧪 Testing Timeout Calculation for ${chalk.bold(ideId)}\n`));
+    
+    // Generate sample response times based on IDE performance characteristics
+    const sampleTimes = generateSampleTimes(ideId);
+    
+    if (sampleTimes.length === 0) {
+      console.log(chalk.yellow('⚠️  No historical data available for testing'));
+      console.log(chalk.gray('Run some autonomous tasks first to generate response time data'));
+      return;
+    }
+    
+    console.log(chalk.gray('Sample response times:'));
+    sampleTimes.forEach((time, index) => {
+      console.log(`  ${index + 1}. ${formatDuration(time)}`);
+    });
+    
+    // Calculate timeout using current configuration
+    const timeoutResult = TimeoutCalculator.calculateTimeout(sampleTimes, {
+      defaultTimeout: config.defaultTimeout,
+      minTimeout: config.minTimeout,
+      maxTimeout: config.maxTimeout,
+      bufferPercentage: config.bufferPercentage
+    });
+    
+    console.log(chalk.green(`\n📊 Calculated timeout: ${chalk.bold(formatDuration(timeoutResult.timeout))}`));
+    console.log(chalk.gray(`Based on ${sampleTimes.length} samples with ${config.bufferPercentage * 100}% buffer`));
+    
+    if (timeoutResult.outliersRemoved > 0) {
+      console.log(chalk.yellow(`⚠️  Removed ${timeoutResult.outliersRemoved} outliers from calculation`));
+    }
+    
+    console.log();
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to test timeout configuration:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+function formatDuration(ms) {
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+/**
+ * Parse duration string to milliseconds
+ */
+function parseDuration(str) {
+  const match = str.match(/^(\d+)([smh])$/);
+  if (!match) {
+    console.error(chalk.red('✗ Invalid duration format. Use: 30s, 5m, 1h'));
+    process.exit(1);
+  }
+  
+  const value = parseInt(match[1]);
+  const unit = match[2];
+  
+  switch (unit) {
+    case 's': return value * 1000;
+    case 'm': return value * 60 * 1000;
+    case 'h': return value * 60 * 60 * 1000;
+    default: return value * 1000;
+  }
+}
+
+/**
+ * Generate sample response times for testing
+ */
+function generateSampleTimes(ideId) {
+  // Simulate different IDE performance characteristics
+  const profiles = {
+    'claude-code': [2, 3, 2, 4, 3, 2, 3, 5, 2, 3].map(x => x * 60 * 1000), // 2-5 minutes
+    'cline': [3, 4, 3, 5, 4, 3, 4, 6, 3, 4].map(x => x * 60 * 1000), // 3-6 minutes
+    'cursor': [4, 5, 4, 6, 5, 4, 5, 7, 4, 5].map(x => x * 60 * 1000), // 4-7 minutes
+    'windsurf': [5, 6, 5, 7, 6, 5, 6, 8, 5, 6].map(x => x * 60 * 1000), // 5-8 minutes
+    'antigravity': [3, 4, 3, 5, 4, 3, 4, 6, 3, 4].map(x => x * 60 * 1000), // 3-6 minutes
+  };
+  
+  return profiles[ideId] || profiles['claude-code'];
+}
+
+/**
+ * Main command handler
+ */
+async function handleCommand(args) {
+  const [action, ...restArgs] = args;
+  
+  switch (action) {
+    case 'show':
+      await showConfig();
+      break;
+      
+    case 'set':
+      if (restArgs.length !== 2) {
+        console.error(chalk.red('✗ Usage: vcm config:timeout set <key> <value>'));
+        console.log(chalk.yellow('Available keys: mode, default, minimum, maximum, buffer, ewma, samples'));
+        process.exit(1);
+      }
+      await setConfig(restArgs[0], restArgs[1]);
+      break;
+      
+    case 'reset':
+      await resetConfig();
+      break;
+      
+    case 'test':
+      if (restArgs.length !== 1) {
+        console.error(chalk.red('✗ Usage: vcm config:timeout test <ide-id>'));
+        console.log(chalk.yellow('Available IDEs: claude-code, cline, cursor, windsurf, antigravity'));
+        process.exit(1);
+      }
+      await testConfig(restArgs[0]);
+      break;
+      
+    default:
+      console.log(chalk.cyan('Timeout Configuration Command\n'));
+      console.log(chalk.gray('Manages adaptive timeout settings for autonomous mode\n'));
+      console.log();
+      console.log(chalk.bold('Usage:'));
+      console.log('  vcm config:timeout show                    Show current configuration');
+      console.log('  vcm config:timeout set <key> <value>      Set a configuration value');
+      console.log('  vcm config:timeout reset                  Reset to defaults');
+      console.log('  vcm config:timeout test <ide-id>          Test timeout calculation');
+      console.log();
+      console.log(chalk.bold('Settings:'));
+      console.log('  mode        fixed | adaptive               Timeout mode');
+      console.log('  default     30s | 5m | 1h                 Default timeout');
+      console.log('  minimum     5s | 1m | 30m                Minimum timeout');
+      console.log('  maximum     10m | 30m | 2h               Maximum timeout');
+      console.log('  buffer      0-200                        Buffer percentage');
+      console.log('  ewma        0-1                          EWMA smoothing factor');
+      console.log('  samples     1+                          Minimum samples');
+      console.log();
+      console.log(chalk.bold('Examples:'));
+      console.log('  vcm config:timeout set mode adaptive');
+      console.log('  vcm config:timeout set default 45m');
+      console.log('  vcm config:timeout set buffer 75');
+      console.log('  vcm config:timeout test claude-code');
+      break;
+  }
+}
+
+module.exports = {
+  handleCommand
+};