llm-usage-metrics 0.3.3 → 0.3.5

package/dist/index.js

@@ -748,7 +748,7 @@ function createUsageEvent(input) {
   };
 }
 
-// src/utils/discover-jsonl-files.ts
+// src/utils/discover-files.ts
 import { readdir } from "fs/promises";
 import path3 from "path";
 function getNodeErrorCode(error) {
@@ -759,41 +759,65 @@ function isSkippableDirectoryReadError(error) {
   const code = getNodeErrorCode(error);
   return code === "EACCES" || code === "EPERM";
 }
+function matchesExtension(fileName, extension) {
+  const lowerFileName = fileName.toLowerCase();
+  const lowerExtension = extension.toLowerCase();
+  return lowerFileName.endsWith(lowerExtension);
+}
+function normalizeExtension(extension) {
+  const normalized = extension.trim();
+  if (!normalized) {
+    throw new Error("discoverFiles extension must be a non-empty string");
+  }
+  if (!normalized.startsWith(".")) {
+    throw new Error('discoverFiles extension must start with "."');
+  }
+  return normalized;
+}
 async function walkDirectory(rootDir, acc, options) {
   let entries;
   try {
     entries = await readdir(rootDir, { withFileTypes: true, encoding: "utf8" });
   } catch (error) {
+    if (getNodeErrorCode(error) === "ENOENT") {
+      return;
+    }
     if (options.allowPermissionSkip && isSkippableDirectoryReadError(error)) {
       return;
     }
     throw error;
   }
-  entries.sort((left, right) => compareByCodePoint(left.name, right.name));
+  if (options.sort) {
+    entries.sort((left, right) => compareByCodePoint(left.name, right.name));
+  }
   for (const entry of entries) {
     const entryPath = path3.join(rootDir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDirectory(entryPath, acc, { allowPermissionSkip: true });
+    if (entry.isDirectory() && options.recursive) {
+      await walkDirectory(entryPath, acc, options);
       continue;
     }
-    if (entry.isFile() && entry.name.toLowerCase().endsWith(".jsonl")) {
+    if (entry.isFile() && matchesExtension(entry.name, options.extension)) {
       acc.push(entryPath);
     }
   }
 }
-async function discoverJsonlFiles(rootDir) {
+async function discoverFiles(rootDir, options) {
   const files = [];
-  try {
-    await walkDirectory(rootDir, files, { allowPermissionSkip: false });
-  } catch (error) {
-    if (getNodeErrorCode(error) === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
+  const resolvedOptions = {
+    extension: normalizeExtension(options.extension),
+    recursive: options.recursive ?? true,
+    allowPermissionSkip: options.allowPermissionSkip ?? true,
+    sort: options.sort ?? true
+  };
+  await walkDirectory(rootDir, files, resolvedOptions);
   return files;
 }
 
+// src/utils/discover-jsonl-files.ts
+async function discoverJsonlFiles(rootDir) {
+  return discoverFiles(rootDir, { extension: ".jsonl" });
+}
+
 // src/utils/fs-helpers.ts
 import { access, constants, stat } from "fs/promises";
 async function pathExists(filePath) {
@@ -883,6 +907,9 @@ function asTrimmedText(value) {
   const normalized = value.trim();
   return normalized || void 0;
 }
+function isBlankText(value) {
+  return value.trim().length === 0;
+}
 function toNumberLike(value) {
   if (value === null || value === void 0 || typeof value === "number" || typeof value === "string") {
     return value;
@@ -897,9 +924,6 @@ var SESSION_META_LINE_PATTERN = /"type"\s*:\s*"session_meta"/u;
 var TURN_CONTEXT_LINE_PATTERN = /"type"\s*:\s*"turn_context"/u;
 var EVENT_MSG_LINE_PATTERN = /"type"\s*:\s*"event_msg"/u;
 var TOKEN_COUNT_LINE_PATTERN = /"type"\s*:\s*"token_count"/u;
-function isBlankText(value) {
-  return value.trim().length === 0;
-}
 function shouldParseCodexJsonlLine(lineText) {
   if (SESSION_META_LINE_PATTERN.test(lineText) || TURN_CONTEXT_LINE_PATTERN.test(lineText)) {
     return true;
@@ -1070,45 +1094,466 @@ var CodexSourceAdapter = class {
   }
 };
 
-// src/sources/opencode/opencode-db-path-resolver.ts
+// src/sources/droid/droid-source-adapter.ts
+import { readFile as readFile2 } from "fs/promises";
 import os3 from "os";
 import path5 from "path";
+
+// 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;
+    const totalTokens = billableTokens + reasoningTokens;
+    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 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);
+          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);
+  if (!record) {
+    return mapping;
+  }
+  const projects = asRecord(record.projects);
+  if (!projects) {
+    return mapping;
+  }
+  for (const [key, value] of Object.entries(projects)) {
+    const projectEntry = asRecord(value);
+    const absolutePath = asTrimmedText(projectEntry?.absolutePath);
+    if (absolutePath) {
+      mapping.set(key, absolutePath);
+    }
+  }
+  return mapping;
+}
+async function loadProjectsJson(geminiDir) {
+  const projectsPath = path6.join(geminiDir, "projects.json");
+  try {
+    const content = await readFile3(projectsPath, "utf8");
+    const parsed = JSON.parse(content);
+    return parseProjectsJson(parsed);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function discoverSessionFiles(geminiDir) {
+  const tmpDir = path6.join(geminiDir, "tmp");
+  const allSessionFiles = [];
+  const discoveredFiles = await discoverFiles(tmpDir, { extension: ".json" });
+  for (const filePath of discoveredFiles) {
+    const parentDir = path6.basename(path6.dirname(filePath));
+    if (parentDir.toLowerCase() === "chats") {
+      allSessionFiles.push(filePath);
+    }
+  }
+  return allSessionFiles;
+}
+function resolveRepoRoot(filePath, sessionData, projectMapping) {
+  const projectHash = asTrimmedText(sessionData.projectHash);
+  if (projectHash) {
+    const mappedRoot = projectMapping.get(projectHash);
+    if (mappedRoot) {
+      return mappedRoot;
+    }
+  }
+  const chatsDir = path6.dirname(filePath);
+  const projectDir = path6.dirname(chatsDir);
+  const projectIdentifier = path6.basename(projectDir);
+  return projectMapping.get(projectIdentifier);
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function extractTokenUsage(tokens) {
+  if (!tokens) {
+    return null;
+  }
+  const input = Math.max(0, toFiniteNumber(tokens.input) ?? 0);
+  const tool = Math.max(0, toFiniteNumber(tokens.tool) ?? 0);
+  const output = Math.max(0, toFiniteNumber(tokens.output) ?? 0);
+  const thoughts = Math.max(0, toFiniteNumber(tokens.thoughts) ?? 0);
+  const cached = Math.max(0, toFiniteNumber(tokens.cached) ?? 0);
+  const inputTokens = input + tool;
+  const outputTokens = output;
+  const reasoningTokens = thoughts;
+  const cacheReadTokens = cached;
+  const declaredTotal = Math.max(0, toFiniteNumber(tokens.total) ?? 0);
+  const componentTotal = inputTokens + outputTokens + reasoningTokens + cacheReadTokens;
+  const totalTokens = declaredTotal > 0 ? declaredTotal : componentTotal;
+  if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cached === 0) {
+    return null;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    cacheReadTokens,
+    totalTokens
+  };
+}
+function normalizeTimestamp2(candidate) {
+  if (typeof candidate !== "string" || isBlankText(candidate)) {
+    return void 0;
+  }
+  const date = new Date(candidate.trim());
+  if (Number.isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date.toISOString();
+}
+var GeminiSourceAdapter = class {
+  id = "gemini";
+  geminiDir;
+  requireGeminiDir;
+  projectMapping = null;
+  constructor(options = {}) {
+    this.geminiDir = options.geminiDir ?? defaultGeminiDir;
+    this.requireGeminiDir = options.requireGeminiDir ?? false;
+  }
+  getNormalizedGeminiDir() {
+    if (isBlankText(this.geminiDir)) {
+      throw new Error("Gemini directory must be a non-empty path");
+    }
+    return this.geminiDir.trim();
+  }
+  async getProjectMapping(normalizedGeminiDir) {
+    if (this.projectMapping) {
+      return this.projectMapping;
+    }
+    this.projectMapping = await loadProjectsJson(normalizedGeminiDir);
+    return this.projectMapping;
+  }
+  async getProjectMappingForParse() {
+    if (this.projectMapping) {
+      return this.projectMapping;
+    }
+    if (isBlankText(this.geminiDir)) {
+      return /* @__PURE__ */ new Map();
+    }
+    this.projectMapping = await loadProjectsJson(this.geminiDir.trim());
+    return this.projectMapping;
+  }
+  async discoverFiles() {
+    const normalizedDir = this.getNormalizedGeminiDir();
+    if (this.requireGeminiDir && !await pathReadable(normalizedDir)) {
+      throw new Error(`Gemini directory is missing or unreadable: ${normalizedDir}`);
+    }
+    if (this.requireGeminiDir && !await pathIsDirectory(normalizedDir)) {
+      throw new Error(`Gemini directory is not a directory: ${normalizedDir}`);
+    }
+    await this.getProjectMapping(normalizedDir);
+    return discoverSessionFiles(normalizedDir);
+  }
+  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 sessionData;
+    try {
+      const content = await readFile3(filePath, "utf8");
+      sessionData = JSON.parse(content);
+    } catch {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "json_parse_error");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const sessionDataRecord = asRecord(sessionData);
+    if (!sessionDataRecord) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_session_data");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    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)) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_messages_array");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const messages = sessionDataRecord.messages;
+    for (const rawMessage of messages) {
+      const message = asRecord(rawMessage);
+      if (!message) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_message");
+        continue;
+      }
+      if (message.type !== "gemini") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "non_gemini_message");
+        continue;
+      }
+      const tokens = extractTokenUsage(asRecord(message.tokens));
+      if (!tokens) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "no_token_usage");
+        continue;
+      }
+      const timestamp = normalizeTimestamp2(message.timestamp);
+      if (!timestamp) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+        continue;
+      }
+      const model = asTrimmedText(message.model);
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId,
+            timestamp,
+            repoRoot,
+            provider: "google",
+            model,
+            ...tokens,
+            costMode: "estimated"
+          })
+        );
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/opencode/opencode-db-path-resolver.ts
+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 ?? path5.join(homeDir, ".local", "share");
+  const xdgDataHome = env.XDG_DATA_HOME ?? path7.join(homeDir, ".local", "share");
   return [
-    path5.join(xdgDataHome, "opencode", "opencode.db"),
-    path5.join(xdgDataHome, "opencode", "db.sqlite"),
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.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 = path5.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path7.join(homeDir, "Library", "Application Support");
   return [
-    path5.join(appSupportDir, "opencode", "opencode.db"),
-    path5.join(appSupportDir, "opencode", "db.sqlite"),
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.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 ? path5.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 ? [
-    path5.join(roamingBase, "opencode", "opencode.db"),
-    path5.join(roamingBase, "opencode", "db.sqlite")
+    path7.join(roamingBase, "opencode", "opencode.db"),
+    path7.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.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 ?? os3.homedir();
+  const homeDir = options.homeDir ?? os5.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -1174,10 +1619,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;
@@ -1191,7 +1636,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())) {
@@ -1209,7 +1654,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;
     }
@@ -1236,7 +1681,7 @@ function normalizeSessionIdCandidate(value) {
   }
   return asTrimmedText(value);
 }
-function resolveRepoRoot(messagePayload) {
+function resolveRepoRoot2(messagePayload) {
   const pathPayload = asRecord(messagePayload.path);
   return asTrimmedText(pathPayload?.root) ?? asTrimmedText(pathPayload?.cwd) ?? asTrimmedText(messagePayload.cwd) ?? asTrimmedText(messagePayload.repo_root) ?? asTrimmedText(messagePayload.repoRoot) ?? asTrimmedText(messagePayload.project_root) ?? asTrimmedText(messagePayload.projectRoot);
 }
@@ -1291,7 +1736,7 @@ function parseOpenCodeMessageRows(rows, sourceId) {
     }
     const provider = asTrimmedText(payload.providerID) ?? asTrimmedText(payload.provider);
     const model = asTrimmedText(payload.modelID) ?? asTrimmedText(payload.model);
-    const repoRoot = resolveRepoRoot(payload);
+    const repoRoot = resolveRepoRoot2(payload);
     const tokens = asRecord(payload.tokens);
     const tokenCache = asRecord(tokens?.cache);
     const inputTokens = toNumberLike(tokens?.input);
@@ -1615,9 +2060,9 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os4 from "os";
-import path6 from "path";
-var defaultSessionsDir2 = path6.join(os4.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;
@@ -1625,14 +2070,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 isBlankText3(value) {
-  return value.trim().length === 0;
-}
-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);
@@ -1649,7 +2091,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;
     }
@@ -1669,7 +2111,7 @@ function extractUsageFromRecord(usage) {
     totalTokens: toNumberLike(usage.totalTokens),
     costUsd: toNumberLike(cost?.total)
   };
-  const toFiniteNumber = (value) => {
+  const toFiniteNumber2 = (value) => {
     if (value === null || value === void 0) {
       return void 0;
     }
@@ -1691,10 +2133,10 @@ function extractUsageFromRecord(usage) {
     extracted.totalTokens
   ];
   const hasPositiveUsageSignal = usageCandidates.some((value) => {
-    const parsed = toFiniteNumber(value);
+    const parsed = toFiniteNumber2(value);
     return parsed !== void 0 && parsed > 0;
   });
-  const explicitCost = toFiniteNumber(extracted.costUsd);
+  const explicitCost = toFiniteNumber2(extracted.costUsd);
   const hasPositiveCostSignal = explicitCost !== void 0 && explicitCost > 0;
   return hasPositiveUsageSignal || hasPositiveCostSignal ? extracted : void 0;
 }
@@ -1713,7 +2155,7 @@ function extractUsage(line, message) {
   return extractUsageFromRecord(messageUsage);
 }
 function getFallbackSessionId2(filePath) {
-  return path6.basename(filePath, ".jsonl");
+  return path8.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -1728,12 +2170,12 @@ 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;
   }
   async discoverFiles() {
-    if (isBlankText3(this.sessionsDir)) {
+    if (isBlankText(this.sessionsDir)) {
       throw new Error("PI sessions directory must be a non-empty path");
     }
     const normalizedSessionsDir = this.sessionsDir.trim();
@@ -1851,6 +2293,36 @@ var sourceRegistrations = [
       });
     }
   },
+  {
+    id: "gemini",
+    sourceDirOverride: { kind: "directory" },
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "gemini",
+        options.geminiDir,
+        sourceDirectoryOverrides
+      );
+      return new GeminiSourceAdapter({
+        geminiDir: directoryConfig.path,
+        requireGeminiDir: directoryConfig.requireExistingPath
+      });
+    }
+  },
+  {
+    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" },
@@ -1931,6 +2403,8 @@ function createDefaultAdapters(options) {
   validateOpencodeOverride(options.opencodeDb);
   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));
