claude-usage-dashboard 1.5.0 → 1.5.2

package/server/pricing.js

@@ -1,52 +1,52 @@
-export const MODEL_PRICING = {
-  'claude-opus-4-6': {
-    input_price_per_mtok: 5,
-    output_price_per_mtok: 25,
-    cache_read_price_per_mtok: 0.50,
-    cache_creation_price_per_mtok: 6.25,
-  },
-  'claude-sonnet-4-6': {
-    input_price_per_mtok: 3,
-    output_price_per_mtok: 15,
-    cache_read_price_per_mtok: 0.30,
-    cache_creation_price_per_mtok: 3.75,
-  },
-  'claude-haiku-4-5': {
-    input_price_per_mtok: 1,
-    output_price_per_mtok: 5,
-    cache_read_price_per_mtok: 0.10,
-    cache_creation_price_per_mtok: 1.25,
-  },
-};
-
-export const PLAN_DEFAULTS = {
-  pro: 20,
-  max5x: 100,
-  max20x: 200,
-};
-
-export function getModelPricing(modelId) {
-  return MODEL_PRICING[modelId] || null;
-}
-
-/**
- * Calculate the API cost for a single usage record.
- * Returns 0 for unknown models.
- *
- * In Claude Code logs, input_tokens is the non-cached input.
- * cache_read_tokens and cache_creation_tokens are separate, additive fields.
- * cost = input * input_rate + cache_read * read_rate + cache_creation * write_rate + output * output_rate
- */
-export function calculateRecordCost(record) {
-  const pricing = MODEL_PRICING[record.model];
-  if (!pricing) return 0;
-
-  const M = 1_000_000;
-
-  return (
-    (record.input_tokens / M) * pricing.input_price_per_mtok +
-    (record.cache_read_tokens / M) * pricing.cache_read_price_per_mtok +
-    (record.cache_creation_tokens / M) * pricing.cache_creation_price_per_mtok +
-    (record.output_tokens / M) * pricing.output_price_per_mtok
-  );
-}
+export const MODEL_PRICING = {
+  'claude-opus-4-6': {
+    input_price_per_mtok: 5,
+    output_price_per_mtok: 25,
+    cache_read_price_per_mtok: 0.50,
+    cache_creation_price_per_mtok: 6.25,
+  },
+  'claude-sonnet-4-6': {
+    input_price_per_mtok: 3,
+    output_price_per_mtok: 15,
+    cache_read_price_per_mtok: 0.30,
+    cache_creation_price_per_mtok: 3.75,
+  },
+  'claude-haiku-4-5': {
+    input_price_per_mtok: 1,
+    output_price_per_mtok: 5,
+    cache_read_price_per_mtok: 0.10,
+    cache_creation_price_per_mtok: 1.25,
+  },
+};
+
+export const PLAN_DEFAULTS = {
+  pro: 20,
+  max5x: 100,
+  max20x: 200,
+};
+
+export function getModelPricing(modelId) {
+  return MODEL_PRICING[modelId] || null;
+}
+
+/**
+ * Calculate the API cost for a single usage record.
+ * Returns 0 for unknown models.
+ *
+ * In Claude Code logs, input_tokens is the non-cached input.
+ * cache_read_tokens and cache_creation_tokens are separate, additive fields.
+ * cost = input * input_rate + cache_read * read_rate + cache_creation * write_rate + output * output_rate
+ */
+export function calculateRecordCost(record) {
+  const pricing = MODEL_PRICING[record.model];
+  if (!pricing) return 0;
+
+  const M = 1_000_000;
+
+  return (
+    (record.input_tokens / M) * pricing.input_price_per_mtok +
+    (record.cache_read_tokens / M) * pricing.cache_read_price_per_mtok +
+    (record.cache_creation_tokens / M) * pricing.cache_creation_price_per_mtok +
+    (record.output_tokens / M) * pricing.output_price_per_mtok
+  );
+}

package/server/quota-cycles.js

