@vibescore/tracker 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/lib/rollout.js

@@ -469,49 +469,253 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
   }
   if (touchedGroups.size === 0) return 0;
 
-  const grouped = new Map();
+  const groupQueued = hourlyState.groupQueued && typeof hourlyState.groupQueued === 'object' ? hourlyState.groupQueued : {};
+  let codexTouched = false;
+  const legacyGroups = new Set();
+  for (const groupKey of touchedGroups) {
+    if (Object.prototype.hasOwnProperty.call(groupQueued, groupKey)) {
+      legacyGroups.add(groupKey);
+    }
+    if (!codexTouched && groupKey.startsWith(`${DEFAULT_SOURCE}${BUCKET_SEPARATOR}`)) {
+      codexTouched = true;
+    }
+  }
+
+  const groupedBuckets = new Map();
   for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
     if (!bucket || !bucket.totals) continue;
     const parsed = parseBucketKey(key);
     const hourStart = parsed.hourStart;
     if (!hourStart) continue;
     const groupKey = groupBucketKey(parsed.source, hourStart);
-    if (!touchedGroups.has(groupKey)) continue;
+    if (!touchedGroups.has(groupKey) || legacyGroups.has(groupKey)) continue;
 
-    let group = grouped.get(groupKey);
+    const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+    const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+    let group = groupedBuckets.get(groupKey);
     if (!group) {
-      group = {
-        source: normalizeSourceInput(parsed.source) || DEFAULT_SOURCE,
-        hourStart,
-        models: new Set(),
-        totals: initTotals()
-      };
-      grouped.set(groupKey, group);
+      group = { source, hourStart, buckets: new Map() };
+      groupedBuckets.set(groupKey, group);
+    }
+
+    if (bucket.queuedKey != null && typeof bucket.queuedKey !== 'string') {
+      bucket.queuedKey = null;
+    }
+    group.buckets.set(model, bucket);
+  }
+
+  if (codexTouched) {
+    const recomputeGroups = new Set();
+    for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+      if (!bucket || !bucket.totals) continue;
+      const parsed = parseBucketKey(key);
+      const hourStart = parsed.hourStart;
+      if (!hourStart) continue;
+      const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+      if (source !== 'every-code') continue;
+      const groupKey = groupBucketKey(source, hourStart);
+      if (legacyGroups.has(groupKey) || groupedBuckets.has(groupKey)) continue;
+      const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+      if (model !== DEFAULT_MODEL) continue;
+      recomputeGroups.add(groupKey);
+    }
+
+    if (recomputeGroups.size > 0) {
+      for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+        if (!bucket || !bucket.totals) continue;
+        const parsed = parseBucketKey(key);
+        const hourStart = parsed.hourStart;
+        if (!hourStart) continue;
+        const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+        const groupKey = groupBucketKey(source, hourStart);
+        if (!recomputeGroups.has(groupKey)) continue;
+        let group = groupedBuckets.get(groupKey);
+        if (!group) {
+          group = { source, hourStart, buckets: new Map() };
+          groupedBuckets.set(groupKey, group);
+        }
+        if (bucket.queuedKey != null && typeof bucket.queuedKey !== 'string') {
+          bucket.queuedKey = null;
+        }
+        const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+        group.buckets.set(model, bucket);
+      }
     }
-    group.models.add(parsed.model || DEFAULT_MODEL);
-    addTotals(group.totals, bucket.totals);
   }
 
+  const codexDominants = collectCodexDominantModels(hourlyState);
+
   const toAppend = [];
