vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/provider-checker/cli-installer.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Direct CLI providers that can be auto-installed
+const CLI_AUTO_INSTALL = {
+  'cline': { cmd: 'cline', pkg: '@cline/cli', type: 'npm' },
+  'opencode': {
+    cmd: 'opencode',
+    type: 'direct',
+    installScript: 'curl -fsSL https://raw.githubusercontent.com/opencode-ai/opencode/refs/heads/main/install | bash',
+    // Well-known install locations that may not be in Electron's PATH
+    knownPaths: [
+      path.join(os.homedir(), '.opencode', 'bin'),
+    ]
+  },
+};
+
+/**
+ * Build an augmented PATH that includes known install directories for a provider.
+ */
+function getAugmentedPath(providerId) {
+  const config = CLI_AUTO_INSTALL[providerId];
+  if (!config || !config.knownPaths || config.knownPaths.length === 0) {
+    return process.env.PATH || '';
+  }
+  const existing = process.env.PATH || '';
+  const extras = config.knownPaths.filter(p => !existing.split(path.delimiter).includes(p));
+  return extras.length > 0 ? extras.join(path.delimiter) + path.delimiter + existing : existing;
+}
+
+/**
+ * Check if a CLI command is available in PATH or well-known install locations.
+ * @param {string} cmd - command name
+ * @param {string} [providerId] - optional provider id to check knownPaths
+ */
+function isCLIAvailable(cmd, providerId) {
+  // 1. Try the augmented PATH (covers Electron's stripped-down env)
+  try {
+    const { execSync } = require('child_process');
+    const augPath = providerId ? getAugmentedPath(providerId) : (process.env.PATH || '');
+    const env = { ...process.env, PATH: augPath };
+    const command = process.platform === 'win32' ? `where "${cmd}"` : `which "${cmd}"`;
+    execSync(command, { stdio: 'ignore', env });
+    return true;
+  } catch {
+    // fall through
+  }
+
+  // 2. Check knownPaths directly on disk (handles case where even `which` can't find it)
+  if (providerId) {
+    const config = CLI_AUTO_INSTALL[providerId];
+    if (config && config.knownPaths) {
+      for (const dir of config.knownPaths) {
+        const fullPath = path.join(dir, cmd);
+        try {
+          fs.accessSync(fullPath, fs.constants.X_OK);
+          return true;
+        } catch {
+          // continue
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Install a CLI tool and wait for it to complete.
+ * Returns { installed: bool, note: string }.
+ */
+async function installCLI(providerId) {
+  const config = CLI_AUTO_INSTALL[providerId];
+  if (!config) {
+    return { installed: false, note: `Unknown provider: ${providerId}` };
+  }
+
+  // Augmented PATH so the install script and post-install verification can find binaries
+  const augPath = getAugmentedPath(providerId);
+  const spawnEnv = { ...process.env, PATH: augPath };
+
+  return new Promise((resolve) => {
+    if (config.type === 'direct' && config.installScript) {
+      // Direct installation using shell script
+      const proc = spawn('bash', ['-c', config.installScript], { stdio: ['ignore', 'pipe', 'pipe'], env: spawnEnv });
+      let out = '';
+      proc.stdout.on('data', d => { out += d.toString(); });
+      proc.stderr.on('data', d => { out += d.toString(); });
+      proc.on('error', () => resolve({ installed: false, note: `Failed to run install script for ${providerId}` }));
+      proc.on('close', (code) => {
+        if (code === 0 && isCLIAvailable(config.cmd, providerId)) {
+          resolve({ installed: true, note: `Installed ${providerId} via direct script` });
+        } else {
+          resolve({ installed: false, note: `Install script for ${providerId} exited (${code})` });
+        }
+      });
+    } else {
+      // NPM installation
+      const proc = spawn('npm', ['install', '-g', config.pkg], { stdio: ['ignore', 'pipe', 'pipe'], env: spawnEnv });
+      let out = '';
+      proc.stdout.on('data', d => { out += d.toString(); });
+      proc.stderr.on('data', d => { out += d.toString(); });
+      proc.on('error', () => resolve({ installed: false, note: `Failed to run npm install -g ${config.pkg}` }));
+      proc.on('close', (code) => {
+        if (code === 0 && isCLIAvailable(config.cmd, providerId)) {
+          resolve({ installed: true, note: `Installed ${config.pkg} via npm` });
+        } else {
+          resolve({ installed: false, note: `npm install -g ${config.pkg} exited (${code})` });
+        }
+      });
+    }
+  });
+}
+
+module.exports = {
+  CLI_AUTO_INSTALL,
+  isCLIAvailable,
+  installCLI
+};

package/src/utils/provider-checker/cli-utils.js

@@ -0,0 +1,15 @@
+/**
+ * CLI Utilities Module
+ * 
+ * Contains CLI command availability and installation utilities.
+ * 
+ * NOTE: This module re-exports from cli-installer.js to avoid duplication.
+ */
+
+const { CLI_AUTO_INSTALL, isCLIAvailable, installCLI } = require('./cli-installer');
+
+module.exports = {
+  CLI_AUTO_INSTALL,
+  isCLIAvailable,
+  installCLI
+};

package/src/utils/provider-checker/format-utils.js

@@ -0,0 +1,32 @@
+/**
+ * Format Utilities Module
+ * 
+ * Contains formatting utilities for dates and other data.
+ */
+
+/**
+ * Format a checkedAt ISO timestamp for display.
+ * e.g. "April 12, 2025 at 4:23 pm"
+ */
+function formatCheckedAt(checkedAt) {
+  if (!checkedAt) return '';
+  const d = new Date(checkedAt);
+  if (isNaN(d.getTime())) return checkedAt;
+  
+  const months = [
+    'January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'
+  ];
+  
+  const hours = d.getHours();
+  const ampm = hours >= 12 ? 'pm' : 'am';
+  const hour12 = hours % 12 || 12;
+  const minutes = d.getMinutes().toString().padStart(2, '0');
+  const timePart = `${hour12}:${minutes} ${ampm}`;
+  
+  return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart}`;
+}
+
+module.exports = {
+  formatCheckedAt
+};

package/src/utils/provider-checker/ide-manager.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { execSync } = require('child_process');
+
+// Map provider id → { process: process name for tasklist/pgrep, app: app name for opening }
+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;
+  }
+}
+
+module.exports = {
+  IDE_INFO,
+  isIDERunning,
+  openIDEApp
+};

package/src/utils/provider-checker/ide-utils.js

@@ -0,0 +1,71 @@
+/**
+ * IDE Utilities Module
+ * 
+ * Contains IDE process detection and launching utilities.
+ */
+
+const { execSync } = require('child_process');
+
+// Map provider id → { process: process name for tasklist/pgrep, app: app name for opening }
+const IDE_INFO = {
+  windsurf:       { process: 'Windsurf',            app: 'Windsurf' },
+  cursor:         { process: 'Cursor',              app: 'Cursor' },
+  antigravity:    { process: 'Antigravity',         app: 'Antigravity' },
+  'vscode':       { process: 'Code',                app: 'Visual Studio Code' },
+  'vscode-insiders': { process: 'Code - Insiders',  app: 'Visual Studio Code - Insiders' },
+};
+
+/**
+ * Returns true if the IDE process is currently running.
+ */
+function isIDERunning(processName) {
+  if (!processName) return false;
+
+  if (process.platform === 'darwin') {
+    // macOS: use pgrep
+    try {
+      const result = execSync(`pgrep -i "${processName}"`, { encoding: 'utf8' });
+      return result.trim().length > 0;
+    } catch (_) {
+      return false;
+    }
+  } else if (process.platform === 'win32') {
+    // Windows: use tasklist
+    try {
+      const result = execSync('tasklist', { encoding: 'utf8' });
+      return result.toLowerCase().includes(processName.toLowerCase());
+    } catch (_) {
+      return false;
+    }
+  } else {
+    // Linux: use pgrep
+    try {
+      const result = execSync(`pgrep -i "${processName}"`, { encoding: 'utf8' });
+      return result.trim().length > 0;
+    } catch (_) {
+      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, '\\"')}"` : '';
+    const { execSync } = require('child_process');
+    execSync(`open -a "${appName}"${safeRepo}`, { stdio: 'ignore' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+module.exports = {
+  IDE_INFO,
+  isIDERunning,
+  openIDEApp
+};

package/src/utils/provider-checker/node-detector.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the Node.js executable path
+ * When running in Electron, process.execPath points to electron executable, not node
+ */
+function getNodeExecutable() {
+  // First try to get the actual node executable from process.env
+  if (process.env.NODE_BINARY_PATH) {
+    return process.env.NODE_BINARY_PATH;
+  }
+  
+  // Try to find node in PATH
+  try {
+    const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
+    const nodePath = execSync(nodeCmd, { encoding: 'utf8' }).trim().split('\n')[0];
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  } catch (_) {}
+  
+  // Fallback: try common node installation paths
+  const commonPaths = process.platform === 'win32'
+    ? [
+        'C:\\Program Files\\nodejs\\node.exe',
+        'C:\\Program Files (x86)\\nodejs\\node.exe',
+        path.join(process.env.PROGRAMFILES || '', 'nodejs', 'node.exe'),
+        path.join(process.env['PROGRAMFILES(X86)'] || '', 'nodejs', 'node.exe')
+      ]
+    : [
+        '/usr/bin/node',
+        '/usr/local/bin/node',
+        '/opt/homebrew/bin/node'
+      ];
+  
+  for (const nodePath of commonPaths) {
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  }
+  
+  // Last resort: use process.execPath (might be electron but worth trying)
+  console.warn('[AGENT CHECK] Could not find node executable, falling back to process.execPath');
+  return process.execPath;
+}
+
+const NODE_EXECUTABLE = getNodeExecutable();
+
+module.exports = {
+  getNodeExecutable,
+  NODE_EXECUTABLE
+};

package/src/utils/provider-checker/node-utils.js

@@ -0,0 +1,61 @@
+/**
+ * Node Utilities Module
+ * 
+ * Contains Node.js executable detection and related utilities.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the Node.js executable path
+ * When running in Electron, process.execPath points to electron executable, not node
+ */
+function getNodeExecutable() {
+  // First try to get the actual node executable from process.env
+  if (process.env.NODE_BINARY_PATH) {
+    return process.env.NODE_BINARY_PATH;
+  }
+  
+  // Try to find node in PATH
+  try {
+    const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
+    const nodePath = execSync(nodeCmd, { encoding: 'utf8' }).trim().split('\n')[0];
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  } catch (_) {}
+  
+  // Fallback: try common node installation paths
+  const commonPaths = process.platform === 'win32'
+    ? [
+        'C:\\Program Files\\nodejs\\node.exe',
+        'C:\\Program Files (x86)\\nodejs\\node.exe',
+        path.join(process.env.PROGRAMFILES || '', 'nodejs', 'node.exe'),
+        path.join(process.env['PROGRAMFILES(X86)'] || '', 'nodejs', 'node.exe')
+      ]
+    : [
+        '/usr/bin/node',
+        '/usr/local/bin/node',
+        '/opt/homebrew/bin/node'
+      ];
+  
+  for (const nodePath of commonPaths) {
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  }
+  
+  // Last resort: use process.execPath (might be electron but worth trying)
+  console.warn('[AGENT CHECK] Could not find node executable, falling back to process.execPath');
+  return process.execPath;
+}
+
+// Cache the node executable path
+const NODE_EXECUTABLE = getNodeExecutable();
+
+module.exports = {
+  getNodeExecutable,
+  NODE_EXECUTABLE
+};

package/src/utils/provider-checker/process-spawn.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { spawn } = require('child_process');
+
+/**
+ * Spawn a process and wait for it to exit. Returns { code, output }.
+ */
+function spawnAndWait(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    let output = '';
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
+    child.stdout && child.stdout.on('data', d => { output += d.toString(); });
+    child.stderr && child.stderr.on('data', d => { output += d.toString(); });
+    child.on('error', () => resolve({ code: -1, output }));
+    child.on('exit', (code) => resolve({ code, output }));
+    return child;
+  });
+}
+
+module.exports = {
+  spawnAndWait
+};

package/src/utils/provider-checker/process-utils.js

@@ -0,0 +1,37 @@
+/**
+ * Process Utilities Module
+ * 
+ * Contains process spawning and management utilities.
+ */
+
+const { spawn } = require('child_process');
+
+/**
+ * Spawn a process and wait for it to exit. Returns { code, output }.
+ */
+function spawnAndWait(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    let output = '';
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({ code, output });
+    });
+
+    child.on('error', (error) => {
+      resolve({ code: -1, output: error.message });
+    });
+  });
+}
+
+module.exports = {
+  spawnAndWait
+};

package/src/utils/provider-checker/provider-validator.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { CLI_AUTO_INSTALL, isCLIAvailable, installCLI } = require('./cli-installer');
+const { getResultFilePath, addTestRequirement, removeTestRequirement } = require('./requirements-manager');
+const { runAgentCheck } = require('./agent-runner');
+
+/**
+ * Check a single provider end-to-end using the actual REQUIREMENTS.md.
+ *
+ * Flow:
+ *   1. Add test requirement to top of REQUIREMENTS.md
+ *   2. Run the agent for 1 iteration
+ *   3. On success, requirement is auto-moved to Verified by the agent; remove it
+ *   4. On failure, leave requirement in pending for the NEXT agent (caller handles cleanup)
+ *
+ * Returns { status, message, checkedAt, requirementLeftPending }
+ */
+async function checkProvider(providerId, config = {}, repoPath, onProgress = null, signal = null) {
+  const { getProviderDefinition } = require('../provider-registry');
+  console.log(`[AGENT CHECK] Checking provider: ${providerId} in repo: ${repoPath}`);
+
+  const def = getProviderDefinition(providerId);
+  if (!def) {
+    console.error(`[AGENT CHECK] Unknown provider: ${providerId}`);
+    return { status: 'error', message: `Unknown provider: ${providerId}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
+  }
+
+  // No platform restrictions needed anymore - all IDEs have cross-platform support
+
+  if (!repoPath) {
+    console.error(`[AGENT CHECK] No repository path available`);
+    return { status: 'error', message: 'No repository path available', checkedAt: new Date().toISOString(), requirementLeftPending: false };
+  }
+
+  const { getRequirementsPath } = require('vibecodingmachine-core');
+  let reqPath;
+  try {
+    reqPath = await getRequirementsPath(repoPath);
+  } catch {
+    reqPath = path.join(repoPath, '.vibecodingmachine', 'REQUIREMENTS.md');
+  }
+
+  // Ensure .vibecodingmachine directory exists
+  const vibeDir = path.join(repoPath, '.vibecodingmachine');
+  const tempDir = path.join(vibeDir, 'temp');
+  try {
+    fs.mkdirSync(vibeDir, { recursive: true });
+    fs.mkdirSync(tempDir, { recursive: true });
+    console.log(`[AGENT CHECK] Ensured .vibecodingmachine directories exist`);
+  } catch (err) {
+    console.error(`[AGENT CHECK] Failed to create .vibecodingmachine directories: ${err.message}`);
+    return { status: 'error', message: `Could not create .vibecodingmachine: ${err.message}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
+  }
+
+  // Ensure REQUIREMENTS.md exists with proper structure
+  try {
+    if (!fs.existsSync(reqPath)) {
+      const initialRequirements = `# Requirements for this project
+
+## ⏳ Requirements not yet completed
+
+## ✅ Verified by AI
+
+`;
+      fs.writeFileSync(reqPath, initialRequirements, 'utf8');
+      console.log(`[AGENT CHECK] Created initial REQUIREMENTS.md`);
+    } else {
+      console.log(`[AGENT CHECK] REQUIREMENTS.md already exists`);
+    }
+  } catch (err) {
+    console.error(`[AGENT CHECK] Failed to ensure REQUIREMENTS.md: ${err.message}`);
+    return { status: 'error', message: `Could not create REQUIREMENTS.md: ${err.message}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
+  }
+
+  const resultFile = getResultFilePath(repoPath);
+
+  // Ensure the config has repoPath set for the child process
+  try {
+    const { getRepoPath, setRepoPath } = require('./config');
+    const currentRepoPath = await getRepoPath();
+    if (currentRepoPath !== repoPath) {
+      console.log(`[AGENT CHECK] Setting main config repoPath to: ${repoPath}`);
+      await setRepoPath(repoPath);
+      console.log(`[AGENT CHECK] Wrote repoPath to config successfully`);
+    } else {
+      console.log(`[AGENT CHECK] repoPath already configured: ${currentRepoPath}`);
+    }
+  } catch (err) {
+    console.warn(`[AGENT CHECK] Warning: Could not ensure repoPath in config: ${err.message}`);
+    // Don't fail - we'll try anyway
+  }
+
+  // For direct CLI providers: auto-install if missing
+  const cliInfo = CLI_AUTO_INSTALL[providerId];
+  if (cliInfo && !isCLIAvailable(cliInfo.cmd, providerId)) {
+    if (onProgress) onProgress(providerId, 'installing');
+    const { installed, note } = await installCLI(providerId);
+    if (!installed) {
+      return { status: 'error', message: `${def.name} not installed and auto-install failed: ${note}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
+    }
+  }
+
+  // Add test requirement (idempotent — safe to call even if already present from a prior failed agent)
+  try { addTestRequirement(reqPath, resultFile); } catch (err) {
+    return { status: 'error', message: `Could not write to REQUIREMENTS.md: ${err.message}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
+  }
+
+  const { DIRECT_TIMEOUT_MS, IDE_TIMEOUT_MS } = require('./agent-runner');
+  const timeoutMs = def.type === 'ide' ? IDE_TIMEOUT_MS : DIRECT_TIMEOUT_MS;
+  const result = await runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal, onProgress);
+
+  if (result.status === 'success') {
+    // Agent completed — requirement has been moved to Verified; remove it and the result file
+    try { removeTestRequirement(reqPath); } catch { }
+    try { fs.unlinkSync(resultFile); } catch { }
+    return { ...result, requirementLeftPending: false };
+  }
+
+  // Agent failed — leave the requirement in pending for the next agent
+  return { ...result, requirementLeftPending: true };
+}
+
+/**
+ * Check all providers sequentially.
+ * The test requirement is shared: it stays pending between agents until one
+ * succeeds, then it's removed. If all fail, it's removed at the end.
+ *
+ * Returns { [providerId]: checkResult }
+ */
+async function checkAllProviders(providerIds, config = {}, repoPath, onProgress = null, signal = null) {
+  const results = {};
+
+  for (const id of providerIds) {
+    if (signal && signal.cancelled) break;
+    if (onProgress) onProgress(id, 'checking');
+    results[id] = await checkProvider(id, config, repoPath, onProgress, signal);
+    if (onProgress) onProgress(id, 'done', results[id]);
+  }
+
+  // Final cleanup — remove requirement if still pending (all agents failed or skipped)
+  if (repoPath) {
+    const { getRequirementsPath } = require('vibecodingmachine-core');
+    let reqPath;
+    try { reqPath = await getRequirementsPath(repoPath); } catch {
+      reqPath = path.join(repoPath, '.vibecodingmachine', 'REQUIREMENTS.md');
+    }
+    try { removeTestRequirement(reqPath); } catch { }
+    try { fs.unlinkSync(getResultFilePath(repoPath)); } catch { }
+  }
+
+  return results;
+}
+
+module.exports = {
+  checkProvider,
+  checkAllProviders
+};