vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/antigravity-installer.js

@@ -11,16 +11,70 @@ async function installAntigravity() {
   const spinner = ora('Checking system requirements...').start();
   await new Promise((r) => setTimeout(r, 800));
 
-  if (os.platform() !== 'darwin') {
-    spinner.fail('Automated Antigravity installation is only supported on macOS');
+  const platform = os.platform();
+  const arch = os.arch();
+  const isArm = arch === 'arm64';
+
+  // Handle Windows platform
+  if (platform === 'win32') {
+    spinner.succeed(`System OK (${arch === 'x64' ? 'x64' : 'ARM64'})`);
+    
+    try {
+      const cacheDir = path.join(os.homedir(), '.vibecodingmachine', 'cache');
+      await fs.ensureDir(cacheDir);
+      
+      // Try to find Antigravity installation on Windows
+      const possiblePaths = [
+        'C:\\Program Files\\Google\\Antigravity\\Antigravity.exe',
+        'C:\\Program Files (x86)\\Google\\Antigravity\\Antigravity.exe',
+        path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'Antigravity', 'Antigravity.exe'),
+        'antigravity.exe' // Try PATH
+      ];
+
+      let antigravityPath = null;
+      for (const testPath of possiblePaths) {
+        try {
+          if (await fs.pathExists(testPath)) {
+            antigravityPath = testPath;
+            break;
+          }
+        } catch (e) {
+          // Continue checking
+        }
+      }
+
+      if (antigravityPath) {
+        console.log(chalk.green('\n✅ Antigravity is already installed!'));
+        console.log(chalk.gray(`Found at: ${antigravityPath}`));
+        return true;
+      }
+
+      console.log(chalk.yellow('\n⚠️  Antigravity not found. Please install manually:'));
+      console.log(chalk.cyan('1. Download from: https://antigravity.dev'));
+      console.log(chalk.cyan('2. Run the installer'));
+      console.log(chalk.cyan('3. Antigravity should be automatically detected'));
+      
+      return false;
+    } catch (error) {
+      spinner.fail('Windows installation check failed');
+      console.log(chalk.red('\nInstallation error:'), error.message);
+      return false;
+    }
+  }
+
+  // macOS installation (existing logic)
+  if (platform !== 'darwin' && platform !== 'win32') {
+    spinner.fail('Automated Antigravity installation is only supported on macOS and Windows');
     return false;
   }
 
-  const arch = os.arch();
-  const isArm = arch === 'arm64';
+  // macOS-specific installation
+  if (platform === 'darwin') {
+    const macArch = os.arch();
+    const macIsArm = macArch === 'arm64';
 
-  // URLs from electron-app IDE installer
-  const downloadUrl = isArm
+    // URLs from electron-app IDE installer
+    const downloadUrl = macIsArm
     ? 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-arm/Antigravity.dmg'
     : 'https://edgedl.me.gvt1.com/edgedl/release2/j0qc3/antigravity/stable/1.11.2-6251250307170304/darwin-x64/Antigravity.dmg';
 

package/src/utils/clarification-actions.js

@@ -0,0 +1,290 @@
+/**
+ * Clarification Actions Module
+ * 
+ * Handles clarification-related requirement actions.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const { getRequirementsPath } = require('vibecodingmachine-core');
+const { confirmAction } = require('./requirement-helpers');
+
+/**
+ * Edit clarification responses
+ */
+async function editClarificationResponses(req, tree) {
+  console.log(chalk.bold.cyan(`\n✍️  Editing responses for: ${req.title}\n`));
+
+  if (!req.questions || req.questions.length === 0) {
+    console.log(chalk.yellow('No questions found for this requirement.'));
+    return;
+  }
+
+  const { questions } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'questions',
+      message: 'Select questions to respond to:',
+      choices: req.questions.map((q, idx) => ({
+        name: `${idx + 1}. ${q.question.replace(/^\d+\.\s*/, '')}`,
+        value: idx,
+        checked: !!q.response
+      }))
+    }
+  ]);
+
+  if (questions.length === 0) {
+    console.log(chalk.gray('No questions selected.'));
+    return;
+  }
+
+  for (const qIdx of questions) {
+    const question = req.questions[qIdx];
+    console.log(chalk.bold(`\nQuestion ${qIdx + 1}: ${question.question.replace(/^\d+\.\s*/, '')}`));
+    
+    if (question.response) {
+      console.log(chalk.gray(`Current response: ${question.response}`));
+    }
+
+    const { response } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'response',
+        message: 'Your response:',
+        default: question.response || ''
+      }
+    ]);
+
+    question.response = response.trim();
+  }
+
+  // Save the updated requirement
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and update the requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx !== -1) {
+    // Build new requirement content
+    const newReqContent = [
+      `### ${req.title}`,
+      ''
+    ];
+
+    if (req.questions && req.questions.length > 0) {
+      newReqContent.push('**Questions:**');
+      req.questions.forEach((q, idx) => {
+        newReqContent.push(`${idx + 1}. ${q.question}`);
+        if (q.response) {
+          newReqContent.push(`   → ${q.response}`);
+        }
+        newReqContent.push('');
+      });
+    }
+
+    if (req.details && req.details.length > 0) {
+      newReqContent.push('**Details:**');
+      req.details.forEach(detail => {
+        newReqContent.push(detail);
+      });
+      newReqContent.push('');
+    }
+
+    // Replace the requirement
+    lines.splice(startIdx, endIdx - startIdx, ...newReqContent);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('\n✓ Responses updated!'));
+  }
+}
+
+/**
+ * Move clarification requirement to TODO
+ */
+async function moveClarificationToTodo(req, tree) {
+  const reqPath = await getRequirementsPath();
+
+  const confirmed = await confirmAction(`Move "${req.title}" back to TODO? (r/y/N)`);
+  if (!confirmed) {
+    console.log(chalk.gray('Cancelled.'));
+    return;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove from clarification section
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx !== -1) {
+    // Extract the requirement content
+    const reqContent = lines.slice(startIdx, endIdx);
+    
+    // Remove from clarification section
+    lines.splice(startIdx, endIdx - startIdx);
+
+    // Find TODO section and insert there
+    let insertIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith('## ⏳ Requirements not yet completed')) {
+        insertIdx = i + 2; // After the section header and empty line
+        break;
+      }
+    }
+
+    if (insertIdx !== -1) {
+      lines.splice(insertIdx, 0, ...reqContent);
+    }
+    
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('\n✓ Moved to TODO!'));
+  }
+}
+
+/**
+ * Delete clarification requirement
+ */
+async function deleteClarification(req, tree) {
+  const reqPath = await getRequirementsPath();
+
+  const confirmed = await confirmAction(`Delete "${req.title}"? This cannot be undone. (r/y/N)`);
+  if (!confirmed) {
+    console.log(chalk.gray('Cancelled.'));
+    return;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove the clarification requirement
+  let startIdx = -1;
+  let endIdx = -1;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      startIdx = i;
+      // Find the end of this requirement
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith('###') || lines[j].startsWith('##')) {
+          endIdx = j;
+          break;
+        }
+      }
+      if (endIdx === -1) endIdx = lines.length;
+      break;
+    }
+  }
+
+  if (startIdx !== -1) {
+    lines.splice(startIdx, endIdx - startIdx);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    console.log(chalk.green('\n✓ Requirement deleted!'));
+  }
+}
+
+/**
+ * Show clarification actions menu
+ */
+async function showClarificationActions(req, tree, loadClarification) {
+  const actions = [
+    { label: '✍️  Add/Edit Responses', value: 'edit-responses' },
+    { label: '↩️  Move back to TODO (after clarification)', value: 'move-to-todo' },
+    { label: '🗑️  Delete', value: 'delete' },
+    { label: '↩️  Back', value: 'back' }
+  ];
+
+  console.log(chalk.bold.cyan(`\n❓ ${req.title}\n`));
+
+  // Show questions and responses
+  if (req.questions && req.questions.length > 0) {
+    console.log(chalk.gray('Questions:'));
+    req.questions.forEach((q, idx) => {
+      console.log(chalk.gray(`  ${idx + 1}. ${q.question.replace(/^\d+\.\s*/, '')}`));
+      if (q.response) {
+        console.log(chalk.green(`     → ${q.response}`));
+      } else {
+        console.log(chalk.yellow('     → (no response)'));
+      }
+    });
+    console.log();
+  }
+
+  if (req.details && req.details.length > 0) {
+    console.log(chalk.gray('Details:'));
+    req.details.forEach(detail => {
+      console.log(chalk.gray(`  ${detail}`));
+    });
+    console.log();
+  }
+
+  try {
+    const { action } = await inquirer.prompt([{
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: actions
+    }]);
+
+    switch (action) {
+      case 'edit-responses':
+        await editClarificationResponses(req, tree);
+        break;
+      case 'move-to-todo':
+        await moveClarificationToTodo(req, tree);
+        break;
+      case 'delete':
+        await deleteClarification(req, tree);
+        break;
+      case 'back':
+        return;
+    }
+
+    // Reload clarification if not going back
+    if (action !== 'back' && loadClarification) {
+      await loadClarification();
+    }
+  } catch (error) {
+    console.error(chalk.red('Error performing clarification action:'), error);
+  }
+}
+
+module.exports = {
+  editClarificationResponses,
+  moveClarificationToTodo,
+  deleteClarification,
+  showClarificationActions
+};