-  const groupQueued = hourlyState.groupQueued && typeof hourlyState.groupQueued === 'object' ? hourlyState.groupQueued : {};
-  for (const group of grouped.values()) {
-    const model = group.models.size === 1 ? [...group.models][0] : DEFAULT_MODEL;
-    const key = totalsKey(group.totals);
-    const groupKey = groupBucketKey(group.source, group.hourStart);
-    if (groupQueued[groupKey] === key) continue;
+  for (const group of groupedBuckets.values()) {
+    const unknownBucket = group.buckets.get(DEFAULT_MODEL) || null;
+    const dominantModel = pickDominantModel(group.buckets);
+    let alignedModel = null;
+    if (unknownBucket?.alignedModel) {
+      const normalized = normalizeModelInput(unknownBucket.alignedModel);
+      alignedModel = normalized && normalized !== DEFAULT_MODEL ? normalized : null;
+    }
+    const zeroTotals = initTotals();
+    const zeroKey = totalsKey(zeroTotals);
+
+    if (dominantModel) {
+      if (alignedModel && !group.buckets.has(alignedModel)) {
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model: alignedModel,
+            hour_start: group.hourStart,
+            input_tokens: zeroTotals.input_tokens,
+            cached_input_tokens: zeroTotals.cached_input_tokens,
+            output_tokens: zeroTotals.output_tokens,
+            reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+            total_tokens: zeroTotals.total_tokens
+          })
+        );
+      }
+      if (unknownBucket && !alignedModel && unknownBucket.queuedKey && unknownBucket.queuedKey !== zeroKey) {
+        if (unknownBucket.retractedUnknownKey !== zeroKey) {
+          toAppend.push(
+            JSON.stringify({
+              source: group.source,
+              model: DEFAULT_MODEL,
+              hour_start: group.hourStart,
+              input_tokens: zeroTotals.input_tokens,
+              cached_input_tokens: zeroTotals.cached_input_tokens,
+              output_tokens: zeroTotals.output_tokens,
+              reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+              total_tokens: zeroTotals.total_tokens
+            })
+          );
+          unknownBucket.retractedUnknownKey = zeroKey;
+        }
+      }
+      if (unknownBucket) unknownBucket.alignedModel = null;
+      for (const [model, bucket] of group.buckets.entries()) {
+        if (model === DEFAULT_MODEL) continue;
+        let totals = bucket.totals;
+        if (model === dominantModel && unknownBucket?.totals) {
+          totals = cloneTotals(bucket.totals);
+          addTotals(totals, unknownBucket.totals);
+        }
+        const key = totalsKey(totals);
+        if (bucket.queuedKey === key) continue;
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model,
+            hour_start: group.hourStart,
+            input_tokens: totals.input_tokens,
+            cached_input_tokens: totals.cached_input_tokens,
+            output_tokens: totals.output_tokens,
+            reasoning_output_tokens: totals.reasoning_output_tokens,
+            total_tokens: totals.total_tokens
+          })
+        );
+        bucket.queuedKey = key;
+      }
+      continue;
+    }
+
+    if (!unknownBucket?.totals) continue;
+    let outputModel = DEFAULT_MODEL;
+    if (group.source === 'every-code') {
+      const aligned = findNearestCodexModel(group.hourStart, codexDominants);
+      if (aligned) outputModel = aligned;
+    }
+    const nextAligned = outputModel !== DEFAULT_MODEL ? outputModel : null;
+    if (alignedModel && alignedModel !== nextAligned) {
+      toAppend.push(
+        JSON.stringify({
+          source: group.source,
+          model: alignedModel,
+          hour_start: group.hourStart,
+          input_tokens: zeroTotals.input_tokens,
+          cached_input_tokens: zeroTotals.cached_input_tokens,
+          output_tokens: zeroTotals.output_tokens,
+          reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+          total_tokens: zeroTotals.total_tokens
+        })
+      );
+    }
+    if (!alignedModel && nextAligned && unknownBucket.queuedKey && unknownBucket.queuedKey !== zeroKey) {
+      if (unknownBucket.retractedUnknownKey !== zeroKey) {
+        toAppend.push(
+          JSON.stringify({
+            source: group.source,
+            model: DEFAULT_MODEL,
+            hour_start: group.hourStart,
+            input_tokens: zeroTotals.input_tokens,
+            cached_input_tokens: zeroTotals.cached_input_tokens,
+            output_tokens: zeroTotals.output_tokens,
+            reasoning_output_tokens: zeroTotals.reasoning_output_tokens,
+            total_tokens: zeroTotals.total_tokens
+          })
+        );
+        unknownBucket.retractedUnknownKey = zeroKey;
+      }
+    }
+    if (unknownBucket) unknownBucket.alignedModel = nextAligned;
+    const key = totalsKey(unknownBucket.totals);
+    const outputKey = outputModel === DEFAULT_MODEL ? key : `${key}|${outputModel}`;
+    if (unknownBucket.queuedKey === outputKey) continue;
     toAppend.push(
       JSON.stringify({
         source: group.source,
-        model,
+        model: outputModel,
         hour_start: group.hourStart,
-        input_tokens: group.totals.input_tokens,
-        cached_input_tokens: group.totals.cached_input_tokens,
-        output_tokens: group.totals.output_tokens,
-        reasoning_output_tokens: group.totals.reasoning_output_tokens,
-        total_tokens: group.totals.total_tokens
+        input_tokens: unknownBucket.totals.input_tokens,
+        cached_input_tokens: unknownBucket.totals.cached_input_tokens,
+        output_tokens: unknownBucket.totals.output_tokens,
+        reasoning_output_tokens: unknownBucket.totals.reasoning_output_tokens,
+        total_tokens: unknownBucket.totals.total_tokens
       })
     );
