llm-usage-metrics 0.3.4 → 0.3.6

package/dist/index.js

@@ -1094,11 +1094,199 @@ var CodexSourceAdapter = class {
   }
 };
 
-// src/sources/gemini/gemini-source-adapter.ts
+// src/sources/droid/droid-source-adapter.ts
 import { readFile as readFile2 } from "fs/promises";
 import os3 from "os";
 import path5 from "path";
-var defaultGeminiDir = path5.join(os3.homedir(), ".gemini");
+
+// src/sources/parse-diagnostics.ts
+function incrementSkippedReason(reasons, reason) {
+  const current = reasons.get(reason) ?? 0;
+  reasons.set(reason, current + 1);
+}
+function toSkippedRowReasonStats(reasons) {
+  return [...reasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason));
+}
+function toParseDiagnostics(events, skippedRows, skippedRowReasons) {
+  return {
+    events,
+    skippedRows,
+    skippedRowReasons: toSkippedRowReasonStats(skippedRowReasons)
+  };
+}
+
+// src/sources/droid/droid-source-adapter.ts
+var defaultSessionsDir2 = path5.join(os3.homedir(), ".factory", "sessions");
+var DROID_SESSION_START_LINE_PATTERN = /"type"\s*:\s*"session_start"/u;
+var DROID_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
+function shouldParseDroidJsonlLine(lineText) {
+  return DROID_SESSION_START_LINE_PATTERN.test(lineText) || DROID_MESSAGE_LINE_PATTERN.test(lineText);
+}
+var UNIX_SECONDS_ABS_CUTOFF = 1e10;
+function normalizeTimestampCandidate(candidate) {
+  let date;
+  if (typeof candidate === "number" && Number.isFinite(candidate)) {
+    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF ? candidate * 1e3 : candidate;
+    date = new Date(timestampMs);
+  } else {
+    const normalizedText = asTrimmedText(candidate);
+    if (!normalizedText) {
+      return void 0;
+    }
+    date = new Date(normalizedText);
+  }
+  if (Number.isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date.toISOString();
+}
+function getSettingsSessionId(filePath) {
+  return path5.basename(filePath, ".settings.json");
+}
+function getSiblingJsonlPath(settingsPath) {
+  return path5.join(path5.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
+}
+function isSessionStartRecord(line) {
+  return asTrimmedText(line.type) === "session_start";
+}
+function isMessageRecord(line) {
+  return asTrimmedText(line.type) === "message";
+}
+function resolveRepoRootFromSessionStart(line) {
+  const payload = asRecord(line.session_start);
+  return asTrimmedText(payload?.cwd);
+}
+var DroidSourceAdapter = class {
+  id = "droid";
+  sessionsDir;
+  requireSessionsDir;
+  constructor(options = {}) {
+    this.sessionsDir = options.sessionsDir ?? defaultSessionsDir2;
+    this.requireSessionsDir = options.requireSessionsDir ?? false;
+  }
+  getNormalizedSessionsDir() {
+    if (isBlankText(this.sessionsDir)) {
+      throw new Error("Droid sessions directory must be a non-empty path");
+    }
+    return this.sessionsDir.trim();
+  }
+  async discoverFiles() {
+    const normalizedDir = this.getNormalizedSessionsDir();
+    if (this.requireSessionsDir && !await pathReadable(normalizedDir)) {
+      throw new Error(`Droid sessions directory is missing or unreadable: ${normalizedDir}`);
+    }
+    if (this.requireSessionsDir && !await pathIsDirectory(normalizedDir)) {
+      throw new Error(`Droid sessions directory is not a directory: ${normalizedDir}`);
+    }
+    return discoverFiles(normalizedDir, { extension: ".settings.json" });
+  }
+  async parseFile(filePath) {
+    const { events } = await this.parseFileWithDiagnostics(filePath);
+    return events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const events = [];
+    let skippedRows = 0;
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    let settingsJson;
+    try {
+      const content = await readFile2(filePath, "utf8");
+      settingsJson = JSON.parse(content);
+    } catch {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "json_parse_error");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const settings = asRecord(settingsJson);
+    if (!settings) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_settings_data");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const tokenUsage = asRecord(settings.tokenUsage);
+    if (!tokenUsage) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "no_token_usage");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const inputTokens = normalizeNonNegativeInteger(toNumberLike(tokenUsage.inputTokens));
+    const outputTokens = normalizeNonNegativeInteger(toNumberLike(tokenUsage.outputTokens));
+    const reasoningTokens = normalizeNonNegativeInteger(toNumberLike(tokenUsage.thinkingTokens));
+    const cacheReadTokens = normalizeNonNegativeInteger(toNumberLike(tokenUsage.cacheReadTokens));
+    const cacheWriteTokens = normalizeNonNegativeInteger(
+      toNumberLike(tokenUsage.cacheCreationTokens)
+    );
+    const billableTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+    if (billableTokens === 0) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "no_token_usage");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    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);
+    let repoRoot;
+    let fallbackMessageTimestamp;
+    try {
+      for await (const line of readJsonlObjects(jsonlPath, {
+        shouldParseLine: shouldParseDroidJsonlLine
+      })) {
+        if (!repoRoot && isSessionStartRecord(line)) {
+          repoRoot = resolveRepoRootFromSessionStart(line) ?? repoRoot;
+          if (hasValidPrimaryTimestamp) {
+            break;
+          }
+          continue;
+        }
+        if (!hasValidPrimaryTimestamp && isMessageRecord(line)) {
+          fallbackMessageTimestamp = normalizeTimestampCandidate(line.timestamp);
+          if (fallbackMessageTimestamp) {
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    const timestamp = primaryTimestamp ?? fallbackMessageTimestamp;
+    if (!timestamp) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    try {
+      events.push(
+        createUsageEvent({
+          source: this.id,
+          sessionId: getSettingsSessionId(filePath),
+          timestamp,
+          repoRoot,
+          provider,
+          model,
+          inputTokens,
+          outputTokens,
+          reasoningTokens,
+          cacheReadTokens,
+          cacheWriteTokens,
+          totalTokens,
+          costMode: "estimated"
+        })
+      );
+    } catch {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/gemini/gemini-source-adapter.ts
+import { readFile as readFile3 } from "fs/promises";
+import os4 from "os";
+import path6 from "path";
+var defaultGeminiDir = path6.join(os4.homedir(), ".gemini");
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
   const record = asRecord(data);
@@ -1119,9 +1307,9 @@ function parseProjectsJson(data) {
   return mapping;
 }
 async function loadProjectsJson(geminiDir) {
-  const projectsPath = path5.join(geminiDir, "projects.json");
+  const projectsPath = path6.join(geminiDir, "projects.json");
   try {
-    const content = await readFile2(projectsPath, "utf8");
+    const content = await readFile3(projectsPath, "utf8");
     const parsed = JSON.parse(content);
     return parseProjectsJson(parsed);
   } catch {
@@ -1129,11 +1317,11 @@ async function loadProjectsJson(geminiDir) {
   }
 }
 async function discoverSessionFiles(geminiDir) {
-  const tmpDir = path5.join(geminiDir, "tmp");
+  const tmpDir = path6.join(geminiDir, "tmp");
   const allSessionFiles = [];
   const discoveredFiles = await discoverFiles(tmpDir, { extension: ".json" });
   for (const filePath of discoveredFiles) {
-    const parentDir = path5.basename(path5.dirname(filePath));
+    const parentDir = path6.basename(path6.dirname(filePath));
     if (parentDir.toLowerCase() === "chats") {
       allSessionFiles.push(filePath);
     }
@@ -1148,9 +1336,9 @@ function resolveRepoRoot(filePath, sessionData, projectMapping) {
       return mappedRoot;
     }
   }
-  const chatsDir = path5.dirname(filePath);
-  const projectDir = path5.dirname(chatsDir);
-  const projectIdentifier = path5.basename(projectDir);
+  const chatsDir = path6.dirname(filePath);
+  const projectDir = path6.dirname(chatsDir);
+  const projectIdentifier = path6.basename(projectDir);
   return projectMapping.get(projectIdentifier);
 }
 function toFiniteNumber(value) {
@@ -1197,20 +1385,6 @@ function extractTokenUsage(tokens) {
     totalTokens
   };
 }
-function incrementSkippedReason(reasons, reason) {
-  const current = reasons.get(reason) ?? 0;
-  reasons.set(reason, current + 1);
-}
-function toSkippedRowReasonStats(reasons) {
-  return [...reasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason));
-}
-function toParseDiagnostics(events, skippedRows, skippedRowReasons) {
-  return {
-    events,
-    skippedRows,
-    skippedRowReasons: toSkippedRowReasonStats(skippedRowReasons)
-  };
-}
 function normalizeTimestamp2(candidate) {
   if (typeof candidate !== "string" || isBlankText(candidate)) {
     return void 0;
@@ -1274,7 +1448,7 @@ var GeminiSourceAdapter = class {
     const skippedRowReasons = /* @__PURE__ */ new Map();
     let sessionData;
     try {
-      const content = await readFile2(filePath, "utf8");
+      const content = await readFile3(filePath, "utf8");
       sessionData = JSON.parse(content);
     } catch {
       skippedRows++;
@@ -1287,7 +1461,7 @@ var GeminiSourceAdapter = class {
       incrementSkippedReason(skippedRowReasons, "invalid_session_data");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
     }
-    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path5.basename(filePath, ".json");
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path6.basename(filePath, ".json");
     const projectMapping = await this.getProjectMappingForParse();
     const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
     if (!Array.isArray(sessionDataRecord.messages)) {
@@ -1344,44 +1518,44 @@ var GeminiSourceAdapter = class {
 };
 
 // src/sources/opencode/opencode-db-path-resolver.ts
-import os4 from "os";
-import path6 from "path";
+import os5 from "os";
+import path7 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = env.XDG_DATA_HOME ?? path6.join(homeDir, ".local", "share");
+  const xdgDataHome = env.XDG_DATA_HOME ?? path7.join(homeDir, ".local", "share");
   return [
-    path6.join(xdgDataHome, "opencode", "opencode.db"),
-    path6.join(xdgDataHome, "opencode", "db.sqlite"),
-    path6.join(homeDir, ".opencode", "opencode.db"),
-    path6.join(homeDir, ".opencode", "db.sqlite")
+    path7.join(xdgDataHome, "opencode", "opencode.db"),
+    path7.join(xdgDataHome, "opencode", "db.sqlite"),
+    path7.join(homeDir, ".opencode", "opencode.db"),
+    path7.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getMacOsCandidates(homeDir) {
-  const appSupportDir = path6.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path7.join(homeDir, "Library", "Application Support");
   return [
-    path6.join(appSupportDir, "opencode", "opencode.db"),
-    path6.join(appSupportDir, "opencode", "db.sqlite"),
-    path6.join(homeDir, ".opencode", "opencode.db"),
-    path6.join(homeDir, ".opencode", "db.sqlite")
+    path7.join(appSupportDir, "opencode", "opencode.db"),
+    path7.join(appSupportDir, "opencode", "db.sqlite"),
+    path7.join(homeDir, ".opencode", "opencode.db"),
+    path7.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
-  const roamingBase = env.APPDATA ?? env.LOCALAPPDATA ?? (env.USERPROFILE ? path6.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
+  const roamingBase = env.APPDATA ?? env.LOCALAPPDATA ?? (env.USERPROFILE ? path7.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
-    path6.join(roamingBase, "opencode", "opencode.db"),
-    path6.join(roamingBase, "opencode", "db.sqlite")
+    path7.join(roamingBase, "opencode", "opencode.db"),
+    path7.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path6.join(homeDir, ".opencode", "opencode.db"),
-    path6.join(homeDir, ".opencode", "db.sqlite")
+    path7.join(homeDir, ".opencode", "opencode.db"),
+    path7.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os4.homedir();
+  const homeDir = options.homeDir ?? os5.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -1447,10 +1621,10 @@ async function loadNodeSqliteModule() {
 }
 
 // src/sources/opencode/opencode-row-parser.ts
-var UNIX_SECONDS_ABS_CUTOFF = 1e10;
-function normalizeTimestampCandidate(candidate) {
+var UNIX_SECONDS_ABS_CUTOFF2 = 1e10;
+function normalizeTimestampCandidate2(candidate) {
   if (typeof candidate === "number" && Number.isFinite(candidate)) {
-    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF ? candidate * 1e3 : candidate;
+    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF2 ? candidate * 1e3 : candidate;
     const date = new Date(timestampMs);
     if (Number.isNaN(date.getTime())) {
       return void 0;
@@ -1464,7 +1638,7 @@ function normalizeTimestampCandidate(candidate) {
     }
     const numericTimestamp = Number(trimmed);
     if (Number.isFinite(numericTimestamp)) {
-      return normalizeTimestampCandidate(numericTimestamp);
+      return normalizeTimestampCandidate2(numericTimestamp);
     }
     const date = new Date(trimmed);
     if (Number.isNaN(date.getTime())) {
@@ -1482,7 +1656,7 @@ function resolveTimestamp(rowTimestamp, messagePayload) {
     messagePayload.time_created
   ];
   for (const candidate of timestampCandidates) {
-    const resolved = normalizeTimestampCandidate(candidate);
+    const resolved = normalizeTimestampCandidate2(candidate);
     if (resolved) {
       return resolved;
     }
@@ -1888,9 +2062,9 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os5 from "os";
-import path7 from "path";
-var defaultSessionsDir2 = path7.join(os5.homedir(), ".pi", "agent", "sessions");
+import os6 from "os";
+import path8 from "path";
+var defaultSessionsDir3 = path8.join(os6.homedir(), ".pi", "agent", "sessions");
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
@@ -1898,11 +2072,11 @@ function shouldParsePiJsonlLine(lineText) {
   return PI_MESSAGE_LINE_PATTERN.test(lineText) || PI_SESSION_LINE_PATTERN.test(lineText) || PI_MODEL_CHANGE_LINE_PATTERN.test(lineText);
 }
 var allowAllProviders = () => true;
-var UNIX_SECONDS_ABS_CUTOFF2 = 1e10;
-function normalizeTimestampCandidate2(candidate) {
+var UNIX_SECONDS_ABS_CUTOFF3 = 1e10;
+function normalizeTimestampCandidate3(candidate) {
   let date;
   if (typeof candidate === "number" && Number.isFinite(candidate)) {
-    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF2 ? candidate * 1e3 : candidate;
+    const timestampMs = Math.abs(candidate) <= UNIX_SECONDS_ABS_CUTOFF3 ? candidate * 1e3 : candidate;
     date = new Date(timestampMs);
   } else {
     const normalizedText = asTrimmedText(candidate);
@@ -1919,7 +2093,7 @@ function normalizeTimestampCandidate2(candidate) {
 function resolveTimestamp2(line, message, state) {
   const candidates = [line.timestamp, message?.timestamp, state.sessionTimestamp];
   for (const candidate of candidates) {
-    const normalizedTimestamp = normalizeTimestampCandidate2(candidate);
+    const normalizedTimestamp = normalizeTimestampCandidate3(candidate);
     if (normalizedTimestamp) {
       return normalizedTimestamp;
     }
@@ -1983,7 +2157,7 @@ function extractUsage(line, message) {
   return extractUsageFromRecord(messageUsage);
 }
 function getFallbackSessionId2(filePath) {
-  return path7.basename(filePath, ".jsonl");
+  return path8.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -1998,7 +2172,7 @@ var PiSourceAdapter = class {
   providerFilter;
   requireSessionsDir;
   constructor(options = {}) {
-    this.sessionsDir = options.sessionsDir ?? defaultSessionsDir2;
+    this.sessionsDir = options.sessionsDir ?? defaultSessionsDir3;
     this.providerFilter = options.providerFilter ?? allowAllProviders;
     this.requireSessionsDir = options.requireSessionsDir ?? false;
   }
@@ -2136,6 +2310,21 @@ var sourceRegistrations = [
       });
     }
   },
+  {
+    id: "droid",
+    sourceDirOverride: { kind: "directory" },
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "droid",
+        options.droidDir,
+        sourceDirectoryOverrides
+      );
+      return new DroidSourceAdapter({
+        sessionsDir: directoryConfig.path,
+        requireSessionsDir: directoryConfig.requireExistingPath
+      });
+    }
+  },
   {
     id: "opencode",
     sourceDirOverride: { kind: "unsupported", flag: "--opencode-db" },
@@ -2217,6 +2406,7 @@ function createDefaultAdapters(options) {
   validateDirectoryOverride("--pi-dir", options.piDir);
   validateDirectoryOverride("--codex-dir", options.codexDir);
   validateDirectoryOverride("--gemini-dir", options.geminiDir);
+  validateDirectoryOverride("--droid-dir", options.droidDir);
   const sourceDirectoryOverrides = parseSourceDirectoryOverrides(options.sourceDir);
   validateSourceDirectoryOverrideIds(sourceDirectoryOverrides);
   return sourceRegistrations.map((source) => source.create(options, sourceDirectoryOverrides));
@@ -2592,7 +2782,7 @@ function aggregateEfficiency(options) {
 // src/efficiency/git-outcome-collector.ts
 import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
-import path8 from "path";
+import path9 from "path";
 import { stat as stat2 } from "fs/promises";
 var GIT_COMMIT_MARKER = "";
 var SHORTSTAT_PATTERN = /(\d+)\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/u;
@@ -2612,13 +2802,13 @@ function resolveGitCommandFailureReason(result) {
 }
 function resolveRepoDir(repoDir) {
   if (repoDir === void 0) {
-    return path8.resolve(process.cwd());
+    return path9.resolve(process.cwd());
   }
   const normalizedRepoDir = repoDir.trim();
   if (!normalizedRepoDir) {
     throw new Error("--repo-dir must be a non-empty path");
   }
-  return path8.resolve(normalizedRepoDir);
+  return path9.resolve(normalizedRepoDir);
 }
 function getNodeErrorCode2(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
@@ -2990,21 +3180,21 @@ async function collectGitOutcomes(options, deps = {}) {
 
 // src/efficiency/repo-attribution.ts
 import { access as access2, constants as constants2, realpath } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 async function hasGitMarker(directoryPath) {
   try {
-    await access2(path9.join(directoryPath, ".git"), constants2.F_OK);
+    await access2(path10.join(directoryPath, ".git"), constants2.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 function normalizeComparablePath(value) {
-  const normalizedPath = path9.normalize(path9.resolve(value));
+  const normalizedPath = path10.normalize(path10.resolve(value));
   return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 async function resolveComparablePath(value) {
-  const resolvedPath = path9.resolve(value);
+  const resolvedPath = path10.resolve(value);
   try {
     return normalizeComparablePath(await realpath(resolvedPath));
   } catch {
@@ -3016,12 +3206,12 @@ async function resolveRepoRootFromPathHint(pathHint) {
   if (!trimmedPath) {
     return void 0;
   }
-  let currentPath = path9.resolve(trimmedPath);
+  let currentPath = path10.resolve(trimmedPath);
   for (; ; ) {
     if (await hasGitMarker(currentPath)) {
       return currentPath;
     }
-    const parentPath = path9.dirname(currentPath);
+    const parentPath = path10.dirname(currentPath);
     if (parentPath === currentPath) {
       return void 0;
     }
@@ -3275,6 +3465,12 @@ function resolveExplicitSourceIds(options, sourceFilter) {
   if (options.codexDir) {
     explicitSourceIds.add("codex");
   }
+  if (options.geminiDir) {
+    explicitSourceIds.add("gemini");
+  }
+  if (options.droidDir) {
+    explicitSourceIds.add("droid");
+  }
   if (options.opencodeDb) {
     explicitSourceIds.add("opencode");
   }
@@ -3314,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) {
@@ -3342,8 +3538,8 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/cli/parse-file-cache.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import path10 from "path";
+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";
 function createCacheKey(source, filePath) {
@@ -3433,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)) {
@@ -3482,7 +3678,22 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path10.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  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) {
@@ -3568,9 +3779,16 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path10.dirname(this.cacheFilePath), { recursive: true });
-    await writeFile2(this.cacheFilePath, payloadText, "utf8");
-    this.dirty = false;
+    await mkdir2(path11.dirname(this.cacheFilePath), { recursive: true });
+    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 {
@@ -3589,9 +3807,20 @@ 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 readFile3(this.cacheFilePath, "utf8");
+      content = await readFile4(this.cacheFilePath, "utf8");
     } catch {
       return;
     }
@@ -3614,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) {
@@ -3673,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
@@ -3714,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 = [];
@@ -3862,8 +4111,8 @@ function applyPricingToEvents(events, pricingSource) {
 }
 
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import path11 from "path";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import path12 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -4006,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,
@@ -4047,7 +4296,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -4406,7 +4655,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile4(this.cacheFilePath, "utf8");
+      content = await readFile5(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -4441,7 +4690,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path11.dirname(this.cacheFilePath);
+    const directoryPath = path12.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -4615,6 +4864,12 @@ function resolveScopeNote(options) {
   if (hasActiveTextOption(options.codexDir)) {
     activeFilters.push("--codex-dir");
   }
+  if (hasActiveTextOption(options.geminiDir)) {
+    activeFilters.push("--gemini-dir");
+  }
+  if (hasActiveTextOption(options.droidDir)) {
+    activeFilters.push("--droid-dir");
+  }
   if (hasActiveTextOption(options.opencodeDb)) {
     activeFilters.push("--opencode-db");
   }
@@ -5586,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":
@@ -5630,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) {
@@ -5847,7 +6196,7 @@ function addSharedOptions(command, options = {}) {
   const allowedSourcesLabel = getAllowedSourcesLabel(supportedSourceIds);
   const supportedSourcesSummary = `(${supportedSourceIds.length}): ${allowedSourcesLabel}`;
   const includePerModelColumns = options.includePerModelColumns ?? true;
-  const configuredCommand = command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--gemini-dir <path>", "Path to .gemini directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
+  const configuredCommand = command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--gemini-dir <path>", "Path to .gemini directory").option("--droid-dir <path>", "Path to Droid sessions directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
     "--source-dir <source-id=path>",
     "Override source directory for directory-backed sources (repeatable)",
     collectRepeatedOption,
@@ -5921,10 +6270,10 @@ function rootDescription() {
     "  $ llm-usage monthly --since 2026-01-01 --until 2026-01-31 --source pi,codex --json",
     "  $ llm-usage monthly --source opencode --opencode-db /path/to/opencode.db --json",
     "  $ llm-usage monthly --model claude --per-model-columns",
-    "  $ llm-usage daily --source-dir pi=/tmp/pi-sessions --source-dir gemini=/tmp/.gemini",
-    "  $ llm-usage daily --pi-dir /tmp/pi-sessions --gemini-dir /tmp/.gemini",
+    "  $ llm-usage daily --source-dir pi=/tmp/pi-sessions --source-dir gemini=/tmp/.gemini --source-dir droid=/tmp/droid-sessions",
+    "  $ llm-usage daily --pi-dir /tmp/pi-sessions --gemini-dir /tmp/.gemini --droid-dir /tmp/droid-sessions",
     "  $ llm-usage efficiency weekly --repo-dir /path/to/repo --json",
-    "  $ npx --yes llm-usage-metrics daily"
+    "  $ npx --yes llm-usage-metrics@latest daily"
   ].join("\n");
 }
 function createCli(options = {}) {