claude-code-templates 1.20.1 → 1.20.3

package/src/analytics.js

@@ -1191,6 +1191,27 @@ class ClaudeAnalytics {
       }
     });
 
+    // Activity heatmap data endpoint - needs full conversation history
+    this.app.get('/api/activity', async (req, res) => {
+      try {
+        console.log(`🔥 /api/activity called - loading all conversations...`);
+        // Get all conversations without the 150 limit for accurate heatmap data
+        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 +2054,172 @@ 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();
+    today.setHours(23, 59, 59, 999);
+
+    console.log(`🔥 Generating activity data for ${conversations.length} conversations (FULL DATASET)...`);
+    
+    // Show date range of conversations
+    if (conversations.length > 0) {
+      const dates = conversations.map(c => c.lastModified ? new Date(c.lastModified) : null).filter(Boolean);
+      dates.sort((a, b) => a - b);
+      console.log(`🔥 Server conversation date range: ${dates[0]?.toLocaleDateString()} to ${dates[dates.length - 1]?.toLocaleDateString()}`);
+      
+      // Show some sample conversations with dates
+      console.log(`🔥 First 3 conversations by date:`);
+      const sortedConversations = conversations
+        .filter(c => c.lastModified)
+        .sort((a, b) => new Date(a.lastModified) - new Date(b.lastModified))
+        .slice(0, 3);
+      sortedConversations.forEach((conv, i) => {
+        console.log(`  ${i+1}: ${conv.filename} - ${new Date(conv.lastModified).toLocaleDateString()}`);
+      });
+    }
+
+    // Process conversations for daily activity
+    conversations.forEach(conversation => {
+      if (!conversation.lastModified) return;
+      
+      const date = new Date(conversation.lastModified);
+      if (date < oneYearAgo || date > today) 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

package/src/index.js

@@ -607,6 +607,7 @@ async function installIndividualSetting(settingName, targetDir, options) {
       if (response.status === 404) {
         console.log(chalk.red(`❌ Setting "${settingName}" not found`));
         console.log(chalk.yellow('Available settings: enable-telemetry, disable-telemetry, allow-npm-commands, deny-sensitive-files, use-sonnet, use-haiku, retention-7-days, retention-90-days'));
+        console.log(chalk.yellow('Available statuslines: statusline/context-monitor'));
         return;
       }
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -615,9 +616,39 @@ async function installIndividualSetting(settingName, targetDir, options) {
     const settingConfigText = await response.text();
     const settingConfig = JSON.parse(settingConfigText);
 
-    // Remove description field before merging
+    // Check if there are additional files to download (e.g., Python scripts)
+    const additionalFiles = {};
+    
+    // For statusline settings, check if there's a corresponding Python file
+    if (settingName.includes('statusline/')) {
+      const pythonFileName = settingName.split('/')[1] + '.py';
+      const pythonUrl = githubUrl.replace('.json', '.py');
+      
+      try {
+        console.log(chalk.gray(`📥 Downloading Python script: ${pythonFileName}...`));
+        const pythonResponse = await fetch(pythonUrl);
+        if (pythonResponse.ok) {
+          const pythonContent = await pythonResponse.text();
+          additionalFiles['.claude/scripts/' + pythonFileName] = {
+            content: pythonContent,
+            executable: true
+          };
+        }
+      } catch (error) {
+        console.log(chalk.yellow(`⚠️  Could not download Python script: ${error.message}`));
+      }
+    }
+
+    // Extract and handle additional files before removing them from config
+    const configFiles = settingConfig.files || {};
+    
+    // Merge downloaded files with config files
+    Object.assign(additionalFiles, configFiles);
+    
+    // Remove description and files fields before merging
     if (settingConfig && typeof settingConfig === 'object') {
       delete settingConfig.description;
+      delete settingConfig.files;
     }
     
     // Use shared locations if provided (batch mode), otherwise ask user
@@ -817,6 +848,37 @@ async function installIndividualSetting(settingName, targetDir, options) {
       // Write the merged configuration
       await fs.writeJson(actualTargetFile, mergedConfig, { spaces: 2 });
       
+      // Install additional files if any exist
+      if (Object.keys(additionalFiles).length > 0) {
+        console.log(chalk.blue(`📄 Installing ${Object.keys(additionalFiles).length} additional file(s)...`));
+        
+        for (const [filePath, fileConfig] of Object.entries(additionalFiles)) {
+          try {
+            // Resolve tilde (~) to home directory
+            const resolvedFilePath = filePath.startsWith('~') 
+              ? path.join(require('os').homedir(), filePath.slice(1))
+              : path.resolve(currentTargetDir, filePath);
+            
+            // Ensure directory exists
+            await fs.ensureDir(path.dirname(resolvedFilePath));
+            
+            // Write file content
+            await fs.writeFile(resolvedFilePath, fileConfig.content, 'utf8');
+            
+            // Make file executable if specified
+            if (fileConfig.executable) {
+              await fs.chmod(resolvedFilePath, 0o755);
+              console.log(chalk.gray(`🔧 Made executable: ${resolvedFilePath}`));
+            }
+            
+            console.log(chalk.green(`✅ File installed: ${resolvedFilePath}`));
+            
+          } catch (fileError) {
+            console.log(chalk.red(`❌ Failed to install file ${filePath}: ${fileError.message}`));
+          }
+        }
+      }
+      
       if (!options.silent) {
         console.log(chalk.green(`✅ Setting "${settingName}" installed successfully in ${installLocation}!`));
         console.log(chalk.cyan(`📁 Configuration merged into: ${actualTargetFile}`));