-    groupQueued[groupKey] = key;
+    unknownBucket.queuedKey = outputKey;
+  }
+
+  if (legacyGroups.size > 0) {
+    const grouped = new Map();
+    for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+      if (!bucket || !bucket.totals) continue;
+      const parsed = parseBucketKey(key);
+      const hourStart = parsed.hourStart;
+      if (!hourStart) continue;
+      const groupKey = groupBucketKey(parsed.source, hourStart);
+      if (!legacyGroups.has(groupKey)) continue;
+
+      let group = grouped.get(groupKey);
+      if (!group) {
+        group = {
+          source: normalizeSourceInput(parsed.source) || DEFAULT_SOURCE,
+          hourStart,
+          models: new Set(),
+          totals: initTotals()
+        };
+        grouped.set(groupKey, group);
+      }
+      group.models.add(parsed.model || DEFAULT_MODEL);
+      addTotals(group.totals, bucket.totals);
+    }
+
+    for (const group of grouped.values()) {
+      const model = group.models.size === 1 ? [...group.models][0] : DEFAULT_MODEL;
+      const key = totalsKey(group.totals);
+      const groupKey = groupBucketKey(group.source, group.hourStart);
+      if (groupQueued[groupKey] === key) continue;
+      toAppend.push(
+        JSON.stringify({
+          source: group.source,
+          model,
+          hour_start: group.hourStart,
+          input_tokens: group.totals.input_tokens,
+          cached_input_tokens: group.totals.cached_input_tokens,
+          output_tokens: group.totals.output_tokens,
+          reasoning_output_tokens: group.totals.reasoning_output_tokens,
+          total_tokens: group.totals.total_tokens
+        })
+      );
+      groupQueued[groupKey] = key;
+    }
   }
 
   hourlyState.groupQueued = groupQueued;
@@ -523,6 +727,91 @@ async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets })
   return toAppend.length;
 }
 
+function pickDominantModel(buckets) {
+  let dominantModel = null;
+  let dominantTotal = -1;
+  for (const [model, bucket] of buckets.entries()) {
+    if (model === DEFAULT_MODEL) continue;
+    const total = Number(bucket?.totals?.total_tokens || 0);
+    if (
+      dominantModel == null ||
+      total > dominantTotal ||
+      (total === dominantTotal && model < dominantModel)
+    ) {
+      dominantModel = model;
+      dominantTotal = total;
+    }
+  }
+  return dominantModel;
+}
+
+function cloneTotals(totals) {
+  const cloned = initTotals();
+  addTotals(cloned, totals || {});
+  return cloned;
+}
+
+function collectCodexDominantModels(hourlyState) {
+  const grouped = new Map();
+  for (const [key, bucket] of Object.entries(hourlyState.buckets || {})) {
+    if (!bucket || !bucket.totals) continue;
+    const parsed = parseBucketKey(key);
+    const hourStart = parsed.hourStart;
+    if (!hourStart) continue;
+    const source = normalizeSourceInput(parsed.source) || DEFAULT_SOURCE;
+    if (source !== DEFAULT_SOURCE) continue;
+    const model = normalizeModelInput(parsed.model) || DEFAULT_MODEL;
+    if (model === DEFAULT_MODEL) continue;
+
+    let models = grouped.get(hourStart);
+    if (!models) {
+      models = new Map();
+      grouped.set(hourStart, models);
+    }
+    const total = Number(bucket.totals.total_tokens || 0);
+    models.set(model, (models.get(model) || 0) + total);
+  }
+
+  const dominants = [];
+  for (const [hourStart, models] of grouped.entries()) {
+    let dominantModel = null;
+    let dominantTotal = -1;
+    for (const [model, total] of models.entries()) {
+      if (
+        dominantModel == null ||
+        total > dominantTotal ||
+        (total === dominantTotal && model < dominantModel)
+      ) {
+        dominantModel = model;
+        dominantTotal = total;
+      }
+    }
+    if (dominantModel) {
+      dominants.push({ hourStart, model: dominantModel });
+    }
+  }
+
+  return dominants;
+}
+
+function findNearestCodexModel(hourStart, dominants) {
+  if (!hourStart || !dominants || dominants.length === 0) return null;
+  const target = Date.parse(hourStart);
+  if (!Number.isFinite(target)) return null;
+
+  let best = null;
+  for (const entry of dominants) {
+    const candidate = Date.parse(entry.hourStart);
+    if (!Number.isFinite(candidate)) continue;
+    const diff = Math.abs(candidate - target);
+    if (!best || diff < best.diff || (diff === best.diff && candidate < best.time)) {
+      best = { diff, time: candidate, model: entry.model };
+    }
+  }
+
+  return best ? best.model : null;
+}
+
 function normalizeHourlyState(raw) {
   const state = raw && typeof raw === 'object' ? raw : {};
   const version = Number(state.version || 1);

package/src/lib/uploader.js

@@ -78,7 +78,7 @@ async function readBatch(queuePath, startOffset, maxBuckets) {
     const model = normalizeModel(bucket?.model) || DEFAULT_MODEL;
     bucket.source = source;
     bucket.model = model;
-    bucketMap.set(bucketKey(source, hourStart), bucket);
+    bucketMap.set(bucketKey(source, model, hourStart), bucket);
     linesRead += 1;
     if (linesRead >= maxBuckets) break;
   }
@@ -97,8 +97,8 @@ async function safeFileSize(p) {
   }
 }
 
-function bucketKey(source, hourStart) {
-  return `${source}${BUCKET_SEPARATOR}${hourStart}`;
+function bucketKey(source, model, hourStart) {
+  return `${source}${BUCKET_SEPARATOR}${model}${BUCKET_SEPARATOR}${hourStart}`;
 }
 
 function normalizeSource(value) {