IMPROVE: Make git stats calculations accurate and date-aware

- Implemented proper time-based filtering using actual week date ranges
- Added date overlap calculations for partial week inclusion
- Improved 24-hour stats with daily estimates from recent week
- Enhanced table formatting with proper color coding
- Added dynamic sparkline patterns based on activity levels
- Better handling of zero-activity periods
- More accurate net change calculations and display

Author: raold

static/dashboard.html

@@ -2224,43 +2224,127 @@ <h3>Database Health</h3>
                     return { commits: 0, additions: 0, deletions: 0, netChange: 0 };
                 }
 
-                // For this simple implementation, use the most recent weeks
+                const now = new Date();
+                const cutoffDate = new Date(now);
+                cutoffDate.setDate(cutoffDate.getDate() - days);
+                
+                console.log(`Calculating stats for last ${days} days (since ${cutoffDate.toISOString().split('T')[0]})`);
+                
                 const weeklyData = gitData.weekly_stats;
-                const weeksToInclude = Math.min(Math.ceil(days / 7), weeklyData.length);
-                const recentWeeks = weeklyData.slice(-weeksToInclude);
+                let relevantWeeks = [];
+                
+                // Filter weeks that overlap with our time period
+                for (const week of weeklyData) {
+                    const weekStart = new Date(week.date_start);
+                    const weekEnd = new Date(week.date_end);
+                    
+                    // Check if this week overlaps with our period
+                    if (weekEnd >= cutoffDate && weekStart <= now) {
+                        relevantWeeks.push(week);
+                    }
+                }
+                
+                console.log(`Found ${relevantWeeks.length} relevant weeks for ${days}-day period:`, 
+                    relevantWeeks.map(w => w.week));
+                
+                // For accurate calculation, we need to consider partial weeks
+                let totalCommits = 0;
+                let totalAdditions = 0;
+                let totalDeletions = 0;
 
-                const totalCommits = recentWeeks.reduce((sum, week) => sum + (week.commits || 0), 0);
-                const totalAdditions = recentWeeks.reduce((sum, week) => sum + (week.additions || 0), 0);
-                const totalDeletions = recentWeeks.reduce((sum, week) => sum + (week.deletions || 0), 0);
+                for (const week of relevantWeeks) {
+                    const weekStart = new Date(week.date_start);
+                    const weekEnd = new Date(week.date_end);
+                    
+                    // Calculate what portion of this week falls within our period
+                    const periodStart = new Date(Math.max(weekStart.getTime(), cutoffDate.getTime()));
+                    const periodEnd = new Date(Math.min(weekEnd.getTime(), now.getTime()));
+                    const weekDuration = weekEnd.getTime() - weekStart.getTime();
+                    const periodDuration = periodEnd.getTime() - periodStart.getTime();
+                    const fraction = Math.min(1, Math.max(0, periodDuration / weekDuration));
+                    
+                    // Apply fraction to the week's stats
+                    const weekCommits = Math.round((week.commits || 0) * fraction);
+                    const weekAdditions = Math.round((week.additions || 0) * fraction);
+                    const weekDeletions = Math.round((week.deletions || 0) * fraction);
+                    
+                    totalCommits += weekCommits;
+                    totalAdditions += weekAdditions;
+                    totalDeletions += weekDeletions;
+                    
+                    console.log(`Week ${week.week}: ${weekCommits} commits (${(fraction*100).toFixed(1)}% of ${week.commits})`);
+                }
+                
+                // Special handling for very recent periods
+                if (days === 1) {
+                    // For 24h, use only the most recent day's estimated activity
+                    const mostRecentWeek = weeklyData[weeklyData.length - 1];
+                    if (mostRecentWeek) {
+                        // Estimate daily average from the most recent week
+                        totalCommits = Math.round((mostRecentWeek.commits || 0) / 7);
+                        totalAdditions = Math.round((mostRecentWeek.additions || 0) / 7);
+                        totalDeletions = Math.round((mostRecentWeek.deletions || 0) / 7);
+                    }
+                }
 
