llm-usage-metrics 0.3.5 → 0.3.6

package/README.md

@@ -63,6 +63,8 @@ llm-usage daily
 
 OpenCode source support requires Node.js 24+ runtime with built-in `node:sqlite`.
 
+For `droid`, `Input`, `Output`, `Reasoning`, `Cache Read`, and `Cache Write` come directly from session files, and `totalTokens` is billable raw tokens (`Input + Output + Cache Read + Cache Write`, excluding `Reasoning`). Factory dashboard totals may differ because Factory applies standard-token normalization/multipliers.
+
 ## 🎯 Usage
 
 ### Basic Reports
@@ -256,6 +258,8 @@ pnpm run perf:production-benchmark -- \
 | `LLM_USAGE_PARSE_MAX_PARALLEL`   | Max parallel file parses (`1-64`) |
 | `LLM_USAGE_PARSE_CACHE_ENABLED`  | Enable parse cache (`1/0`)        |
 
+Parse cache is source-sharded on disk (`parse-file-cache.<source>.json`) so source-scoped runs avoid loading unrelated cache blobs.
+
 See full environment variable reference in the [documentation](https://ayagmar.github.io/llm-usage-metrics/configuration/).
 
 ### Update Checks

package/dist/index.js

@@ -1217,7 +1217,6 @@ var DroidSourceAdapter = class {
       toNumberLike(tokenUsage.cacheCreationTokens)
     );
     const billableTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
-    const totalTokens = billableTokens + reasoningTokens;
     if (billableTokens === 0) {
       skippedRows++;
       incrementSkippedReason(skippedRowReasons, "no_token_usage");
@@ -1225,6 +1224,7 @@ var DroidSourceAdapter = class {
     }
     const provider = asTrimmedText(settings.providerLock);
     const model = asTrimmedText(settings.model);
+    const totalTokens = billableTokens;
     const primaryTimestamp = normalizeTimestampCandidate(settings.providerLockTimestamp);
     const hasValidPrimaryTimestamp = Boolean(primaryTimestamp);
     const jsonlPath = getSiblingJsonlPath(filePath);
@@ -1243,7 +1243,9 @@ var DroidSourceAdapter = class {
         }
         if (!hasValidPrimaryTimestamp && isMessageRecord(line)) {
           fallbackMessageTimestamp = normalizeTimestampCandidate(line.timestamp);
-          break;
+          if (fallbackMessageTimestamp) {
+            break;
+          }
         }
       }
     } catch {
@@ -3508,7 +3510,7 @@ function selectAdaptersForParsing(adapters, sourceFilter) {
 }
 
 // src/cli/build-usage-data-parsing.ts
-import { stat as stat3 } from "fs/promises";
+import { stat as stat4 } from "fs/promises";
 
 // src/cli/normalize-skipped-row-reasons.ts
 function toPositiveInteger(value) {
@@ -3536,7 +3538,7 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/cli/parse-file-cache.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path11 from "path";
 var PARSE_FILE_CACHE_VERSION = 2;
 var CACHE_KEY_SEPARATOR = "\0";
@@ -3627,7 +3629,7 @@ function cloneUsageEvents(events) {
   return events.map((event) => cloneUsageEvent(event));
 }
 function cloneSkippedRowReasons(skippedRowReasons) {
-  return (skippedRowReasons ?? []).map((stat4) => ({ reason: stat4.reason, count: stat4.count }));
+  return (skippedRowReasons ?? []).map((stat5) => ({ reason: stat5.reason, count: stat5.count }));
 }
 function normalizeCachedEvents(value) {
   if (!Array.isArray(value)) {
@@ -3678,6 +3680,21 @@ function normalizeCacheEntry(value) {
 function getDefaultParseFileCachePath() {
   return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
+function normalizeCacheShardSource(source) {
+  const normalizedSource = normalizeCacheSource(source);
+  if (!normalizedSource) {
+    return "unknown";
+  }
+  return normalizedSource.replace(/[^a-z0-9._-]/gu, "_");
+}
+function getSourceShardedParseFileCachePath(cacheFilePath, source) {
+  const parsedPath = path11.parse(cacheFilePath);
+  const sourceShard = normalizeCacheShardSource(source);
+  if (parsedPath.ext.length > 0) {
+    return path11.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
+  }
+  return path11.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
+}
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
     this.cacheFilePath = cacheFilePath;
@@ -3763,8 +3780,15 @@ var ParseFileCache = class _ParseFileCache {
       payloadText = bestPayloadText;
     }
     await mkdir2(path11.dirname(this.cacheFilePath), { recursive: true });
-    await writeFile2(this.cacheFilePath, payloadText, "utf8");
-    this.dirty = false;
+    const temporaryPath = `${this.cacheFilePath}.${process.pid}.${this.now()}.tmp`;
+    try {
+      await writeFile2(temporaryPath, payloadText, "utf8");
+      await rename(temporaryPath, this.cacheFilePath);
+      this.dirty = false;
+    } catch (error) {
+      await rm(temporaryPath, { force: true }).catch(() => void 0);
+      throw error;
+    }
   }
   toPayload(entries) {
     return {
@@ -3783,6 +3807,17 @@ var ParseFileCache = class _ParseFileCache {
     };
   }
   async loadFromDisk() {
+    let cacheFileSizeBytes;
+    try {
+      const cacheStat = await stat3(this.cacheFilePath);
+      cacheFileSizeBytes = cacheStat.size;
+    } catch {
+      return;
+    }
+    if (cacheFileSizeBytes > this.limits.maxBytes) {
+      this.dirty = true;
+      return;
+    }
     let content;
     try {
       content = await readFile4(this.cacheFilePath, "utf8");
@@ -3808,6 +3843,7 @@ var ParseFileCache = class _ParseFileCache {
     }
     if (Buffer.byteLength(content, "utf8") > this.limits.maxBytes) {
       this.dirty = true;
+      return;
     }
     const entries = Array.isArray(payloadRecord.entries) ? payloadRecord.entries : [];
     for (const rawEntry of entries) {
@@ -3867,7 +3903,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, parseFileCach
       let parseFileDiagnostics;
       if (parseFileCache) {
         try {
-          const fileStat = await stat3(filePath);
+          const fileStat = await stat4(filePath);
           fileFingerprint = {
             size: fileStat.size,
             mtimeMs: fileStat.mtimeMs
@@ -3908,25 +3944,44 @@ function getErrorReason(error) {
   return String(error);
 }
 async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, options = {}) {
-  const parseCache = options.parseCache?.enabled ? await ParseFileCache.load({
-    cacheFilePath: options.parseCacheFilePath,
-    limits: {
+  const parseCacheBySource = /* @__PURE__ */ new Map();
+  if (options.parseCache?.enabled) {
+    const parseCacheLimits = {
       ttlMs: options.parseCache.ttlMs,
       maxEntries: options.parseCache.maxEntries,
       maxBytes: options.parseCache.maxBytes
-    },
-    now: options.now
-  }) : void 0;
+    };
+    const cacheFilePath = options.parseCacheFilePath ?? getDefaultParseFileCachePath();
+    await Promise.all(
+      adaptersToParse.map(async (adapter) => {
+        const sourceId = adapter.id.toLowerCase();
+        if (parseCacheBySource.has(sourceId)) {
+          return;
+        }
+        parseCacheBySource.set(
+          sourceId,
+          await ParseFileCache.load({
+            cacheFilePath: getSourceShardedParseFileCachePath(cacheFilePath, sourceId),
+            limits: parseCacheLimits,
+            now: options.now
+          })
+        );
+      })
+    );
+  }
   const parseResults = await Promise.allSettled(
     adaptersToParse.map(
-      (adapter) => parseAdapterEvents(adapter, maxParallelFileParsing, parseCache)
+      (adapter) => parseAdapterEvents(
+        adapter,
+        maxParallelFileParsing,
+        parseCacheBySource.get(adapter.id.toLowerCase())
+      )
     )
   );
-  if (parseCache) {
-    try {
-      await parseCache.persist();
-    } catch {
-    }
+  if (parseCacheBySource.size > 0) {
+    await Promise.allSettled(
+      [...parseCacheBySource.values()].map(async (parseCache) => parseCache.persist())
+    );
   }
   const sourceFailures = [];
   const successfulParseResults = [];
@@ -4200,7 +4255,7 @@ function normalizeModelPricing(rawModelPricing) {
     return void 0;
   }
   const cacheReadPerToken = toNonNegativeNumber3(rawModelPricing.cache_read_input_token_cost) ?? toNonNegativeNumber3(rawModelPricing.cache_read_input_token_cost_priority);
-  const cacheWritePerToken = toNonNegativeNumber3(rawModelPricing.cache_creation_input_token_cost);
+  const cacheWritePerToken = toNonNegativeNumber3(rawModelPricing.cache_creation_input_token_cost) ?? toNonNegativeNumber3(rawModelPricing.cache_creation_input_token_cost_priority);
   const reasoningPerToken = toNonNegativeNumber3(rawModelPricing.output_cost_per_reasoning_token);
   const modelPricing = {
     inputPer1MUsd: inputPerToken * ONE_MILLION2,
@@ -5786,6 +5841,8 @@ function renderTerminalTable(rows, options = {}) {
 }
 
 // src/render/render-efficiency-report.ts
+var periodColumnIndex = 0;
+var minimumEfficiencyColumnWidth = 1;
 function getReportTitle(granularity) {
   switch (granularity) {
     case "daily":
@@ -5830,22 +5887,114 @@ function toTableSortRow(row) {
     costIncomplete: row.costIncomplete
   };
 }
+function measureRenderedTableWidth(columnWidths) {
+  if (columnWidths.length === 0) {
+    return 0;
+  }
+  return columnWidths.reduce((sum, width) => sum + width, 0) + columnWidths.length * 3 + 1;
+}
+function computeColumnWidths2(headerCells, bodyRows) {
+  const columnCount = Math.max(
+    headerCells.length,
+    ...bodyRows.map((row) => row.length),
+    efficiencyTableHeaders.length
+  );
+  const widths = Array.from({ length: columnCount }, () => 0);
+  const measureRow = (row) => {
+    for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+      for (const line of splitCellLines(row[columnIndex] ?? "")) {
+        widths[columnIndex] = Math.max(widths[columnIndex], visibleWidth(line));
+      }
+    }
+  };
+  measureRow(headerCells);
+  for (const row of bodyRows) {
+    measureRow(row);
+  }
+  return widths;
+}
+function resolveWrappedCells(headerCells, bodyRows, widths) {
+  let wrappedHeaderCells = [...headerCells];
+  let wrappedBodyRows = bodyRows.map((row) => [...row]);
+  for (let columnIndex = 0; columnIndex < widths.length; columnIndex += 1) {
+    const columnWidth = widths[columnIndex] ?? 0;
+    if (columnWidth <= 0) {
+      continue;
+    }
+    wrappedHeaderCells = wrapTableColumn([wrappedHeaderCells], {
+      columnIndex,
+      width: columnWidth
+    })[0] ?? [];
+    wrappedBodyRows = wrapTableColumn(wrappedBodyRows, {
+      columnIndex,
+      width: columnWidth
+    });
+  }
+  return {
+    wrappedHeaderCells,
+    wrappedBodyRows
+  };
+}
+function fitTableCellsToTerminal(headerCells, bodyRows) {
+  const naturalWidths = computeColumnWidths2(headerCells, bodyRows);
+  const terminalWidth = resolveTtyColumns(process.stdout);
+  if (terminalWidth === void 0 || measureRenderedTableWidth(naturalWidths) <= terminalWidth) {
+    return {
+      headerCells: [...headerCells],
+      bodyRows: bodyRows.map((row) => [...row]),
+      widths: naturalWidths
+    };
+  }
+  const constrainedWidths = [...naturalWidths];
+  let renderedTableWidth = measureRenderedTableWidth(constrainedWidths);
+  while (renderedTableWidth > terminalWidth && constrainedWidths.some((width) => width > minimumEfficiencyColumnWidth)) {
+    let widestIndex = -1;
+    let widestWidth = -1;
+    for (let columnIndex = 0; columnIndex < constrainedWidths.length; columnIndex += 1) {
+      const columnWidth = constrainedWidths[columnIndex];
+      if (columnWidth <= minimumEfficiencyColumnWidth || columnWidth <= widestWidth) {
+        continue;
+      }
+      widestIndex = columnIndex;
+      widestWidth = columnWidth;
+    }
+    if (widestIndex === -1) {
+      break;
+    }
+    const overflowColumns = renderedTableWidth - terminalWidth;
+    const maxReducibleWidth = widestWidth - minimumEfficiencyColumnWidth;
+    const reduction = Math.min(overflowColumns, maxReducibleWidth);
+    if (reduction <= 0) {
+      break;
+    }
+    constrainedWidths[widestIndex] -= reduction;
+    renderedTableWidth -= reduction;
+  }
+  const { wrappedHeaderCells, wrappedBodyRows } = resolveWrappedCells(
+    headerCells,
+    bodyRows,
+    constrainedWidths
+  );
+  return {
+    headerCells: wrappedHeaderCells,
+    bodyRows: wrappedBodyRows,
+    widths: constrainedWidths
+  };
+}
 function renderTerminalEfficiencyTable(rows) {
+  const headerCells = Array.from(efficiencyTableHeaders);
   const bodyRows = toEfficiencyTableCells(rows);
   const tableSortRows = rows.map((row) => toTableSortRow(row));
-  const periodColumnWidth = Math.max(
-    efficiencyTableHeaders[0].length,
-    ...rows.map((row) => row.periodKey.length)
-  );
+  const fittedCells = fitTableCellsToTerminal(headerCells, bodyRows);
   return renderUnicodeTable({
-    headerCells: efficiencyTableHeaders,
-    bodyRows,
-    measureHeaderCells: efficiencyTableHeaders,
-    measureBodyRows: bodyRows,
+    headerCells: fittedCells.headerCells,
+    bodyRows: fittedCells.bodyRows,
+    measureHeaderCells: fittedCells.headerCells,
+    measureBodyRows: fittedCells.bodyRows,
     usageRows: tableSortRows,
     tableLayout: "compact",
-    modelsColumnIndex: 0,
-    modelsColumnWidth: periodColumnWidth
+    modelsColumnIndex: periodColumnIndex,
+    modelsColumnWidth: fittedCells.widths[periodColumnIndex] ?? efficiencyTableHeaders[periodColumnIndex].length
   });
 }
 function toMarkdownSafeCell(value) {