codetime-cli 0.7.1 → 0.7.3

package/bin/codetime.mjs

@@ -1030,7 +1030,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.7.1" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.7.3" : "0.1.1";
 var DEFAULT_API_URL = "https://codetime.dev";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1046,6 +1046,10 @@ function stringField(object, key) {
   const value = object[key];
   return typeof value === "string" ? value : void 0;
 }
+function nonEmptyStringField(object, key) {
+  const value = stringField(object, key);
+  return value && value.trim().length > 0 ? value : void 0;
+}
 function numberField(object, key) {
   const value = object[key];
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -1291,16 +1295,17 @@ async function parseAmpSessionFile(filePath, options) {
   const messages = Array.isArray(raw.messages) ? raw.messages.filter(isPlainObject) : [];
   const ledger = objectField(raw, "usageLedger");
   const rawEvents = Array.isArray(ledger.events) ? ledger.events.filter(isPlainObject) : [];
+  const state = new SessionParserState(filePath, options, (event) => baseAmpEvent(event));
+  state.sessionId = sessionId;
   if (rawEvents.length === 0) {
-    return [];
+    collectAmpMessageUsage(state, messages, sessionId, threadId, options);
+    return state.events.filter((event) => matchesBackfillFilters(event, options));
   }
   const events = [...rawEvents].sort((a, b) => {
     const ta = timestampFrom(stringField(a, "timestamp")) || "";
     const tb = timestampFrom(stringField(b, "timestamp")) || "";
     return ta.localeCompare(tb);
   });
-  const state = new SessionParserState(filePath, options, (event) => baseAmpEvent(event));
-  state.sessionId = sessionId;
   const firstTs = timestampFrom(stringField(events[0], "timestamp")) || (/* @__PURE__ */ new Date()).toISOString();
   state.ensureSessionStarted(firstTs, 0);
   let lastTs = firstTs;
@@ -1315,7 +1320,7 @@ async function parseAmpSessionFile(filePath, options) {
     const cache = cacheTokensFor(messages, toMessageId);
     const cacheRead = cache.cacheReadInputTokens;
     const cacheWrite = cache.cacheCreationInputTokens;
-    const totalTokens = input + output + cacheRead + cacheWrite;
+    const { billableOutput, totalTokens } = foldAmpTotal(input, output, cacheRead, cacheWrite, numberField(tokens, "total") || 0);
     if (totalTokens <= 0) {
       continue;
     }
@@ -1324,7 +1329,7 @@ async function parseAmpSessionFile(filePath, options) {
     const fromMessageId = numberField(ev, "fromMessageId");
     const metrics = {
       tokensInput: input + cacheRead + cacheWrite || void 0,
-      tokensOutput: output || void 0,
+      tokensOutput: billableOutput || void 0,
       tokensCachedInput: cacheRead + cacheWrite || void 0,
       tokensCacheReadInput: cacheRead || void 0,
       tokensCacheCreationInput: cacheWrite || void 0,
@@ -1367,6 +1372,79 @@ async function parseAmpSessionFile(filePath, options) {
   );
   return state.events.filter((event) => matchesBackfillFilters(event, options));
 }
+function foldAmpTotal(input, output, cacheRead, cacheWrite, explicitTotal) {
+  const partsSum = input + output + cacheRead + cacheWrite;
+  const missing = Math.max(0, explicitTotal - partsSum);
+  return { billableOutput: output + missing, totalTokens: partsSum + missing };
+}
+function collectAmpMessageUsage(state, messages, sessionId, threadId, _options) {
+  const rows = [];
+  for (const message of messages) {
+    if (stringField(message, "role") !== "assistant") {
+      continue;
+    }
+    const usage = objectField(message, "usage");
+    if (Object.keys(usage).length === 0) {
+      continue;
+    }
+    const ts = timestampFrom(stringField(usage, "timestamp")) || timestampFrom(stringField(message, "timestamp"));
+    if (!ts) {
+      continue;
+    }
+    const model = stringField(usage, "model") || stringField(message, "model") || void 0;
+    const input = numberField(usage, "inputTokens") || 0;
+    const output = numberField(usage, "outputTokens") || 0;
+    const cacheWrite = numberField(usage, "cacheCreationInputTokens") || 0;
+    const cacheRead = numberField(usage, "cacheReadInputTokens") || 0;
+    const { billableOutput, totalTokens } = foldAmpTotal(input, output, cacheRead, cacheWrite, numberField(usage, "totalTokens") || 0);
+    if (totalTokens <= 0) {
+      continue;
+    }
+    rows.push({ ts, model, input, billableOutput, cacheRead, cacheWrite, totalTokens });
+  }
+  if (rows.length === 0) {
+    return;
+  }
+  rows.sort((a, b) => a.ts.localeCompare(b.ts));
+  state.ensureSessionStarted(rows[0].ts, 0);
+  let lastTs = rows[0].ts;
+  for (const [index, r] of rows.entries()) {
+    lastTs = r.ts;
+    state.push(
+      baseAmpEvent({
+        ts: r.ts,
+        type: "model.usage",
+        sessionId,
+        model: r.model,
+        confidence: "exact",
+        metrics: {
+          tokensInput: r.input + r.cacheRead + r.cacheWrite || void 0,
+          tokensOutput: r.billableOutput || void 0,
+          tokensCachedInput: r.cacheRead + r.cacheWrite || void 0,
+          tokensCacheReadInput: r.cacheRead || void 0,
+          tokensCacheCreationInput: r.cacheWrite || void 0,
+          tokensTotal: r.totalTokens,
+          modelCalls: 1
+        },
+        refs: stringRefs({ threadId })
+      }),
+      index + 1,
+      "messages",
+      "model.usage"
+    );
+  }
+  state.push(
+    baseAmpEvent({
+      ts: lastTs,
+      type: "session.ended",
+      sessionId,
+      confidence: "derived"
+    }),
+    rows.length,
+    "messages",
+    "session"
+  );
+}
 function baseAmpEvent(event) {
   return {
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -1863,7 +1941,10 @@ async function parseClaudeCodeSessionFile(filePath, options) {
     if (topType !== "assistant") {
       continue;
     }
-    model = stringField(message, "model") || model;
+    const parsedModel = stringField(message, "model");
+    if (parsedModel && parsedModel !== "<synthetic>") {
+      model = parsedModel;
+    }
     const messageId = stringField(message, "id");
     const requestId = stringField(raw, "requestId");
     const usageKey = messageId ? `${messageId}:${requestId}` : null;
@@ -2316,6 +2397,9 @@ async function parseCodexSessionFile(filePath, options) {
   let turnIdAtLastUserMessage;
   let sessionMetaLocked = false;
   let lastTokenUsageKey;
+  const replaySecond = detectSubagentReplaySecond(text, lines);
+  let skipReplay = replaySecond !== void 0;
+  let previousTotals = { input: 0, cached: 0, output: 0, reasoning: 0, total: 0 };
   const pendingToolCalls = /* @__PURE__ */ new Map();
   const turnLastEventAt = /* @__PURE__ */ new Map();
   const turnStartedAt = /* @__PURE__ */ new Map();
@@ -2473,8 +2557,19 @@ async function parseCodexSessionFile(filePath, options) {
         if (tierFromInfo) {
           serviceTier = tierFromInfo.toLowerCase();
         }
-        const usage = tokenUsageFromPayload(payload);
+        const totalUsage = objectField(info, "total_token_usage");
+        const hasTotal = Object.keys(totalUsage).length > 0;
+        const usage = tokenUsageFromPayload(payload) ?? (hasTotal ? codexUsageDelta(totalUsage, previousTotals, info) : void 0);
+        if (hasTotal) {
+          previousTotals = readCodexCumulative(totalUsage);
+        }
         if (usage) {
+          if (skipReplay) {
+            if (ts.slice(0, 19) === replaySecond) {
+              break;
+            }
+            skipReplay = false;
+          }
           const usageKey = [
             usage.tokensInput,
             usage.tokensCachedInput,
@@ -2727,7 +2822,9 @@ function headlessCodexUsage(raw) {
   const billableOutput = output + reasoning;
   return {
     tokensInput: input || void 0,
-    tokensCachedInput: cached || void 0,
+    // Clamp cached to input so non-cached (input - cached) never goes negative
+    // (ccusage cached.min(input) in the headless path too).
+    tokensCachedInput: Math.min(cached, input) || void 0,
     tokensOutput: billableOutput || void 0,
     tokensReasoningOutput: reasoning || void 0,
     tokensTotal: total,
@@ -2755,21 +2852,85 @@ function headlessCodexTimestamp(raw) {
   }
   return void 0;
 }
+function detectSubagentReplaySecond(text, lines) {
+  if (!text.includes("thread_spawn")) {
+    return void 0;
+  }
+  let firstSecond;
+  for (const line of lines) {
+    const raw = parseJsonLine(line);
+    if (!raw || stringField(raw, "type") !== "event_msg") {
+      continue;
+    }
+    const payload = objectField(raw, "payload");
+    if (stringField(payload, "type") !== "token_count") {
+      continue;
+    }
+    const info = objectField(payload, "info");
+    const hasUsage = Object.keys(objectField(info, "last_token_usage")).length > 0 || Object.keys(objectField(info, "total_token_usage")).length > 0;
+    if (!hasUsage) {
+      continue;
+    }
+    const ts = timestampFrom(raw.timestamp) || timestampFrom(payload.timestamp);
+    if (!ts) {
+      continue;
+    }
+    const second = ts.slice(0, 19);
+    if (firstSecond === void 0) {
+      firstSecond = second;
+    } else {
+      return firstSecond === second ? firstSecond : void 0;
+    }
+  }
+  return void 0;
+}
 function tokenUsageFromPayload(payload) {
   const info = objectField(payload, "info");
   const usage = objectField(info, "last_token_usage");
   if (Object.keys(usage).length === 0) {
     return;
   }
+  const input = numberField(usage, "input_tokens");
+  const cached = numberField(usage, "cached_input_tokens");
   return {
-    tokensInput: numberField(usage, "input_tokens"),
-    tokensCachedInput: numberField(usage, "cached_input_tokens"),
+    tokensInput: input,
+    // Cached input can never exceed total input; clamp so the server's
+    // non-cached = input - cached never goes negative (ccusage cached.min(input)).
+    tokensCachedInput: cached === void 0 ? void 0 : Math.min(cached, input ?? 0),
     tokensOutput: numberField(usage, "output_tokens"),
     tokensReasoningOutput: numberField(usage, "reasoning_output_tokens"),
     tokensTotal: numberField(usage, "total_tokens"),
     modelContextWindow: numberField(info, "model_context_window")
   };
 }
+function readCodexCumulative(usage) {
+  return {
+    input: numberField(usage, "input_tokens") ?? 0,
+    cached: numberField(usage, "cached_input_tokens") ?? 0,
+    output: numberField(usage, "output_tokens") ?? 0,
+    reasoning: numberField(usage, "reasoning_output_tokens") ?? 0,
+    total: numberField(usage, "total_tokens") ?? 0
+  };
+}
+function codexUsageDelta(totalUsage, previous, info) {
+  const cur = readCodexCumulative(totalUsage);
+  const input = Math.max(0, cur.input - previous.input);
+  const cached = Math.max(0, cur.cached - previous.cached);
+  const output = Math.max(0, cur.output - previous.output);
+  const reasoning = Math.max(0, cur.reasoning - previous.reasoning);
+  const total = Math.max(0, cur.total - previous.total);
+  if (input === 0 && cached === 0 && output === 0 && reasoning === 0 && total === 0) {
+    return;
+  }
+  return {
+    tokensInput: input || void 0,
+    tokensCachedInput: Math.min(cached, input) || void 0,
+    tokensOutput: output || void 0,
+    tokensReasoningOutput: reasoning || void 0,
+    tokensTotal: total || void 0,
+    modelContextWindow: numberField(info, "model_context_window")
+  };
+}
 function toolNameFromPayload(payload, payloadType) {
   if (payloadType === "web_search_call") {
     return "web_search";
@@ -2996,11 +3157,10 @@ function readStats(record) {
   return void 0;
 }
 function parseJsonRecord(record, fileStem, fallbackTs) {
-  const sessionId = stringField(record, "sessionId") ?? stringField(record, "session_id") ?? fileStem;
+  const sessionId = nonEmptyStringField(record, "sessionId") ?? nonEmptyStringField(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);
+  if (Array.isArray(record.messages)) {
+    const usages = arrayField(record, "messages").filter(isPlainObject).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") {
@@ -3023,7 +3183,7 @@ function parseJsonlRecords(lines, fileStem, fallbackTs) {
     if (!record) {
       continue;
     }
-    const sid = stringField(record, "sessionId") ?? stringField(record, "session_id");
+    const sid = nonEmptyStringField(record, "sessionId") ?? nonEmptyStringField(record, "session_id");
     if (sid) {
       sessionId = sid;
     }
@@ -3036,7 +3196,7 @@ function parseJsonlRecords(lines, fileStem, fallbackTs) {
       if (!usage) {
         continue;
       }
-      const id = stringField(record, "id");
+      const id = nonEmptyStringField(record, "id");
       if (id === void 0) {
         usages.push(usage);
       } else {
@@ -3317,7 +3477,9 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
           const cost = typeof info.cost === "number" && info.cost > 0 ? info.cost : void 0;
+          let messageHadUsage = false;
           if (tokens) {
+            messageHadUsage = true;
             const metrics = {
               tokensInput: tokens.tokensInput,
               tokensOutput: tokens.tokensOutput,
@@ -3438,7 +3600,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
                   }
                 }
               }
-              if (pd.type === "step-finish") {
+              if (pd.type === "step-finish" && !messageHadUsage) {
                 const stepTokens = opencodeUsageFromInfo(pd);
                 const stepCost = typeof pd.cost === "number" && pd.cost > 0 ? pd.cost : void 0;
                 if (stepTokens) {
@@ -3911,7 +4073,11 @@ function piUsageFromMessage(message) {
   const output = numberField(usage, "output") || 0;
   const cacheRead = numberField(usage, "cacheRead") || 0;
   const cacheWrite = numberField(usage, "cacheWrite") || 0;
-  const totalTokens = numberField(usage, "totalTokens") || input + output + cacheRead + cacheWrite;
+  const explicitTotal = numberField(usage, "totalTokens") || 0;
+  const partsSum = input + output + cacheRead + cacheWrite;
+  const missing = Math.max(0, explicitTotal - partsSum);
+  const billableOutput = output + missing;
+  const totalTokens = partsSum + missing;
   if (totalTokens <= 0) {
     return void 0;
   }
@@ -3919,7 +4085,7 @@ function piUsageFromMessage(message) {
   const costUsd = numberField(cost, "total");
   return {
     tokensInput: input + cacheRead + cacheWrite || void 0,
-    tokensOutput: output || void 0,
+    tokensOutput: billableOutput || void 0,
     tokensCachedInput: cacheRead + cacheWrite || void 0,
     tokensCacheReadInput: cacheRead || void 0,
     tokensCacheCreationInput: cacheWrite || void 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codetime-cli",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "codetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to codetime.dev.",
   "license": "MIT",
   "publishConfig": {