claude-code-templates 1.28.4 → 1.28.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-templates",
-  "version": "1.28.4",
+  "version": "1.28.5",
   "description": "CLI tool to setup Claude Code configurations with framework-specific commands, automation hooks and MCP Servers for your projects",
   "main": "src/index.js",
   "bin": {

package/src/analytics/core/YearInReview2025.js

@@ -904,19 +904,54 @@ class YearInReview2025 {
       }
 
       const subagents = Array.from(agentData.values());
-      const subagentEvents = subagents
-        .filter(agent => agent.timestamp && agent.timestamp.getFullYear() === 2025)
-        .map(agent => ({
-          name: `${agent.type}-${agent.id.substring(0, 4)}`, // e.g., "Plan-a68a" or "Explore-a1e4"
-          timestamp: agent.timestamp,
-          type: agent.type
-        }))
-        .sort((a, b) => a.timestamp - b.timestamp);
+
+      // Group subagents by type for cleaner visualization
+      const groupedByType = {};
+      subagents.forEach(agent => {
+        const type = agent.type || 'Unknown';
+        if (!groupedByType[type]) {
+          groupedByType[type] = { count: 0, timestamps: [] };
+        }
+        groupedByType[type].count++;
+        if (agent.timestamp && agent.timestamp.getFullYear() === 2025) {
+          groupedByType[type].timestamps.push(agent.timestamp);
+        }
+      });
+
+      // Create events grouped by type (one event per type per day)
+      const subagentEvents = [];
+      Object.entries(groupedByType).forEach(([type, data]) => {
+        // Group timestamps by day to avoid too many events
+        const dayMap = new Map();
+        data.timestamps.forEach(ts => {
+          const dayKey = ts.toISOString().split('T')[0];
+          if (!dayMap.has(dayKey)) {
+            dayMap.set(dayKey, { count: 0, timestamp: ts });
+          }
+          dayMap.get(dayKey).count++;
+        });
+
+        // Create one event per day per type
+        dayMap.forEach((dayData, dayKey) => {
+          subagentEvents.push({
+            name: type, // Just "Plan" or "Explore", not "Plan-a68a"
+            timestamp: dayData.timestamp,
+            type: type,
+            count: dayData.count // How many times used that day
+          });
+        });
+      });
+
+      subagentEvents.sort((a, b) => a.timestamp - b.timestamp);
 
       return {
-        subagents: subagents.map(a => ({ id: a.id, type: a.type })),
+        subagents: Object.entries(groupedByType).map(([type, data]) => ({
+          type,
+          count: data.count
+        })),
         total: subagents.length,
-        events: subagentEvents
+        events: subagentEvents,
+        grouped: groupedByType // Include grouped data for display
       };
     } catch (error) {
       console.warn('Could not analyze subagents:', error.message);

package/src/analytics-web/2025.html

@@ -1637,19 +1637,20 @@
             }
 
             if (data.subagents && data.subagents.events) {
-                console.log(`🤖 Adding ${data.subagents.events.length} subagent events to timeline`);
+                console.log(`🤖 Adding ${data.subagents.events.length} subagent events to timeline (grouped by type)`);
                 data.subagents.events.forEach((event, index) => {
                     const eventDate = new Date(event.timestamp);
                     const eventDayOfYear = getDayOfYear(eventDate);
                     timeline.push({
                         type: 'component-layer2',
                         componentType: 'subagent',
-                        name: event.name,
+                        name: event.name, // Now just "Plan" or "Explore", not "Plan-a68a"
                         date: eventDate,
-                        dayOfYear: eventDayOfYear
+                        dayOfYear: eventDayOfYear,
+                        count: event.count || 1 // How many times used that day
                     });
                     if (index === 0) {
-                        console.log(`  - First subagent "${event.name}": date=${eventDate.toLocaleDateString()}, dayOfYear=${eventDayOfYear.toFixed(3)}`);
+                        console.log(`  - First subagent "${event.name}": date=${eventDate.toLocaleDateString()}, dayOfYear=${eventDayOfYear.toFixed(3)}, count=${event.count || 1}`);
                     }
                 });
             }
@@ -1922,13 +1923,18 @@
                         // showEvent(`Installed: ${event.name}`); // Disabled - notifications removed
                     } else if (event.type === 'component-layer2') {
                         const node = getOrCreateComponentNode(event.name, event.componentType);
-                        node.addUse();
+
+                        // Add uses based on event count (for grouped subagents)
+                        const useCount = event.count || 1;
+                        for (let j = 0; j < useCount; j++) {
+                            node.addUse();
+                        }
 
                         // Create beam to this component node
                         const beam = new Beam(node, event.name);
                         beams.push(beam);
 
-                        console.log(`🔷 ${event.componentType}: ${event.name} at ${event.date?.toLocaleDateString()} (count: ${node.count}, size: ${node.targetSize.toFixed(1)})`);
+                        console.log(`🔷 ${event.componentType}: ${event.name} at ${event.date?.toLocaleDateString()} (added: ${useCount}, total: ${node.count}, size: ${node.targetSize.toFixed(1)})`);
                     }
                 }
             });