@@ -1,274 +1,274 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { parseLogDirectory } from './parser.js';
-import { filterByDateRange } from './aggregator.js';
-import { calculateRecordCost } from './pricing.js';
-
-const MAX_HISTORY = 52;
-
-/**
- * Pure computation: given records (already filtered to a cycle) and quota data,
- * compute actual tokens/cost and project at 100% utilization.
- */
-export function computeCycleData(records, quotaData) {
-  const overallUtil = quotaData.seven_day?.utilization || 0;
-  const opusUtil = quotaData.seven_day_opus?.utilization || 0;
-  const sonnetUtil = quotaData.seven_day_sonnet?.utilization || 0;
-
-  // Per-type accumulators
-  let inTok = 0, outTok = 0, crTok = 0, cwTok = 0, totalCost = 0;
-  let opusIn = 0, opusOut = 0, opusCR = 0, opusCW = 0, opusCost = 0;
-  let sonIn = 0, sonOut = 0, sonCR = 0, sonCW = 0, sonnetCost = 0;
-
-  for (const r of records) {
-    const cost = calculateRecordCost(r);
-    inTok += r.input_tokens; outTok += r.output_tokens;
-    crTok += r.cache_read_tokens; cwTok += r.cache_creation_tokens;
-    totalCost += cost;
-
-    if (r.model?.includes('opus')) {
-      opusIn += r.input_tokens; opusOut += r.output_tokens;
-      opusCR += r.cache_read_tokens; opusCW += r.cache_creation_tokens;
-      opusCost += cost;
-    } else if (r.model?.includes('sonnet')) {
-      sonIn += r.input_tokens; sonOut += r.output_tokens;
-      sonCR += r.cache_read_tokens; sonCW += r.cache_creation_tokens;
-      sonnetCost += cost;
-    }
-  }
-
-  totalCost = Math.round(totalCost * 100) / 100;
-  opusCost = Math.round(opusCost * 100) / 100;
-  sonnetCost = Math.round(sonnetCost * 100) / 100;
-
-  function buildTokens(inp, out, cr, cw) {
-    return { input: inp, output: out, cacheRead: cr, cacheCreation: cw };
-  }
-
-  function project(actual, utilization) {
-    if (utilization <= 0) return null;
-    return Math.round(actual / (utilization / 100));
-  }
-
-  function projectCost(actual, utilization) {
-    if (utilization <= 0) return null;
-    return Math.round((actual / (utilization / 100)) * 100) / 100;
-  }
-
-  // actualTokens = total excluding cache reads (in + out + cw) — used for projections
-  const totalExclCR = inTok + outTok + cwTok;
-  const opusExclCR = opusIn + opusOut + opusCW;
-  const sonExclCR = sonIn + sonOut + sonCW;
-
-  return {
-    overall: {
-      utilization: overallUtil,
-      tokens: buildTokens(inTok, outTok, crTok, cwTok),
-      actualTokens: totalExclCR,
-      projectedTokensAt100: project(totalExclCR, overallUtil),
-      actualCost: totalCost,
-      projectedCostAt100: projectCost(totalCost, overallUtil),
-    },
-    models: {
-      opus: {
-        utilization: opusUtil,
-        tokens: buildTokens(opusIn, opusOut, opusCR, opusCW),
-        actualTokens: opusExclCR,
-        projectedTokensAt100: project(opusExclCR, opusUtil),
-        actualCost: opusCost,
-        projectedCostAt100: projectCost(opusCost, opusUtil),
-      },
-      sonnet: {
-        utilization: sonnetUtil,
-        tokens: buildTokens(sonIn, sonOut, sonCR, sonCW),
-        actualTokens: sonExclCR,
-        projectedTokensAt100: project(sonExclCR, sonnetUtil),
-        actualCost: sonnetCost,
-        projectedCostAt100: projectCost(sonnetCost, sonnetUtil),
-      },
-    },
-  };
-}
-
-/**
- * Update the quota cycle snapshot file for this machine.
- * Called after each successful quota API fetch.
- *
- * @param {object} quotaData - Quota API response (must have available === true)
- * @param {string} logBaseDir - This machine's log directory (~/.claude/projects/)
- * @param {string} machineName - Identifier for this machine
- * @param {string} [snapshotDir] - Directory for snapshot files (defaults to syncDir or ~/.claude/)
- * @param {string} [syncDir] - Shared sync directory; used as fallback when snapshotDir is not set
- */
-export function updateQuotaCycleSnapshot(quotaData, logBaseDir, machineName, snapshotDir, syncDir) {
-  if (!quotaData?.available || !quotaData.seven_day?.resets_at) return;
-
-  const dir = snapshotDir || syncDir || path.join(os.homedir(), '.claude');
-  const filePath = path.join(dir, `quota-cycles-${machineName}.json`);
-
-  // Normalize resets_at to second precision — the API returns varying microseconds
-  // on each call (e.g. .905316 vs .581788) which would cause false cycle switches
-  const rawResetsAt = new Date(quotaData.seven_day.resets_at);
-  rawResetsAt.setMilliseconds(0);
-  const resetsAt = rawResetsAt.toISOString();
-  const start = new Date(rawResetsAt.getTime() - 7 * 24 * 60 * 60 * 1000).toISOString();
-
-  let snapshot;
-  try {
-    snapshot = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-  } catch {
-    snapshot = { schemaVersion: 1, machineName, currentCycle: null, history: [] };
-  }
-
-  // Compare normalized timestamps to detect actual cycle boundary changes
-  const storedResetNorm = snapshot.currentCycle
-    ? new Date(snapshot.currentCycle.resets_at).setMilliseconds(0)
-    : null;
-  if (snapshot.currentCycle && storedResetNorm !== rawResetsAt.getTime()) {
-    snapshot.history.unshift(snapshot.currentCycle);
-    if (snapshot.history.length > MAX_HISTORY) {
-      snapshot.history = snapshot.history.slice(0, MAX_HISTORY);
-    }
-    snapshot.currentCycle = null;
-  }
-
-  const allRecords = parseLogDirectory(logBaseDir);
-  const cycleRecords = filterByDateRange(allRecords, start, resetsAt);
-  const cycleData = computeCycleData(cycleRecords, quotaData);
-
-  snapshot.currentCycle = {
-    resets_at: resetsAt,
-    start,
-    lastUpdated: new Date().toISOString(),
-    ...cycleData,
-  };
-
-  fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
-}
-
-/**
- * Load and merge quota cycle data from all machines.
- *
- * @param {string} machineName - This machine's name
- * @param {string|null} syncDir - Shared sync directory (null if single-machine)
- * @param {string} [snapshotDir] - Directory for snapshot files (defaults to ~/.claude/)
- * @returns {{ currentCycle: object|null, history: object[], machines: string[] }}
- */
-export function loadQuotaCycles(machineName, syncDir, snapshotDir) {
-  const dir = snapshotDir || syncDir || path.join(os.homedir(), '.claude');
-  const empty = { currentCycle: null, history: [], machines: [] };
-
-  let files;
-  try {
-    files = fs.readdirSync(dir).filter(f => f.startsWith('quota-cycles-') && f.endsWith('.json'));
-  } catch {
-    return empty;
-  }
-
-  if (files.length === 0) return empty;
-
-  const snapshots = [];
-  for (const file of files) {
-    try {
-      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf-8'));
-      if (data.schemaVersion === 1) snapshots.push(data);
-    } catch { /* skip corrupt files */ }
-  }
-
-  if (snapshots.length === 0) return empty;
-
-  const machines = snapshots.map(s => s.machineName);
-
-  if (snapshots.length === 1) {
-    const s = snapshots[0];
-    return { currentCycle: s.currentCycle, history: s.history, machines };
-  }
-
-  return {
-    currentCycle: mergeCycles(snapshots.map(s => s.currentCycle).filter(Boolean)),
-    history: mergeHistories(snapshots.map(s => s.history)),
-    machines,
-  };
-}
-
-function mergeCycles(cycles) {
-  if (cycles.length === 0) return null;
-  if (cycles.length === 1) return cycles[0];
-
-  const byReset = new Map();
-  for (const c of cycles) {
-    const key = c.resets_at;
-    if (!byReset.has(key)) byReset.set(key, []);
-    byReset.get(key).push(c);
-  }
-
-  let bestKey = null, bestCount = 0;
-  for (const [key, arr] of byReset) {
-    if (arr.length > bestCount || (arr.length === bestCount && key > bestKey)) { bestKey = key; bestCount = arr.length; }
-  }
-
-  const sameCycle = byReset.get(bestKey);
-  return mergeSamePeriodCycles(sameCycle);
-}
-
-function mergeSamePeriodCycles(cycles) {
-  const mostRecent = cycles.reduce((a, b) =>
-    new Date(a.lastUpdated) > new Date(b.lastUpdated) ? a : b
-  );
-
-  return {
-    resets_at: mostRecent.resets_at,
-    start: mostRecent.start,
-    lastUpdated: mostRecent.lastUpdated,
-    overall: mergeMetrics(cycles.map(c => c.overall), mostRecent.overall.utilization),
-    models: {
-      opus: mergeMetrics(cycles.map(c => c.models.opus), mostRecent.models?.opus?.utilization || 0),
-      sonnet: mergeMetrics(cycles.map(c => c.models.sonnet), mostRecent.models?.sonnet?.utilization || 0),
-    },
-  };
-}
-
-function mergeMetrics(metricsArray, utilization) {
-  const totalTokens = metricsArray.reduce((sum, m) => sum + (m?.actualTokens || 0), 0);
-  const totalCost = Math.round(metricsArray.reduce((sum, m) => sum + (m?.actualCost || 0), 0) * 100) / 100;
-
-  // Merge per-type token breakdown
-  const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
-  for (const m of metricsArray) {
-    if (m?.tokens) {
-      tokens.input += m.tokens.input || 0;
-      tokens.output += m.tokens.output || 0;
-      tokens.cacheRead += m.tokens.cacheRead || 0;
-      tokens.cacheCreation += m.tokens.cacheCreation || 0;
-    }
-  }
-
-  return {
-    utilization,
-    tokens,
-    actualTokens: totalTokens,
-    projectedTokensAt100: utilization > 0 ? Math.round(totalTokens / (utilization / 100)) : null,
-    actualCost: totalCost,
-    projectedCostAt100: utilization > 0 ? Math.round((totalCost / (utilization / 100)) * 100) / 100 : null,
-  };
-}
-
-function mergeHistories(historyArrays) {
-  const byReset = new Map();
-  for (const history of historyArrays) {
-    for (const entry of history) {
-      const key = entry.resets_at;
-      if (!byReset.has(key)) byReset.set(key, []);
-      byReset.get(key).push(entry);
-    }
-  }
-
-  const merged = [];
-  for (const [, entries] of byReset) {
-    merged.push(mergeSamePeriodCycles(entries));
-  }
-
-  merged.sort((a, b) => new Date(b.resets_at) - new Date(a.resets_at));
-  return merged.slice(0, MAX_HISTORY);
-}
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { parseLogDirectory } from './parser.js';
+import { filterByDateRange } from './aggregator.js';
+import { calculateRecordCost } from './pricing.js';
+
+const MAX_HISTORY = 52;
+
+/**
+ * Pure computation: given records (already filtered to a cycle) and quota data,
+ * compute actual tokens/cost and project at 100% utilization.
+ */
+export function computeCycleData(records, quotaData) {
+  const overallUtil = quotaData.seven_day?.utilization || 0;
+  const opusUtil = quotaData.seven_day_opus?.utilization || 0;
+  const sonnetUtil = quotaData.seven_day_sonnet?.utilization || 0;
+
+  // Per-type accumulators
+  let inTok = 0, outTok = 0, crTok = 0, cwTok = 0, totalCost = 0;
+  let opusIn = 0, opusOut = 0, opusCR = 0, opusCW = 0, opusCost = 0;
+  let sonIn = 0, sonOut = 0, sonCR = 0, sonCW = 0, sonnetCost = 0;
+
+  for (const r of records) {
+    const cost = calculateRecordCost(r);
+    inTok += r.input_tokens; outTok += r.output_tokens;
+    crTok += r.cache_read_tokens; cwTok += r.cache_creation_tokens;
+    totalCost += cost;
+
+    if (r.model?.includes('opus')) {
+      opusIn += r.input_tokens; opusOut += r.output_tokens;
+      opusCR += r.cache_read_tokens; opusCW += r.cache_creation_tokens;
+      opusCost += cost;
+    } else if (r.model?.includes('sonnet')) {
+      sonIn += r.input_tokens; sonOut += r.output_tokens;
+      sonCR += r.cache_read_tokens; sonCW += r.cache_creation_tokens;
+      sonnetCost += cost;
+    }
+  }
+
+  totalCost = Math.round(totalCost * 100) / 100;
+  opusCost = Math.round(opusCost * 100) / 100;
+  sonnetCost = Math.round(sonnetCost * 100) / 100;
+
+  function buildTokens(inp, out, cr, cw) {
+    return { input: inp, output: out, cacheRead: cr, cacheCreation: cw };
+  }
+
+  function project(actual, utilization) {
+    if (utilization <= 0) return null;
+    return Math.round(actual / (utilization / 100));
+  }
+
+  function projectCost(actual, utilization) {
+    if (utilization <= 0) return null;
+    return Math.round((actual / (utilization / 100)) * 100) / 100;
+  }
+
+  // actualTokens = total excluding cache reads (in + out + cw) — used for projections
+  const totalExclCR = inTok + outTok + cwTok;
+  const opusExclCR = opusIn + opusOut + opusCW;
+  const sonExclCR = sonIn + sonOut + sonCW;
+
+  return {
+    overall: {
+      utilization: overallUtil,
+      tokens: buildTokens(inTok, outTok, crTok, cwTok),
+      actualTokens: totalExclCR,
+      projectedTokensAt100: project(totalExclCR, overallUtil),
+      actualCost: totalCost,
+      projectedCostAt100: projectCost(totalCost, overallUtil),
+    },
+    models: {
+      opus: {
+        utilization: opusUtil,
+        tokens: buildTokens(opusIn, opusOut, opusCR, opusCW),
+        actualTokens: opusExclCR,
+        projectedTokensAt100: project(opusExclCR, opusUtil),
+        actualCost: opusCost,
+        projectedCostAt100: projectCost(opusCost, opusUtil),
+      },
+      sonnet: {
+        utilization: sonnetUtil,
+        tokens: buildTokens(sonIn, sonOut, sonCR, sonCW),
+        actualTokens: sonExclCR,
+        projectedTokensAt100: project(sonExclCR, sonnetUtil),
+        actualCost: sonnetCost,
+        projectedCostAt100: projectCost(sonnetCost, sonnetUtil),
+      },
+    },
+  };
+}
+
+/**
+ * Update the quota cycle snapshot file for this machine.
+ * Called after each successful quota API fetch.
+ *
+ * @param {object} quotaData - Quota API response (must have available === true)
+ * @param {string} logBaseDir - This machine's log directory (~/.claude/projects/)
+ * @param {string} machineName - Identifier for this machine
+ * @param {string} [snapshotDir] - Directory for snapshot files (defaults to syncDir or ~/.claude/)
+ * @param {string} [syncDir] - Shared sync directory; used as fallback when snapshotDir is not set
+ */
+export function updateQuotaCycleSnapshot(quotaData, logBaseDir, machineName, snapshotDir, syncDir) {
+  if (!quotaData?.available || !quotaData.seven_day?.resets_at) return;
+
+  const dir = snapshotDir || syncDir || path.join(os.homedir(), '.claude');
+  const filePath = path.join(dir, `quota-cycles-${machineName}.json`);
+
+  // Normalize resets_at to second precision — the API returns varying microseconds
+  // on each call (e.g. .905316 vs .581788) which would cause false cycle switches
+  const rawResetsAt = new Date(quotaData.seven_day.resets_at);
+  rawResetsAt.setMilliseconds(0);
+  const resetsAt = rawResetsAt.toISOString();
+  const start = new Date(rawResetsAt.getTime() - 7 * 24 * 60 * 60 * 1000).toISOString();
+
+  let snapshot;
+  try {
+    snapshot = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    snapshot = { schemaVersion: 1, machineName, currentCycle: null, history: [] };
+  }
+
+  // Compare normalized timestamps to detect actual cycle boundary changes
+  const storedResetNorm = snapshot.currentCycle
+    ? new Date(snapshot.currentCycle.resets_at).setMilliseconds(0)
+    : null;
+  if (snapshot.currentCycle && storedResetNorm !== rawResetsAt.getTime()) {
+    snapshot.history.unshift(snapshot.currentCycle);
+    if (snapshot.history.length > MAX_HISTORY) {
+      snapshot.history = snapshot.history.slice(0, MAX_HISTORY);
+    }
+    snapshot.currentCycle = null;
+  }
+
+  const allRecords = parseLogDirectory(logBaseDir);
+  const cycleRecords = filterByDateRange(allRecords, start, resetsAt);
+  const cycleData = computeCycleData(cycleRecords, quotaData);
+
+  snapshot.currentCycle = {
+    resets_at: resetsAt,
+    start,
+    lastUpdated: new Date().toISOString(),
+    ...cycleData,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
+}
+
+/**
+ * Load and merge quota cycle data from all machines.
+ *
+ * @param {string} machineName - This machine's name
+ * @param {string|null} syncDir - Shared sync directory (null if single-machine)
+ * @param {string} [snapshotDir] - Directory for snapshot files (defaults to ~/.claude/)
+ * @returns {{ currentCycle: object|null, history: object[], machines: string[] }}
+ */
+export function loadQuotaCycles(machineName, syncDir, snapshotDir) {
+  const dir = snapshotDir || syncDir || path.join(os.homedir(), '.claude');
+  const empty = { currentCycle: null, history: [], machines: [] };
+
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter(f => f.startsWith('quota-cycles-') && f.endsWith('.json'));
+  } catch {
+    return empty;
+  }
+
+  if (files.length === 0) return empty;
+
+  const snapshots = [];
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf-8'));
+      if (data.schemaVersion === 1) snapshots.push(data);
+    } catch { /* skip corrupt files */ }
+  }
+
+  if (snapshots.length === 0) return empty;
+
+  const machines = snapshots.map(s => s.machineName);
+
+  if (snapshots.length === 1) {
+    const s = snapshots[0];
+    return { currentCycle: s.currentCycle, history: s.history, machines };
+  }
+
+  return {
+    currentCycle: mergeCycles(snapshots.map(s => s.currentCycle).filter(Boolean)),
+    history: mergeHistories(snapshots.map(s => s.history)),
+    machines,
+  };
+}
+
+function mergeCycles(cycles) {
+  if (cycles.length === 0) return null;
+  if (cycles.length === 1) return cycles[0];
+
+  const byReset = new Map();
+  for (const c of cycles) {
+    const key = c.resets_at;
+    if (!byReset.has(key)) byReset.set(key, []);
+    byReset.get(key).push(c);
+  }
+
+  let bestKey = null, bestCount = 0;
+  for (const [key, arr] of byReset) {
+    if (arr.length > bestCount || (arr.length === bestCount && key > bestKey)) { bestKey = key; bestCount = arr.length; }
+  }
+
+  const sameCycle = byReset.get(bestKey);
+  return mergeSamePeriodCycles(sameCycle);
+}
+
+function mergeSamePeriodCycles(cycles) {
+  const mostRecent = cycles.reduce((a, b) =>
+    new Date(a.lastUpdated) > new Date(b.lastUpdated) ? a : b
+  );
+
+  return {
+    resets_at: mostRecent.resets_at,
+    start: mostRecent.start,
+    lastUpdated: mostRecent.lastUpdated,
+    overall: mergeMetrics(cycles.map(c => c.overall), mostRecent.overall.utilization),
+    models: {
+      opus: mergeMetrics(cycles.map(c => c.models.opus), mostRecent.models?.opus?.utilization || 0),
+      sonnet: mergeMetrics(cycles.map(c => c.models.sonnet), mostRecent.models?.sonnet?.utilization || 0),
+    },
+  };
+}
+
+function mergeMetrics(metricsArray, utilization) {
+  const totalTokens = metricsArray.reduce((sum, m) => sum + (m?.actualTokens || 0), 0);
+  const totalCost = Math.round(metricsArray.reduce((sum, m) => sum + (m?.actualCost || 0), 0) * 100) / 100;
+
+  // Merge per-type token breakdown
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+  for (const m of metricsArray) {
+    if (m?.tokens) {
+      tokens.input += m.tokens.input || 0;
+      tokens.output += m.tokens.output || 0;
+      tokens.cacheRead += m.tokens.cacheRead || 0;
+      tokens.cacheCreation += m.tokens.cacheCreation || 0;
+    }
+  }
+
+  return {
+    utilization,
+    tokens,
+    actualTokens: totalTokens,
+    projectedTokensAt100: utilization > 0 ? Math.round(totalTokens / (utilization / 100)) : null,
+    actualCost: totalCost,
+    projectedCostAt100: utilization > 0 ? Math.round((totalCost / (utilization / 100)) * 100) / 100 : null,
+  };
+}
+
+function mergeHistories(historyArrays) {
+  const byReset = new Map();
+  for (const history of historyArrays) {
+    for (const entry of history) {
+      const key = entry.resets_at;
+      if (!byReset.has(key)) byReset.set(key, []);
+      byReset.get(key).push(entry);
+    }
+  }
+
+  const merged = [];
+  for (const [, entries] of byReset) {
+    merged.push(mergeSamePeriodCycles(entries));
+  }
+
+  merged.sort((a, b) => new Date(b.resets_at) - new Date(a.resets_at));
+  return merged.slice(0, MAX_HISTORY);
+}