codetime-cli 0.3.2 → 0.4.0

package/bin/codetime.mjs

@@ -152,9 +152,9 @@ var init_fs = __esm({
 
 // src/cli.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir3, rm, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, rm, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
 import os3 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -190,6 +190,7 @@ var TELEMETRY_EVENT_TYPES = [
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "opencode", "pi", "amp", "gemini"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -972,7 +973,7 @@ import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import path2 from "node:path";
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.3.2" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.4.0" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -997,6 +998,12 @@ function objectField(object, key) {
   }
   return object[key];
 }
+function arrayField(object, key) {
+  if (!isPlainObject(object) || !Array.isArray(object[key])) {
+    return [];
+  }
+  return object[key];
+}
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1966,7 +1973,7 @@ function fileActivitiesFromClaudeToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromClaudeToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField(input, "edits")) {
+  for (const edit of arrayField2(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -2010,17 +2017,17 @@ function fileMetricsFromClaudeToolInput(tool, input) {
   }
   return {};
 }
-function arrayField(object, key) {
+function arrayField2(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function claudeToolUseItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function claudeToolResultItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isClaudeToolResultMessage(message) {
   return claudeToolResultItems(message).length > 0;
@@ -2223,12 +2230,13 @@ async function parseCodexSessionFile(filePath, options) {
   const text = await readFile4(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const sourcePathHash = `sha256:${createStableHash(filePath)}`;
-  const serviceTier = await resolveCodexServiceTier(filePath);
   const events = [];
   let sessionId = sessionIdFromFilePath(filePath, "codex");
   let cwd;
   let project;
   let model;
+  let sessionStartEmitted = false;
+  let serviceTier;
   let currentTurnId;
   let lastTurnIdForComplete;
   let turnIdAtLastUserMessage;
@@ -2267,6 +2275,7 @@ async function parseCodexSessionFile(filePath, options) {
         model,
         confidence: "exact"
       }, { filePath, sourcePathHash, lineNumber, topType, payloadType: "session_meta", options }));
+      sessionStartEmitted = true;
       continue;
     }
     if (topType === "turn_context") {
@@ -2274,6 +2283,40 @@ async function parseCodexSessionFile(filePath, options) {
       cwd = stringField(payload, "cwd") || cwd;
       project = cwd ? path7.basename(cwd) : project;
       model = stringField(payload, "model") || model;
+      const tier = stringField(payload, "service_tier");
+      if (tier) {
+        serviceTier = tier.toLowerCase();
+      }
+      continue;
+    }
+    if (topType === "turn.completed" || topType === "result" || topType === void 0) {
+      const usage = headlessCodexUsage(raw);
+      if (usage) {
+        const parsedModel = headlessCodexModel(raw);
+        if (parsedModel) {
+          model = parsedModel;
+        }
+        const eventModel = parsedModel || model || "gpt-5";
+        const headlessTs = headlessCodexTimestamp(raw) || ts;
+        if (!sessionStartEmitted) {
+          events.push(withBackfillRefs(baseCodexEvent({
+            ts: headlessTs,
+            type: "session.started",
+            sessionId,
+            model: eventModel,
+            confidence: "derived"
+          }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "session", options }));
+          sessionStartEmitted = true;
+        }
+        events.push(withBackfillRefs(baseCodexEvent({
+          ts: headlessTs,
+          type: "model.usage",
+          sessionId,
+          model: eventModel,
+          confidence: "partial",
+          metrics: usage
+        }), { filePath, sourcePathHash, lineNumber, topType: topType || "result", payloadType: "headless", options }));
+      }
       continue;
     }
     if (topType !== "event_msg" && topType !== "response_item") {
@@ -2333,6 +2376,11 @@ async function parseCodexSessionFile(filePath, options) {
         break;
       }
       case "token_count": {
+        const info = objectField(payload, "info");
+        const tierFromInfo = stringField(info, "service_tier") || stringField(payload, "service_tier");
+        if (tierFromInfo) {
+          serviceTier = tierFromInfo.toLowerCase();
+        }
         const usage = tokenUsageFromPayload(payload);
         if (usage) {
           const usageKey = [
@@ -2545,43 +2593,6 @@ async function parseCodexSessionFile(filePath, options) {
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
-var codexServiceTierCache = /* @__PURE__ */ new Map();
-async function resolveCodexServiceTier(sessionFilePath) {
-  const home = inferCodexHomeFromSessionPath(sessionFilePath);
-  if (!home) {
-    return void 0;
-  }
-  if (!codexServiceTierCache.has(home)) {
-    codexServiceTierCache.set(home, await readCodexServiceTier(home));
-  }
-  return codexServiceTierCache.get(home) ?? void 0;
-}
-function inferCodexHomeFromSessionPath(sessionFilePath) {
-  if (path7.basename(sessionFilePath) === "history.jsonl") {
-    return path7.dirname(sessionFilePath);
-  }
-  let dir = path7.dirname(sessionFilePath);
-  for (let depth = 0; depth < 10; depth += 1) {
-    const parent = path7.dirname(dir);
-    if (parent === dir) {
-      return void 0;
-    }
-    if (path7.basename(dir) === "sessions") {
-      return parent;
-    }
-    dir = parent;
-  }
-  return void 0;
-}
-async function readCodexServiceTier(codexHomePath) {
-  try {
-    const text = await readFile4(path7.join(codexHomePath, "config.toml"), "utf8");
-    const match = text.match(/(?:^|\n)\s*service_tier\s*=\s*["']?([a-z_]+)["']?/i);
-    return match ? match[1].toLowerCase() : null;
-  } catch {
-    return null;
-  }
-}
 function rewriteCodexModelForTier(model, serviceTier) {
   if (!model) {
     return model;
@@ -2598,6 +2609,55 @@ function baseCodexEvent(event) {
     ...event
   };
 }
+function headlessCodexUsage(raw) {
+  const usage = [
+    objectField(raw, "usage"),
+    objectField(objectField(raw, "data"), "usage"),
+    objectField(objectField(raw, "result"), "usage"),
+    objectField(objectField(raw, "response"), "usage")
+  ].find((candidate) => Object.keys(candidate).length > 0);
+  if (!usage) {
+    return;
+  }
+  const input = numberField(usage, "input_tokens") ?? numberField(usage, "prompt_tokens") ?? 0;
+  const output = numberField(usage, "output_tokens") ?? numberField(usage, "completion_tokens") ?? 0;
+  const cached = numberField(usage, "cached_input_tokens") ?? numberField(usage, "cache_read_input_tokens") ?? numberField(usage, "cached_tokens") ?? 0;
+  const reasoning = numberField(usage, "reasoning_output_tokens") ?? numberField(usage, "reasoning_tokens") ?? 0;
+  const totalField = numberField(usage, "total_tokens");
+  const total = totalField !== void 0 && (totalField > 0 || input + output + reasoning === 0) ? totalField : input + output + reasoning;
+  if (input === 0 && cached === 0 && output === 0 && reasoning === 0 && total === 0) {
+    return;
+  }
+  return {
+    tokensInput: input || void 0,
+    tokensCachedInput: cached || void 0,
+    tokensOutput: output || void 0,
+    tokensReasoningOutput: reasoning || void 0,
+    tokensTotal: total,
+    modelCalls: 1
+  };
+}
+function headlessCodexModel(raw) {
+  for (const source of [raw, objectField(raw, "data"), objectField(raw, "result"), objectField(raw, "response")]) {
+    const model = stringField(source, "model") ?? stringField(source, "model_name");
+    if (model) {
+      return model;
+    }
+  }
+  return void 0;
+}
+function headlessCodexTimestamp(raw) {
+  const data = objectField(raw, "data");
+  const result = objectField(raw, "result");
+  const response = objectField(raw, "response");
+  for (const source of [raw, data, result, response]) {
+    const ts = timestampFrom(source.timestamp) ?? timestampFrom(source.created_at) ?? timestampFrom(source.createdAt);
+    if (ts) {
+      return ts;
+    }
+  }
+  return void 0;
+}
 function tokenUsageFromPayload(payload) {
   const info = objectField(payload, "info");
   const usage = objectField(info, "last_token_usage");
@@ -2628,7 +2688,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   for (const key of ["file_path", "path", "notebook_path"]) {
     addResolvedPathActivity(changes, stringField(args, key), operation, ts, cwd, workdir);
   }
-  for (const file of arrayField2(args, "files")) {
+  for (const file of arrayField3(args, "files")) {
     if (typeof file === "string") {
       addResolvedPathActivity(changes, file, operation, ts, cwd, workdir);
     }
@@ -2641,7 +2701,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   }
   return [...changes.values()];
 }
-function arrayField2(object, key) {
+function arrayField3(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
@@ -2726,9 +2786,314 @@ function createCodexAdapter() {
   };
 }
 
+// src/adapters/gemini.ts
+import { readFile as readFile5, stat as stat4 } from "node:fs/promises";
+import path8 from "node:path";
+init_fs();
+function tokenFromKeys(record, keys) {
+  for (const key of keys) {
+    const value = numberField(record, key);
+    if (value !== void 0) {
+      return Math.max(0, Math.trunc(value));
+    }
+  }
+  return 0;
+}
+function parseTokens(value) {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  const totalRaw = numberField(value, "total") ?? numberField(value, "total_tokens");
+  return {
+    input: tokenFromKeys(value, ["input", "prompt", "input_tokens", "prompt_tokens"]),
+    output: tokenFromKeys(value, ["output", "candidates", "output_tokens", "candidates_tokens"]),
+    cached: tokenFromKeys(value, ["cached", "cached_tokens"]),
+    thoughts: tokenFromKeys(value, ["thoughts", "reasoning", "thoughts_tokens", "reasoning_tokens"]),
+    tool: tokenFromKeys(value, ["tool", "tool_tokens"]),
+    total: totalRaw === void 0 ? void 0 : Math.max(0, Math.trunc(totalRaw))
+  };
+}
+function subtractCachedOverlap(tokens) {
+  const cacheRead = tokens.cached;
+  const cachedPortion = Math.min(tokens.input, cacheRead);
+  return [tokens.input - cachedPortion, cacheRead];
+}
+function normalizeSessionInput(tokens) {
+  const inclusive = tokens.input + tokens.output + tokens.thoughts + tokens.tool;
+  const exclusive = inclusive + tokens.cached;
+  if (tokens.cached > 0 && tokens.total === inclusive && tokens.total !== exclusive) {
+    return subtractCachedOverlap(tokens);
+  }
+  return [tokens.input, tokens.cached];
+}
+function buildUsage(model, ts, tokens, normalize, id) {
+  const finalModel = model?.trim();
+  if (!finalModel) {
+    return void 0;
+  }
+  const [inputWithoutCache, cacheRead] = normalize(tokens);
+  const inputTokens = inputWithoutCache + tokens.tool;
+  const totalTokens = tokens.total ?? inputTokens + tokens.output + cacheRead + tokens.thoughts;
+  let output = tokens.output;
+  let reasoning = tokens.thoughts;
+  const known = inputTokens + output + cacheRead + reasoning;
+  const missing = Math.max(0, totalTokens - known);
+  if (missing > 0) {
+    if (output === 0) {
+      output = missing;
+    } else {
+      reasoning += missing;
+    }
+  }
+  if (inputTokens === 0 && output === 0 && cacheRead === 0 && reasoning === 0) {
+    return void 0;
+  }
+  return {
+    ts,
+    model: finalModel,
+    // codetime convention: tokensInput is cache-inclusive (see amp adapter).
+    tokensInput: inputTokens + cacheRead,
+    tokensOutput: output,
+    tokensCacheRead: cacheRead,
+    tokensReasoning: reasoning,
+    tokensTotal: totalTokens,
+    id
+  };
+}
+function parseDirectEvent(record, modelHint, fallbackTs) {
+  const tokens = parseTokens(record.tokens);
+  if (!tokens) {
+    return void 0;
+  }
+  const ts = timestampFrom(stringField(record, "timestamp")) ?? timestampFrom(stringField(record, "created_at")) ?? fallbackTs;
+  const model = stringField(record, "model") ?? modelHint;
+  return buildUsage(model, ts, tokens, normalizeSessionInput, stringField(record, "id"));
+}
+function parseStatsEvents(stats, modelHint, ts) {
+  if (!isPlainObject(stats)) {
+    return [];
+  }
+  const models = objectField(stats, "models");
+  const perModel = Object.entries(models).filter((entry) => isPlainObject(entry[1])).map(([model, data]) => {
+    const tokens2 = parseTokens(data.tokens);
+    return tokens2 ? buildUsage(model, ts, tokens2, subtractCachedOverlap, void 0) : void 0;
+  }).filter((usage2) => usage2 !== void 0);
+  if (perModel.length > 0) {
+    return perModel;
+  }
+  const tokens = parseTokens(stats);
+  if (!tokens) {
+    return [];
+  }
+  const usage = buildUsage(modelHint ?? "unknown", ts, tokens, subtractCachedOverlap, void 0);
+  return usage ? [usage] : [];
+}
+function readStats(record) {
+  if (isPlainObject(record.stats)) {
+    return record.stats;
+  }
+  const result = record.result;
+  if (isPlainObject(result) && isPlainObject(result.stats)) {
+    return result.stats;
+  }
+  return void 0;
+}
+function parseJsonRecord(record, fileStem, fallbackTs) {
+  const sessionId = stringField(record, "sessionId") ?? stringField(record, "session_id") ?? fileStem;
+  const sessionTs = timestampFrom(stringField(record, "startTime")) ?? timestampFrom(stringField(record, "lastUpdated")) ?? fallbackTs;
+  const messages = arrayField(record, "messages").filter(isPlainObject);
+  if (messages.length > 0) {
+    const usages = messages.filter((message) => stringField(message, "type") === "gemini").map((message) => parseDirectEvent(message, void 0, sessionTs)).filter((usage) => usage !== void 0);
+    return { sessionId, usages };
+  }
+  if (stringField(record, "type") === "gemini") {
+    const usage = parseDirectEvent(record, void 0, fallbackTs);
+    return { sessionId, usages: usage ? [usage] : [] };
+  }
+  const statsTs = timestampFrom(stringField(record, "timestamp")) ?? fallbackTs;
+  return {
+    sessionId,
+    usages: parseStatsEvents(readStats(record), stringField(record, "model"), statsTs)
+  };
+}
+function parseJsonlRecords(lines, fileStem, fallbackTs) {
+  let sessionId = fileStem;
+  let currentModel;
+  const usages = [];
+  const directIndexes = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const record = parseJsonLine(line);
+    if (!record) {
+      continue;
+    }
+    const sid = stringField(record, "sessionId") ?? stringField(record, "session_id");
+    if (sid) {
+      sessionId = sid;
+    }
+    const model = stringField(record, "model");
+    if (model) {
+      currentModel = model;
+    }
+    if (stringField(record, "type") === "gemini") {
+      const usage = parseDirectEvent(record, currentModel, fallbackTs);
+      if (!usage) {
+        continue;
+      }
+      const id = stringField(record, "id");
+      if (id === void 0) {
+        usages.push(usage);
+      } else {
+        const existing = directIndexes.get(id);
+        if (existing === void 0) {
+          directIndexes.set(id, usages.length);
+          usages.push(usage);
+        } else {
+          usages[existing] = usage;
+        }
+      }
+      continue;
+    }
+    const stats = readStats(record);
+    if (stats !== void 0) {
+      const statsTs = timestampFrom(stringField(record, "timestamp")) ?? fallbackTs;
+      usages.push(...parseStatsEvents(stats, currentModel, statsTs));
+    }
+  }
+  return { sessionId, usages };
+}
+async function parseGeminiSessionFile(filePath, options) {
+  const text = await readFile5(filePath, "utf8");
+  const fileStem = path8.basename(filePath).replace(/\.jsonl?$/, "");
+  const info = await stat4(filePath);
+  const fallbackTs = info.mtime.toISOString();
+  let parsed;
+  if (filePath.endsWith(".jsonl")) {
+    parsed = parseJsonlRecords(text.split("\n"), fileStem, fallbackTs);
+  } else {
+    let raw;
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      return [];
+    }
+    if (!isPlainObject(raw)) {
+      return [];
+    }
+    parsed = parseJsonRecord(raw, fileStem, fallbackTs);
+  }
+  if (parsed.usages.length === 0) {
+    return [];
+  }
+  const usages = parsed.usages.sort((a, b) => a.ts.localeCompare(b.ts));
+  const sessionId = `gemini_${parsed.sessionId}`;
+  const state = new SessionParserState(filePath, options, (event) => baseGeminiEvent(event));
+  state.sessionId = sessionId;
+  state.ensureSessionStarted(usages[0].ts, 0);
+  let lastTs = usages[0].ts;
+  for (const [index, usage] of usages.entries()) {
+    lastTs = usage.ts;
+    const metrics = {
+      tokensInput: usage.tokensInput || void 0,
+      tokensOutput: usage.tokensOutput || void 0,
+      tokensCachedInput: usage.tokensCacheRead || void 0,
+      tokensCacheReadInput: usage.tokensCacheRead || void 0,
+      tokensReasoningOutput: usage.tokensReasoning || void 0,
+      tokensTotal: usage.tokensTotal,
+      modelCalls: 1
+    };
+    state.push(
+      baseGeminiEvent({
+        ts: usage.ts,
+        type: "model.usage",
+        sessionId,
+        model: usage.model,
+        confidence: "exact",
+        metrics,
+        refs: stringRefs({ messageId: usage.id })
+      }),
+      index + 1,
+      "jsonl",
+      "model.usage"
+    );
+  }
+  state.push(
+    baseGeminiEvent({
+      ts: lastTs,
+      type: "session.ended",
+      sessionId,
+      confidence: "derived"
+    }),
+    usages.length,
+    "jsonl",
+    "session"
+  );
+  return state.events.filter((event) => matchesBackfillFilters(event, options));
+}
+function baseGeminiEvent(event) {
+  return {
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: "gemini",
+    agent: "gemini",
+    // Gemini logs carry no cwd/project metadata; pin all events to a stable
+    // synthetic workspace so downstream rollups keep them grouped together.
+    workspaceId: createWorkspaceId({ projectName: "gemini" }),
+    ...event
+  };
+}
+function geminiDataDirs(home, env) {
+  const override = env?.GEMINI_DATA_DIR;
+  if (override && override.trim()) {
+    return override.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => path8.resolve(entry));
+  }
+  return [path8.join(home, ".gemini", "tmp")];
+}
+async function geminiBackfillFiles(sourceRoot, home, env) {
+  const roots = sourceRoot ? [path8.resolve(sourceRoot)] : geminiDataDirs(home, env);
+  const fileLists = await Promise.all(
+    roots.map((root) => listFilesByExtensions(root, [".json", ".jsonl"]))
+  );
+  const files = fileLists.flat().sort();
+  return Promise.all(files.map(async (filePath) => {
+    const info = await stat4(filePath);
+    return { path: filePath, modifiedAt: info.mtime.toISOString() };
+  }));
+}
+function createGeminiAdapter() {
+  return {
+    id: "gemini",
+    label: "Gemini CLI",
+    agentName: "gemini",
+    kind: "agent",
+    detectPath(home, env) {
+      return geminiDataDirs(home, env)[0];
+    },
+    // Gemini has no plugin/hook surface, so there is nothing for codetime to
+    // "install". Report installed = true whenever a data dir is on disk so
+    // `detect` accurately shows "already covered via backfill".
+    installedPath(home, env) {
+      return geminiDataDirs(home, env)[0];
+    },
+    async isInstalled(home, env) {
+      for (const dir of geminiDataDirs(home, env)) {
+        if (await pathExists(dir).catch(() => false)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    installEntries() {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return geminiDataDirs(home, env);
+    },
+    parseSessionFile: parseGeminiSessionFile
+  };
+}
+
 // src/adapters/opencode.ts
 import os2 from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -2759,7 +3124,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
     for (const session of sessions) {
       const sessionId = session.id;
       const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path8.basename(cwd) : void 0;
+      const project = cwd ? path9.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -2849,7 +3214,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const assistantAgent = stringField(info, "agent") || "opencode";
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path8.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path9.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -3091,33 +3456,33 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path8.resolve(override);
+    return path9.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path8.join(path8.resolve(xdgConfig), "opencode");
+    return path9.join(path9.resolve(xdgConfig), "opencode");
   }
-  return path8.join(home, ".config", "opencode");
+  return path9.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  const primary = xdgData && xdgData.trim() ? path8.join(path8.resolve(xdgData), "opencode", "opencode.db") : path8.join(home, ".local", "share", "opencode", "opencode.db");
-  return [primary, path8.join(home, ".opencode", "opencode.db")];
+  const primary = xdgData && xdgData.trim() ? path9.join(path9.resolve(xdgData), "opencode", "opencode.db") : path9.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path9.join(home, ".opencode", "opencode.db")];
 }
 async function opencodeBackfillFiles(sourceRoot, home = os2.homedir(), env) {
-  const { stat: stat6 } = await import("node:fs/promises");
+  const { stat: stat7 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat6(sourceRoot).catch(() => null);
+    const info = await stat7(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of opencodeDataCandidates(home, env)) {
-    const info = await stat6(candidatePath).catch(() => null);
+    const info = await stat7(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -3180,12 +3545,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path8.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path9.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path8.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path8.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path9.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path9.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -3193,7 +3558,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path8.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path9.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -3205,10 +3570,10 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import path9 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path10 from "node:path";
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile5(filePath, "utf8");
+  const text = await readFile6(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -3237,7 +3602,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path9.basename(cwd) : project;
+      project = cwd ? path10.basename(cwd) : project;
       continue;
     }
     if (entryType === "model_change") {
@@ -3635,16 +4000,16 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path9.resolve(override);
+    return path10.resolve(override);
   }
-  return path9.join(home, ".pi", "agent");
+  return path10.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path9.resolve(override);
+    return path10.resolve(override);
   }
-  return path9.join(piAgentDir(home, env), "sessions");
+  return path10.join(piAgentDir(home, env), "sessions");
 }
 function createPiAdapter() {
   return {
@@ -3656,12 +4021,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path9.join(piAgentDir(home, env), "extensions", "codetime.ts");
+      return path10.join(piAgentDir(home, env), "extensions", "codetime.ts");
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path9.join(piAgentDir(home, env), "extensions", "codetime.ts"));
+        return await pathExists2(path10.join(piAgentDir(home, env), "extensions", "codetime.ts"));
       } catch {
         return false;
       }
@@ -3669,7 +4034,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path9.join(piAgentDir(home, env), "extensions", "codetime.ts"),
+        path: path10.join(piAgentDir(home, env), "extensions", "codetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -4102,15 +4467,15 @@ function hookCommandFromGroup(group) {
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 function configDir(home = homedir()) {
-  return path10.join(home, ".codetime");
+  return path11.join(home, ".codetime");
 }
 function configPath(home = homedir()) {
-  return path10.join(configDir(home), "config.json");
+  return path11.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path10.join(configDir(home), "machine-id");
+  return path11.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -4157,15 +4522,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir2, rename, stat as stat4 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir2, rename, stat as stat5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path11.join(home, ".codetime", "logs");
+  return path12.join(home, ".codetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path11.join(logDir(home), name);
+  return path12.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -4175,7 +4540,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat4(file);
+    const info = await stat5(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -4340,8 +4705,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path13) {
-  return new URL(path13, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path14) {
+  return new URL(path14, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -4406,7 +4771,7 @@ async function deleteMachine(remote, id) {
 }
 
 // src/lib/types.ts
-var BACKFILL_STATE_SCHEMA_VERSION = 3;
+var BACKFILL_STATE_SCHEMA_VERSION = 4;
 
 // src/cli.ts
 function createRegistry() {
@@ -4416,6 +4781,7 @@ function createRegistry() {
   registry.register(createPiAdapter());
   registry.register(createOpenCodeAdapter());
   registry.register(createAmpAdapter());
+  registry.register(createGeminiAdapter());
   return registry;
 }
 var defaultContext = {
@@ -4676,7 +5042,7 @@ async function backfillCommand(options, ctx, registry) {
   }
   if (action === "import" && !options["dry-run"]) {
     const requested = normalizeBackfillSource(stringOption(options.source) || "all");
-    const supported = /* @__PURE__ */ new Set(["all", "codex", "claude-code", "opencode", "pi", "amp"]);
+    const supported = /* @__PURE__ */ new Set(["all", ...BACKFILL_SOURCE_IDS]);
     if (!supported.has(requested)) {
       write(ctx.stderr, `Unsupported backfill source: ${requested}
 `);
@@ -4821,11 +5187,14 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "amp") {
     return ampBackfillFiles(stringOption(options["source-root"]), resolveHome(options, ctx), ctx.env);
   }
+  if (source.id === "gemini") {
+    return geminiBackfillFiles(stringOption(options["source-root"]), resolveHome(options, ctx), ctx.env);
+  }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat5(filePath);
+    const info = await stat6(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -4901,7 +5270,7 @@ function writeBackfillPlan(plan, options, ctx) {
 }
 async function importBackfillPlan(plan, options, ctx, registry) {
   const source = normalizeBackfillSource(stringOption(options.source) || "all");
-  const supportedSources = /* @__PURE__ */ new Set(["codex", "claude-code", "opencode", "pi", "amp"]);
+  const supportedSources = new Set(BACKFILL_SOURCE_IDS);
   const home = resolveHome(options, ctx);
   if (source !== "all" && !supportedSources.has(source)) {
     write(ctx.stderr, `Unsupported backfill source: ${source}
@@ -5134,13 +5503,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path12.join(home, ".codetime", "backfill-state.json");
+  return path13.join(home, ".codetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path12.join(home, ".codetime", "sync-local-trigger.json");
+  return path13.join(home, ".codetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path12.join(home, ".codetime", "sync-local-trigger.lock");
+  return path13.join(home, ".codetime", "sync-local-trigger.lock");
 }
 async function readBackfillIncrementalState(home, ctx) {
   const statePath = backfillIncrementalStatePath(home);
@@ -5163,7 +5532,7 @@ async function readBackfillIncrementalState(home, ctx) {
     return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
   }
   const sources = {};
-  for (const source of ["codex", "claude-code", "opencode", "pi", "amp"]) {
+  for (const source of BACKFILL_SOURCE_IDS) {
     const item = state.sources[source];
     if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
       sources[source] = { watermarkTs: item.watermarkTs };
@@ -5180,7 +5549,7 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     state.sources[source] = { watermarkTs: latest };
   }
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir3(path12.dirname(statePath), { recursive: true });
+  await mkdir3(path13.dirname(statePath), { recursive: true });
   await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -5208,7 +5577,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir3(path12.dirname(statePath), { recursive: true });
+  await mkdir3(path13.dirname(statePath), { recursive: true });
   await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -5223,7 +5592,7 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir3(path12.dirname(lockPath), { recursive: true });
+  await mkdir3(path13.dirname(lockPath), { recursive: true });
   await writeFile2(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
@@ -5283,10 +5652,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path12.resolve(path12.dirname(cliPath), "../bin/codetime.mjs")];
+  return [path13.resolve(path13.dirname(cliPath), "../bin/codetime.mjs")];
 }
 function resolveHome(options, ctx) {
-  return path12.resolve(stringOption(options.home) || ctx.env.HOME || os3.homedir());
+  return path13.resolve(stringOption(options.home) || ctx.env.HOME || os3.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codetime-cli",
   "type": "module",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {
@@ -35,7 +35,7 @@
   "devDependencies": {
     "cac": "^7.0.0",
     "esbuild": "^0.28.0",
-    "@codetime/shared": "0.3.2"
+    "@codetime/shared": "0.4.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",