@cryptiklemur/lattice 1.6.0 → 1.8.0

package/server/src/analytics/engine.ts

@@ -520,6 +520,216 @@ function aggregate(sessions: SessionData[], period: AnalyticsPeriod): AnalyticsP
 
   var tokenFlowSankey: AnalyticsPayload["tokenFlowSankey"] = { nodes: sankeyNodes, links: sankeyLinks };
 
+  var activityCalendarMap = new Map<string, { count: number; tokens: number; cost: number }>();
+  for (var aci = 0; aci < filtered.length; aci++) {
+    var acSess = filtered[aci];
+    var acDate = formatDate(acSess.endTime > 0 ? acSess.endTime : acSess.startTime);
+    var acEntry = activityCalendarMap.get(acDate);
+    if (!acEntry) {
+      acEntry = { count: 0, tokens: 0, cost: 0 };
+      activityCalendarMap.set(acDate, acEntry);
+    }
+    acEntry.count++;
+    acEntry.tokens += acSess.inputTokens + acSess.outputTokens;
+    acEntry.cost += acSess.cost;
+  }
+
+  var activityCalendar: AnalyticsPayload["activityCalendar"] = [];
+  if (dates.length > 0) {
+    var calStart = new Date(dates[0]);
+    var calEnd = new Date(dates[dates.length - 1]);
+    var calCursor = new Date(calStart);
+    while (calCursor <= calEnd) {
+      var calKey = formatDate(calCursor.getTime());
+      var calData = activityCalendarMap.get(calKey);
+      activityCalendar.push({
+        date: calKey,
+        count: calData ? calData.count : 0,
+        tokens: calData ? calData.tokens : 0,
+        cost: calData ? calData.cost : 0,
+      });
+      calCursor.setDate(calCursor.getDate() + 1);
+    }
+  }
+
+  var hourlyHeatmap: AnalyticsPayload["hourlyHeatmap"] = [];
+  var heatmapGrid = new Map<string, number>();
+  for (var hmi = 0; hmi < filtered.length; hmi++) {
+    var hmSess = filtered[hmi];
+    if (hmSess.startTime <= 0) continue;
+    var hmDate = new Date(hmSess.startTime);
+    var hmDay = hmDate.getDay();
+    var hmHour = hmDate.getHours();
+    var hmKey = hmDay + ":" + hmHour;
+    heatmapGrid.set(hmKey, (heatmapGrid.get(hmKey) || 0) + 1);
+  }
+  for (var hd = 0; hd < 7; hd++) {
+    for (var hh = 0; hh < 24; hh++) {
+      var hhKey = hd + ":" + hh;
+      hourlyHeatmap.push({ day: hd, hour: hh, count: heatmapGrid.get(hhKey) || 0 });
+    }
+  }
+
+  var sessionTimeline: AnalyticsPayload["sessionTimeline"] = [];
+  var tlSorted = filtered
+    .filter(function (s) { return s.startTime > 0 && s.endTime > 0; })
+    .sort(function (a, b) { return b.startTime - a.startTime; });
+  var tlCap = Math.min(tlSorted.length, 50);
+  for (var tli = 0; tli < tlCap; tli++) {
+    var tlSess = tlSorted[tli];
+    sessionTimeline.push({
+      id: tlSess.id,
+      title: tlSess.title,
+      project: tlSess.project,
+      start: tlSess.startTime,
+      end: tlSess.endTime,
+      cost: tlSess.cost,
+    });
+  }
+
+  var dailySummaryMap = new Map<string, { sessions: number; cost: number; tokens: number; tools: Map<string, number>; models: Map<string, number> }>();
+  for (var dsi = 0; dsi < filtered.length; dsi++) {
+    var dsSess = filtered[dsi];
+    var dsDate = formatDate(dsSess.endTime > 0 ? dsSess.endTime : dsSess.startTime);
+    var dsEntry = dailySummaryMap.get(dsDate);
+    if (!dsEntry) {
+      dsEntry = { sessions: 0, cost: 0, tokens: 0, tools: new Map(), models: new Map() };
+      dailySummaryMap.set(dsDate, dsEntry);
+    }
+    dsEntry.sessions++;
+    dsEntry.cost += dsSess.cost;
+    dsEntry.tokens += dsSess.inputTokens + dsSess.outputTokens;
+    dsSess.tools.forEach(function (count, tool) {
+      dsEntry!.tools.set(tool, (dsEntry!.tools.get(tool) || 0) + count);
+    });
+    dsSess.models.forEach(function (val, key) {
+      dsEntry!.models.set(key, (dsEntry!.models.get(key) || 0) + val.cost);
+    });
+  }
+
+  var dailySummaries: AnalyticsPayload["dailySummaries"] = [];
+  var dsSortedDates = Array.from(dailySummaryMap.keys()).sort();
+  for (var dsdi = 0; dsdi < dsSortedDates.length; dsdi++) {
+    var dsd = dsSortedDates[dsdi];
+    var dsData = dailySummaryMap.get(dsd)!;
+    var topTool = "";
+    var topToolCount = 0;
+    dsData.tools.forEach(function (count, tool) {
+      if (count > topToolCount) {
+        topToolCount = count;
+        topTool = tool;
+      }
+    });
+    var modelMix: Record<string, number> = {};
+    var modelTotal = 0;
+    dsData.models.forEach(function (cost) { modelTotal += cost; });
+    if (modelTotal > 0) {
+      dsData.models.forEach(function (cost, model) {
+        modelMix[model] = Math.round((cost / modelTotal) * 100) / 100;
+      });
+    }
+    dailySummaries.push({
+      date: dsd,
+      sessions: dsData.sessions,
+      cost: dsData.cost,
+      tokens: dsData.tokens,
+      topTool: topTool,
+      modelMix: modelMix,
+    });
+  }
+
+  var toolTreemap: AnalyticsPayload["toolTreemap"] = [];
+  toolStats.forEach(function (val, key) {
+    toolTreemap.push({
+      name: key,
+      count: val.count,
+      avgCost: val.sessions > 0 ? val.totalCost / val.sessions : 0,
+    });
+  });
+  toolTreemap.sort(function (a, b) { return b.count - a.count; });
+
+  var toolCategoryMap: Record<string, string> = {
+    Read: "Read", Glob: "Read", Grep: "Read", LS: "Read",
+    Edit: "Write", Write: "Write", MultiEdit: "Write",
+    Bash: "Execute",
+    Agent: "AI", Skill: "AI",
+  };
+  var toolSunburst: AnalyticsPayload["toolSunburst"] = [];
+  toolStats.forEach(function (val, key) {
+    var category = toolCategoryMap[key] || "Other";
+    toolSunburst.push({ name: key, category: category, count: val.count });
+  });
+  toolSunburst.sort(function (a, b) { return b.count - a.count; });
+
+  var totalToolCalls = 0;
+  toolStats.forEach(function (val) { totalToolCalls += val.count; });
+  var permissionStats: AnalyticsPayload["permissionStats"] = {
+    allowed: totalToolCalls,
+    denied: 0,
+    alwaysAllowed: 0,
+  };
+
+  var projectRadarMap = new Map<string, { cost: number; sessions: number; totalDuration: number; durationCount: number; tools: Set<string>; totalTokens: number }>();
+  for (var pri = 0; pri < filtered.length; pri++) {
+    var prSess = filtered[pri];
+    var prEntry = projectRadarMap.get(prSess.project);
+    if (!prEntry) {
+      prEntry = { cost: 0, sessions: 0, totalDuration: 0, durationCount: 0, tools: new Set(), totalTokens: 0 };
+      projectRadarMap.set(prSess.project, prEntry);
+    }
+    prEntry.cost += prSess.cost;
+    prEntry.sessions++;
+    prEntry.totalTokens += prSess.inputTokens + prSess.outputTokens;
+    if (prSess.startTime > 0 && prSess.endTime > prSess.startTime) {
+      prEntry.totalDuration += prSess.endTime - prSess.startTime;
+      prEntry.durationCount++;
+    }
+    prSess.tools.forEach(function (_count, tool) { prEntry!.tools.add(tool); });
+  }
+  var projectRadar: AnalyticsPayload["projectRadar"] = [];
+  projectRadarMap.forEach(function (val, key) {
+    projectRadar.push({
+      project: key,
+      cost: val.cost,
+      sessions: val.sessions,
+      avgDuration: val.durationCount > 0 ? val.totalDuration / val.durationCount : 0,
+      toolDiversity: val.tools.size,
+      tokensPerSession: val.sessions > 0 ? val.totalTokens / val.sessions : 0,
+    });
+  });
+  projectRadar.sort(function (a, b) { return b.cost - a.cost; });
+  if (projectRadar.length > 5) projectRadar.length = 5;
+
+  var contextWindowSizesForComplexity: Record<string, number> = { opus: 200000, sonnet: 200000, haiku: 200000, other: 200000 };
+  var sessionComplexity: AnalyticsPayload["sessionComplexity"] = [];
+  for (var sci = 0; sci < filtered.length; sci++) {
+    var scSess = filtered[sci];
+    var scUniqueTools = scSess.tools.size;
+    var scMessages = scSess.contextMessages.length;
+    var scRunning = 0;
+    var scPrimaryModel = "other";
+    var scMaxTokens = 0;
+    scSess.models.forEach(function (val, key) {
+      if (val.tokens > scMaxTokens) { scMaxTokens = val.tokens; scPrimaryModel = key; }
+    });
+    var scWindowSize = contextWindowSizesForComplexity[scPrimaryModel] || 200000;
+    for (var scmi = 0; scmi < scSess.contextMessages.length; scmi++) {
+      scRunning += scSess.contextMessages[scmi].inputTokens;
+    }
+    var scContextPercent = Math.min((scRunning / scWindowSize) * 100, 100);
+    var scScore = (scMessages * 1) + (scUniqueTools * 5) + (scContextPercent * 0.5);
+    sessionComplexity.push({
+      id: scSess.id,
+      title: scSess.title,
+      score: Math.round(scScore * 10) / 10,
+      messages: scMessages,
+      tools: scUniqueTools,
+      contextPercent: Math.round(scContextPercent * 10) / 10,
+    });
+  }
+  sessionComplexity.sort(function (a, b) { return b.score - a.score; });
+  if (sessionComplexity.length > 20) sessionComplexity.length = 20;
+
   return {
     totalCost: totalCost,
     totalSessions: filtered.length,
@@ -545,6 +755,15 @@ function aggregate(sessions: SessionData[], period: AnalyticsPeriod): AnalyticsP
     responseTimeData: responseTimeData,
     contextUtilization: contextUtilization,
     tokenFlowSankey: tokenFlowSankey,
+    activityCalendar: activityCalendar,
+    hourlyHeatmap: hourlyHeatmap,
+    sessionTimeline: sessionTimeline,
+    dailySummaries: dailySummaries,
+    toolTreemap: toolTreemap,
+    toolSunburst: toolSunburst,
+    permissionStats: permissionStats,
+    projectRadar: projectRadar,
+    sessionComplexity: sessionComplexity,
   };
 }
 

