llm-usage-metrics 0.6.0 → 0.7.1

package/dist/index.js

@@ -106,9 +106,6 @@ function getParsingRuntimeConfig(env = process.env) {
   };
 }
 
-// src/update/update-notifier.ts
-import { spawn as spawn2 } from "child_process";
-
 // src/update/update-cache-repository.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path2 from "path";
@@ -529,7 +526,6 @@ async function runInteractiveInstallAndRestart(options) {
 
 // src/update/update-notifier.ts
 var UPDATE_CHECK_SKIP_ENV_VAR = "LLM_USAGE_SKIP_UPDATE_CHECK";
-var UPDATE_CHECK_REFRESH_ENV_VAR = "LLM_USAGE_REFRESH_UPDATE_CHECK";
 function isTruthyEnvFlag(value) {
   if (value === void 0) {
     return false;
@@ -588,32 +584,6 @@ function toResolveLatestVersionOptions(options, env) {
     now: options.now
   };
 }
-function runDetachedCommandWithSpawn(command, args, options = {}) {
-  const child = spawn2(command, args, {
-    env: options.env,
-    stdio: options.stdio ?? "ignore",
-    detached: true
-  });
-  child.on("error", () => void 0);
-  child.unref();
-}
-function scheduleBackgroundUpdateRefresh(options, env, argv) {
-  const spawnDetachedCommand = options.spawnDetachedCommand ?? runDetachedCommandWithSpawn;
-  spawnDetachedCommand(options.execPath ?? process.execPath, argv.slice(1), {
-    env: {
-      ...env,
-      [UPDATE_CHECK_REFRESH_ENV_VAR]: "1"
-    },
-    stdio: "ignore"
-  });
-}
-async function refreshUpdateCheckCache(options) {
-  try {
-    const env = options.env ?? process.env;
-    await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
-  } catch {
-  }
-}
 async function checkForUpdatesAndMaybeRestart(options) {
   const env = options.env ?? process.env;
   const argv = options.argv ?? process.argv;
@@ -630,19 +600,7 @@ async function checkForUpdatesAndMaybeRestart(options) {
     return { continueExecution: true };
   }
   try {
-    const resolveOptions = toResolveLatestVersionOptions(options, env);
-    const cacheFilePath = resolveOptions.cacheFilePath ?? getDefaultUpdateCheckCachePath();
-    const cachePayload = await readUpdateCheckCachePayload(cacheFilePath);
-    const cacheTtlMs = resolveOptions.cacheTtlMs ?? DEFAULT_UPDATE_CHECK_CACHE_TTL_MS;
-    const now = resolveOptions.now ?? Date.now;
-    if (!cachePayload || !isCacheFresh(cachePayload, cacheTtlMs, now)) {
-      try {
-        scheduleBackgroundUpdateRefresh(options, env, argv);
-      } catch {
-      }
-      return { continueExecution: true };
-    }
-    const latestVersion = cachePayload.latestVersion;
+    const latestVersion = await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
     if (!latestVersion || !shouldOfferUpdate(options.currentVersion, latestVersion)) {
       return { continueExecution: true };
     }
@@ -694,7 +652,8 @@ var knownSourceColors = {
   codex: "#22c55e",
   gemini: "#eab308",
   droid: "#3b82f6",
-  opencode: "#a855f7"
+  opencode: "#a855f7",
+  claude: "#d97757"
 };
 var fallbackColors = ["#f97316", "#06b6d4", "#ef4444", "#84cc16", "#f43f5e"];
 function getSourceColor(source, index) {
@@ -1076,8 +1035,14 @@ function escapeBareAutolinks(value) {
     (_, prefix, email) => `${prefix}${email.replace("@", "\\@")}`
   );
 }
+function escapeHtmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
 function escapeMarkdownText(value) {
-  const escapedMarkdownText = value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(markdownSpecialCharacterPattern, "\\$&");
+  const escapedMarkdownText = escapeHtmlText(value).replace(
+    markdownSpecialCharacterPattern,
+    "\\$&"
+  );
   return escapeBareAutolinks(escapedMarkdownText);
 }
 function toMarkdownSafeCell(value) {
@@ -1270,7 +1235,8 @@ var sourceStylePolicies = /* @__PURE__ */ new Map([
   ["codex", (palette) => palette.magenta],
   ["gemini", (palette) => palette.yellow],
   ["droid", (palette) => palette.green],
-  ["opencode", (palette) => palette.blue]
+  ["opencode", (palette) => palette.blue],
+  ["claude", (palette) => palette.cyan]
 ]);
 function resolveSourceStyler(source, palette = defaultTerminalStylePalette) {
   const stylePolicy = sourceStylePolicies.get(source);
@@ -2651,7 +2617,7 @@ function aggregateEfficiency(options) {
 }
 
 // src/efficiency/git-outcome-collector.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import path3 from "path";
 import { stat } from "fs/promises";
@@ -2850,7 +2816,7 @@ function parseGitLogShortstatLines(lines, authorEmail) {
 }
 async function runGitCommand(repoDir, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn3("git", args, {
+    const child = spawn2("git", args, {
       cwd: repoDir,
       env: {
         ...process.env,
@@ -3431,7 +3397,7 @@ function formatEnvVarOverrides(overrides) {
   return lines;
 }
 
-// src/sources/codex/codex-source-adapter.ts
+// src/sources/claude/claude-source-adapter.ts
 import os2 from "os";
 import path6 from "path";
 
@@ -3566,11 +3532,6 @@ async function discoverFiles(rootDir, options) {
   return toCanonicalFiles(files, resolvedOptions);
 }
 
-// src/utils/discover-jsonl-files.ts
-async function discoverJsonlFiles(rootDir) {
-  return discoverFiles(rootDir, { extension: ".jsonl" });
-}
-
 // src/utils/fs-helpers.ts
 import { access as access2, constants as constants2, stat as stat3 } from "fs/promises";
 async function pathExists(filePath) {
@@ -3652,6 +3613,22 @@ async function* readJsonlObjects(filePath, options = {}) {
   }
 }
 
+// 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/parsing-utils.ts
 var MIN_PLAUSIBLE_UNIX_SECONDS_ABS = 1e8;
 var UNIX_SECONDS_ABS_CUTOFF = 1e10;
@@ -3704,8 +3681,178 @@ function normalizeTimestampCandidate(candidate) {
   return date.toISOString();
 }
 
+// src/sources/claude/claude-source-adapter.ts
+var defaultClaudeProjectsDir = path6.join(os2.homedir(), ".claude", "projects");
+var CLAUDE_ASSISTANT_LINE_PATTERN = /"type"\s*:\s*"assistant"/u;
+var CLAUDE_USAGE_LINE_PATTERN = /"usage"\s*:/u;
+function shouldParseClaudeJsonlLine(lineText) {
+  return CLAUDE_ASSISTANT_LINE_PATTERN.test(lineText) && CLAUDE_USAGE_LINE_PATTERN.test(lineText);
+}
+function getFallbackSessionId(filePath) {
+  return path6.basename(filePath, ".jsonl");
+}
+function resolveProvider(message, model) {
+  const explicitProvider = asTrimmedText(message.provider);
+  if (explicitProvider) {
+    return explicitProvider;
+  }
+  if (model?.toLowerCase().startsWith("claude-")) {
+    return "anthropic";
+  }
+  return void 0;
+}
+function parseUsage(usage) {
+  const inputTokens = normalizeNonNegativeInteger(toNumberLike(usage.input_tokens));
+  const outputTokens = normalizeNonNegativeInteger(toNumberLike(usage.output_tokens));
+  const cacheReadTokens = normalizeNonNegativeInteger(toNumberLike(usage.cache_read_input_tokens));
+  const cacheWriteTokens = normalizeNonNegativeInteger(
+    toNumberLike(usage.cache_creation_input_tokens)
+  );
+  const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  if (totalTokens === 0) {
+    return void 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens: 0,
+    cacheReadTokens,
+    cacheWriteTokens,
+    totalTokens
+  };
+}
+function createDedupKey(filePath, line, message, timestamp, model) {
+  const messageId = asTrimmedText(message.id);
+  if (messageId) {
+    return `${filePath}\0${messageId}`;
+  }
+  const uuid = asTrimmedText(line.uuid);
+  if (uuid) {
+    return `${filePath}\0${uuid}`;
+  }
+  return `${filePath}\0${timestamp}\0${model ?? ""}`;
+}
+function comparePendingEvents(left, right) {
+  if (left.timestamp !== right.timestamp) {
+    return compareByCodePoint(left.timestamp, right.timestamp);
+  }
+  return left.sequence - right.sequence;
+}
+var ClaudeSourceAdapter = class {
+  id = "claude";
+  projectsDir;
+  requireProjectsDir;
+  constructor(options = {}) {
+    this.projectsDir = options.projectsDir ?? defaultClaudeProjectsDir;
+    this.requireProjectsDir = options.requireProjectsDir ?? false;
+  }
+  getNormalizedProjectsDir() {
+    if (isBlankText(this.projectsDir)) {
+      throw new Error("Claude projects directory must be a non-empty path");
+    }
+    return this.projectsDir.trim();
+  }
+  async discoverFiles() {
+    const normalizedProjectsDir = this.getNormalizedProjectsDir();
+    if (this.requireProjectsDir && !await pathReadable(normalizedProjectsDir)) {
+      throw new Error(
+        `Claude projects directory is missing or unreadable: ${normalizedProjectsDir}`
+      );
+    }
+    if (this.requireProjectsDir && !await pathIsDirectory(normalizedProjectsDir)) {
+      throw new Error(`Claude projects directory is not a directory: ${normalizedProjectsDir}`);
+    }
+    return discoverFiles(normalizedProjectsDir, { extension: ".jsonl" });
+  }
+  async parseFile(filePath) {
+    const { events } = await this.parseFileWithDiagnostics(filePath);
+    return events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const eventsByDedupKey = /* @__PURE__ */ new Map();
+    let skippedRows = 0;
+    let sequence = 0;
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    for await (const line of readJsonlObjects(filePath, {
+      shouldParseLine: shouldParseClaudeJsonlLine
+    })) {
+      if (asTrimmedText(line.type) !== "assistant") {
+        continue;
+      }
+      const message = asRecord(line.message);
+      if (!message || asTrimmedText(message.role) !== "assistant") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_assistant_message");
+        continue;
+      }
+      const model = asTrimmedText(message.model);
+      if (model === "<synthetic>") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "synthetic_message");
+        continue;
+      }
+      const usage = parseUsage(asRecord(message.usage) ?? {});
+      if (!usage) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "no_token_usage");
+        continue;
+      }
+      const timestamp = normalizeTimestampCandidate(line.timestamp);
+      if (!timestamp) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+        continue;
+      }
+      const dedupKey = createDedupKey(filePath, line, message, timestamp, model);
+      const sessionId = asTrimmedText(line.sessionId) ?? getFallbackSessionId(filePath);
+      const repoRoot = asTrimmedText(line.cwd);
+      const provider = resolveProvider(message, model);
+      sequence += 1;
+      eventsByDedupKey.set(dedupKey, {
+        sessionId,
+        timestamp,
+        repoRoot,
+        provider,
+        model,
+        usage,
+        sequence
+      });
+    }
+    const events = [];
+    for (const pendingEvent of [...eventsByDedupKey.values()].sort(comparePendingEvents)) {
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId: pendingEvent.sessionId,
+            timestamp: pendingEvent.timestamp,
+            repoRoot: pendingEvent.repoRoot,
+            provider: pendingEvent.provider,
+            model: pendingEvent.model,
+            ...pendingEvent.usage,
+            costMode: "estimated"
+          })
+        );
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
 // src/sources/codex/codex-source-adapter.ts
-var defaultSessionsDir = path6.join(os2.homedir(), ".codex", "sessions");
+import os3 from "os";
+import path7 from "path";
+
+// src/utils/discover-jsonl-files.ts
+async function discoverJsonlFiles(rootDir) {
+  return discoverFiles(rootDir, { extension: ".jsonl" });
+}
+
+// src/sources/codex/codex-source-adapter.ts
+var defaultSessionsDir = path7.join(os3.homedir(), ".codex", "sessions");
 var LEGACY_CODEX_MODEL_FALLBACK = "legacy-codex-unknown";
 var SESSION_META_LINE_PATTERN = /"type"\s*:\s*"session_meta"/u;
 var TURN_CONTEXT_LINE_PATTERN = /"type"\s*:\s*"turn_context"/u;
@@ -3799,8 +3946,8 @@ function createLastUsageOnlyKey(timestamp, usage) {
     usage.totalTokens
   ].join(":");
 }
-function getFallbackSessionId(filePath) {
-  return path6.basename(filePath, ".jsonl");
+function getFallbackSessionId2(filePath) {
+  return path7.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromPayload(payload) {
   if (!payload) {
@@ -3840,7 +3987,7 @@ var CodexSourceAdapter = class {
   async parseFile(filePath) {
     const events = [];
     const state = {
-      sessionId: getFallbackSessionId(filePath),
+      sessionId: getFallbackSessionId2(filePath),
       provider: "openai"
     };
     for await (const line of readJsonlObjects(filePath, {
@@ -3932,37 +4079,19 @@ var CodexSourceAdapter = class {
 
 // src/sources/droid/droid-source-adapter.ts
 import { readFile as readFile2 } from "fs/promises";
-import os3 from "os";
-import path7 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 = path7.join(os3.homedir(), ".factory", "sessions");
+import os4 from "os";
+import path8 from "path";
+var defaultSessionsDir2 = path8.join(os4.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);
 }
 function getSettingsSessionId(filePath) {
-  return path7.basename(filePath, ".settings.json");
+  return path8.basename(filePath, ".settings.json");
 }
 function getSiblingJsonlPath(settingsPath) {
-  return path7.join(path7.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
+  return path8.join(path8.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
 }
 function isSessionStartRecord(line) {
   return asTrimmedText(line.type) === "session_start";
@@ -4106,11 +4235,11 @@ var DroidSourceAdapter = class {
 
 // src/sources/gemini/gemini-source-adapter.ts
 import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import os4 from "os";
-import path8 from "path";
-var defaultGeminiDir = path8.join(os4.homedir(), ".gemini");
+import os5 from "os";
+import path9 from "path";
+var defaultGeminiDir = path9.join(os5.homedir(), ".gemini");
 function getProjectsJsonPath(geminiDir) {
-  return path8.join(geminiDir, "projects.json");
+  return path9.join(geminiDir, "projects.json");
 }
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
@@ -4145,7 +4274,7 @@ async function loadProjectsJson(geminiDir) {
   }
 }
 async function discoverSessionFiles(geminiDir) {
-  const tmpDir = path8.join(geminiDir, "tmp");
+  const tmpDir = path9.join(geminiDir, "tmp");
   let projectEntries;
   try {
     projectEntries = await readdir2(tmpDir, { withFileTypes: true, encoding: "utf8" });
@@ -4162,7 +4291,7 @@ async function discoverSessionFiles(geminiDir) {
     if (!projectEntry.isDirectory() && !projectEntry.isSymbolicLink()) {
       continue;
     }
-    const chatsDir = path8.join(tmpDir, projectEntry.name, "chats");
+    const chatsDir = path9.join(tmpDir, projectEntry.name, "chats");
     const discoveredChatFiles = await discoverFiles(chatsDir, { extension: ".json" });
     allSessionFiles.push(...discoveredChatFiles);
   }
@@ -4176,9 +4305,9 @@ function resolveRepoRoot(filePath, sessionData, projectMapping) {
       return mappedRoot;
     }
   }
-  const chatsDir = path8.dirname(filePath);
-  const projectDir = path8.dirname(chatsDir);
-  const projectIdentifier = path8.basename(projectDir);
+  const chatsDir = path9.dirname(filePath);
+  const projectDir = path9.dirname(chatsDir);
+  const projectIdentifier = path9.basename(projectDir);
   return projectMapping.get(projectIdentifier);
 }
 function toFiniteNumber(value) {
@@ -4287,7 +4416,7 @@ var GeminiSourceAdapter = class {
       incrementSkippedReason(skippedRowReasons, "invalid_session_data");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
     }
-    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path8.basename(filePath, ".json");
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path9.basename(filePath, ".json");
     const projectMapping = await this.getProjectMappingForParse();
     const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
     if (!Array.isArray(sessionDataRecord.messages)) {
@@ -4344,8 +4473,8 @@ var GeminiSourceAdapter = class {
 };
 
 // src/sources/opencode/opencode-db-path-resolver.ts
-import os5 from "os";
-import path9 from "path";
+import os6 from "os";
+import path10 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
@@ -4357,39 +4486,39 @@ function normalizeEnvPath(value) {
   return normalized || void 0;
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path9.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path10.join(homeDir, ".local", "share");
   return [
-    path9.join(xdgDataHome, "opencode", "opencode.db"),
-    path9.join(xdgDataHome, "opencode", "db.sqlite"),
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(xdgDataHome, "opencode", "opencode.db"),
+    path10.join(xdgDataHome, "opencode", "db.sqlite"),
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getMacOsCandidates(homeDir) {
-  const appSupportDir = path9.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path10.join(homeDir, "Library", "Application Support");
   return [
-    path9.join(appSupportDir, "opencode", "opencode.db"),
-    path9.join(appSupportDir, "opencode", "db.sqlite"),
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(appSupportDir, "opencode", "opencode.db"),
+    path10.join(appSupportDir, "opencode", "db.sqlite"),
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
   const userProfile = normalizeEnvPath(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath(env.APPDATA) ?? normalizeEnvPath(env.LOCALAPPDATA) ?? (userProfile ? path9.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingBase = normalizeEnvPath(env.APPDATA) ?? normalizeEnvPath(env.LOCALAPPDATA) ?? (userProfile ? path10.join(userProfile, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
-    path9.join(roamingBase, "opencode", "opencode.db"),
-    path9.join(roamingBase, "opencode", "db.sqlite")
+    path10.join(roamingBase, "opencode", "opencode.db"),
+    path10.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os5.homedir();
+  const homeDir = options.homeDir ?? os6.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -4878,9 +5007,9 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os6 from "os";
-import path10 from "path";
-var defaultSessionsDir3 = path10.join(os6.homedir(), ".pi", "agent", "sessions");
+import os7 from "os";
+import path11 from "path";
+var defaultSessionsDir3 = path11.join(os7.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;
@@ -4953,8 +5082,8 @@ function extractUsage(line, message) {
   }
   return extractUsageFromRecord(messageUsage);
 }
-function getFallbackSessionId2(filePath) {
-  return path10.basename(filePath, ".jsonl");
+function getFallbackSessionId3(filePath) {
+  return path11.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -4986,7 +5115,7 @@ var PiSourceAdapter = class {
   }
   async parseFile(filePath) {
     const events = [];
-    const state = { sessionId: getFallbackSessionId2(filePath) };
+    const state = { sessionId: getFallbackSessionId3(filePath) };
     for await (const line of readJsonlObjects(filePath, {
       shouldParseLine: shouldParsePiJsonlLine
     })) {
@@ -5125,6 +5254,21 @@ var sourceRegistrations = [
     create: (options) => new OpenCodeSourceAdapter({
       dbPath: options.opencodeDb
     })
+  },
+  {
+    id: "claude",
+    sourceDirOverride: { kind: "directory" },
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "claude",
+        options.claudeDir,
+        sourceDirectoryOverrides
+      );
+      return new ClaudeSourceAdapter({
+        projectsDir: directoryConfig.path,
+        requireProjectsDir: directoryConfig.requireExistingPath
+      });
+    }
   }
 ];
 var sourceDirUnsupportedFlags = new Map(
@@ -5201,6 +5345,7 @@ function createDefaultAdapters(options) {
   validateDirectoryOverride("--codex-dir", options.codexDir);
   validateDirectoryOverride("--gemini-dir", options.geminiDir);
   validateDirectoryOverride("--droid-dir", options.droidDir);
+  validateDirectoryOverride("--claude-dir", options.claudeDir);
   const sourceDirectoryOverrides = parseSourceDirectoryOverrides(options.sourceDir);
   validateSourceDirectoryOverrideIds(sourceDirectoryOverrides);
   return sourceRegistrations.map((source) => source.create(options, sourceDirectoryOverrides));
@@ -5316,6 +5461,9 @@ function resolveExplicitSourceIds(options, sourceFilter) {
   if (options.droidDir) {
     explicitSourceIds.add("droid");
   }
+  if (options.claudeDir) {
+    explicitSourceIds.add("claude");
+  }
   if (options.opencodeDb) {
     explicitSourceIds.add("opencode");
   }
@@ -5444,7 +5592,7 @@ function normalizeSkippedRowReasons(value) {
 
 // src/cli/parse-file-cache.ts
 import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat4, writeFile as writeFile2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var PARSE_FILE_CACHE_VERSION = 5;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
@@ -5671,7 +5819,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 function normalizeCacheShardSource(source) {
   const normalizedSource = normalizeCacheSource(source);
@@ -5681,12 +5829,12 @@ function normalizeCacheShardSource(source) {
   return normalizedSource.replace(/[^a-z0-9._-]/gu, "_");
 }
 function getSourceShardedParseFileCachePath(cacheFilePath, source) {
-  const parsedPath = path11.parse(cacheFilePath);
+  const parsedPath = path12.parse(cacheFilePath);
   const sourceShard = normalizeCacheShardSource(source);
   if (parsedPath.ext.length > 0) {
-    return path11.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
+    return path12.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
   }
-  return path11.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
+  return path12.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -5694,6 +5842,9 @@ var ParseFileCache = class _ParseFileCache {
     this.limits = limits;
     this.now = now;
   }
+  cacheFilePath;
+  limits;
+  now;
   entriesByKey = /* @__PURE__ */ new Map();
   dirty = false;
   static async load(options) {
@@ -5780,7 +5931,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path11.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path12.dirname(this.cacheFilePath), { recursive: true });
     const temporaryPath = `${this.cacheFilePath}.${process.pid}.${this.now()}.tmp`;
     try {
       await writeFile2(temporaryPath, payloadText, "utf8");
@@ -6267,9 +6418,92 @@ function applyPricingToEvents(events, pricingSource) {
   });
 }
 
+// src/pricing/pricing-override-source.ts
+import { readFile as readFile5 } from "fs/promises";
+function toFiniteUsdRate(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeReasoningBilling(value) {
+  if (value === "included-in-output" || value === "separate") {
+    return value;
+  }
+  return void 0;
+}
+function normalizePricingOverride(raw) {
+  const inputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.inputPer1MUsd));
+  const outputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.outputPer1MUsd));
+  if (inputPer1MUsd === void 0 || outputPer1MUsd === void 0) {
+    return void 0;
+  }
+  const cacheReadPer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheReadPer1MUsd));
+  const cacheWritePer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheWritePer1MUsd));
+  const reasoningPer1MUsd = toFiniteUsdRate(toNumberLike(raw.reasoningPer1MUsd));
+  const reasoningBilling = normalizeReasoningBilling(raw.reasoningBilling);
+  return {
+    inputPer1MUsd,
+    outputPer1MUsd,
+    ...cacheReadPer1MUsd !== void 0 ? { cacheReadPer1MUsd } : {},
+    ...cacheWritePer1MUsd !== void 0 ? { cacheWritePer1MUsd } : {},
+    ...reasoningPer1MUsd !== void 0 ? { reasoningPer1MUsd } : {},
+    ...reasoningBilling !== void 0 ? { reasoningBilling } : {}
+  };
+}
+function normalizeOverrideFile(payload) {
+  const root = asRecord(payload);
+  const overrides = /* @__PURE__ */ new Map();
+  const modelsRecord = asRecord(root?.models);
+  if (!modelsRecord) {
+    return overrides;
+  }
+  for (const [modelName, rawPricing] of Object.entries(modelsRecord)) {
+    const normalizedModelName = asTrimmedText(modelName)?.toLowerCase();
+    if (!normalizedModelName) {
+      continue;
+    }
+    const pricing = normalizePricingOverride(asRecord(rawPricing) ?? {});
+    if (pricing) {
+      overrides.set(normalizedModelName, pricing);
+    }
+  }
+  return overrides;
+}
+async function loadPricingOverrides(filePath) {
+  const fileContents = await readFile5(filePath, "utf8");
+  const parsed = JSON.parse(fileContents);
+  return normalizeOverrideFile(parsed);
+}
+var PricingOverrideSource = class {
+  overrides;
+  delegate;
+  constructor(overrides, delegate) {
+    this.overrides = overrides;
+    this.delegate = delegate;
+  }
+  resolveModelAlias(model) {
+    if (this.overrides.has(model.toLowerCase())) {
+      return model;
+    }
+    return this.delegate.resolveModelAlias(model);
+  }
+  getPricing(model) {
+    const override = this.overrides.get(model.toLowerCase());
+    if (override) {
+      return override;
+    }
+    return this.delegate.getPricing(model);
+  }
+};
+
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import path13 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -6453,7 +6687,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path13.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -6812,7 +7046,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile5(this.cacheFilePath, "utf8");
+      content = await readFile6(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -6847,7 +7081,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path12.dirname(this.cacheFilePath);
+    const directoryPath = path13.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -6859,7 +7093,27 @@ var LiteLLMPricingFetcher = class {
 };
 
 // src/cli/build-usage-data-pricing.ts
+function wrapWithPricingOverrides(overrides, delegate) {
+  if (!overrides || overrides.size === 0) {
+    return delegate;
+  }
+  return new PricingOverrideSource(overrides, delegate);
+}
 async function resolvePricingSource(options, runtimeConfig) {
+  let pricingOverrides;
+  if (options.pricingOverrides) {
+    try {
+      pricingOverrides = await loadPricingOverrides(options.pricingOverrides);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Could not load --pricing-overrides from ${options.pricingOverrides}: ${reason}`,
+        {
+          cause: error
+        }
+      );
+    }
+  }
   const litellmPricingFetcher = new LiteLLMPricingFetcher({
     sourceUrl: options.pricingUrl,
     offline: options.pricingOffline,
@@ -6868,10 +7122,11 @@ async function resolvePricingSource(options, runtimeConfig) {
   });
   try {
     const fromCache = await litellmPricingFetcher.load();
+    const source = wrapWithPricingOverrides(pricingOverrides, litellmPricingFetcher);
     if (options.pricingOffline) {
-      return { source: litellmPricingFetcher, origin: "offline-cache" };
+      return { source, origin: "offline-cache" };
     }
-    return { source: litellmPricingFetcher, origin: fromCache ? "cache" : "network" };
+    return { source, origin: fromCache ? "cache" : "network" };
   } catch (error) {
     if (options.pricingOffline) {
       throw new Error("Offline pricing mode enabled but cached pricing is unavailable", {
@@ -6958,6 +7213,7 @@ var RuntimeProfileCollector = class {
   constructor(now = () => performance.now()) {
     this.now = now;
   }
+  now;
   sourceSelection;
   sourceStats = /* @__PURE__ */ new Map();
   stageDurations = /* @__PURE__ */ new Map();
@@ -7251,6 +7507,9 @@ function resolveScopeNote(options) {
   if (hasActiveTextOption(options.droidDir)) {
     activeFilters.push("--droid-dir");
   }
+  if (hasActiveTextOption(options.claudeDir)) {
+    activeFilters.push("--claude-dir");
+  }
   if (hasActiveTextOption(options.opencodeDb)) {
     activeFilters.push("--opencode-db");
   }
@@ -7435,11 +7694,12 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 }
 
 // src/cli/share-artifact.ts
-import { spawn as spawn4 } from "child_process";
-import { writeFile as writeFile4 } from "fs/promises";
-import path13 from "path";
+import { spawn as spawn3 } from "child_process";
+import { constants as constants3 } from "fs";
+import { access as access3, writeFile as writeFile4 } from "fs/promises";
+import path14 from "path";
 async function writeShareSvgFile(fileName, svgContent) {
-  const outputPath = path13.resolve(process.cwd(), fileName);
+  const outputPath = path14.resolve(process.cwd(), fileName);
   await writeFile4(outputPath, svgContent, "utf8");
   return outputPath;
 }
@@ -7449,27 +7709,74 @@ function stringifyError(error) {
   }
   return String(error);
 }
-function resolveOpenCommand(filePath, platform) {
+var WINDOWS_OPEN_COMMAND = "C:\\Windows\\System32\\rundll32.exe";
+var DARWIN_OPEN_COMMAND = "/usr/bin/open";
+var UNIX_OPEN_COMMAND = "/usr/bin/xdg-open";
+var WINDOWS_FALLBACK_COMMANDS = ["rundll32.exe"];
+var DARWIN_FALLBACK_COMMANDS = ["open"];
+var UNIX_FALLBACK_COMMANDS = ["xdg-open"];
+async function fileExists(filePath) {
+  try {
+    await access3(filePath, constants3.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBinaryPath(primaryPath, fallbackNames) {
+  if (await fileExists(primaryPath)) {
+    return primaryPath;
+  }
+  const pathDirs = (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean);
+  for (const fallbackName of fallbackNames) {
+    for (const dir of pathDirs) {
+      const candidate = path14.join(dir, fallbackName);
+      if (await fileExists(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+async function resolveOpenCommand(filePath, platform) {
   if (platform === "win32") {
+    const resolvedPath2 = await resolveBinaryPath(WINDOWS_OPEN_COMMAND, WINDOWS_FALLBACK_COMMANDS);
+    if (!resolvedPath2) {
+      throw new Error(
+        "Could not find rundll32.exe. Please ensure Windows System32 is accessible or rundll32.exe is available on PATH."
+      );
+    }
     return {
-      command: "cmd",
-      args: ["/c", "start", "", filePath]
+      command: resolvedPath2,
+      args: ["shell32.dll,ShellExec_RunDLL", filePath]
     };
   }
   if (platform === "darwin") {
+    const resolvedPath2 = await resolveBinaryPath(DARWIN_OPEN_COMMAND, DARWIN_FALLBACK_COMMANDS);
+    if (!resolvedPath2) {
+      throw new Error(
+        "Could not find open command. Please ensure macOS is properly configured or open is available on PATH."
+      );
+    }
     return {
-      command: "open",
+      command: resolvedPath2,
       args: [filePath]
     };
   }
+  const resolvedPath = await resolveBinaryPath(UNIX_OPEN_COMMAND, UNIX_FALLBACK_COMMANDS);
+  if (!resolvedPath) {
+    throw new Error(
+      "Could not find xdg-open. Please install xdg-utils or ensure it is in your PATH."
+    );
+  }
   return {
-    command: "xdg-open",
+    command: resolvedPath,
     args: [filePath]
   };
 }
 async function spawnDetached(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn4(command, args, {
+    const child = spawn3(command, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -7494,7 +7801,7 @@ async function spawnDetached(command, args) {
 async function openShareSvgFile(filePath, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const runDetached = deps.spawnDetached ?? spawnDetached;
-  const { command, args } = resolveOpenCommand(filePath, platform);
+  const { command, args } = await resolveOpenCommand(filePath, platform);
   await runDetached(command, args);
 }
 async function writeAndOpenShareSvgFile(fileName, svgContent, deps = {}) {
@@ -7782,7 +8089,7 @@ function resolveTerminalContextLines(optimizeData, options) {
     const bestRow = rowsWithSavings.length > 0 ? rowsWithSavings.reduce(
       (best, current) => (current.savingsUsd ?? Number.NEGATIVE_INFINITY) > (best.savingsUsd ?? Number.NEGATIVE_INFINITY) ? current : best
     ) : void 0;
-    if (!bestRow || bestRow.savingsUsd === void 0) {
+    if (bestRow?.savingsUsd === void 0) {
       lines.push("ALL best candidate: unavailable (missing baseline or candidate pricing)");
     } else if (bestRow.savingsUsd > 0) {
       lines.push(
@@ -9654,7 +9961,7 @@ function registerSharedReportOptions(command, profile) {
   const allowedSourcesLabel = getAllowedSourcesLabel(supportedSourceIds);
   const supportedSourcesSummary = `(${supportedSourceIds.length}): ${allowedSourcesLabel}`;
   const profileConfig = sharedOptionProfileConfig[profile];
-  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(
+  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("--claude-dir <path>", "Path to Claude projects 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
@@ -9669,7 +9976,10 @@ function registerSharedReportOptions(command, profile) {
     "--model <name>",
     "Filter by model (repeatable/comma-separated; exact when exact match exists after source/provider/date filters, otherwise substring)",
     collectRepeatedOption
-  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
+  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option(
+    "--pricing-overrides <path>",
+    "Path to a JSON file of per-model pricing overrides (takes precedence over LiteLLM)"
+  ).option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
     "--ignore-pricing-failures",
     "Continue without estimated costs when pricing cannot be loaded"
   ).option("--json", "Render output as JSON");
@@ -9983,15 +10293,6 @@ var { packageName, packageVersion } = loadPackageMetadataFromRuntime();
 var updateRuntimeConfig = getUpdateNotifierRuntimeConfig();
 var cli = createCli({ version: packageVersion });
 async function main() {
-  if (process.env[UPDATE_CHECK_REFRESH_ENV_VAR] === "1") {
-    await refreshUpdateCheckCache({
-      packageName,
-      currentVersion: packageVersion,
-      cacheTtlMs: updateRuntimeConfig.cacheTtlMs,
-      fetchTimeoutMs: updateRuntimeConfig.fetchTimeoutMs
-    });
-    return;
-  }
   const updateResult = await checkForUpdatesAndMaybeRestart({
     packageName,
     currentVersion: packageVersion,