vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/monitoring/compliance-progress-tracker.js

@@ -0,0 +1,437 @@
+/**
+ * Compliance Progress Tracker
+ * 
+ * Tracks progress toward 100% file size compliance across the codebase.
+ * Provides metrics, trends, and projections for completion tracking.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ComplianceProgressTracker {
+  constructor(options = {}) {
+    this.options = {
+      maxFileSize: options.maxFileSize || 555,
+      historyFile: options.historyFile || path.resolve(__dirname, '../../../.compliance-history.json'),
+      trackingEnabled: options.trackingEnabled !== false,
+      ...options
+    };
+    
+    this.historyData = this.loadHistory();
+  }
+
+  /**
+   * Load historical progress data
+   */
+  loadHistory() {
+    try {
+      if (fs.existsSync(this.options.historyFile)) {
+        return JSON.parse(fs.readFileSync(this.options.historyFile, 'utf8'));
+      }
+    } catch (error) {
+      console.warn('Failed to load compliance history:', error.message);
+    }
+    
+    return {
+      snapshots: [],
+      milestones: [],
+      projections: {}
+    };
+  }
+
+  /**
+   * Save historical progress data
+   */
+  saveHistory() {
+    try {
+      fs.writeFileSync(this.options.historyFile, JSON.stringify(this.historyData, null, 2));
+    } catch (error) {
+      console.error('Failed to save compliance history:', error.message);
+    }
+  }
+
+  /**
+   * Track current compliance progress
+   */
+  trackProgress(scanResults, taskStats = {}) {
+    const timestamp = new Date().toISOString();
+    
+    const currentSnapshot = {
+      timestamp,
+      totalFiles: scanResults.totalFiles || 0,
+      compliantFiles: scanResults.compliantFiles || 0,
+      nonCompliantFiles: scanResults.nonCompliantFiles || 0,
+      totalViolations: scanResults.totalViolations || 0,
+      compliancePercentage: this.calculateCompliancePercentage(scanResults),
+      tasksCompleted: taskStats.completed || 0,
+      tasksTotal: taskStats.total || 0,
+      taskCompletionPercentage: taskStats.total > 0 ? (taskStats.completed / taskStats.total) * 100 : 0,
+      estimatedHoursRemaining: this.estimateHoursRemaining(scanResults, taskStats),
+      trend: this.calculateTrend(),
+      projectedCompletion: this.projectCompletionDate(scanResults, taskStats)
+    };
+
+    // Add to history
+    this.historyData.snapshots.push(currentSnapshot);
+    
+    // Keep only last 30 days of snapshots
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+    this.historyData.snapshots = this.historyData.snapshots.filter(
+      snapshot => new Date(snapshot.timestamp) > thirtyDaysAgo
+    );
+
+    // Check for milestones
+    this.checkMilestones(currentSnapshot);
+
+    // Update projections
+    this.updateProjections(currentSnapshot);
+
+    // Save updated history
+    this.saveHistory();
+
+    return currentSnapshot;
+  }
+
+  /**
+   * Calculate compliance percentage
+   */
+  calculateCompliancePercentage(scanResults) {
+    if (!scanResults.totalFiles || scanResults.totalFiles === 0) {
+      return 0;
+    }
+    
+    return Math.round((scanResults.compliantFiles / scanResults.totalFiles) * 100);
+  }
+
+  /**
+   * Calculate trend based on recent snapshots
+   */
+  calculateTrend() {
+    const snapshots = this.historyData.snapshots;
+    if (snapshots.length < 2) {
+      return 'insufficient_data';
+    }
+
+    const recent = snapshots.slice(-5); // Last 5 snapshots
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+
+    const complianceChange = last.compliancePercentage - first.compliancePercentage;
+    const taskChange = last.taskCompletionPercentage - first.taskCompletionPercentage;
+
+    if (complianceChange > 5 && taskChange > 5) {
+      return 'improving';
+    } else if (complianceChange < -5 || taskChange < -5) {
+      return 'declining';
+    } else if (Math.abs(complianceChange) < 2 && Math.abs(taskChange) < 2) {
+      return 'stalled';
+    } else {
+      return 'stable';
+    }
+  }
+
+  /**
+   * Estimate hours remaining to completion
+   */
+  estimateHoursRemaining(scanResults, taskStats) {
+    const remainingTasks = (taskStats.total || 0) - (taskStats.completed || 0);
+    const avgHoursPerTask = 4; // Average estimation from task generator
+    
+    return remainingTasks * avgHoursPerTask;
+  }
+
+  /**
+   * Project completion date based on current progress rate
+   */
+  projectCompletionDate(scanResults, taskStats) {
+    const snapshots = this.historyData.snapshots;
+    if (snapshots.length < 3) {
+      return null;
+    }
+
+    // Calculate completion rate from recent snapshots
+    const recent = snapshots.slice(-7); // Last week of data
+    if (recent.length < 2) {
+      return null;
+    }
+
+    const firstRecent = recent[0];
+    const lastRecent = recent[recent.length - 1];
+    
+    const daysDiff = (new Date(lastRecent.timestamp) - new Date(firstRecent.timestamp)) / (1000 * 60 * 60 * 24);
+    const complianceProgress = lastRecent.compliancePercentage - firstRecent.compliancePercentage;
+    const taskProgress = lastRecent.taskCompletionPercentage - firstRecent.taskCompletionPercentage;
+    
+    if (daysDiff === 0 || (complianceProgress === 0 && taskProgress === 0)) {
+      return null;
+    }
+
+    // Project based on task completion (more reliable)
+    const taskCompletionRate = taskProgress / daysDiff; // Percentage per day
+    const remainingTaskPercentage = 100 - lastRecent.taskCompletionPercentage;
+    const daysToComplete = remainingTaskPercentage / taskCompletionRate;
+    
+    if (daysToComplete < 0 || daysToComplete > 365) { // Cap at 1 year
+      return null;
+    }
+
+    const projectedDate = new Date();
+    projectedDate.setDate(projectedDate.getDate() + Math.ceil(daysToComplete));
+    
+    return projectedDate.toISOString();
+  }
+
+  /**
+   * Check for and record milestones
+   */
+  checkMilestones(snapshot) {
+    const milestones = [
+      { threshold: 10, name: 'Initial Progress', description: '10% compliance achieved' },
+      { threshold: 25, name: 'Quarter Progress', description: '25% compliance achieved' },
+      { threshold: 50, name: 'Halfway There', description: '50% compliance achieved' },
+      { threshold: 75, name: 'Major Progress', description: '75% compliance achieved' },
+      { threshold: 90, name: 'Near Complete', description: '90% compliance achieved' },
+      { threshold: 95, name: 'Almost Done', description: '95% compliance achieved' },
+      { threshold: 100, name: 'Complete', description: '100% compliance achieved' }
+    ];
+
+    for (const milestone of milestones) {
+      if (snapshot.compliancePercentage >= milestone.threshold) {
+        // Check if milestone was already achieved
+        const alreadyAchieved = this.historyData.milestones.some(m => 
+          m.name === milestone.name
+        );
+
+        if (!alreadyAchieved) {
+          this.historyData.milestones.push({
+            ...milestone,
+            achievedAt: snapshot.timestamp,
+            compliancePercentage: snapshot.compliancePercentage,
+            taskCompletionPercentage: snapshot.taskCompletionPercentage
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Update projections based on current data
+   */
+  updateProjections(snapshot) {
+    this.historyData.projections = {
+      lastUpdated: snapshot.timestamp,
+      currentComplianceRate: snapshot.compliancePercentage,
+      currentTaskRate: snapshot.taskCompletionPercentage,
+      projectedCompletion: snapshot.projectedCompletion,
+      estimatedHoursRemaining: snapshot.estimatedHoursRemaining,
+      trend: snapshot.trend
+    };
+  }
+
+  /**
+   * Get current progress summary
+   */
+  getProgressSummary() {
+    const latest = this.historyData.snapshots[this.historyData.snapshots.length - 1];
+    
+    if (!latest) {
+      return {
+        status: 'no_data',
+        message: 'No progress data available'
+      };
+    }
+
+    return {
+      status: latest.compliancePercentage === 100 ? 'complete' : 'in_progress',
+      compliancePercentage: latest.compliancePercentage,
+      taskCompletionPercentage: latest.taskCompletionPercentage,
+      filesRemaining: latest.nonCompliantFiles,
+      tasksRemaining: latest.tasksTotal - latest.tasksCompleted,
+      trend: latest.trend,
+      projectedCompletion: latest.projectedCompletion,
+      estimatedHoursRemaining: latest.estimatedHoursRemaining,
+      nextMilestone: this.getNextMilestone(latest.compliancePercentage),
+      recentMilestones: this.historyData.milestones.slice(-3).reverse()
+    };
+  }
+
+  /**
+   * Get next milestone
+   */
+  getNextMilestone(currentPercentage) {
+    const milestones = [
+      { threshold: 10, name: 'Initial Progress' },
+      { threshold: 25, name: 'Quarter Progress' },
+      { threshold: 50, name: 'Halfway There' },
+      { threshold: 75, name: 'Major Progress' },
+      { threshold: 90, name: 'Near Complete' },
+      { threshold: 95, name: 'Almost Done' },
+      { threshold: 100, name: 'Complete' }
+    ];
+
+    for (const milestone of milestones) {
+      if (currentPercentage < milestone.threshold) {
+        const alreadyAchieved = this.historyData.milestones.some(m => 
+          m.name === milestone.name
+        );
+        
+        if (!alreadyAchieved) {
+          return {
+            ...milestone,
+            percentageToGo: milestone.threshold - currentPercentage,
+            estimatedDaysToReach: this.estimateDaysToMilestone(milestone.threshold, currentPercentage)
+          };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Estimate days to reach a milestone
+   */
+  estimateDaysToMilestone(targetPercentage, currentPercentage) {
+    const snapshots = this.historyData.snapshots;
+    if (snapshots.length < 3) {
+      return null;
+    }
+
+    const recent = snapshots.slice(-7);
+    if (recent.length < 2) {
+      return null;
+    }
+
+    const firstRecent = recent[0];
+    const lastRecent = recent[recent.length - 1];
+    
+    const daysDiff = (new Date(lastRecent.timestamp) - new Date(firstRecent.timestamp)) / (1000 * 60 * 60 * 24);
+    const progressRate = (lastRecent.compliancePercentage - firstRecent.compliancePercentage) / daysDiff;
+    
+    if (progressRate <= 0) {
+      return null;
+    }
+
+    const percentageToGo = targetPercentage - currentPercentage;
+    return Math.ceil(percentageToGo / progressRate);
+  }
+
+  /**
+   * Generate progress report
+   */
+  generateProgressReport() {
+    const summary = this.getProgressSummary();
+    const latest = this.historyData.snapshots[this.historyData.snapshots.length - 1];
+    
+    const report = {
+      generatedAt: new Date().toISOString(),
+      summary,
+      currentSnapshot: latest,
+      milestones: this.historyData.milestones,
+      projections: this.historyData.projections,
+      recommendations: this.generateRecommendations(summary),
+      history: {
+        totalSnapshots: this.historyData.snapshots.length,
+        dateRange: {
+          start: this.historyData.snapshots[0]?.timestamp,
+          end: this.historyData.snapshots[this.historyData.snapshots.length - 1]?.timestamp
+        }
+      }
+    };
+
+    return report;
+  }
+
+  /**
+   * Generate recommendations based on progress
+   */
+  generateRecommendations(summary) {
+    const recommendations = [];
+
+    if (summary.status === 'complete') {
+      recommendations.push({
+        type: 'celebration',
+        title: '🎉 Congratulations!',
+        description: '100% compliance achieved! All files are under 555 lines.',
+        priority: 'info'
+      });
+      return recommendations;
+    }
+
+    if (summary.trend === 'declining') {
+      recommendations.push({
+        type: 'warning',
+        title: 'Progress Declining',
+        description: 'Compliance progress has been declining recently. Consider reviewing recent changes.',
+        priority: 'high'
+      });
+    }
+
+    if (summary.trend === 'stalled') {
+      recommendations.push({
+        type: 'suggestion',
+        title: 'Progress Stalled',
+        description: 'Progress has stalled. Focus on completing high-priority refactoring tasks.',
+        priority: 'medium'
+      });
+    }
+
+    if (summary.filesRemaining > 50) {
+      recommendations.push({
+        type: 'action',
+        title: 'Focus on Large Files',
+        description: `${summary.filesRemaining} files still need refactoring. Start with the largest files first.`,
+        priority: 'high'
+      });
+    }
+
+    if (summary.nextMilestone && summary.nextMilestone.estimatedDaysToReach) {
+      if (summary.nextMilestone.estimatedDaysToReach > 30) {
+        recommendations.push({
+          type: 'suggestion',
+          title: 'Accelerate Progress',
+          description: `At current rate, reaching ${summary.nextMilestone.name} will take ${summary.nextMilestone.estimatedDaysToReach} days. Consider increasing refactoring capacity.`,
+          priority: 'medium'
+        });
+      }
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Export progress data for external analysis
+   */
+  exportProgressData(format = 'json') {
+    const data = this.generateProgressReport();
+
+    switch (format.toLowerCase()) {
+      case 'json':
+        return JSON.stringify(data, null, 2);
+      case 'csv':
+        return this.generateCSV(data);
+      default:
+        throw new Error(`Unsupported export format: ${format}`);
+    }
+  }
+
+  /**
+   * Generate CSV format for snapshots
+   */
+  generateCSV(data) {
+    const snapshots = this.historyData.snapshots;
+    if (snapshots.length === 0) {
+      return 'timestamp,totalFiles,compliantFiles,nonCompliantFiles,compliancePercentage,tasksCompleted,tasksTotal,taskCompletionPercentage\n';
+    }
+
+    const headers = 'timestamp,totalFiles,compliantFiles,nonCompliantFiles,compliancePercentage,tasksCompleted,tasksTotal,taskCompletionPercentage,trend\n';
+    const rows = snapshots.map(snapshot => 
+      `${snapshot.timestamp},${snapshot.totalFiles},${snapshot.compliantFiles},${snapshot.nonCompliantFiles},${snapshot.compliancePercentage},${snapshot.tasksCompleted},${snapshot.tasksTotal},${snapshot.taskCompletionPercentage},${snapshot.trend}`
+    ).join('\n');
+
+    return headers + rows;
+  }
+}
+
+module.exports = ComplianceProgressTracker;