package/src/utils/config.js

@@ -16,7 +16,13 @@ async function ensureConfigFile() {
   const cfgPath = getConfigPath();
   await fs.ensureDir(path.dirname(cfgPath));
   if (!await fs.pathExists(cfgPath)) {
-    const defaultConfig = { repoPath: null, auto: {} };
+    const defaultConfig = { 
+      repoPath: null, 
+      auto: {
+        specProgressTimeoutMinutes: 5, // Default 5 minutes
+        maxIdeAttempts: 3 // Default 3 attempts
+      } 
+    };
     await fs.writeJson(cfgPath, defaultConfig, { spaces: 2 });
   }
 }
@@ -131,6 +137,117 @@ async function setAutoTimeout(timeoutMs) {
   await writeConfig(cfg);
 }
 
+// Timeout configuration for adaptive timeout management (T052)
+// Using core TimeoutConfigManager for consistency with Electron app
+const { TimeoutConfigManager } = require('../../../core/src/timeout-management');
+
+const DEFAULT_TIMEOUT_CONFIG = Object.freeze({
+  mode: 'fixed', // 'fixed' or 'adaptive'
+  defaultTimeout: 30 * 60 * 1000, // 30 minutes
+  minTimeout: 5 * 60 * 1000, // 5 minutes
+  maxTimeout: 60 * 60 * 1000, // 60 minutes
+  bufferPercentage: 0.5, // 50% buffer
+  ewmaAlpha: 0.3, // EWMA smoothing factor
+  minSamples: 3 // Minimum samples for adaptive calculation
+});
+
+let timeoutConfigManager = null;
+
+// Configuration storage path (same as Electron app)
+const getTimeoutConfigPath = () => {
+  const os = require('os');
+  return path.join(os.homedir(), '.config', 'vibecodingmachine', 'timeout-config.json');
+};
+
+/**
+ * Initialize timeout configuration manager
+ */
+async function initializeTimeoutConfigManager() {
+  if (!timeoutConfigManager) {
+    const configPath = getTimeoutConfigPath();
+    await fs.ensureDir(path.dirname(configPath));
+    
+    let config = {};
+    if (await fs.pathExists(configPath)) {
+      config = await fs.readJson(configPath);
+    }
+    
+    timeoutConfigManager = new TimeoutConfigManager(config);
+  }
+  return timeoutConfigManager;
+}
+
+async function getTimeoutConfig() {
+  try {
+    const manager = await initializeTimeoutConfigManager();
+    const config = manager.getConfig();
+    
+    // Add minSamples for UI compatibility
+    return {
+      ...config,
+      minSamples: 3 // Default value
+    };
+  } catch (error) {
+    console.error('Failed to get timeout configuration:', error);
+    return DEFAULT_TIMEOUT_CONFIG;
+  }
+}
+
+async function setTimeoutConfig(timeoutConfig) {
+  try {
+    const manager = await initializeTimeoutConfigManager();
+    
+    // Apply updates to the manager
+    if (timeoutConfig.mode !== undefined) {
+      manager.setMode(timeoutConfig.mode);
+    }
+    if (timeoutConfig.defaultTimeout !== undefined) {
+      manager.setDefaultTimeout(timeoutConfig.defaultTimeout);
+    }
+    if (timeoutConfig.minTimeout !== undefined) {
+      manager.setMinTimeout(timeoutConfig.minTimeout);
+    }
+    if (timeoutConfig.maxTimeout !== undefined) {
+      manager.setMaxTimeout(timeoutConfig.maxTimeout);
+    }
+    if (timeoutConfig.bufferPercentage !== undefined) {
+      manager.setBufferPercentage(timeoutConfig.bufferPercentage);
+    }
+    if (timeoutConfig.ewmaAlpha !== undefined) {
+      manager.setEWMAAlpha(timeoutConfig.ewmaAlpha);
+    }
+    
+    // Save to storage
+    const newConfig = manager.getConfig();
+    const configPath = getTimeoutConfigPath();
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeJson(configPath, newConfig, { spaces: 2 });
+    
+    return newConfig;
+  } catch (error) {
+    console.error('Failed to set timeout configuration:', error);
+    throw error;
+  }
+}
+
+async function resetTimeoutConfig() {
+  try {
+    const manager = await initializeTimeoutConfigManager();
+    manager.reset();
+    
+    // Save defaults to storage
+    const config = manager.getConfig();
+    const configPath = getTimeoutConfigPath();
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeJson(configPath, config, { spaces: 2 });
+    
+    return config;
+  } catch (error) {
+    console.error('Failed to reset timeout configuration:', error);
+    throw error;
+  }
+}
+
 module.exports = {
   getRepoPath,
   getEffectiveRepoPath,
@@ -147,7 +264,11 @@ module.exports = {
   getProviderCache,
   setProviderCache,
   getAutoTimeout,
-  setAutoTimeout
+  setAutoTimeout,
+  getTimeoutConfig,
+  setTimeoutConfig,
+  resetTimeoutConfig,
+  DEFAULT_TIMEOUT_CONFIG
 };
 
 

package/src/utils/first-run.js

@@ -213,7 +213,7 @@ async function checkFirstRun() {
         const choices = otherIDEs.map(ide => ({
             name: ide.name,
             value: ide.id,
-            checked: true // All IDEs enabled by default as requested
+            checked: false // IDEs must be explicitly selected by user
         }));
 
         const response = await inquirer.prompt([{
@@ -330,12 +330,12 @@ async function checkFirstRun() {
     for (const id of defaultOrder) {
         const def = definitions.find(d => d.id === id);
         if (def && def.type === 'ide') {
-            const isDetectedNow = reDetected.includes(id);
+            // Only enable IDEs that were explicitly selected by user during first run
             const isSelected = selectedIDEs.includes(id);
-            // Enable if detected OR selected during first run
-            enabledMap[id] = isDetectedNow || isSelected;
+            enabledMap[id] = isSelected;
         } else {
-            enabledMap[id] = true; // Keep LLMs enabled by default
+            // Keep LLMs enabled by default (but not IDEs)
+            enabledMap[id] = true;
         }
     }