package/shared/src/analytics.ts

@@ -22,6 +22,17 @@ export interface AnalyticsPayload {
   responseTimeData: Array<{ tokens: number; duration: number; model: string; sessionId: string }>;
   contextUtilization: Array<{ messageIndex: number; contextPercent: number; sessionId: string; title: string }>;
   tokenFlowSankey: { nodes: Array<{ name: string }>; links: Array<{ source: number; target: number; value: number }> };
+
+  activityCalendar: Array<{ date: string; count: number; tokens: number; cost: number }>;
+  hourlyHeatmap: Array<{ day: number; hour: number; count: number }>;
+  sessionTimeline: Array<{ id: string; title: string; project: string; start: number; end: number; cost: number }>;
+  dailySummaries: Array<{ date: string; sessions: number; cost: number; tokens: number; topTool: string; modelMix: Record<string, number> }>;
+
+  toolTreemap: Array<{ name: string; count: number; avgCost: number }>;
+  toolSunburst: Array<{ name: string; category: string; count: number }>;
+  permissionStats: { allowed: number; denied: number; alwaysAllowed: number };
+  projectRadar: Array<{ project: string; cost: number; sessions: number; avgDuration: number; toolDiversity: number; tokensPerSession: number }>;
+  sessionComplexity: Array<{ id: string; title: string; score: number; messages: number; tools: number; contextPercent: number }>;
 }
 
 export type AnalyticsPeriod = "24h" | "7d" | "30d" | "90d" | "all";