claude-code-templates 1.20.2 → 1.21.0

package/src/analytics.js

@@ -1191,6 +1191,90 @@ class ClaudeAnalytics {
       }
     });
 
+    // Clear cache endpoint
+    this.app.post('/api/clear-cache', async (req, res) => {
+      try {
+        console.log('🔥 Clear cache request received');
+        
+        // Clear DataCache
+        if (this.dataCache && typeof this.dataCache.clear === 'function') {
+          this.dataCache.clear();
+          console.log('🔥 Server DataCache cleared');
+        } else {
+          console.log('⚠️ DataCache not available or no clear method');
+        }
+        
+        // Also clear ConversationAnalyzer cache if available
+        if (this.conversationAnalyzer && typeof this.conversationAnalyzer.clearCache === 'function') {
+          this.conversationAnalyzer.clearCache();
+          console.log('🔥 ConversationAnalyzer cache cleared');
+        }
+        
+        res.json({ 
+          success: true, 
+          message: 'Cache cleared successfully',
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('❌ Error clearing cache:', error);
+        res.status(500).json({ 
+          error: 'Failed to clear cache', 
+          details: error.message 
+        });
+      }
+    });
+
+    // Activity heatmap data endpoint - needs full conversation history
+    this.app.get('/api/activity', async (req, res) => {
+      try {
+        // TEMPORARY: Use test data for demo/screenshots
+        console.log(`🔥 /api/activity called - using test data for demo...`);
+        const fs = require('fs');
+        const path = require('path');
+        const testDataPath = path.join(__dirname, 'test-activity-data.json');
+        
+        if (fs.existsSync(testDataPath)) {
+          const testData = JSON.parse(fs.readFileSync(testDataPath, 'utf8'));
+          
+          // Calculate totals
+          const totalContributions = testData.reduce((sum, day) => sum + day.conversations, 0);
+          const totalTools = testData.reduce((sum, day) => sum + day.tools, 0);
+          const totalMessages = testData.reduce((sum, day) => sum + day.messages, 0);
+          const totalTokens = testData.reduce((sum, day) => sum + day.tokens, 0);
+          
+          const activityData = {
+            dailyActivity: testData,
+            totalContributions,
+            activeDays: testData.length,
+            longestStreak: 7, // Sample streak
+            currentStreak: 3,  // Sample current streak
+            totalTools,
+            totalMessages,
+            totalTokens,
+            timestamp: new Date().toISOString()
+          };
+          
+          return res.json(activityData);
+        }
+        
+        // Fallback to real data if test file doesn't exist
+        console.log(`🔥 /api/activity called - loading all conversations...`);
+        const allConversations = await this.conversationAnalyzer.loadConversations(this.stateCalculator);
+        console.log(`🔥 Loaded ${allConversations.length} conversations from server`);
+        
+        // Generate activity data using complete dataset
+        const activityData = this.generateActivityDataFromConversations(allConversations);
+        res.json({
+          conversations: allConversations, // Also include conversations for the heatmap component
+          ...activityData,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error('Error generating activity data:', error);
+        res.status(500).json({ error: 'Failed to generate activity data' });
+      }
+    });
+
     // Main dashboard route
     this.app.get('/', (req, res) => {
       res.sendFile(path.join(__dirname, 'analytics-web', 'index.html'));
@@ -2033,6 +2117,156 @@ class ClaudeAnalytics {
     }
   }
 
+  /**
+   * Generate activity data for the heatmap using complete conversation set
+   * @param {Array} conversations - Complete conversation array (not limited)
+   * @returns {Object} Activity data including daily contributions and stats
+   */
+  generateActivityDataFromConversations(conversations) {
+    const dailyActivity = new Map();
+    const oneYearAgo = new Date();
+    oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);
+    oneYearAgo.setHours(0, 0, 0, 0);
+
+    const today = new Date();
+    const todayEnd = new Date();
+    todayEnd.setHours(23, 59, 59, 999);
+
+    console.log(`🔥 Generating activity data for ${conversations.length} conversations (FULL DATASET)...`);
+
+    // Process conversations for daily activity
+    conversations.forEach(conversation => {
+      if (!conversation.lastModified) return;
+      
+      const date = new Date(conversation.lastModified);
+      if (date < oneYearAgo || date > todayEnd) return;
+
+      const dateKey = date.toISOString().split('T')[0]; // YYYY-MM-DD
+      
+      const current = dailyActivity.get(dateKey) || {
+        conversations: 0,
+        tokens: 0,
+        messages: 0,
+        tools: 0,
+        date: dateKey
+      };
+      
+      current.conversations += 1;
+      current.tokens += conversation.tokens || 0;
+      current.messages += conversation.messageCount || 0;
+      current.tools += (conversation.toolUsage?.totalToolCalls || 0);
+      
+      dailyActivity.set(dateKey, current);
+    });
+
+    // Convert to array and sort by date
+    const activityArray = Array.from(dailyActivity.values())
+      .sort((a, b) => a.date.localeCompare(b.date));
+
+    // Calculate stats
+    const totalContributions = activityArray.reduce((sum, day) => sum + day.conversations, 0);
+    const totalTools = activityArray.reduce((sum, day) => sum + day.tools, 0);
+    const { longestStreak, currentStreak } = this.calculateStreaks(activityArray);
+
+    console.log(`🔥 Activity data generated: ${activityArray.length} active days, ${totalContributions} total contributions, ${totalTools} tool calls`);
+
+    return {
+      dailyActivity: activityArray,
+      totalContributions,
+      totalTools,
+      longestStreak,
+      currentStreak,
+      activeDays: activityArray.length,
+      startDate: oneYearAgo.toISOString().split('T')[0],
+      endDate: today.toISOString().split('T')[0]
+    };
+  }
+
+  /**
+   * Generate activity data for the heatmap (legacy method for backward compatibility)
+   * @returns {Object} Activity data including daily contributions and stats
+   */
+  generateActivityData() {
+    if (!this.data || !this.data.conversations) {
+      return {
+        dailyActivity: [],
+        totalContributions: 0,
+        longestStreak: 0,
+        currentStreak: 0
+      };
+    }
+
+    return this.generateActivityDataFromConversations(this.data.conversations);
+  }
+
+  /**
+   * Calculate contribution streaks
+   * @param {Array} activityArray - Sorted array of daily activity
+   * @returns {Object} Longest and current streak counts
+   */
+  calculateStreaks(activityArray) {
+    if (activityArray.length === 0) {
+      return { longestStreak: 0, currentStreak: 0 };
+    }
+
+    let longestStreak = 0;
+    let currentStreak = 0;
+    let tempStreak = 0;
+    
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+
+    // Create a map of active dates for quick lookup
+    const activeDates = new Set(activityArray.map(day => day.date));
+
+    // Check streak going backwards from today
+    let checkDate = new Date(today);
+    let foundToday = false;
+
+    // First check if today or yesterday has activity
+    for (let i = 0; i < 2; i++) {
+      const dateKey = checkDate.toISOString().split('T')[0];
+      if (activeDates.has(dateKey)) {
+        foundToday = true;
+        break;
+      }
+      checkDate.setDate(checkDate.getDate() - 1);
+    }
+
+    if (foundToday) {
+      // Calculate current streak
+      checkDate = new Date(today);
+      while (true) {
+        const dateKey = checkDate.toISOString().split('T')[0];
+        if (activeDates.has(dateKey)) {
+          currentStreak++;
+          checkDate.setDate(checkDate.getDate() - 1);
+        } else {
+          break;
+        }
+      }
+    }
+
+    // Calculate longest streak by checking all consecutive days
+    const oneYearAgo = new Date(today);
+    oneYearAgo.setFullYear(today.getFullYear() - 1);
+
+    checkDate = new Date(oneYearAgo);
+    while (checkDate <= today) {
+      const dateKey = checkDate.toISOString().split('T')[0];
+      
+      if (activeDates.has(dateKey)) {
+        tempStreak++;
+        longestStreak = Math.max(longestStreak, tempStreak);
+      } else {
+        tempStreak = 0;
+      }
+      
+      checkDate.setDate(checkDate.getDate() + 1);
+    }
+
+    return { longestStreak, currentStreak };
+  }
 
   stop() {
     // Stop file watchers