vibecodingmachine-core 2025.12.25-25 → 2026.1.22-1441

package/src/utils/requirement-helpers.js

@@ -514,8 +514,17 @@ async function loadVerifiedFromChangelog(repoPath) {
     for (const line of lines) {
       const trimmed = line.trim();
 
+      if (trimmed.includes('## Verified Requirements')) {
+        inVerifiedSection = true;
+        continue;
+      }
+
+      if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+        break;
+      }
+
       // Collect items starting with "- " as verified requirements
-      if (trimmed.startsWith('- ') && trimmed.length > 5) {
+      if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 5) {
         let reqText = trimmed.substring(2);
         // Extract title part (before timestamp in parentheses if present)
         const titleMatch = reqText.match(/^(.+?)\s*\([\d-]+\)$/);
@@ -547,6 +556,8 @@ async function getProjectRequirementStats(repoPath) {
     let todoCount = 0;
     let toVerifyCount = 0;
     let verifiedCount = 0;
+    let clarificationCount = 0;
+    let recycledCount = 0;
 
     if (reqPath && await fs.pathExists(reqPath)) {
       const content = await fs.readFile(reqPath, 'utf8');
@@ -562,15 +573,31 @@ async function getProjectRequirementStats(repoPath) {
         'Verified by AI screenshot'
       ];
 
+      const clarificationVariants = [
+        'NEEDING CLARIFICATION',
+        'Requirements that need information',
+        'need information'
+      ];
+
+      const recycledVariants = [
+        '♻️ Recycled',
+        'Recycled'
+      ];
+
       for (const line of lines) {
         const trimmed = line.trim();
 
         if (trimmed.startsWith('###')) {
           if (currentSection) {
-            const requirementText = trimmed.replace(/^###\s*/, '').trim();
-            if (requirementText) {
+            // Remove ALL leading ### markers including spaces between them (handles "###", "### ###", "#### ####", etc.)
+            const requirementText = trimmed.replace(/^(#{1,}\s*)+/, '').trim();
+            // Filter out empty titles and package names
+            const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+            if (requirementText && requirementText.length > 0 && !packageNames.includes(requirementText.toLowerCase())) {
               if (currentSection === 'todo') todoCount++;
               else if (currentSection === 'toverify') toVerifyCount++;
+              else if (currentSection === 'clarification') clarificationCount++;
+              else if (currentSection === 'recycled') recycledCount++;
             }
           }
         } else if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
@@ -579,6 +606,10 @@ async function getProjectRequirementStats(repoPath) {
             currentSection = 'todo';
           } else if (verifySectionVariants.some(v => trimmed.includes(v))) {
             currentSection = 'toverify';
+          } else if (clarificationVariants.some(v => trimmed.includes(v))) {
+            currentSection = 'clarification';
+          } else if (recycledVariants.some(v => trimmed.includes(v))) {
+            currentSection = 'recycled';
           } else {
             currentSection = '';
           }
@@ -590,22 +621,30 @@ async function getProjectRequirementStats(repoPath) {
     const verifiedReqs = await loadVerifiedFromChangelog(repoPath);
     verifiedCount = verifiedReqs.length;
 
-    const total = todoCount + toVerifyCount + verifiedCount;
+    const total = todoCount + toVerifyCount + verifiedCount + clarificationCount + recycledCount;
     const todoPercent = total > 0 ? Math.round((todoCount / total) * 100) : 0;
     const toVerifyPercent = total > 0 ? Math.round((toVerifyCount / total) * 100) : 0;
     const verifiedPercent = total > 0 ? Math.round((verifiedCount / total) * 100) : 0;
+    const clarificationPercent = total > 0 ? Math.round((clarificationCount / total) * 100) : 0;
+    const recycledPercent = total > 0 ? Math.round((recycledCount / total) * 100) : 0;
 
     return {
       todoCount,
       toVerifyCount,
       verifiedCount,
+      clarificationCount,
+      recycledCount,
       total,
       todoPercent,
       toVerifyPercent,
       verifiedPercent,
+      clarificationPercent,
+      recycledPercent,
       todoLabel: `TODO (${todoCount} - ${todoPercent}%)`,
       toVerifyLabel: `TO VERIFY (${toVerifyCount} - ${toVerifyPercent}%)`,
-      verifiedLabel: `VERIFIED (${verifiedCount} - ${verifiedPercent}%)`
+      verifiedLabel: `VERIFIED (${verifiedCount} - ${verifiedPercent}%)`,
+      clarificationLabel: `CLARIFICATION (${clarificationCount} - ${clarificationPercent}%)`,
+      recycledLabel: `RECYCLED (${recycledCount} - ${recycledPercent}%)`
     };
   } catch (error) {
     logger.error('❌ Error getting project requirement stats:', error);

package/src/utils/requirements-parser.js

@@ -112,9 +112,11 @@ function parseRequirementsFile(content) {
       }
 
       const details = [];
-      let package = null;
+      const questions = [];
+      let pkg = null;
       let options = null;
       let optionsType = null;
+      let currentQuestion = null;
 
       // Read package, description, and options
       for (let j = i + 1; j < lines.length; j++) {
@@ -127,7 +129,7 @@ function parseRequirementsFile(content) {
 
         // Check for PACKAGE line
         if (nextLine.startsWith('PACKAGE:')) {
-          package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+          pkg = nextLine.replace(/^PACKAGE:\s*/, '').trim();
         }
         // Check for OPTIONS line (for need information requirements)
         else if (nextLine.startsWith('OPTIONS:')) {
@@ -140,18 +142,41 @@ function parseRequirementsFile(content) {
             options = [optionsText];
           }
         }
+        // Check for QUESTIONS line (pipe-separated)
+        else if (nextLine.startsWith('QUESTIONS:')) {
+          const questionsText = nextLine.replace(/^QUESTIONS:\s*/, '').trim();
+          const parsedQuestions = questionsText.split('|').map(q => q.trim()).filter(Boolean);
+          for (const q of parsedQuestions) {
+            questions.push({ question: q, response: null });
+          }
+        }
+        // Parse numbered questions/responses in needInformation section (CLI-style)
+        else if (currentSection === 'needInformation' && nextLine.match(/^\d+\./)) {
+          if (currentQuestion) {
+            questions.push(currentQuestion);
+          }
+          currentQuestion = { question: nextLine, response: null };
+        }
+        else if (currentSection === 'needInformation' && currentQuestion && nextLine.startsWith('Response:')) {
+          currentQuestion.response = nextLine.replace(/^Response:\s*/, '').trim();
+        }
         // Description line (include all lines including empty ones to preserve formatting)
         else if (nextLine !== undefined) {
           details.push(nextLine);
         }
       }
 
+      if (currentQuestion) {
+        questions.push(currentQuestion);
+      }
+
       const requirement = {
         title,
         description: details.join('\n'),
-        package,
+        package: pkg,
         options,
         optionsType,
+        questions: currentSection === 'needInformation' ? questions : undefined,
         lineIndex: i
       };
 

package/tests/health-tracking/health-reporter.test.js

@@ -0,0 +1,329 @@
+/**
+ * Unit Tests for HealthReporter
+ * 
+ * Tests for formatting health data for CLI and Electron UI display.
+ */
+
+const { HealthReporter } = require('../../../src/health-tracking/health-reporter');
+
+describe('HealthReporter', () => {
+  let reporter;
+  let mockMetrics;
+
+  beforeEach(() => {
+    reporter = new HealthReporter();
+    
+    mockMetrics = {
+      cursor: {
+        successCount: 42,
+        failureCount: 3,
+        successRate: 0.933,
+        averageResponseTime: 121500,
+        currentTimeout: 170100,
+        consecutiveFailures: 0,
+        lastSuccess: '2026-01-21T09:15:00.000Z',
+        lastFailure: '2026-01-20T23:45:00.000Z',
+        totalInteractions: 45,
+        recentInteractions: [
+          {
+            timestamp: '2026-01-21T09:15:00.000Z',
+            outcome: 'success',
+            responseTime: 120000,
+            timeoutUsed: 180000,
+            continuationPromptsDetected: 1,
+            requirementId: 'req-042',
+            errorMessage: null
+          }
+        ]
+      },
+      windsurf: {
+        successCount: 28,
+        failureCount: 15,
+        successRate: 0.651,
+        averageResponseTime: 1490000,
+        currentTimeout: 2086000,
+        consecutiveFailures: 2,
+        lastSuccess: '2026-01-21T08:30:00.000Z',
+        lastFailure: '2026-01-21T07:15:00.000Z',
+        totalInteractions: 43,
+        recentInteractions: [
+          {
+            timestamp: '2026-01-21T08:30:00.000Z',
+            outcome: 'failure',
+            responseTime: null,
+            timeoutUsed: 1800000,
+            continuationPromptsDetected: 0,
+            requirementId: 'req-041',
+            errorMessage: 'Timeout exceeded'
+          }
+        ]
+      }
+    };
+  });
+
+  describe('formatForCLI', () => {
+    it('should format health metrics for CLI display', () => {
+      const formatted = reporter.formatForCLI(mockMetrics);
+
+      expect(formatted).toContain('🖥️  Cursor');
+      expect(formatted).toContain('+42 -3');
+      expect(formatted).toContain('93.3%');
+      expect(formatted).toContain('2.0m');
+      expect(formatted).toContain('✅ Healthy');
+
+      expect(formatted).toContain('🌊  Windsurf');
+      expect(formatted).toContain('+28 -15');
+      expect(formatted).toContain('65.1%');
+      expect(formatted).toContain('24.9m');
+      expect(formatted).toContain('⚠️  2 consecutive failures');
+    });
+
+    it('should handle empty metrics', () => {
+      const formatted = reporter.formatForCLI({});
+
+      expect(formatted).toContain('No IDE health data available');
+    });
+
+    it('should show warning for IDEs with consecutive failures', () => {
+      const metricsWithFailures = {
+        cursor: {
+          ...mockMetrics.cursor,
+          consecutiveFailures: 3
+        }
+      };
+
+      const formatted = reporter.formatForCLI(metricsWithFailures);
+
+      expect(formatted).toContain('⚠️  3 consecutive failures');
+      expect(formatted).not.toContain('✅ Healthy');
+    });
+
+    it('should format timestamps relative to now', () => {
+      const now = new Date('2026-01-21T10:00:00.000Z');
+      const formatted = reporter.formatForCLI(mockMetrics, now);
+
+      expect(formatted).toContain('Last success: 45m ago');
+      expect(formatted).toContain('Last failure: 10h ago');
+    });
+
+    it('should show "Never" for null timestamps', () => {
+      const metricsWithNulls = {
+        cursor: {
+          ...mockMetrics.cursor,
+          lastSuccess: null,
+          lastFailure: null
+        }
+      };
+
+      const formatted = reporter.formatForCLI(metricsWithNulls);
+
+      expect(formatted).toContain('Last success: Never');
+      expect(formatted).toContain('Last failure: Never');
+    });
+  });
+
+  describe('formatForElectron', () => {
+    it('should format health metrics for Electron UI', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      expect(formatted).toHaveProperty('cursor');
+      expect(formatted).toHaveProperty('windsurf');
+
+      const cursorData = formatted.cursor;
+      expect(cursorData.ide).toBe('Cursor');
+      expect(cursorData.successCount).toBe(42);
+      expect(cursorData.failureCount).toBe(3);
+      expect(cursorData.successRate).toBe(93.3);
+      expect(cursorData.averageResponseTime).toBe('2.0m');
+      expect(cursorData.currentTimeout).toBe('2.8m');
+      expect(cursorData.status).toBe('healthy');
+      expect(cursorData.lastSuccess).toBe('45m ago');
+      expect(cursorData.lastFailure).toBe('10h ago');
+    });
+
+    it('should include recent interactions in Electron format', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      const cursorData = formatted.cursor;
+      expect(cursorData.recentInteractions).toHaveLength(1);
+      
+      const interaction = cursorData.recentInteractions[0];
+      expect(interaction.outcome).toBe('success');
+      expect(interaction.displayTime).toBe('2.0m');
+      expect(interaction.requirementId).toBe('req-042');
+    });
+
+    it('should handle IDEs with no interactions', () => {
+      const metricsWithNoInteractions = {
+        vscode: {
+          successCount: 0,
+          failureCount: 0,
+          successRate: 0,
+          averageResponseTime: 0,
+          currentTimeout: 1800000,
+          consecutiveFailures: 0,
+          lastSuccess: null,
+          lastFailure: null,
+          totalInteractions: 0,
+          recentInteractions: []
+        }
+      };
+
+      const formatted = reporter.formatForElectron(metricsWithNoInteractions);
+
+      const vscodeData = formatted.vscode;
+      expect(vscodeData.status).toBe('no-data');
+      expect(vscodeData.successRate).toBe(0);
+      expect(vscodeData.averageResponseTime).toBe('N/A');
+    });
+
+    it('should format response times in human-readable units', () => {
+      const formatted = reporter.formatForElectron(mockMetrics);
+
+      expect(formatted.cursor.averageResponseTime).toBe('2.0m'); // 121.5s
+      expect(formatted.windsurf.averageResponseTime).toBe('24.9m'); // 1490s
+      expect(formatted.cursor.currentTimeout).toBe('2.8m'); // 170.1s
+      expect(formatted.windsurf.currentTimeout).toBe('34.8m'); // 2086s
+    });
+  });
+
+  describe('generateSummary', () => {
+    it('should generate overall health summary', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      expect(summary.totalIDEs).toBe(2);
+      expect(summary.healthyIDEs).toBe(1);
+      expect(summary.problematicIDEs).toBe(1);
+      expect(summary.totalInteractions).toBe(88);
+      expect(summary.overallSuccessRate).toBe(79.5);
+      expect(summary.averageResponseTime).toBe(805750); // Weighted average
+      expect(summary.recommendedIDE).toBe('cursor');
+    });
+
+    it('should handle empty metrics in summary', () => {
+      const summary = reporter.generateSummary({});
+
+      expect(summary.totalIDEs).toBe(0);
+      expect(summary.healthyIDEs).toBe(0);
+      expect(summary.problematicIDEs).toBe(0);
+      expect(summary.totalInteractions).toBe(0);
+      expect(summary.overallSuccessRate).toBe(0);
+      expect(summary.averageResponseTime).toBe(0);
+      expect(summary.recommendedIDE).toBeNull();
+    });
+
+    it('should calculate weighted average response time', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      // Weighted average: (45 * 121500 + 43 * 1490000) / 88
+      const expected = (45 * 121500 + 43 * 1490000) / 88;
+      expect(summary.averageResponseTime).toBeCloseTo(expected, 0);
+    });
+
+    it('should identify recommended IDE based on success rate', () => {
+      const summary = reporter.generateSummary(mockMetrics);
+
+      expect(summary.recommendedIDE).toBe('cursor'); // 93.3% vs 65.1%
+    });
+
+    it('should return null for recommendation when no IDE has sufficient data', () => {
+      const metricsWithInsufficientData = {
+        cursor: {
+          successCount: 1,
+          failureCount: 0,
+          successRate: 1.0,
+          totalInteractions: 1
+        }
+      };
+
+      const summary = reporter.generateSummary(metricsWithInsufficientData);
+
+      expect(summary.recommendedIDE).toBeNull();
+    });
+  });
+
+  describe('formatResponseTime', () => {
+    it('should format milliseconds to human readable format', () => {
+      expect(reporter.formatResponseTime(500)).toBe('500ms');
+      expect(reporter.formatResponseTime(1500)).toBe('1.5s');
+      expect(reporter.formatResponseTime(60000)).toBe('1.0m');
+      expect(reporter.formatResponseTime(121500)).toBe('2.0m');
+      expect(reporter.formatResponseTime(3600000)).toBe('1.0h');
+      expect(reporter.formatResponseTime(7200000)).toBe('2.0h');
+    });
+
+    it('should handle zero and null values', () => {
+      expect(reporter.formatResponseTime(0)).toBe('0ms');
+      expect(reporter.formatResponseTime(null)).toBe('N/A');
+      expect(reporter.formatResponseTime(undefined)).toBe('N/A');
+    });
+  });
+
+  describe('formatTimestamp', () => {
+    it('should format timestamps relative to now', () => {
+      const now = new Date('2026-01-21T10:00:00.000Z');
+      
+      expect(reporter.formatTimestamp('2026-01-21T09:15:00.000Z', now))
+        .toBe('45m ago');
+      
+      expect(reporter.formatTimestamp('2026-01-21T08:00:00.000Z', now))
+        .toBe('2h ago');
+      
+      expect(reporter.formatTimestamp('2026-01-20T10:00:00.000Z', now))
+        .toBe('24h ago');
+      
+      expect(reporter.formatTimestamp('2026-01-19T10:00:00.000Z', now))
+        .toBe('2d ago');
+    });
+
+    it('should handle null timestamps', () => {
+      expect(reporter.formatTimestamp(null)).toBe('Never');
+      expect(reporter.formatTimestamp(undefined)).toBe('Never');
+    });
+
+    it('should use current time when no reference provided', () => {
+      const timestamp = new Date(Date.now() - 5 * 60 * 1000).toISOString(); // 5 minutes ago
+      const formatted = reporter.formatTimestamp(timestamp);
+      
+      expect(formatted).toBe('5m ago');
+    });
+  });
+
+  describe('getHealthStatus', () => {
+    it('should return healthy for IDEs with no consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 0,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('healthy');
+    });
+
+    it('should return warning for IDEs with consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 3,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('warning');
+    });
+
+    it('should return critical for IDEs with many consecutive failures', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 6,
+        totalInteractions: 10
+      });
+
+      expect(status).toBe('critical');
+    });
+
+    it('should return no-data for IDEs with no interactions', () => {
+      const status = reporter.getHealthStatus({
+        consecutiveFailures: 0,
+        totalInteractions: 0
+      });
+
+      expect(status).toBe('no-data');
+    });
+  });
+});