vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/quota-detectors.js

@@ -0,0 +1,212 @@
+/**
+ * Quota Detectors Module
+ * 
+ * Handles quota limit detection for various AI providers.
+ */
+
+const fs = require('fs');
+
+/**
+ * Check for quota limit indicators in process output and error messages
+ */
+function checkQuotaInOutput(providerId, output, errorMessage) {
+  const debugLog = (msg) => {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${msg}\n`;
+    try {
+      fs.appendFileSync(`/tmp/vibe-${providerId}-quota-debug.log`, logLine);
+    } catch (_) {}
+    console.log(`[AGENT CHECK] ${msg}`);
+  };
+  
+  debugLog(`Checking for ${providerId} quota limit...`);
+  
+  // Check process output first for quota error keywords
+  const lowerOutput = output.toLowerCase();
+  const lowerErrorMsg = errorMessage.toLowerCase();
+  debugLog('Checking process output length: ' + output.length);
+  debugLog('Process output sample: ' + output.substring(0, 300));
+  
+  // Check both output and error message for quota keywords
+  const quotaKeywords = [
+    'quota', 
+    'rate limit', 
+    'resource_exhausted', 
+    'usage limit', 
+    'model quota', 
+    'limit exceeded', 
+    'spending cap', 
+    'usage cap', 
+    'you\'ve reached your monthly chat messages quota', 
+    'upgrade to copilot pro', 
+    'wait for your allowance to renew'
+  ];
+  const hasQuotaKeyword = quotaKeywords.some(kw => lowerOutput.includes(kw) || lowerErrorMsg.includes(kw));
+  
+  if (hasQuotaKeyword) {
+    debugLog(`🚨 Quota keywords found in process output or message for ${providerId}`);
+    return {
+      rateLimited: true,
+      rateLimitMessage: output || errorMessage,
+      providerSpecific: setProviderSpecificFlags(providerId, {})
+    };
+  }
+  
+  debugLog(`No quota keywords in process output or message for ${providerId}`);
+  return null;
+}
+
+/**
+ * Set provider-specific rate limit flags for compatibility
+ */
+function setProviderSpecificFlags(providerId, result) {
+  switch (providerId) {
+    case 'antigravity':
+      result.antigravityRateLimited = true;
+      break;
+    case 'windsurf':
+      result.windsurfRateLimited = true;
+      break;
+    case 'cursor':
+      result.cursorRateLimited = true;
+      break;
+    case 'github-copilot':
+      result.githubCopilotRateLimited = true;
+      break;
+  }
+  return result;
+}
+
+/**
+ * Check quota limit using AppleScript UI scraping (macOS only)
+ */
+async function checkQuotaWithAppleScript(providerId) {
+  if (process.platform !== 'darwin') {
+    return null;
+  }
+
+  const debugLog = (msg) => {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${msg}\n`;
+    try {
+      fs.appendFileSync(`/tmp/vibe-${providerId}-quota-debug.log`, logLine);
+    } catch (_) {}
+    console.log(`[AGENT CHECK] ${msg}`);
+  };
+
+  try {
+    const { AppleScriptManager } = require('vibecodingmachine-core');
+    const appleScriptManager = new AppleScriptManager();
+    let quotaCheck = null;
+    
+    // Use specific quota detection methods for each IDE
+    switch (providerId) {
+      case 'antigravity':
+        quotaCheck = await appleScriptManager.checkAntigravityQuotaLimit();
+        break;
+      case 'windsurf':
+        quotaCheck = await appleScriptManager.checkWindsurfQuotaLimit();
+        break;
+      case 'cursor':
+        quotaCheck = await appleScriptManager.checkCursorQuotaLimit();
+        break;
+      case 'github-copilot':
+        // GitHub Copilot uses the same detection as Cursor (both are VS Code extensions)
+        quotaCheck = await appleScriptManager.checkCursorQuotaLimit();
+        break;
+      default:
+        debugLog(`No specific quota detection method available for ${providerId}`);
+        return null;
+    }
+    
+    debugLog(`${providerId} quota check result: ` + JSON.stringify(quotaCheck));
+    
+    if (quotaCheck && (quotaCheck.isRateLimited || quotaCheck.hasQuotaWarning)) {
+      debugLog(`🚨 ${providerId} quota limit detected via AppleScript`);
+      const result = {
+        rateLimited: true,
+        rateLimitMessage: quotaCheck.message || quotaCheck.matchedText || `${providerId} quota limit detected`,
+        providerSpecific: {}
+      };
+      
+      if (quotaCheck.resumeAt) {
+        result.rateLimitResume = quotaCheck.resumeAt;
+      }
+      
+      setProviderSpecificFlags(providerId, result.providerSpecific);
+      return result;
+    }
+    
+    debugLog(`No quota limit detected via AppleScript for ${providerId}`);
+    return null;
+    
+  } catch (error) {
+    debugLog(`AppleScript quota check failed for ${providerId}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Main quota detection function that combines multiple detection methods
+ */
+async function detectQuotaLimit(providerId, output, errorMessage) {
+  // First check output and error messages for quota keywords
+  const outputCheck = checkQuotaInOutput(providerId, output, errorMessage);
+  if (outputCheck) {
+    return outputCheck;
+  }
+  
+  // Then try AppleScript UI scraping as fallback (macOS only)
+  const appleScriptCheck = await checkQuotaWithAppleScript(providerId);
+  if (appleScriptCheck) {
+    return appleScriptCheck;
+  }
+  
+  // No quota limit detected
+  return null;
+}
+
+/**
+ * Check if an error result indicates rate limiting
+ */
+function isRateLimited(errorResult) {
+  return !!(errorResult && (
+    errorResult.rateLimited ||
+    errorResult.antigravityRateLimited ||
+    errorResult.windsurfRateLimited ||
+    errorResult.cursorRateLimited ||
+    errorResult.githubCopilotRateLimited
+  ));
+}
+
+/**
+ * Get rate limit message from error result
+ */
+function getRateLimitMessage(errorResult) {
+  if (!errorResult) return null;
+  
+  return errorResult.rateLimitMessage ||
+         errorResult.message ||
+         'Rate limit detected';
+}
+
+/**
+ * Get rate limit resume time from error result
+ */
+function getRateLimitResume(errorResult) {
+  if (!errorResult) return null;
+  
+  return errorResult.rateLimitResume ||
+         errorResult.resumeAt ||
+         null;
+}
+
+module.exports = {
+  checkQuotaInOutput,
+  setProviderSpecificFlags,
+  checkQuotaWithAppleScript,
+  detectQuotaLimit,
+  isRateLimited,
+  getRateLimitMessage,
+  getRateLimitResume
+};

package/src/utils/requirement-action-handlers.js

@@ -0,0 +1,288 @@
+/**
+ * Requirement Action Handlers Module
+ * 
+ * Contains main action handlers for requirements.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const { t, getRequirementsPath } = require('vibecodingmachine-core');
+const { 
+  getRequirementList, 
+  getSectionTitle, 
+  confirmAction, 
+  confirmAndExit,
+  validateRequirementTitle
+} = require('./requirement-helpers');
+const { 
+  editClarificationResponses, 
+  moveClarificationToTodo, 
+  deleteClarification 
+} = require('./requirement-file-operations');
+const {
+  moveRequirementDown,
+  moveRequirementUp,
+  promoteRequirement,
+  demoteRequirement,
+  moveRequirementToRecycled
+} = require('./requirement-navigation');
+
+/**
+ * Helper to show actions for a clarification 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: '❌ Cancel', value: 'cancel' }
+  ];
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `What would you like to do with "${req.title}"?`,
+      choices: actions
+    }
+  ]);
+
+  switch (action) {
+    case 'edit-responses':
+      await editClarificationResponses(req, tree);
+      if (loadClarification) await loadClarification();
+      break;
+    case 'move-to-todo':
+      await moveClarificationToTodo(req, tree);
+      if (loadClarification) await loadClarification();
+      break;
+    case 'delete':
+      await deleteClarification(req, tree);
+      if (loadClarification) await loadClarification();
+      break;
+    case 'cancel':
+      console.log(chalk.gray('Cancelled.'));
+      break;
+  }
+}
+
+/**
+ * Show requirement actions menu
+ */
+async function showRequirementActions(req, sectionKey, tree) {
+  const actions = [
+    { label: '✏️  Rename/Edit', value: 'rename' },
+    { label: '👍 Thumbs up (promote to Verified)', value: 'thumbs-up' },
+    { label: '👎 Thumbs down (demote to TODO)', value: 'thumbs-down' },
+    { label: '⬆️  Move up', value: 'move-up' },
+    { label: '⬇️  Move down', value: 'move-down' },
+    { label: '🗑️  Delete', value: 'delete' },
+    { label: '❌ Cancel', value: 'cancel' }
+  ];
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: `What would you like to do with "${req.title}"?`,
+      choices: actions
+    }
+  ]);
+
+  await performRequirementAction(action, req, sectionKey, tree);
+}
+
+/**
+ * Helper to perform action on requirement
+ */
+async function performRequirementAction(action, req, sectionKey, tree, loadSection, loadVerified) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  switch (action) {
+    case 'rename':
+      await renameRequirement(req, sectionKey, tree, loadSection);
+      break;
+    case 'thumbs-up':
+      await promoteRequirement(req, sectionKey, tree, loadSection, loadVerified);
+      break;
+    case 'thumbs-down':
+      await demoteRequirement(req.title, sectionKey, tree, loadSection, loadVerified);
+      break;
+    case 'move-up':
+      await moveRequirementUp(req, sectionKey, tree);
+      break;
+    case 'move-down':
+      await moveRequirementDown(req, sectionKey, tree);
+      break;
+    case 'delete':
+      await deleteRequirement(req, sectionKey, tree, loadSection);
+      break;
+    case 'cancel':
+      console.log(chalk.gray('Cancelled.'));
+      break;
+  }
+}
+
+/**
+ * Helper to rename requirement (title and description)
+ */
+async function renameRequirement(req, sectionKey, tree, loadSection) {
+  const reqPath = await getRequirementsPath();
+
+  console.log(chalk.cyan('\n✏️  Rename/Edit Requirement\n'));
+
+  const { newTitle } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'newTitle',
+      message: 'Enter new title:',
+      default: req.title
+    }
+  ]);
+
+  const validationError = validateRequirementTitle(newTitle);
+  if (validationError) {
+    console.log(chalk.red(`Error: ${validationError}`));
+    return;
+  }
+
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and update the requirement
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(`### ${req.title}`)) {
+      lines[i] = lines[i].replace(req.title, newTitle);
+      break;
+    }
+  }
+
+  await fs.writeFile(reqPath, lines.join('\n'));
+  console.log(chalk.green('\n✓ Requirement renamed!'));
+  
+  if (loadSection) await loadSection();
+}
+
+/**
+ * Helper to move requirement to recycled section (used to delete)
+ */
+async function deleteRequirement(req, sectionKey, tree, loadSection) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const sectionTitle = getSectionTitle(sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) return;
+
+  const confirmed = await confirmAction(`Delete "${req.title}"? This cannot be undone. (r/y/N)`);
+  if (!confirmed) {
+    console.log(chalk.gray('Cancelled.'));
+    return;
+  }
+
+  const reqPath = await getRequirementsPath();
+  await moveRequirementToRecycled(reqPath, req.title, sectionTitle);
+
+  console.log(chalk.green('\n✓ Requirement moved to recycled!'));
+  
+  if (loadSection) await loadSection();
+}
+
+/**
+ * Helper to permanently delete requirement from file (used for recycled items)
+ */
+async function permanentlyDeleteRequirement(req, sectionKey, tree, loadSection) {
+  const reqList = getRequirementList(tree, sectionKey);
+  const reqIndex = reqList.findIndex(r => r.title === req.title);
+
+  if (reqIndex === -1) return;
+
+  const confirmed = await confirmAction(`Permanently delete "${req.title}"? This cannot be undone. (r/y/N)`);
+  if (!confirmed) {
+    console.log(chalk.gray('Cancelled.'));
+    return;
+  }
+
+  const reqPath = await getRequirementsPath();
+  const content = await fs.readFile(reqPath, 'utf8');
+  const lines = content.split('\n');
+
+  // Find and remove 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) {
+    lines.splice(startIdx, endIdx - startIdx);
+    await fs.writeFile(reqPath, lines.join('\n'));
+  }
+
+  console.log(chalk.green('\n✓ Requirement permanently deleted!'));
+  
+  if (loadSection) await loadSection();
+}
+
+/**
+ * Helper to handle adding requirements
+ */
+async function handleAddRequirement(type) {
+  const reqCommands = require('../commands/requirements');
+  const packages = ['all', 'cli', 'core', 'electron-app', 'web', 'mobile'];
+
+  if (type === 'single') {
+    const { package: pkg } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'package',
+        message: 'Which package?',
+        choices: packages
+      }
+    ]);
+
+    await reqCommands.add({ package: pkg, interactive: true });
+  } else if (type === 'bulk') {
+    const { selectedPackages } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedPackages',
+        message: 'Select packages to add requirements to:',
+        choices: packages.map(pkg => ({ name: pkg, value: pkg }))
+      }
+    ]);
+
+    if (selectedPackages.length === 0) {
+      console.log(chalk.yellow('No packages selected.'));
+      return;
+    }
+
+    for (const pkg of selectedPackages) {
+      await reqCommands.add({ package: pkg, interactive: true });
+    }
+  }
+}
+
+module.exports = {
+  showClarificationActions,
+  showRequirementActions,
+  performRequirementAction,
+  renameRequirement,
+  deleteRequirement,
+  permanentlyDeleteRequirement,
+  handleAddRequirement
+};