@@ -2306,7 +2780,7 @@ function aggregateEfficiency(options) {
 // src/efficiency/git-outcome-collector.ts
 import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
-import path7 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;
@@ -2326,13 +2800,13 @@ function resolveGitCommandFailureReason(result) {
 }
 function resolveRepoDir(repoDir) {
   if (repoDir === void 0) {
-    return path7.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 path7.resolve(normalizedRepoDir);
+  return path9.resolve(normalizedRepoDir);
 }
 function getNodeErrorCode2(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
@@ -2704,21 +3178,21 @@ async function collectGitOutcomes(options, deps = {}) {
 
 // src/efficiency/repo-attribution.ts
 import { access as access2, constants as constants2, realpath } from "fs/promises";
-import path8 from "path";
+import path10 from "path";
 async function hasGitMarker(directoryPath) {
   try {
-    await access2(path8.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 = path8.normalize(path8.resolve(value));
+  const normalizedPath = path10.normalize(path10.resolve(value));
   return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 async function resolveComparablePath(value) {
-  const resolvedPath = path8.resolve(value);
+  const resolvedPath = path10.resolve(value);
   try {
     return normalizeComparablePath(await realpath(resolvedPath));
   } catch {
@@ -2730,20 +3204,20 @@ async function resolveRepoRootFromPathHint(pathHint) {
   if (!trimmedPath) {
     return void 0;
   }
-  let currentPath = path8.resolve(trimmedPath);
+  let currentPath = path10.resolve(trimmedPath);
   for (; ; ) {
     if (await hasGitMarker(currentPath)) {
       return currentPath;
     }
-    const parentPath = path8.dirname(currentPath);
+    const parentPath = path10.dirname(currentPath);
     if (parentPath === currentPath) {
       return void 0;
     }
     currentPath = parentPath;
   }
 }
-async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot2 = resolveRepoRootFromPathHint) {
-  const resolvedTargetRepoRoot = await resolveRepoRoot2(repoDir).catch(() => void 0);
+async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot3 = resolveRepoRootFromPathHint) {
+  const resolvedTargetRepoRoot = await resolveRepoRoot3(repoDir).catch(() => void 0);
   const targetRepoPath = await resolveComparablePath(resolvedTargetRepoRoot ?? repoDir);
   const rootCache = /* @__PURE__ */ new Map();
   const matchedEvents = [];
@@ -2756,7 +3230,7 @@ async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot2 = re
     }
     const eventRepoRoot = event.repoRoot;
     const cachedRootPromise = rootCache.get(eventRepoRoot) ?? (async () => {
-      const resolvedRoot2 = await resolveRepoRoot2(eventRepoRoot).catch(() => void 0);
+      const resolvedRoot2 = await resolveRepoRoot3(eventRepoRoot).catch(() => void 0);
       if (!resolvedRoot2) {
         return void 0;
       }
@@ -2989,6 +3463,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");
   }
@@ -3056,8 +3536,8 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/cli/parse-file-cache.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir2, readFile as readFile4, 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) {
@@ -3196,7 +3676,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path9.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -3282,7 +3762,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path9.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path11.dirname(this.cacheFilePath), { recursive: true });
     await writeFile2(this.cacheFilePath, payloadText, "utf8");
     this.dirty = false;
   }
@@ -3305,7 +3785,7 @@ var ParseFileCache = class _ParseFileCache {
   async loadFromDisk() {
     let content;
     try {
-      content = await readFile2(this.cacheFilePath, "utf8");
+      content = await readFile4(this.cacheFilePath, "utf8");
     } catch {
       return;
     }
@@ -3576,8 +4056,8 @@ function applyPricingToEvents(events, pricingSource) {
 }
 
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path10 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 = {
@@ -3585,20 +4065,34 @@ var litellm_model_map_default = {
     k2p5: "kimi-k2.5",
     "kimi-k2p5": "kimi-k2.5",
     "kimi-k2.5": "kimi-k2.5",
+    "kimi-k2.5-free": "kimi-k2.5",
     "moonshotai.kimi-k2.5": "kimi-k2.5",
     "moonshot/kimi-k2.5": "kimi-k2.5",
+    "gpt-5.3-codex-spark": "gpt-5.3-codex",
+    "gemini-3-pro": "gemini-3-pro",
+    "antigravity-gemini-3-flash": "gemini-3-flash",
+    "antigravity-gemini-3-pro": "gemini-3-pro",
+    "antigravity-gemini-3-pro-high": "gemini-3-pro",
+    "minimax-m2.1": "minimax-m2.1",
+    "minimax-m2.1-free": "minimax-m2.1",
+    "minimax-m2.5": "minimax-m2.5",
+    "minimax-m2.5-free": "minimax-m2.5",
     "claude sonnet 4.6": "claude-sonnet-4.6",
     "claude-sonnet-4.6": "claude-sonnet-4.6",
     "claude-sonnet-4-6": "claude-sonnet-4.6",
     "anthropic/claude-sonnet-4.6": "claude-sonnet-4.6",
-    "anthropic.claude-sonnet-4-6": "claude-sonnet-4.6",
-    "gpt-5.3-codex": "gpt-5.2-codex"
+    "anthropic.claude-sonnet-4-6": "claude-sonnet-4.6"
   },
   notes: {
-    "gpt-5.3-codex": "Temporary fallback to gpt-5.2-codex until upstream publishes direct gpt-5.3-codex token pricing"
+    "gpt-5.3-codex-spark": "Alias to gpt-5.3-codex because upstream publishes token pricing on the gpt-5.3-codex key"
   },
   preferredPricingKeyByCanonicalModel: {
     "kimi-k2.5": "moonshot/kimi-k2.5",
+    "gpt-5.3-codex": "gpt-5.3-codex",
+    "gemini-3-flash": "gemini/gemini-3-flash-preview",
+    "gemini-3-pro": "gemini/gemini-3-pro-preview",
+    "minimax-m2.1": "openrouter/minimax/minimax-m2.1",
+    "minimax-m2.5": "openrouter/minimax/minimax-m2.5",
     "claude-sonnet-4.6": "anthropic.claude-sonnet-4-6"
   }
 };
@@ -3747,7 +4241,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path10.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("/");
@@ -4106,7 +4600,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile3(this.cacheFilePath, "utf8");
+      content = await readFile5(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -4141,7 +4635,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path10.dirname(this.cacheFilePath);
+    const directoryPath = path12.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -4315,6 +4809,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");
   }
@@ -4341,7 +4841,7 @@ function hasMeaningfulEfficiencyUsageSignal(event) {
 async function buildEfficiencyData(granularity, options, deps = {}) {
   const buildUsage = deps.buildUsageData ?? buildUsageData;
   const collectOutcomes = deps.collectGitOutcomes ?? collectGitOutcomes;
-  const resolveRepoRoot2 = deps.resolveRepoRoot ?? resolveRepoRootFromPathHint;
+  const resolveRepoRoot3 = deps.resolveRepoRoot ?? resolveRepoRootFromPathHint;
   const repoDir = options.repoDir?.trim();
   if (options.repoDir !== void 0 && !repoDir) {
     throw new Error("--repo-dir must be a non-empty path");
@@ -4350,7 +4850,7 @@ async function buildEfficiencyData(granularity, options, deps = {}) {
   const attribution = await attributeUsageEventsToRepo(
     usageData.events,
     repoDir ?? process.cwd(),
-    resolveRepoRoot2
+    resolveRepoRoot3
   );
   const matchedEventsWithSignal = attribution.matchedEvents.filter(
     (event) => hasMeaningfulEfficiencyUsageSignal(event)
@@ -5547,7 +6047,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("--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,
@@ -5621,9 +6121,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",
+    "  $ 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 = {}) {