vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/ide-handlers.js

@@ -0,0 +1,212 @@
+/**
+ * IDE Handlers Module
+ * 
+ * Handles IDE-specific operations like checking if IDEs are running, launching IDEs, and IDE installation.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * IDE information mapping
+ */
+const IDE_INFO = {
+  windsurf:       { process: 'Windsurf',            app: 'Windsurf' },
+  cursor:         { process: 'Cursor',              app: 'Cursor' },
+  antigravity:    { process: 'Antigravity',         app: 'Antigravity' },
+  kiro:           { process: 'Kiro',                app: 'Kiro' },
+  'github-copilot': { process: 'Code',              app: 'Visual Studio Code' },
+  'amazon-q':     { process: 'Code',                app: 'Visual Studio Code' },
+  cline:          { process: 'Code',                app: 'Visual Studio Code' },
+  vscode:         { process: 'Code',                app: 'Visual Studio Code' },
+  replit:         { process: null,                  app: null },   // web-based
+};
+
+/**
+ * Returns true if the IDE process is currently running.
+ */
+function isIDERunning(processName) {
+  if (!processName) return false;
+
+  if (process.platform === 'darwin') {
+    // macOS: use pgrep
+    try {
+      execSync(`pgrep -x "${processName}"`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  } else if (process.platform === 'win32') {
+    // Windows: use tasklist
+    try {
+      const result = execSync(`tasklist /FI "IMAGENAME eq ${processName}.exe" /NH`, {
+        encoding: 'utf8',
+        stdio: 'pipe',
+        shell: true,
+        windowsHide: true
+      });
+      return result.toLowerCase().includes(processName.toLowerCase());
+    } catch {
+      return false;
+    }
+  }
+
+  // Other platforms: assume not running
+  return false;
+}
+
+/**
+ * Open the IDE using `open -a <app> <repoPath>` (macOS).
+ * Returns true when the launch command was sent.
+ */
+async function openIDEApp(appName, repoPath) {
+  if (!appName || process.platform !== 'darwin') return false;
+  try {
+    const safeRepo = repoPath ? ` "${repoPath.replace(/"/g, '\\"')}"` : '';
+    execSync(`open -a "${appName}"${safeRepo}`, { stdio: 'ignore' });
+    // Give it a few seconds to start before the automation begins
+    await new Promise(r => setTimeout(r, 5000));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check IDE installation and launch if needed
+ */
+async function checkAndLaunchIDE(providerId, def, repoPath) {
+  const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
+  if (!info || !info.process) {
+    return { success: true, note: '' }; // Non-IDE provider
+  }
+
+  let ideLaunchNote = '';
+  
+  if (!isIDERunning(info.process)) {
+    // macOS: launch the app if not running
+    if (process.platform === 'darwin' && info.app) {
+      const launchSuccess = await openIDEApp(info.app, repoPath);
+      if (launchSuccess) {
+        ideLaunchNote = ` (VCM launched ${info.app})`;
+      } else {
+        // Failed to launch on macOS - check if installed
+        const { IDEInstaller } = require('../../../electron-app/src/main/ide-installer');
+        const installer = new IDEInstaller();
+        const ideKey = def.ide || providerId;
+        const checkResult = await installer.checkIDEInstallation(ideKey);
+        if (!checkResult.installed) {
+          return {
+            success: false,
+            error: `${info.app} is not installed. Please download from ${IDEInstaller.IDE_CONFIG[ideKey]?.downloadBrowserUrl || 'its official website'}`
+          };
+        }
+      }
+    }
+    // Windows: check if installed, install if possible, launch if installed
+    else if (process.platform === 'win32') {
+      const { IDEInstaller } = require('../../../electron-app/src/main/ide-installer');
+      const installer = new IDEInstaller();
+      const ideKey = def.ide || providerId;
+      const ideConfig = IDEInstaller.IDE_CONFIG[ideKey];
+
+      // Check if IDE is installed
+      let checkResult = await installer.checkIDEInstallation(ideKey);
+
+      if (!checkResult.installed) {
+        // IDE is not installed - try to install if we have a download URL
+        const downloadUrl = ideConfig?.downloadUrl?.[process.platform];
+        
+        if (downloadUrl) {
+          console.log(`[AGENT CHECK] Installing ${ideKey}...`);
+          try {
+            const installResult = await installer.installIDE(ideKey);
+            if (installResult.success) {
+              ideLaunchNote = ` (VCM installed ${ideKey})`;
+              // Launch after installation
+              await new Promise(resolve => setTimeout(resolve, 2000));
+              const launchSuccess = await installer.launchIDE(ideKey, repoPath);
+              if (launchSuccess) {
+                ideLaunchNote += ` (VCM launched ${ideKey})`;
+              }
+            } else {
+              return {
+                success: false,
+                error: `Failed to install ${ideKey}: ${installResult.error}`
+              };
+            }
+          } catch (error) {
+            return {
+              success: false,
+              error: `Error installing ${ideKey}: ${error.message}`
+            };
+          }
+        } else {
+          return {
+            success: false,
+            error: `${ideKey} is not installed and no automatic installation is available`
+          };
+        }
+      } else {
+        // IDE is installed, try to launch it
+        const launchSuccess = await installer.launchIDE(ideKey, repoPath);
+        if (launchSuccess) {
+          ideLaunchNote = ` (VCM launched ${ideKey})`;
+        }
+      }
+    }
+    // Linux: check if installed and try to launch
+    else {
+      const { IDEInstaller } = require('../../../electron-app/src/main/ide-installer');
+      const installer = new IDEInstaller();
+      const ideKey = def.ide || providerId;
+      
+      try {
+        const checkResult = await installer.checkIDEInstallation(ideKey);
+        if (!checkResult.installed) {
+          return {
+            success: false,
+            error: `${ideKey} is not installed`
+          };
+        }
+        
+        const launchSuccess = await installer.launchIDE(ideKey, repoPath);
+        if (launchSuccess) {
+          ideLaunchNote = ` (VCM launched ${ideKey})`;
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Error checking/launching ${ideKey}: ${error.message}`
+        };
+      }
+    }
+  }
+
+  return { success: true, note: ideLaunchNote };
+}
+
+/**
+ * Get IDE information for a provider
+ */
+function getIDEInfo(providerId, def) {
+  return IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
+}
+
+/**
+ * Check if a provider is IDE-based
+ */
+function isIDEProvider(providerId, def) {
+  const info = getIDEInfo(providerId, def);
+  return info && info.process !== null;
+}
+
+module.exports = {
+  IDE_INFO,
+  isIDERunning,
+  openIDEApp,
+  checkAndLaunchIDE,
+  getIDEInfo,
+  isIDEProvider
+};

package/src/utils/interactive/clarification-actions.js

@@ -0,0 +1,348 @@
+const { t, getRequirementsPath } = require('vibecodingmachine-core');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+
+// Helper to edit clarification responses
+async function editClarificationResponses(req, tree) {
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the requirement line
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  // Extract existing responses
+  const responses = [];
+  let i = reqIndex + 1;
+  while (i < lines.length && lines[i].startsWith('  - ')) {
+    responses.push(lines[i].substring(4).trim());
+    i++;
+  }
+
+  console.log(chalk.blue(`\n📝 Editing responses for: ${req.title}\n`));
+  
+  if (responses.length > 0) {
+    console.log(chalk.yellow('Current responses:'));
+    responses.forEach((resp, idx) => console.log(chalk.gray(`  ${idx + 1}. ${resp}`)));
+    console.log();
+  }
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '➕ Add response', value: 'add' },
+        ...(responses.length > 0 ? [{ name: '✏️  Edit response', value: 'edit' }] : []),
+        ...(responses.length > 0 ? [{ name: '🗑️  Delete response', value: 'delete' }] : []),
+        { name: '⬅️  Back', value: 'back' }
+      ]
+    }
+  ]);
+
+  if (action === 'back') return;
+
+  switch (action) {
+    case 'add':
+      await addClarificationResponse(reqPath, reqIndex, lines, responses);
+      break;
+    case 'edit':
+      await editClarificationResponse(reqPath, reqIndex, lines, responses);
+      break;
+    case 'delete':
+      await deleteClarificationResponse(reqPath, reqIndex, lines, responses);
+      break;
+  }
+}
+
+async function addClarificationResponse(reqPath, reqIndex, lines, responses) {
+  const { response } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'response',
+      message: 'Enter new response:',
+      validate: input => input.trim().length > 0 || 'Response cannot be empty'
+    }
+  ]);
+
+  // Insert the new response after the requirement
+  const insertIndex = reqIndex + 1 + responses.length;
+  lines.splice(insertIndex, 0, `  - ${response}`);
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Response added'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+async function editClarificationResponse(reqPath, reqIndex, lines, responses) {
+  const { responseIndex, newResponse } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'responseIndex',
+      message: 'Select response to edit:',
+      choices: responses.map((resp, idx) => ({ name: resp, value: idx }))
+    },
+    {
+      type: 'input',
+      name: 'newResponse',
+      message: 'Enter new response:',
+      default: responses[0],
+      validate: input => input.trim().length > 0 || 'Response cannot be empty'
+    }
+  ]);
+
+  const lineIndex = reqIndex + 1 + responseIndex;
+  lines[lineIndex] = `  - ${newResponse}`;
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Response updated'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+async function deleteClarificationResponse(reqPath, reqIndex, lines, responses) {
+  const { responseIndex } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'responseIndex',
+      message: 'Select response to delete:',
+      choices: responses.map((resp, idx) => ({ name: resp, value: idx }))
+    }
+  ]);
+
+  const confirmed = await confirmAction('Delete this response? (r/y/N):');
+  if (!confirmed) return;
+
+  const lineIndex = reqIndex + 1 + responseIndex;
+  lines.splice(lineIndex, 1);
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Response deleted'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to move clarification requirement back to TODO
+async function moveClarificationToTodo(req, tree) {
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the requirement in clarification section
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  // Extract the requirement and its responses
+  const requirementLines = [lines[reqIndex]];
+  let i = reqIndex + 1;
+  while (i < lines.length && lines[i].startsWith('  - ')) {
+    requirementLines.push(lines[i]);
+    i++;
+  }
+
+  // Remove from clarification section
+  lines.splice(reqIndex, requirementLines.length);
+
+  // Add to TODO section
+  const todoIndex = lines.findIndex(line => line.includes('Requirements not yet completed'));
+  if (todoIndex !== -1) {
+    // Find the end of the TODO section header
+    let insertIndex = todoIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+      insertIndex++;
+    }
+    
+    // Insert the requirement
+    lines.splice(insertIndex, 0, ...requirementLines);
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Requirement moved back to TODO'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to move clarification requirement to recycled (used to delete)
+async function deleteClarification(req, tree) {
+  const confirmed = await confirmAction('Delete this requirement? (r/y/N):');
+  if (!confirmed) return;
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find the requirement in clarification section
+  const reqIndex = lines.findIndex(line => line.includes(req.title));
+  if (reqIndex === -1) {
+    console.error(chalk.red('❌ Requirement not found'));
+    return;
+  }
+
+  // Extract the requirement and its responses
+  const requirementLines = [lines[reqIndex]];
+  let i = reqIndex + 1;
+  while (i < lines.length && lines[i].startsWith('  - ')) {
+    requirementLines.push(lines[i]);
+    i++;
+  }
+
+  // Remove from clarification section
+  lines.splice(reqIndex, requirementLines.length);
+
+  // Add to recycled section
+  await moveRequirementToRecycled(reqPath, req.title, 'clarification', requirementLines);
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('✅ Requirement deleted'));
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+
+// Helper to show actions for a requirement
+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' }
+  ];
+
+  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;
+  }
+}
+
+// Helper to confirm exit and exit if confirmed (default N)
+async function confirmAndExit() {
+  console.log(chalk.gray('\n[DEBUG] confirmAndExit called'));
+  console.log();
+  process.stdout.write(chalk.yellow(`${t('interactive.confirm.exit')} `));
+
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    let data = '';
+    process.stdin.on('data', (key) => {
+      data += key;
+
+      // Accept 'r' or 'y' for yes, anything else for no
+      if (key.toLowerCase() === 'r' || key.toLowerCase() === 'y') {
+        process.stdout.write(key);
+        process.stdout.write('\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        console.log(chalk.cyan('\n👋 Goodbye!\n'));
+        process.exit(0);
+      } else if (key === '\r' || key === '\n' || key === '\u0003') { // Enter, Esc, or Ctrl+C
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      } else if (data.length > 1) { // Any other input
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      }
+    });
+  });
+}
+
+// Helper to show confirmation prompt (r/y for yes, N for no, default N)
+async function confirmAction(message) {
+  console.log();
+  process.stdout.write(chalk.yellow(`${message} `));
+
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    let data = '';
+    process.stdin.on('data', (key) => {
+      data += key;
+
+      // Accept 'r' or 'y' for yes, anything else for no
+      if (key.toLowerCase() === 'r' || key.toLowerCase() === 'y') {
+        process.stdout.write(key);
+        process.stdout.write('\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(true);
+      } else if (key === '\r' || key === '\n' || key === '\u0003') { // Enter, Esc, or Ctrl+C
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      } else if (data.length > 1) { // Any other input
+        process.stdout.write('N\n');
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        resolve(false);
+      }
+    });
+  });
+}
+
+// Helper to move requirement to recycled section
+async function moveRequirementToRecycled(reqPath, requirementTitle, fromSection, requirementLines = null) {
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find recycled section
+  const recycledIndex = lines.findIndex(line => line.includes('♻️ Recycled'));
+  if (recycledIndex === -1) {
+    // Create recycled section
+    lines.push('## ♻️ Recycled');
+    lines.push('');
+    lines.push(`- ${requirementTitle}`);
+  } else {
+    // Add to existing recycled section
+    let insertIndex = recycledIndex + 1;
+    while (insertIndex < lines.length && lines[insertIndex].trim() === '') {
+      insertIndex++;
+    }
+    
+    if (requirementLines) {
+      lines.splice(insertIndex, 0, ...requirementLines);
+    } else {
+      lines.splice(insertIndex, 0, `- ${requirementTitle}`);
+    }
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+}
+
+module.exports = {
+  editClarificationResponses,
+  moveClarificationToTodo,
+  deleteClarification,
+  showClarificationActions,
+  confirmAndExit,
+  confirmAction,
+  moveRequirementToRecycled
+};