llm-usage-metrics 0.3.3 → 0.3.4

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,294 @@ var CodexSourceAdapter = class {
   }
 };
 
-// src/sources/opencode/opencode-db-path-resolver.ts
+// src/sources/gemini/gemini-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");
+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 = path5.join(geminiDir, "projects.json");
+  try {
+    const content = await readFile2(projectsPath, "utf8");
+    const parsed = JSON.parse(content);
+    return parseProjectsJson(parsed);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function discoverSessionFiles(geminiDir) {
+  const tmpDir = path5.join(geminiDir, "tmp");
+  const allSessionFiles = [];
+  const discoveredFiles = await discoverFiles(tmpDir, { extension: ".json" });
+  for (const filePath of discoveredFiles) {
+    const parentDir = path5.basename(path5.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 = path5.dirname(filePath);
+  const projectDir = path5.dirname(chatsDir);
+  const projectIdentifier = path5.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 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;
+  }
+  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 readFile2(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) ?? path5.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 os4 from "os";
+import path6 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 ?? path6.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")
+    path6.join(xdgDataHome, "opencode", "opencode.db"),
+    path6.join(xdgDataHome, "opencode", "db.sqlite"),
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getMacOsCandidates(homeDir) {
-  const appSupportDir = path5.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path6.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")
+    path6.join(appSupportDir, "opencode", "opencode.db"),
+    path6.join(appSupportDir, "opencode", "db.sqlite"),
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.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 ? path6.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
-    path5.join(roamingBase, "opencode", "opencode.db"),
-    path5.join(roamingBase, "opencode", "db.sqlite")
+    path6.join(roamingBase, "opencode", "opencode.db"),
+    path6.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.join(homeDir, ".opencode", "db.sqlite")
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os3.homedir();
+  const homeDir = options.homeDir ?? os4.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -1236,7 +1509,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 +1564,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 +1888,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 os5 from "os";
+import path7 from "path";
+var defaultSessionsDir2 = path7.join(os5.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;
@@ -1626,9 +1899,6 @@ function shouldParsePiJsonlLine(lineText) {
 }
 var allowAllProviders = () => true;
 var UNIX_SECONDS_ABS_CUTOFF2 = 1e10;
-function isBlankText3(value) {
-  return value.trim().length === 0;
-}
 function normalizeTimestampCandidate2(candidate) {
   let date;
   if (typeof candidate === "number" && Number.isFinite(candidate)) {
@@ -1669,7 +1939,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 +1961,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 +1983,7 @@ function extractUsage(line, message) {
   return extractUsageFromRecord(messageUsage);
 }
 function getFallbackSessionId2(filePath) {
-  return path6.basename(filePath, ".jsonl");
+  return path7.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -1733,7 +2003,7 @@ var PiSourceAdapter = class {
     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 +2121,21 @@ 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: "opencode",
     sourceDirOverride: { kind: "unsupported", flag: "--opencode-db" },
@@ -1931,6 +2216,7 @@ function createDefaultAdapters(options) {
   validateOpencodeOverride(options.opencodeDb);
   validateDirectoryOverride("--pi-dir", options.piDir);
   validateDirectoryOverride("--codex-dir", options.codexDir);
+  validateDirectoryOverride("--gemini-dir", options.geminiDir);
   const sourceDirectoryOverrides = parseSourceDirectoryOverrides(options.sourceDir);
   validateSourceDirectoryOverrideIds(sourceDirectoryOverrides);
   return sourceRegistrations.map((source) => source.create(options, sourceDirectoryOverrides));
@@ -2306,7 +2592,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 path8 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 +2612,13 @@ function resolveGitCommandFailureReason(result) {
 }
 function resolveRepoDir(repoDir) {
   if (repoDir === void 0) {
-    return path7.resolve(process.cwd());
+    return path8.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 path8.resolve(normalizedRepoDir);
 }
 function getNodeErrorCode2(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) {
@@ -2704,21 +2990,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 path9 from "path";
 async function hasGitMarker(directoryPath) {
   try {
-    await access2(path8.join(directoryPath, ".git"), constants2.F_OK);
+    await access2(path9.join(directoryPath, ".git"), constants2.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 function normalizeComparablePath(value) {
-  const normalizedPath = path8.normalize(path8.resolve(value));
+  const normalizedPath = path9.normalize(path9.resolve(value));
   return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
 }
 async function resolveComparablePath(value) {
-  const resolvedPath = path8.resolve(value);
+  const resolvedPath = path9.resolve(value);
   try {
     return normalizeComparablePath(await realpath(resolvedPath));
   } catch {
@@ -2730,20 +3016,20 @@ async function resolveRepoRootFromPathHint(pathHint) {
   if (!trimmedPath) {
     return void 0;
   }
-  let currentPath = path8.resolve(trimmedPath);
+  let currentPath = path9.resolve(trimmedPath);
   for (; ; ) {
     if (await hasGitMarker(currentPath)) {
       return currentPath;
     }
-    const parentPath = path8.dirname(currentPath);
+    const parentPath = path9.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 +3042,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;
       }
@@ -3056,8 +3342,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 readFile3, writeFile as writeFile2 } from "fs/promises";
+import path10 from "path";
 var PARSE_FILE_CACHE_VERSION = 2;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
@@ -3196,7 +3482,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path9.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path10.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -3282,7 +3568,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path9.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path10.dirname(this.cacheFilePath), { recursive: true });
     await writeFile2(this.cacheFilePath, payloadText, "utf8");
     this.dirty = false;
   }
@@ -3305,7 +3591,7 @@ var ParseFileCache = class _ParseFileCache {
   async loadFromDisk() {
     let content;
     try {
-      content = await readFile2(this.cacheFilePath, "utf8");
+      content = await readFile3(this.cacheFilePath, "utf8");
     } catch {
       return;
     }
@@ -3576,8 +3862,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 readFile4, writeFile as writeFile3 } from "fs/promises";
+import path11 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -3585,20 +3871,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 +4047,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path10.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -4106,7 +4406,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile3(this.cacheFilePath, "utf8");
+      content = await readFile4(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -4141,7 +4441,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path10.dirname(this.cacheFilePath);
+    const directoryPath = path11.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -4341,7 +4641,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 +4650,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 +5847,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("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
     "--source-dir <source-id=path>",
     "Override source directory for directory-backed sources (repeatable)",
     collectRepeatedOption,
@@ -5621,7 +5921,8 @@ 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",
+    "  $ llm-usage daily --pi-dir /tmp/pi-sessions --gemini-dir /tmp/.gemini",
     "  $ llm-usage efficiency weekly --repo-dir /path/to/repo --json",
     "  $ npx --yes llm-usage-metrics daily"
   ].join("\n");