fleetlens 0.12.0 → 0.12.2

package/dist/daemon-worker.js

@@ -159,7 +159,19 @@ function dailyActivity(sessions) {
   };
   for (const s of sessions) {
     const startDay = sessionDay(s);
-    if (startDay) {
+    if (s.dailyBreakdown && s.dailyBreakdown.length > 0) {
+      for (const d of s.dailyBreakdown) {
+        const bucket = touchBucket(d.day);
+        bucket.toolCalls += d.toolCalls;
+        bucket.turns += d.turns;
+        bucket.tokens.input += d.tokens.input;
+        bucket.tokens.output += d.tokens.output;
+        bucket.tokens.cacheRead += d.tokens.cacheRead;
+        bucket.tokens.cacheWrite += d.tokens.cacheWrite;
+      }
+      if (startDay)
+        touchBucket(startDay).durationMs += s.durationMs ?? 0;
+    } else if (startDay) {
       const bucket = touchBucket(startDay);
       bucket.toolCalls += s.toolCallCount ?? 0;
       bucket.turns += s.turnCount ?? 0;
@@ -169,31 +181,30 @@ function dailyActivity(sessions) {
       bucket.tokens.cacheWrite += s.totalUsage.cacheWrite;
       bucket.durationMs += s.durationMs ?? 0;
     }
+    const presenceDays = /* @__PURE__ */ new Set();
     const segments = s.activeSegments;
     if (segments && segments.length > 0) {
-      const touchedDays = /* @__PURE__ */ new Set();
       for (const seg of segments) {
         let cur = seg.startMs;
         while (cur < seg.endMs) {
           const day = toLocalDay(cur);
-          touchedDays.add(day);
+          presenceDays.add(day);
           const d = new Date(cur);
           d.setHours(24, 0, 0, 0);
           const dayEndMs = Math.min(d.getTime(), seg.endMs);
-          const bucket = touchBucket(day);
-          bucket.airTimeMs += dayEndMs - cur;
+          touchBucket(day).airTimeMs += dayEndMs - cur;
           cur = dayEndMs;
         }
       }
-      for (const day of touchedDays) {
-        const bucket = touchBucket(day);
-        bucket.sessions++;
-      }
     } else if (startDay) {
-      const bucket = touchBucket(startDay);
-      bucket.sessions++;
-      bucket.airTimeMs += s.airTimeMs ?? 0;
+      presenceDays.add(startDay);
+      touchBucket(startDay).airTimeMs += s.airTimeMs ?? 0;
     }
+    if (s.dailyBreakdown)
+      for (const d of s.dailyBreakdown)
+        presenceDays.add(d.day);
+    for (const day of presenceDays)
+      touchBucket(day).sessions++;
   }
   const range = minDay && maxDay ? daysBetween(minDay, maxDay) : [];
   const out = [];
@@ -1238,9 +1249,31 @@ function parseTranscript(rawLines) {
   let linesAdded = 0;
   let linesRemoved = 0;
   const filesEdited = /* @__PURE__ */ new Set();
+  const perDay = /* @__PURE__ */ new Map();
+  const fallbackDay = startMs !== void 0 ? toLocalDay(startMs) : void 0;
+  const dayBucket = (ts) => {
+    let day;
+    if (ts) {
+      const ms = Date.parse(ts);
+      if (!Number.isNaN(ms))
+        day = toLocalDay(ms);
+    }
+    day = day ?? fallbackDay;
+    if (!day)
+      return void 0;
+    let b = perDay.get(day);
+    if (!b) {
+      b = { toolCalls: 0, turns: 0, tokens: { ...BLANK_USAGE2 } };
+      perDay.set(day, b);
+    }
+    return b;
+  };
   for (const e of events) {
     if (e.role === "tool-call") {
       toolCallCount++;
+      const tcDay = dayBucket(e.timestamp);
+      if (tcDay)
+        tcDay.toolCalls++;
       const toolBlock = e.blocks.find((b) => b && b.type === "tool_use");
       if (toolBlock) {
         const input = toolBlock.input ?? {};
@@ -1277,6 +1310,9 @@ function parseTranscript(rawLines) {
           firstUserPreview = e.teammateMessage ? e.teammateMessage.body : e.preview;
         }
         turnCount++;
+        const turnDay = dayBucket(e.timestamp);
+        if (turnDay)
+          turnDay.turns++;
         lastUserPreview = e.preview;
       }
     }
@@ -1318,6 +1354,14 @@ function parseTranscript(rawLines) {
           totalUsage.output += u.output;
           totalUsage.cacheRead += u.cacheRead;
           totalUsage.cacheWrite += u.cacheWrite;
+          const ts = typeof o.timestamp === "string" ? o.timestamp : void 0;
+          const b = dayBucket(ts);
+          if (b) {
+            b.tokens.input += u.input;
+            b.tokens.output += u.output;
+            b.tokens.cacheRead += u.cacheRead;
+            b.tokens.cacheWrite += u.cacheWrite;
+          }
         }
       }
     }
@@ -1341,6 +1385,7 @@ function parseTranscript(rawLines) {
       lastAgentPreview,
       toolCallCount,
       turnCount,
+      dailyBreakdown: Array.from(perDay.entries()).map(([day, v]) => ({ day, toolCalls: v.toolCalls, turns: v.turns, tokens: v.tokens })).sort((a, b) => a.day.localeCompare(b.day)),
       airTimeMs,
       activeSegments,
       linesAdded,
@@ -1359,6 +1404,7 @@ var init_parser = __esm({
   "../parser/dist/parser.js"() {
     "use strict";
     init_user_input();
+    init_analytics();
     BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
     TEAMMATE_MSG_RE = /^\s*<teammate-message\s+teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/;
   }
@@ -1632,7 +1678,7 @@ async function loadCalibrationEvents(root = DEFAULT_ROOT) {
   out.sort((a, b) => a.ts.localeCompare(b.ts));
   return out;
 }
-function aggregateUsageFromLines(lines, seenKeys, usage) {
+function aggregateUsageFromLines(lines, seenKeys, usage, perDay, fallbackDay) {
   for (const raw of lines) {
     if (!raw || typeof raw !== "object")
       continue;
@@ -1652,35 +1698,85 @@ function aggregateUsageFromLines(lines, seenKeys, usage) {
     const u = m.usage;
     if (u) {
       const toNum = (v) => typeof v === "number" ? v : 0;
-      usage.input += toNum(u.input_tokens);
-      usage.output += toNum(u.output_tokens);
-      usage.cacheRead += toNum(u.cache_read_input_tokens);
-      usage.cacheWrite += toNum(u.cache_creation_input_tokens);
+      const inp = toNum(u.input_tokens);
+      const out = toNum(u.output_tokens);
+      const cr = toNum(u.cache_read_input_tokens);
+      const cw = toNum(u.cache_creation_input_tokens);
+      usage.input += inp;
+      usage.output += out;
+      usage.cacheRead += cr;
+      usage.cacheWrite += cw;
+      if (perDay) {
+        let day;
+        const ts = typeof r.timestamp === "string" ? r.timestamp : void 0;
+        if (ts) {
+          const ms = Date.parse(ts);
+          if (!Number.isNaN(ms))
+            day = toLocalDay(ms);
+        }
+        day = day ?? fallbackDay;
+        if (day) {
+          let d = perDay.get(day);
+          if (!d) {
+            d = { ...BLANK_USAGE3 };
+            perDay.set(day, d);
+          }
+          d.input += inp;
+          d.output += out;
+          d.cacheRead += cr;
+          d.cacheWrite += cw;
+        }
+      }
     }
   }
 }
-async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId) {
+async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId, fallbackDay) {
   const usage = { ...BLANK_USAGE3 };
   const seenKeys = /* @__PURE__ */ new Set();
-  aggregateUsageFromLines(parentLines, seenKeys, usage);
+  const perDay = /* @__PURE__ */ new Map();
+  aggregateUsageFromLines(parentLines, seenKeys, usage, perDay, fallbackDay);
   const subagentsDir = path.join(projectDirPath, sessionId, "subagents");
   let entries;
   try {
     entries = await fs.readdir(subagentsDir);
   } catch {
-    return usage;
+    return { usage, perDay };
   }
   const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
   if (jsonlFiles.length === 0)
-    return usage;
+    return { usage, perDay };
   await Promise.all(jsonlFiles.map(async (f) => {
     try {
       const lines = await readJsonlFile(path.join(subagentsDir, f));
-      aggregateUsageFromLines(lines, seenKeys, usage);
+      aggregateUsageFromLines(lines, seenKeys, usage, perDay, fallbackDay);
     } catch {
     }
   }));
-  return usage;
+  return { usage, perDay };
+}
+function mergeDailyTokens(base, perDayTokens, totalUsage) {
+  const counts = new Map((base ?? []).map((d) => [d.day, d]));
+  const days = /* @__PURE__ */ new Set([...counts.keys(), ...perDayTokens.keys()]);
+  const out = [...days].sort((a, b) => a.localeCompare(b)).map((day) => ({
+    day,
+    toolCalls: counts.get(day)?.toolCalls ?? 0,
+    turns: counts.get(day)?.turns ?? 0,
+    tokens: { ...perDayTokens.get(day) ?? BLANK_USAGE3 }
+  }));
+  if (out.length > 0) {
+    const summed = out.reduce((a, r) => ({
+      input: a.input + r.tokens.input,
+      output: a.output + r.tokens.output,
+      cacheRead: a.cacheRead + r.tokens.cacheRead,
+      cacheWrite: a.cacheWrite + r.tokens.cacheWrite
+    }), { ...BLANK_USAGE3 });
+    const first = out[0].tokens;
+    first.input += totalUsage.input - summed.input;
+    first.output += totalUsage.output - summed.output;
+    first.cacheRead += totalUsage.cacheRead - summed.cacheRead;
+    first.cacheWrite += totalUsage.cacheWrite - summed.cacheWrite;
+  }
+  return out;
 }
 async function scanWorkflowAggregate(projectDirPath, sessionId) {
   const dir = path.join(projectDirPath, sessionId, "workflows");
@@ -1738,7 +1834,10 @@ async function getCachedMeta(f) {
     const { meta } = parseTranscript(rawLines);
     const sessionId = sessionIdFromFileName(f.fileName);
     const projectDirPath = path.dirname(f.fullPath);
-    meta.totalUsage = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId);
+    const fallbackDay = meta.firstTimestamp ? toLocalDay(Date.parse(meta.firstTimestamp)) : void 0;
+    const { usage, perDay: perDayTokens } = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId, fallbackDay);
+    meta.totalUsage = usage;
+    meta.dailyBreakdown = mergeDailyTokens(meta.dailyBreakdown, perDayTokens, usage);
     const wf = await scanWorkflowAggregate(projectDirPath, sessionId);
     const full = {
       ...meta,
@@ -5471,16 +5570,12 @@ function bucketToRollup(b) {
   };
 }
 function buildRollupsForRange(sessions, sinceDay) {
-  const buckets = dailyActivity(sessions);
   const startCounts = /* @__PURE__ */ new Map();
   for (const s of sessions) {
     const d = sessionDay(s);
     if (d) startCounts.set(d, (startCounts.get(d) ?? 0) + 1);
   }
-  return buckets.filter((b) => !sinceDay || b.date >= sinceDay).map((b) => ({
-    ...bucketToRollup(b),
-    sessions: startCounts.get(b.date) ?? 0
-  }));
+  return dailyActivity(sessions).filter((b) => !sinceDay || b.date >= sinceDay).map((b) => ({ ...bucketToRollup(b), uniqueSessions: startCounts.get(b.date) ?? 0 }));
 }
 function dayBoundsMs(day) {
   const [y, m, d] = day.split("-").map(Number);
@@ -15051,14 +15146,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.12.0",
+    current: "0.12.2",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.12.0",
+    current: "0.12.2",
     latest,
-    updateAvailable: shouldUpdate("0.12.0", latest)
+    updateAvailable: shouldUpdate("0.12.2", latest)
   };
 }