vibecodingmachine-core 2025.12.1-534 → 2025.12.22-2230

package/src/utils/requirements-parser.js

@@ -0,0 +1,324 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Parse requirements file and extract all sections
+ * This matches the CLI's parsing logic to ensure consistency
+ * @param {string} content - The requirements file content
+ * @returns {Object} Parsed requirements with sections: requirements, completed, needInformation, changelog, verified
+ */
+function parseRequirementsFile(content) {
+  const lines = content.split('\n');
+  const requirements = [];
+  const completed = [];
+  const needInformation = [];
+  const changelog = [];
+  const verified = [];
+  const current = [];
+
+  let currentSection = '';
+  let inSection = false;
+
+  // Section detection patterns (matching CLI logic)
+  const sectionPatterns = {
+    todo: ['⏳ Requirements not yet completed', 'Requirements not yet completed'],
+    verify: [
+      '🔍 TO VERIFY BY HUMAN',
+      'TO VERIFY BY HUMAN',
+      '🔍 TO VERIFY',
+      'TO VERIFY',
+      '✅ TO VERIFY',
+      '✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+      'Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+      'Verified by AI screenshot'
+    ],
+    verified: ['📝 VERIFIED', 'VERIFIED'],
+    changelog: ['CHANGELOG'],
+    needInformation: ['❓ Requirements needing', 'Requirements needing', 'needing manual feedback', 'needing information'],
+    current: ['🔨 Current In Progress Requirement', 'Current In Progress Requirement']
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check for section headers (## but not ###)
+    if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      // Determine which section we're entering
+      if (sectionPatterns.todo.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'todo';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verify.some(pattern => {
+        const matches = trimmed.includes(pattern);
+        // Make sure it's not a VERIFIED section (without TO VERIFY)
+        if (matches && !trimmed.includes('📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+          return true;
+        }
+        return false;
+      })) {
+        currentSection = 'verify';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verified.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'verified';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.changelog.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'changelog';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.needInformation.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'needInformation';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.current.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'current';
+        inSection = true;
+        continue;
+      } else {
+        // Different section header - exit current section
+        if (inSection) {
+          // Check if we're leaving TO VERIFY section
+          if (currentSection === 'verify') {
+            const isTodoSection = trimmed.includes('⏳ Requirements not yet completed') || trimmed.includes('Requirements not yet completed');
+            const isVerifiedSection = trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED');
+            const isRecycledSection = trimmed === '## ♻️ RECYCLED' || trimmed.startsWith('## ♻️ RECYCLED') ||
+              trimmed === '## 📦 RECYCLED' || trimmed.startsWith('## 📦 RECYCLED');
+            const isClarificationSection = trimmed.includes('## ❓ Requirements needing') || trimmed.includes('❓ Requirements needing');
+
+            if (isVerifiedSection || isTodoSection || isRecycledSection || isClarificationSection) {
+              inSection = false;
+              currentSection = '';
+            }
+            // Otherwise continue - might be REJECTED or CHANGELOG which are not section boundaries for TO VERIFY
+          } else {
+            inSection = false;
+            currentSection = '';
+          }
+        }
+        continue;
+      }
+    }
+
+    // Parse requirements in new format (### header)
+    if (inSection && trimmed.startsWith('###')) {
+      const title = trimmed.replace(/^###\s*/, '').trim();
+
+      // Skip malformed requirements (title is just a package name, empty, or too short)
+      const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+      if (!title || title.length === 0 || packageNames.includes(title.toLowerCase())) {
+        continue;
+      }
+
+      const details = [];
+      let package = null;
+      let options = null;
+      let optionsType = null;
+
+      // Read package, description, and options
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextLine = lines[j].trim();
+
+        // Stop if we hit another requirement or section
+        if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+          break;
+        }
+
+        // Check for PACKAGE line
+        if (nextLine.startsWith('PACKAGE:')) {
+          package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+        }
+        // Check for OPTIONS line (for need information requirements)
+        else if (nextLine.startsWith('OPTIONS:')) {
+          optionsType = 'checkbox'; // default
+          const optionsText = nextLine.replace(/^OPTIONS:\s*/, '').trim();
+          // Parse options (could be checkbox or radio)
+          if (optionsText.includes('|')) {
+            options = optionsText.split('|').map(opt => opt.trim()).filter(opt => opt);
+          } else {
+            options = [optionsText];
+          }
+        }
+        // Description line (include all lines including empty ones to preserve formatting)
+        else if (nextLine !== undefined) {
+          details.push(nextLine);
+        }
+      }
+
+      const requirement = {
+        title,
+        description: details.join('\n'),
+        package,
+        options,
+        optionsType,
+        lineIndex: i
+      };
+
+      // Add to appropriate array based on current section
+      if (currentSection === 'todo') {
+        requirements.push(requirement);
+      } else if (currentSection === 'verify') {
+        completed.push(requirement);
+      } else if (currentSection === 'needInformation') {
+        needInformation.push(requirement);
+      } else if (currentSection === 'changelog') {
+        changelog.push(requirement);
+      } else if (currentSection === 'verified') {
+        verified.push(requirement);
+      } else if (currentSection === 'current') {
+        current.push(requirement);
+      }
+    }
+
+    // Also support old format (lines starting with -) for backwards compatibility
+    if (inSection && trimmed.startsWith('- ') && !trimmed.startsWith('###')) {
+      const requirementText = trimmed.substring(2).trim();
+      if (requirementText) {
+        // Extract date if present (format: "2025-12-25 2:35 PM MDT - " or "2025-10-03: ")
+        const dateTimeMatch = requirementText.match(/^(\d{4}-\d{2}-\d{2})(?:\s+\d{1,2}:\d{2}\s+[AP]M(?:\s+[A-Z]{2,5})?)?\s*[-:]\s*/);
+        const date = dateTimeMatch ? dateTimeMatch[1] : null;
+        const title = dateTimeMatch ? requirementText.substring(dateTimeMatch[0].length).trim() : requirementText;
+
+        const requirement = {
+          title: title.length > 100 ? title.substring(0, 100) + '...' : title,
+          description: title,
+          date: date
+        };
+
+        if (currentSection === 'todo') {
+          requirements.push(requirement);
+        } else if (currentSection === 'verify' || currentSection === 'completed') {
+          completed.push(requirement);
+        } else if (currentSection === 'changelog') {
+          changelog.push(requirement);
+        }
+      }
+    }
+  }
+
+  // Remove duplicates based on title (keep first occurrence)
+  const seenTitles = new Set();
+  const uniqueRequirements = [];
+  for (const req of requirements) {
+    const normalizedTitle = req.title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+    if (!seenTitles.has(normalizedTitle)) {
+      seenTitles.add(normalizedTitle);
+      uniqueRequirements.push(req);
+    }
+  }
+
+  return {
+    requirements: uniqueRequirements,
+    completed,
+    needInformation,
+    changelog,
+    verified,
+    current
+  };
+}
+
+/**
+ * Load verified requirements from CHANGELOG.md
+ * @param {string} repoPath - Path to repository root
+ * @returns {Promise<Array>} Array of verified requirement titles
+ */
+async function loadVerifiedFromChangelog(repoPath) {
+  try {
+    const changelogPath = path.join(repoPath, 'CHANGELOG.md');
+    if (!await fs.pathExists(changelogPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(changelogPath, 'utf8');
+    const lines = content.split('\n');
+    const requirements = [];
+    let inVerifiedSection = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Check for Verified Requirements section
+      if (trimmed.includes('## Verified Requirements')) {
+        inVerifiedSection = true;
+        continue;
+      }
+
+      // Exit section if we hit another ## header
+      if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+        break;
+      }
+
+      // Only collect items from within the Verified Requirements section
+      if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 10) {
+        const title = trimmed.substring(2).trim();
+        // Extract date if present (format: "Title (2025-12-05)")
+        const dateMatch = title.match(/^(.+?)\s*\((\d{4}-\d{2}-\d{2})\)$/);
+        const cleanTitle = dateMatch ? dateMatch[1].trim() : title;
+        const date = dateMatch ? dateMatch[2] : null;
+
+        requirements.push({
+          title: cleanTitle,
+          description: cleanTitle,
+          date: date
+        });
+      }
+    }
+
+    return requirements;
+  } catch (error) {
+    // If CHANGELOG.md doesn't exist or can't be read, return empty array
+    return [];
+  }
+}
+
+/**
+ * Load and parse requirements from file
+ * @param {string} reqPath - Path to requirements file
+ * @param {string} repoPath - Optional path to repository root (for loading CHANGELOG.md)
+ * @returns {Promise<Object>} Parsed requirements
+ */
+async function loadRequirementsFromFile(reqPath, repoPath = null) {
+  try {
+    const parsed = {
+      requirements: [],
+      completed: [],
+      needInformation: [],
+      changelog: [],
+      verified: [],
+      current: []
+    };
+
+    if (await fs.pathExists(reqPath)) {
+      const content = await fs.readFile(reqPath, 'utf8');
+      const fileParsed = parseRequirementsFile(content);
+      Object.assign(parsed, fileParsed);
+    }
+
+    // Also load verified from CHANGELOG.md if repoPath is provided
+    if (repoPath) {
+      const verifiedFromChangelog = await loadVerifiedFromChangelog(repoPath);
+      // Merge with verified from requirements file (CHANGELOG.md takes precedence)
+      if (verifiedFromChangelog.length > 0) {
+        parsed.verified = verifiedFromChangelog;
+      }
+    }
+
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to load requirements from file: ${error.message}`);
+  }
+}
+
+module.exports = {
+  parseRequirementsFile,
+  loadRequirementsFromFile,
+  loadVerifiedFromChangelog
+};
+
+
+
+
+
+
+

package/src/utils/update-checker.js

@@ -1,6 +1,7 @@
 const https = require('https');
 const fs = require('fs');
 const path = require('path');
+const { shouldCheckUpdates } = require('./env-helpers');
 
 /**
  * Check for updates from npm registry
@@ -9,6 +10,9 @@ const path = require('path');
  * @returns {Promise<Object>} Update info or null if no update available
  */
 async function checkForUpdates(packageName, currentVersion) {
+  if (!shouldCheckUpdates()) {
+    return { hasUpdate: false, currentVersion };
+  }
   return new Promise((resolve, reject) => {
     const registryUrl = `https://registry.npmjs.org/${packageName}`;
 
@@ -80,6 +84,9 @@ function isVersionNewer(version1, version2) {
  * @returns {Promise<Object>} Update info or null if no update available
  */
 async function checkForCLIUpdates(currentVersion) {
+  if (!shouldCheckUpdates()) {
+    return { hasUpdate: false, currentVersion };
+  }
   return new Promise((resolve, reject) => {
     const manifestUrl = `https://d3fh7zgi8horze.cloudfront.net/downloads/version.json?t=${Date.now()}`;
 

package/test-quota-system.js

@@ -0,0 +1,67 @@
+const { fetchQuotaForAgent } = require('./src/quota-management/index.js');
+const sharedAuth = require('./src/auth/shared-auth-storage');
+const ProviderManager = require('./src/ide-integration/provider-manager.cjs');
+
+async function testQuotaSystem() {
+    console.log('🧪 Starting Quota System Verification Test...');
+
+    // 1. Test Global Iterations Quota
+    console.log('\n--- Test 1: Global Iterations ---');
+    // Mock sharedAuth.canRunAutoMode
+    const originalCanRun = sharedAuth.canRunAutoMode;
+    sharedAuth.canRunAutoMode = async () => ({
+        canRun: true,
+        todayUsage: 4,
+        maxIterations: 10
+    });
+
+    try {
+        const globalQuota = await fetchQuotaForAgent('global:iterations');
+        console.log('Global Quota Type:', globalQuota.type);
+        console.log('Global Remaining:', globalQuota.remaining);
+        console.log('Global Limit:', globalQuota.limit);
+        if (globalQuota.remaining === 6 && globalQuota.type === 'global') {
+            console.log('✅ Global iterations test passed');
+        } else {
+            console.log('❌ Global iterations test failed');
+        }
+    } catch (error) {
+        console.error('❌ Global iterations test error:', error);
+    } finally {
+        sharedAuth.canRunAutoMode = originalCanRun;
+    }
+
+    // 2. Test Local Agent (Infinite)
+    console.log('\n--- Test 2: Local Agent (Infinite) ---');
+    try {
+        const localQuota = await fetchQuotaForAgent('local-ollama:qwen2.5');
+        console.log('Local Quota Type:', localQuota.type);
+        console.log('Local Remaining:', localQuota.remaining);
+        if (localQuota.remaining === Infinity && localQuota.type === 'infinite') {
+            console.log('✅ Local agent test passed');
+        } else {
+            console.log('❌ Local agent test failed');
+        }
+    } catch (error) {
+        console.error('❌ Local agent test error:', error);
+    }
+
+    // 3. Test Provider Rate Limit
+    console.log('\n--- Test 3: Provider Rate Limit ---');
+    try {
+        const providerQuota = await fetchQuotaForAgent('anthropic:claude-3');
+        console.log('Provider Quota Type:', providerQuota.type);
+        console.log('Provider Available (Remaining > 0):', providerQuota.remaining > 0);
+        if (providerQuota.type === 'rate-limit') {
+            console.log('✅ Provider rate limit test passed');
+        } else {
+            console.log('❌ Provider rate limit test failed');
+        }
+    } catch (error) {
+        console.error('❌ Provider rate limit test error:', error);
+    }
+
+    console.log('\n🏁 Quota System Verification Finished.');
+}
+
+testQuotaSystem().catch(console.error);

package/test-requirement-stats.js

@@ -0,0 +1,66 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const { getProjectRequirementStats } = require('./src/utils/requirement-helpers');
+
+async function testStats() {
+    const testRepo = path.join(os.tmpdir(), 'vbc-test-stats-repo');
+    const hostname = os.hostname();
+    const vibecodingmachineDir = path.join(testRepo, '.vibecodingmachine');
+    const reqPath = path.join(vibecodingmachineDir, `REQUIREMENTS-${hostname}.md`);
+    const changelogPath = path.join(testRepo, 'CHANGELOG.md');
+
+    try {
+        await fs.ensureDir(vibecodingmachineDir);
+
+        const reqContent = `# Requirements
+## ⏳ Requirements not yet completed
+### Req 1
+Details 1
+### Req 2
+Details 2
+
+## ✅ Verified by AI screenshot
+### Req 3
+Details 3
+`;
+        await fs.writeFile(reqPath, reqContent);
+
+        const changelogContent = `# Changelog
+## Verified Requirements
+- Req 4 (2025-12-18)
+- Req 5 (2025-12-18)
+`;
+        await fs.writeFile(changelogPath, changelogContent);
+
+        console.log('🧪 Testing getProjectRequirementStats...');
+        const stats = await getProjectRequirementStats(testRepo);
+
+        console.log('Result:', JSON.stringify(stats, null, 2));
+
+        const expected = {
+            todoCount: 2,
+            toVerifyCount: 1,
+            verifiedCount: 2,
+            total: 5
+        };
+
+        if (stats.todoCount === expected.todoCount &&
+            stats.toVerifyCount === expected.toVerifyCount &&
+            stats.verifiedCount === expected.verifiedCount &&
+            stats.total === expected.total) {
+            console.log('✅ PASS: Stats match expected values');
+        } else {
+            console.error('❌ FAIL: Stats do not match expected values');
+            process.exit(1);
+        }
+
+    } catch (error) {
+        console.error('❌ Error in test:', error);
+        process.exit(1);
+    } finally {
+        await fs.remove(testRepo);
+    }
+}
+
+testStats();