-                return {
+                const result = {
                     commits: totalCommits,
                     additions: totalAdditions,
                     deletions: totalDeletions,
                     netChange: totalAdditions - totalDeletions
                 };
+                
+                console.log(`${days}-day stats:`, result);
+                return result;
             }
 
             function updateTableForPeriod(period, stats) {
                 console.log(`Updating table for period: ${period}`, stats);
 
-                // Update main branch (assuming all data is from main)
+                // Update main branch with calculated stats
                 updateElement('main-commits', stats.commits);
-                updateElement('main-added', '+' + stats.additions.toLocaleString());
-                updateElement('main-deleted', '-' + stats.deletions.toLocaleString());
+                updateElement('main-added', stats.additions > 0 ? '+' + stats.additions.toLocaleString() : '0');
+                updateElement('main-deleted', stats.deletions > 0 ? '-' + stats.deletions.toLocaleString() : '0');
 
-                // Update testing and develop branches (showing as inactive for now)
+                // Update testing and develop branches (showing as inactive for this period)
                 updateElement('testing-commits', '--');
-                updateElement('testing-added', '--');
+                updateElement('testing-added', '--');  
                 updateElement('testing-deleted', '--');
                 updateElement('develop-commits', '--');
                 updateElement('develop-added', '--');
                 updateElement('develop-deleted', '--');
 
                 // Update activity summary
                 updateElement('total-commits', stats.commits);
-                updateElement('net-changes', (stats.netChange >= 0 ? '+' : '') + stats.netChange.toLocaleString());
-                updateElement('active-branches', '1');
+                const netChangeText = stats.netChange === 0 ? '0' : 
+                    (stats.netChange > 0 ? '+' : '') + stats.netChange.toLocaleString();
+                updateElement('net-changes', netChangeText);
+                
+                // Count active branches (main is active if it has commits)
+                const activeBranches = stats.commits > 0 ? 1 : 0;
+                updateElement('active-branches', activeBranches);
+                
+                // Color the net changes appropriately
+                const netChangesEl = document.getElementById('net-changes');
+                if (netChangesEl) {
+                    if (stats.netChange > 0) {
+                        netChangesEl.style.color = '#b8bb26'; // Green for positive
+                    } else if (stats.netChange < 0) {
+                        netChangesEl.style.color = '#fb4934'; // Red for negative  
+                    } else {
+                        netChangesEl.style.color = '#ebdbb2'; // Default for zero
+                    }
+                }
+                
+                // Update main branch added/deleted colors
+                const mainAddedEl = document.getElementById('main-added');
+                const mainDeletedEl = document.getElementById('main-deleted');
+                if (mainAddedEl) {
+                    mainAddedEl.style.color = stats.additions > 0 ? '#b8bb26' : '#a89984';
+                }
+                if (mainDeletedEl) {
+                    mainDeletedEl.style.color = stats.deletions > 0 ? '#fb4934' : '#a89984';
+                }
 
                 // Update time filter active state
                 document.querySelectorAll('.time-filter').forEach(btn => {
@@ -2269,6 +2353,37 @@ <h3>Database Health</h3>
                         btn.classList.add('active');
                     }
                 });
+                
+                // Update sparkline activity indicator for main branch
+                updateSparklineForPeriod('main-spark', period, stats);
+            }
+            
+            function updateSparklineForPeriod(elementId, period, stats) {
+                const sparklineEl = document.getElementById(elementId);
+                if (!sparklineEl) return;
+                
+                // Generate activity pattern based on actual data
+                let pattern = '';
+                if (stats.commits === 0) {
+                    pattern = '▁▁▁▁▁▁▁▁▁▁▁▁'; // Flat line for no activity
+                } else if (stats.commits < 5) {
+                    pattern = '▁▁▂▁▂▁▁▂▁▁▂▁'; // Light activity
+                } else if (stats.commits < 15) {
+                    pattern = '▂▃▄▂▅▃▂▄▃▂▃▂'; // Moderate activity
+                } else {
+                    pattern = '▃▅▆▄▇▅▃▆▄▃▅▃'; // High activity
+                }
+                
+                sparklineEl.textContent = pattern;
+                
+                // Color based on activity level
+                if (stats.commits === 0) {
+                    sparklineEl.style.color = '#a89984'; // Dim gray
+                } else if (stats.commits < 10) {
+                    sparklineEl.style.color = '#fabd2f'; // Yellow
+                } else {
+                    sparklineEl.style.color = '#b8bb26'; // Green
+                }
             }
 
             function setupActivityTableControls() {