@cryptiklemur/lattice 1.4.0 → 1.6.0

package/server/src/analytics/engine.ts

@@ -0,0 +1,606 @@
+import { readdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { AnalyticsPayload, AnalyticsPeriod, AnalyticsScope } from "@lattice/shared";
+import { estimateCost, projectPathToHash } from "../project/session";
+import { loadConfig } from "../config";
+
+interface ResponseTimeDatum {
+  tokens: number;
+  duration: number;
+  model: string;
+}
+
+interface ContextMessage {
+  messageIndex: number;
+  inputTokens: number;
+  model: string;
+}
+
+interface SessionData {
+  id: string;
+  title: string;
+  project: string;
+  cost: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheCreationTokens: number;
+  models: Map<string, { cost: number; tokens: number }>;
+  tools: Map<string, number>;
+  startTime: number;
+  endTime: number;
+  responseTimePoints: ResponseTimeDatum[];
+  contextMessages: ContextMessage[];
+}
+
+interface CacheEntry {
+  data: AnalyticsPayload;
+  timestamp: number;
+}
+
+var cache = new Map<string, CacheEntry>();
+var CACHE_TTL = 5 * 60 * 1000;
+
+function bucketModel(model: string): "opus" | "sonnet" | "haiku" | "other" {
+  if (model.includes("opus")) return "opus";
+  if (model.includes("haiku")) return "haiku";
+  if (model.includes("sonnet")) return "sonnet";
+  return "other";
+}
+
+function getPeriodCutoff(period: AnalyticsPeriod): number {
+  if (period === "all") return 0;
+  var now = Date.now();
+  var hours: Record<string, number> = { "24h": 24, "7d": 168, "30d": 720, "90d": 2160 };
+  return now - (hours[period] || 0) * 60 * 60 * 1000;
+}
+
+function formatDate(ts: number): string {
+  var d = new Date(ts);
+  var year = d.getFullYear();
+  var month = String(d.getMonth() + 1).padStart(2, "0");
+  var day = String(d.getDate()).padStart(2, "0");
+  return year + "-" + month + "-" + day;
+}
+
+function getCostBucket(cost: number): string {
+  if (cost < 0.01) return "$0-0.01";
+  if (cost < 0.05) return "$0.01-0.05";
+  if (cost < 0.10) return "$0.05-0.10";
+  if (cost < 0.50) return "$0.10-0.50";
+  if (cost < 1.00) return "$0.50-1.00";
+  if (cost < 5.00) return "$1.00-5.00";
+  return "$5.00+";
+}
+
+function parseSessionFile(filePath: string, sessionId: string, projectSlug: string): SessionData | null {
+  try {
+    var text: string;
+    try {
+      text = require("node:fs").readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+
+    var lines = text.split("\n");
+    var data: SessionData = {
+      id: sessionId,
+      title: "",
+      project: projectSlug,
+      cost: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      models: new Map(),
+      tools: new Map(),
+      startTime: 0,
+      endTime: 0,
+      responseTimePoints: [],
+      contextMessages: [],
+    };
+
+    var lastUserTimestamp = 0;
+    var assistantIndex = 0;
+
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (!line) continue;
+
+      var parsed: Record<string, unknown>;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+
+      var timestamp = 0;
+      if (typeof parsed.timestamp === "string") {
+        var ts = new Date(parsed.timestamp as string).getTime();
+        if (!isNaN(ts)) timestamp = ts;
+      }
+
+      if (timestamp > 0) {
+        if (data.startTime === 0 || timestamp < data.startTime) data.startTime = timestamp;
+        if (timestamp > data.endTime) data.endTime = timestamp;
+      }
+
+      if (parsed.type === "assistant") {
+        var message = parsed.message as Record<string, unknown> | undefined;
+        if (!message) continue;
+
+        var usage = message.usage as Record<string, number> | undefined;
+        var model = (message.model as string) || "";
+
+        if (usage) {
+          var inTok = usage.input_tokens || 0;
+          var outTok = usage.output_tokens || 0;
+          var cacheRead = usage.cache_read_input_tokens || 0;
+          var cacheCreation = usage.cache_creation_input_tokens || 0;
+
+          data.inputTokens += inTok;
+          data.outputTokens += outTok;
+          data.cacheReadTokens += cacheRead;
+          data.cacheCreationTokens += cacheCreation;
+
+          var cost = estimateCost(model, inTok, outTok, cacheRead, cacheCreation);
+          data.cost += cost;
+
+          var bucket = bucketModel(model);
+          var existing = data.models.get(bucket);
+          if (existing) {
+            existing.cost += cost;
+            existing.tokens += inTok + outTok;
+          } else {
+            data.models.set(bucket, { cost: cost, tokens: inTok + outTok });
+          }
+
+          if (outTok > 0 && timestamp > 0 && lastUserTimestamp > 0) {
+            var dur = timestamp - lastUserTimestamp;
+            if (dur > 0 && dur < 600000) {
+              data.responseTimePoints.push({ tokens: outTok, duration: dur, model: bucket });
+            }
+          }
+
+          data.contextMessages.push({ messageIndex: assistantIndex, inputTokens: inTok + cacheRead + cacheCreation, model: bucket });
+          assistantIndex++;
+        }
+
+        if (!data.title && message.content) {
+          if (typeof message.content === "string" && message.content.length > 0) {
+            data.title = message.content.slice(0, 80);
+          }
+        }
+      } else if (parsed.type === "user") {
+        if (timestamp > 0) lastUserTimestamp = timestamp;
+        var userMsg = parsed.message as Record<string, unknown> | undefined;
+        if (!userMsg || !Array.isArray(userMsg.content)) continue;
+
+        var contentArr = userMsg.content as Array<Record<string, unknown>>;
+        for (var j = 0; j < contentArr.length; j++) {
+          var block = contentArr[j];
+          if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            var toolName = (block.name as string) || "unknown";
+            data.tools.set(toolName, (data.tools.get(toolName) || 0) + 1);
+          }
+        }
+
+        if (!data.title && Array.isArray(userMsg.content)) {
+          for (var k = 0; k < contentArr.length; k++) {
+            if (contentArr[k].type === "text" && typeof contentArr[k].text === "string") {
+              data.title = (contentArr[k].text as string).slice(0, 80);
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    if (!data.title) data.title = "Session " + sessionId.slice(0, 8);
+
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function getSessionFilesForProject(projectPath: string): Array<{ path: string; id: string }> {
+  var hash = projectPathToHash(projectPath);
+  var dir = join(homedir(), ".claude", "projects", hash);
+  if (!existsSync(dir)) return [];
+
+  var files: Array<{ path: string; id: string }> = [];
+  try {
+    var entries = readdirSync(dir);
+    for (var i = 0; i < entries.length; i++) {
+      if (entries[i].endsWith(".jsonl")) {
+        files.push({
+          path: join(dir, entries[i]),
+          id: entries[i].replace(".jsonl", ""),
+        });
+      }
+    }
+  } catch {
+    return [];
+  }
+  return files;
+}
+
+function aggregate(sessions: SessionData[], period: AnalyticsPeriod): AnalyticsPayload {
+  var cutoff = getPeriodCutoff(period);
+  var filtered: SessionData[] = [];
+  for (var i = 0; i < sessions.length; i++) {
+    var s = sessions[i];
+    var sessionTime = s.endTime > 0 ? s.endTime : s.startTime;
+    if (sessionTime >= cutoff) filtered.push(s);
+  }
+
+  var totalCost = 0;
+  var totalInput = 0;
+  var totalOutput = 0;
+  var totalCacheRead = 0;
+  var totalCacheCreation = 0;
+  var totalDuration = 0;
+  var durationCount = 0;
+
+  var dailyCost = new Map<string, { total: number; opus: number; sonnet: number; haiku: number; other: number }>();
+  var dailySessions = new Map<string, number>();
+  var dailyTokens = new Map<string, { input: number; output: number; cacheRead: number }>();
+  var dailyCacheHit = new Map<string, { cacheRead: number; totalInput: number }>();
+
+  var modelStats = new Map<string, { sessions: number; cost: number; tokens: number }>();
+  var projectStats = new Map<string, { cost: number; sessions: number; tokens: number }>();
+  var toolStats = new Map<string, { count: number; totalCost: number; sessions: number }>();
+
+  var costBuckets = new Map<string, number>();
+  var bucketOrder = ["$0-0.01", "$0.01-0.05", "$0.05-0.10", "$0.10-0.50", "$0.50-1.00", "$1.00-5.00", "$5.00+"];
+  for (var b = 0; b < bucketOrder.length; b++) {
+    costBuckets.set(bucketOrder[b], 0);
+  }
+
+  for (var si = 0; si < filtered.length; si++) {
+    var sess = filtered[si];
+    totalCost += sess.cost;
+    totalInput += sess.inputTokens;
+    totalOutput += sess.outputTokens;
+    totalCacheRead += sess.cacheReadTokens;
+    totalCacheCreation += sess.cacheCreationTokens;
+
+    if (sess.startTime > 0 && sess.endTime > 0 && sess.endTime > sess.startTime) {
+      totalDuration += sess.endTime - sess.startTime;
+      durationCount++;
+    }
+
+    var date = formatDate(sess.endTime > 0 ? sess.endTime : sess.startTime);
+
+    var dc = dailyCost.get(date);
+    if (!dc) {
+      dc = { total: 0, opus: 0, sonnet: 0, haiku: 0, other: 0 };
+      dailyCost.set(date, dc);
+    }
+    dc.total += sess.cost;
+    sess.models.forEach(function (val, key) {
+      dc![key as "opus" | "sonnet" | "haiku" | "other"] += val.cost;
+    });
+
+    dailySessions.set(date, (dailySessions.get(date) || 0) + 1);
+
+    var dt = dailyTokens.get(date);
+    if (!dt) {
+      dt = { input: 0, output: 0, cacheRead: 0 };
+      dailyTokens.set(date, dt);
+    }
+    dt.input += sess.inputTokens;
+    dt.output += sess.outputTokens;
+    dt.cacheRead += sess.cacheReadTokens;
+
+    var dch = dailyCacheHit.get(date);
+    if (!dch) {
+      dch = { cacheRead: 0, totalInput: 0 };
+      dailyCacheHit.set(date, dch);
+    }
+    dch.cacheRead += sess.cacheReadTokens;
+    dch.totalInput += sess.inputTokens;
+
+    sess.models.forEach(function (val, key) {
+      var ms = modelStats.get(key);
+      if (!ms) {
+        ms = { sessions: 0, cost: 0, tokens: 0 };
+        modelStats.set(key, ms);
+      }
+      ms.sessions++;
+      ms.cost += val.cost;
+      ms.tokens += val.tokens;
+    });
+
+    var ps = projectStats.get(sess.project);
+    if (!ps) {
+      ps = { cost: 0, sessions: 0, tokens: 0 };
+      projectStats.set(sess.project, ps);
+    }
+    ps.cost += sess.cost;
+    ps.sessions++;
+    ps.tokens += sess.inputTokens + sess.outputTokens;
+
+    sess.tools.forEach(function (count, tool) {
+      var ts = toolStats.get(tool);
+      if (!ts) {
+        ts = { count: 0, totalCost: 0, sessions: 0 };
+        toolStats.set(tool, ts);
+      }
+      ts.count += count;
+      ts.totalCost += sess.cost;
+      ts.sessions++;
+    });
+
+    var bucket = getCostBucket(sess.cost);
+    costBuckets.set(bucket, (costBuckets.get(bucket) || 0) + 1);
+  }
+
+  var totalTokensAll = totalInput + totalOutput + totalCacheRead + totalCacheCreation;
+  var cacheHitRate = (totalInput + totalCacheRead) > 0 ? totalCacheRead / (totalInput + totalCacheRead) : 0;
+
+  var dates = Array.from(dailyCost.keys()).sort();
+
+  var costOverTime: AnalyticsPayload["costOverTime"] = [];
+  var cumulativeCost: AnalyticsPayload["cumulativeCost"] = [];
+  var sessionsOverTime: AnalyticsPayload["sessionsOverTime"] = [];
+  var tokensOverTime: AnalyticsPayload["tokensOverTime"] = [];
+  var cacheHitRateOverTime: AnalyticsPayload["cacheHitRateOverTime"] = [];
+
+  var cumTotal = 0;
+  for (var di = 0; di < dates.length; di++) {
+    var d = dates[di];
+    var dcEntry = dailyCost.get(d)!;
+    cumTotal += dcEntry.total;
+
+    costOverTime.push({
+      date: d,
+      total: dcEntry.total,
+      opus: dcEntry.opus,
+      sonnet: dcEntry.sonnet,
+      haiku: dcEntry.haiku,
+      other: dcEntry.other,
+    });
+    cumulativeCost.push({ date: d, total: cumTotal });
+    sessionsOverTime.push({ date: d, count: dailySessions.get(d) || 0 });
+
+    var dtEntry = dailyTokens.get(d);
+    tokensOverTime.push({
+      date: d,
+      input: dtEntry ? dtEntry.input : 0,
+      output: dtEntry ? dtEntry.output : 0,
+      cacheRead: dtEntry ? dtEntry.cacheRead : 0,
+    });
+
+    var dchEntry = dailyCacheHit.get(d);
+    var rate = dchEntry && (dchEntry.totalInput + dchEntry.cacheRead) > 0 ? dchEntry.cacheRead / (dchEntry.totalInput + dchEntry.cacheRead) : 0;
+    cacheHitRateOverTime.push({ date: d, rate: rate });
+  }
+
+  var costDistribution: AnalyticsPayload["costDistribution"] = [];
+  for (var bi = 0; bi < bucketOrder.length; bi++) {
+    costDistribution.push({
+      bucket: bucketOrder[bi],
+      count: costBuckets.get(bucketOrder[bi]) || 0,
+    });
+  }
+
+  var sessionBubbles: AnalyticsPayload["sessionBubbles"] = [];
+  var sorted = filtered.slice().sort(function (a, b) {
+    return (b.endTime || b.startTime) - (a.endTime || a.startTime);
+  });
+  var bubbleCap = Math.min(sorted.length, 200);
+  for (var sbi = 0; sbi < bubbleCap; sbi++) {
+    var sb = sorted[sbi];
+    sessionBubbles.push({
+      id: sb.id,
+      title: sb.title,
+      cost: sb.cost,
+      tokens: sb.inputTokens + sb.outputTokens,
+      timestamp: sb.endTime > 0 ? sb.endTime : sb.startTime,
+      project: sb.project,
+    });
+  }
+
+  var modelUsage: AnalyticsPayload["modelUsage"] = [];
+  var totalModelCost = totalCost || 1;
+  modelStats.forEach(function (val, key) {
+    modelUsage.push({
+      model: key,
+      sessions: val.sessions,
+      cost: val.cost,
+      tokens: val.tokens,
+      percentage: (val.cost / totalModelCost) * 100,
+    });
+  });
+  modelUsage.sort(function (a, b) { return b.cost - a.cost; });
+
+  var projectBreakdown: AnalyticsPayload["projectBreakdown"] = [];
+  projectStats.forEach(function (val, key) {
+    projectBreakdown.push({
+      project: key,
+      cost: val.cost,
+      sessions: val.sessions,
+      tokens: val.tokens,
+    });
+  });
+  projectBreakdown.sort(function (a, b) { return b.cost - a.cost; });
+
+  var toolUsage: AnalyticsPayload["toolUsage"] = [];
+  toolStats.forEach(function (val, key) {
+    toolUsage.push({
+      tool: key,
+      count: val.count,
+      avgCost: val.sessions > 0 ? val.totalCost / val.sessions : 0,
+    });
+  });
+  toolUsage.sort(function (a, b) { return b.count - a.count; });
+
+  var responseTimeData: AnalyticsPayload["responseTimeData"] = [];
+  for (var rti = 0; rti < filtered.length; rti++) {
+    var rtSess = filtered[rti];
+    for (var rtj = 0; rtj < rtSess.responseTimePoints.length; rtj++) {
+      var rtp = rtSess.responseTimePoints[rtj];
+      responseTimeData.push({ tokens: rtp.tokens, duration: rtp.duration, model: rtp.model, sessionId: rtSess.id });
+    }
+    if (responseTimeData.length >= 200) break;
+  }
+  if (responseTimeData.length > 200) responseTimeData.length = 200;
+
+  var contextWindowSizes: Record<string, number> = { opus: 200000, sonnet: 200000, haiku: 200000, other: 200000 };
+  var contextUtilization: AnalyticsPayload["contextUtilization"] = [];
+  var recentSessions = sorted.slice(0, 5);
+  for (var cui = 0; cui < recentSessions.length; cui++) {
+    var cuSess = recentSessions[cui];
+    var runningTokens = 0;
+    var primaryModel = "other";
+    var maxModelTokens = 0;
+    cuSess.models.forEach(function (val, key) {
+      if (val.tokens > maxModelTokens) {
+        maxModelTokens = val.tokens;
+        primaryModel = key;
+      }
+    });
+    var windowSize = contextWindowSizes[primaryModel] || 200000;
+    for (var cmj = 0; cmj < cuSess.contextMessages.length; cmj++) {
+      var cm = cuSess.contextMessages[cmj];
+      runningTokens += cm.inputTokens;
+      contextUtilization.push({
+        messageIndex: cm.messageIndex,
+        contextPercent: Math.min((runningTokens / windowSize) * 100, 100),
+        sessionId: cuSess.id,
+        title: cuSess.title,
+      });
+    }
+  }
+
+  var sankeyNodes = [
+    { name: "Input Tokens" },
+    { name: "Cache Read" },
+    { name: "Cache Creation" },
+    { name: "Opus" },
+    { name: "Sonnet" },
+    { name: "Haiku" },
+    { name: "Other" },
+    { name: "Output Tokens" },
+  ];
+  var modelNodeMap: Record<string, number> = { opus: 3, sonnet: 4, haiku: 5, other: 6 };
+  var sankeyLinks: Array<{ source: number; target: number; value: number }> = [];
+  var modelInputTotals = new Map<string, number>();
+  var modelCacheTotals = new Map<string, number>();
+  var modelCacheCreationTotals = new Map<string, number>();
+  var modelOutputTotals = new Map<string, number>();
+
+  for (var ski = 0; ski < filtered.length; ski++) {
+    var skSess = filtered[ski];
+    var skTotal = skSess.inputTokens + skSess.cacheReadTokens + skSess.cacheCreationTokens;
+    if (skTotal === 0) continue;
+    skSess.models.forEach(function (val, key) {
+      var proportion = val.tokens / (skTotal + skSess.outputTokens || 1);
+      modelInputTotals.set(key, (modelInputTotals.get(key) || 0) + skSess.inputTokens * proportion);
+      modelCacheTotals.set(key, (modelCacheTotals.get(key) || 0) + skSess.cacheReadTokens * proportion);
+      modelCacheCreationTotals.set(key, (modelCacheCreationTotals.get(key) || 0) + skSess.cacheCreationTokens * proportion);
+      modelOutputTotals.set(key, (modelOutputTotals.get(key) || 0) + skSess.outputTokens * proportion);
+    });
+  }
+
+  ["opus", "sonnet", "haiku", "other"].forEach(function (model) {
+    var nodeIdx = modelNodeMap[model];
+    var inputVal = Math.round(modelInputTotals.get(model) || 0);
+    var cacheVal = Math.round(modelCacheTotals.get(model) || 0);
+    var cacheCreationVal = Math.round(modelCacheCreationTotals.get(model) || 0);
+    var outputVal = Math.round(modelOutputTotals.get(model) || 0);
+    if (inputVal > 0) sankeyLinks.push({ source: 0, target: nodeIdx, value: inputVal });
+    if (cacheVal > 0) sankeyLinks.push({ source: 1, target: nodeIdx, value: cacheVal });
+    if (cacheCreationVal > 0) sankeyLinks.push({ source: 2, target: nodeIdx, value: cacheCreationVal });
+    if (outputVal > 0) sankeyLinks.push({ source: nodeIdx, target: 7, value: outputVal });
+  });
+
+  var tokenFlowSankey: AnalyticsPayload["tokenFlowSankey"] = { nodes: sankeyNodes, links: sankeyLinks };
+
+  return {
+    totalCost: totalCost,
+    totalSessions: filtered.length,
+    totalTokens: {
+      input: totalInput,
+      output: totalOutput,
+      cacheRead: totalCacheRead,
+      cacheCreation: totalCacheCreation,
+    },
+    cacheHitRate: cacheHitRate,
+    avgSessionCost: filtered.length > 0 ? totalCost / filtered.length : 0,
+    avgSessionDuration: durationCount > 0 ? totalDuration / durationCount : 0,
+    costOverTime: costOverTime,
+    cumulativeCost: cumulativeCost,
+    sessionsOverTime: sessionsOverTime,
+    tokensOverTime: tokensOverTime,
+    cacheHitRateOverTime: cacheHitRateOverTime,
+    costDistribution: costDistribution,
+    sessionBubbles: sessionBubbles,
+    modelUsage: modelUsage,
+    projectBreakdown: projectBreakdown,
+    toolUsage: toolUsage,
+    responseTimeData: responseTimeData,
+    contextUtilization: contextUtilization,
+    tokenFlowSankey: tokenFlowSankey,
+  };
+}
+
+export function getAnalytics(
+  scope: AnalyticsScope,
+  period: AnalyticsPeriod,
+  projectSlug?: string,
+  sessionId?: string,
+  forceRefresh?: boolean,
+): Promise<AnalyticsPayload> {
+  var cacheKey = scope + ":" + period + ":" + (projectSlug || "all");
+  if (sessionId) cacheKey += ":" + sessionId;
+
+  if (!forceRefresh) {
+    var cached = cache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return Promise.resolve(cached.data);
+    }
+  }
+
+  var sessions: SessionData[] = [];
+  var config = loadConfig();
+
+  if (scope === "global") {
+    for (var i = 0; i < config.projects.length; i++) {
+      var proj = config.projects[i];
+      var files = getSessionFilesForProject(proj.path);
+      for (var j = 0; j < files.length; j++) {
+        var data = parseSessionFile(files[j].path, files[j].id, proj.slug);
+        if (data) sessions.push(data);
+      }
+    }
+  } else if (scope === "project" && projectSlug) {
+    var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+    if (project) {
+      var projFiles = getSessionFilesForProject(project.path);
+      for (var pf = 0; pf < projFiles.length; pf++) {
+        var pData = parseSessionFile(projFiles[pf].path, projFiles[pf].id, projectSlug);
+        if (pData) sessions.push(pData);
+      }
+    }
+  } else if (scope === "session" && projectSlug && sessionId) {
+    var sessProject = config.projects.find(function (p) { return p.slug === projectSlug; });
+    if (sessProject) {
+      var hash = projectPathToHash(sessProject.path);
+      var filePath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+      if (existsSync(filePath)) {
+        var sData = parseSessionFile(filePath, sessionId, projectSlug);
+        if (sData) sessions.push(sData);
+      }
+    }
+  }
+
+  var result = aggregate(sessions, period);
+
+  cache.set(cacheKey, { data: result, timestamp: Date.now() });
+
+  return Promise.resolve(result);
+}

package/server/src/daemon.ts

@@ -28,6 +28,7 @@ import "./handlers/notes";
 import "./handlers/skills";
 import "./handlers/memory";
 import "./handlers/editor";
+import "./handlers/analytics";
 import { startScheduler } from "./features/scheduler";
 import { loadNotes } from "./features/sticky-notes";
 import { cleanupClientTerminals } from "./handlers/terminal";

package/server/src/handlers/analytics.ts

@@ -0,0 +1,34 @@
+import type { ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { getAnalytics } from "../analytics/engine";
+
+registerHandler("analytics", function (clientId: string, message: ClientMessage) {
+  if (message.type === "analytics:request") {
+    var msg = message as { type: string; requestId: string; scope: string; projectSlug?: string; sessionId?: string; period: string; forceRefresh?: boolean };
+
+    getAnalytics(
+      msg.scope as "global" | "project" | "session",
+      msg.period as "24h" | "7d" | "30d" | "90d" | "all",
+      msg.projectSlug,
+      msg.sessionId,
+      msg.forceRefresh
+    ).then(function (data) {
+      sendTo(clientId, {
+        type: "analytics:data",
+        requestId: msg.requestId,
+        scope: msg.scope,
+        period: msg.period,
+        data: data,
+      });
+    }).catch(function (err) {
+      sendTo(clientId, {
+        type: "analytics:error",
+        scope: msg.scope,
+        message: err instanceof Error ? err.message : "Analytics computation failed",
+      });
+    });
+
+    return;
+  }
+});

package/server/src/project/session.ts

@@ -18,7 +18,7 @@ function getProjectPath(projectSlug: string): string | null {
   return project ? project.path : null;
 }
 
-function projectPathToHash(projectPath: string): string {
+export function projectPathToHash(projectPath: string): string {
   return projectPath.replace(/\//g, "-");
 }
 
@@ -43,7 +43,7 @@ var FALLBACK_PRICING: Record<string, { input: number; output: number }> = {
   "claude-haiku-4-5": { input: 0.80, output: 4 },
 };
 
-function loadPricing(): void {
+export function loadPricing(): void {
   if (pricingLoaded) return;
   pricingLoaded = true;
   fetch(LITELLM_PRICING_URL).then(function (res) {
@@ -69,7 +69,7 @@ function loadPricing(): void {
 
 loadPricing();
 
-function getPricing(model: string): { input: number; output: number; cacheRead?: number; cacheCreation?: number } {
+export function getPricing(model: string): { input: number; output: number; cacheRead?: number; cacheCreation?: number } {
   if (pricingCache[model]) return pricingCache[model];
   for (var key in pricingCache) {
     if (key.includes(model) || model.includes(key)) return pricingCache[key];
@@ -84,7 +84,7 @@ function getPricing(model: string): { input: number; output: number; cacheRead?:
   return FALLBACK_PRICING["claude-sonnet-4-6"];
 }
 
-function estimateCost(model: string, inputTokens: number, outputTokens: number, cacheRead: number, cacheCreation: number): number {
+export function estimateCost(model: string, inputTokens: number, outputTokens: number, cacheRead: number, cacheCreation: number): number {
   var pricing = getPricing(model);
   var normalInput = inputTokens - cacheRead - cacheCreation;
   var inputCost = (normalInput * pricing.input) / 1000000;