tokentracker-cli 0.17.2 → 0.18.1

package/src/lib/rollout.js

@@ -6131,6 +6131,372 @@ async function parseGrokBuildIncremental({
   };
 }
 
+function resolveAntigravityBrainDirs(geminiHome) {
+  if (!geminiHome || typeof geminiHome !== "string") return [];
+  return [
+    path.join(geminiHome, "antigravity", "brain"),
+    path.join(geminiHome, "antigravity-ide", "brain"),
+    path.join(geminiHome, "antigravity-cli", "brain"),
+  ];
+}
+
+async function listAntigravitySessionFiles(brainDir) {
+  const out = [];
+  if (!brainDir || typeof brainDir !== "string") return out;
+  const entries = await safeReadDir(brainDir).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const logsDir = path.join(brainDir, entry.name, ".system_generated", "logs");
+    const transcriptPath = path.join(logsDir, "transcript.jsonl");
+    const st = await fs.stat(transcriptPath).catch(() => null);
+    if (st && st.isFile()) {
+      out.push(transcriptPath);
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
+async function listAntigravityTranscripts(geminiHome) {
+  const dirs = resolveAntigravityBrainDirs(geminiHome);
+  const lists = await Promise.all(dirs.map((dir) => listAntigravitySessionFiles(dir)));
+  return lists.flat();
+}
+
+async function parseAntigravityIncremental({
+  sessionFiles,
+  cursors,
+  queuePath,
+  projectQueuePath,
+  onProgress,
+  source,
+  publicRepoResolver,
+}) {
+  await ensureDir(path.dirname(queuePath));
+  let filesProcessed = 0;
+  let eventsAggregated = 0;
+
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
+  const totalFiles = files.length;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
+  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
+  const projectTouchedBuckets = projectEnabled ? new Set() : null;
+  const projectMetaCache = projectEnabled ? new Map() : null;
+  const publicRepoCache = projectEnabled ? new Map() : null;
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || "antigravity";
+
+  if (!cursors.files || typeof cursors.files !== "object") {
+    cursors.files = {};
+  }
+
+  for (let idx = 0; idx < files.length; idx++) {
+    const entry = files[idx];
+    const filePath = typeof entry === "string" ? entry : entry?.path;
+    if (!filePath) continue;
+    const fileSource =
+      typeof entry === "string"
+        ? defaultSource
+        : normalizeSourceInput(entry?.source) || defaultSource;
+    const st = await fs.stat(filePath).catch(() => null);
+    if (!st || !st.isFile()) continue;
+
+    const key = filePath;
+    const prev = cursors.files[key] || null;
+    const inode = st.ino || 0;
+    const size = Number.isFinite(st.size) ? st.size : 0;
+    const mtimeMs = Number.isFinite(st.mtimeMs) ? st.mtimeMs : 0;
+
+    const unchanged =
+      prev && prev.inode === inode && prev.size === size && prev.mtimeMs === mtimeMs;
+    if (unchanged) {
+      filesProcessed += 1;
+      if (cb) {
+        cb({
+          index: idx + 1,
+          total: totalFiles,
+          filePath,
+          filesProcessed,
+          eventsAggregated,
+          bucketsQueued: touchedBuckets.size,
+        });
+      }
+      continue;
+    }
+
+    const sameFile = prev && prev.inode === inode;
+    const lastLine = sameFile ? Number(prev.lastLine || 0) : 0;
+    const initialContextTokens = sameFile ? Number(prev.contextTokens || 0) : 0;
+    const initialModel = sameFile && typeof prev.currentModel === "string" ? prev.currentModel : null;
+
+    const projectContext = projectEnabled
+      ? await resolveProjectContextForFile({
+          filePath,
+          projectMetaCache,
+          publicRepoCache,
+          publicRepoResolver,
+          projectState,
+        })
+      : null;
+    const projectRef = projectContext?.projectRef || null;
+    const projectKey = projectContext?.projectKey || null;
+
+    const result = await parseAntigravityFile({
+      filePath,
+      lastLine,
+      initialContextTokens,
+      initialModel,
+      hourlyState,
+      touchedBuckets,
+      source: fileSource,
+      projectState,
+      projectTouchedBuckets,
+      projectRef,
+      projectKey,
+    });
+
+    cursors.files[key] = {
+      inode,
+      size,
+      mtimeMs,
+      lastLine: result.lastLine,
+      contextTokens: result.contextTokens,
+      currentModel: result.currentModel,
+      updatedAt: new Date().toISOString(),
+    };
+
+    filesProcessed += 1;
+    eventsAggregated += result.eventsAggregated;
+
+    if (cb) {
+      cb({
+        index: idx + 1,
+        total: totalFiles,
+        filePath,
+        filesProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size,
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const projectBucketsQueued = projectEnabled
+    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
+    : 0;
+  hourlyState.updatedAt = new Date().toISOString();
+  cursors.hourly = hourlyState;
+  if (projectState) {
+    projectState.updatedAt = new Date().toISOString();
+    cursors.projectHourly = projectState;
+  }
+
+  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+}
+
+async function parseAntigravityFile({
+  filePath,
+  lastLine,
+  initialContextTokens,
+  initialModel,
+  hourlyState,
+  touchedBuckets,
+  source,
+  projectState,
+  projectTouchedBuckets,
+  projectRef,
+  projectKey,
+}) {
+  const raw = await fs.readFile(filePath, "utf8").catch(() => "");
+  if (!raw.trim()) {
+    return { lastLine: 0, eventsAggregated: 0, contextTokens: 0, currentModel: null };
+  }
+
+  const lines = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  let eventsAggregated = 0;
+  // Resume cached context-token total + model so historical lines (i < lastLine)
+  // don't need to be re-tokenized on every sync. Falls back to a full re-walk
+  // when the cached state is missing (legacy cursor) or the file rotated.
+  const canResume =
+    Number.isFinite(lastLine) && lastLine > 0 && lastLine <= lines.length;
+  const cachedTokens = Number.isFinite(initialContextTokens) ? initialContextTokens : 0;
+  const cachedModel = typeof initialModel === "string" ? initialModel : null;
+  const resumed = canResume && (cachedTokens > 0 || cachedModel !== null);
+  const scanStart = resumed ? lastLine : 0;
+  let currentModel = resumed ? cachedModel : null;
+  let contextTokens = resumed ? cachedTokens : 0;
+  let lastCompletedLine = Math.min(Number.isFinite(lastLine) ? lastLine : 0, lines.length);
+
+  for (let i = scanStart; i < lines.length; i++) {
+    const line = lines[i];
+
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (_e) {
+      if (i >= lastLine) break;
+      continue;
+    }
+
+    const isNewEvent = i >= lastLine;
+
+    if (parsed.type === "USER_INPUT" || parsed.type === "USER_SETTINGS_CHANGE") {
+      const content = typeof parsed.content === "string" ? parsed.content : "";
+      const model = parseAntigravityModelSelection(content);
+      if (model) currentModel = model;
+    }
+
+    const eventContextTokens = antigravityContextTokens(parsed);
+
+    if (!isNewEvent) {
+      contextTokens += eventContextTokens;
+      lastCompletedLine = i + 1;
+      continue;
+    }
+
+    const timestamp = parsed.created_at;
+    if (!timestamp) {
+      contextTokens += eventContextTokens;
+      lastCompletedLine = i + 1;
+      continue;
+    }
+
+    const bucketStart = toUtcHalfHourStart(timestamp);
+    if (!bucketStart) {
+      contextTokens += eventContextTokens;
+      lastCompletedLine = i + 1;
+      continue;
+    }
+
+    let model = currentModel || "antigravity-unknown";
+    let delta = initTotals();
+
+    if (parsed.type === "PLANNER_RESPONSE") {
+      const content = typeof parsed.content === "string" ? parsed.content : "";
+      const thinking = typeof parsed.thinking === "string" ? parsed.thinking : "";
+
+      delta.input_tokens = contextTokens;
+      delta.output_tokens =
+        antigravityValueTokens(content) + antigravityValueTokens(parsed.tool_calls);
+      delta.reasoning_output_tokens = antigravityValueTokens(thinking);
+      delta.total_tokens =
+        delta.input_tokens + delta.output_tokens + delta.reasoning_output_tokens;
+      delta.billable_total_tokens = delta.total_tokens;
+      delta.conversation_count = 1;
+    }
+
+    if (delta.total_tokens === 0) {
+      contextTokens += eventContextTokens;
+      lastCompletedLine = i + 1;
+      continue;
+    }
+
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+    addTotals(bucket.totals, delta);
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
+
+    if (projectKey && projectState && projectTouchedBuckets) {
+      const projectBucket = getProjectBucket(
+        projectState,
+        projectKey,
+        source,
+        bucketStart,
+        projectRef,
+      );
+      addTotals(projectBucket.totals, delta);
+      projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+    }
+    eventsAggregated += 1;
+    contextTokens += eventContextTokens;
+    lastCompletedLine = i + 1;
+  }
+
+  return {
+    lastLine: lastCompletedLine,
+    eventsAggregated,
+    contextTokens,
+    currentModel,
+  };
+}
+
+function parseAntigravityModelSelection(content) {
+  if (typeof content !== "string" || !content) return null;
+  const match = content.match(
+    /changed setting `Model Selection` from .*? to ([^`\n]+?)(?:\s*\([^)]*\))?\.(?:\s+|$)/i,
+  );
+  if (!match) return null;
+  return normalizeAntigravityTranscriptModel(match[1]);
+}
+
+function normalizeAntigravityTranscriptModel(modelName) {
+  if (!modelName || typeof modelName !== "string") return null;
+  let slug = modelName
+    .trim()
+    .replace(/\([^)]*\)/g, " ")
+    .replace(/\b(thinking|xhigh|high|medium|low|fast)\b/gi, " ")
+    .toLowerCase()
+    .replace(/[^a-z0-9.]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-");
+  if (!slug) return null;
+
+  for (const marker of ["gemini", "claude", "gpt"]) {
+    const idx = slug.indexOf(marker);
+    if (idx >= 0) {
+      slug = slug.slice(idx);
+      break;
+    }
+  }
+  if (/^(gemini|claude|gpt)-/.test(slug)) return slug;
+  return `antigravity-${slug}`;
+}
+
+function antigravityContextTokens(event) {
+  if (!event || typeof event !== "object") return 0;
+  let tokens = antigravityValueTokens(event.content);
+  if (event.type === "PLANNER_RESPONSE" && event.tool_calls) {
+    tokens += antigravityValueTokens(event.tool_calls);
+  }
+  return tokens;
+}
+
+function antigravityValueTokens(value) {
+  if (typeof value === "string") return estimateAntigravityTokens(value);
+  if (value == null) return 0;
+  try {
+    return estimateAntigravityTokens(JSON.stringify(value));
+  } catch (_e) {
+    return 0;
+  }
+}
+
+function estimateAntigravityTokens(text) {
+  if (typeof text !== "string" || text.length === 0) return 0;
+  let cjk = 0;
+  let other = 0;
+  for (const ch of text) {
+    if (isCjkCodePoint(ch.codePointAt(0))) {
+      cjk += 1;
+    } else {
+      other += 1;
+    }
+  }
+  return cjk + Math.ceil(other / 4);
+}
+
+function isCjkCodePoint(code) {
+  return (
+    (code >= 0x3400 && code <= 0x4dbf) ||
+    (code >= 0x4e00 && code <= 0x9fff) ||
+    (code >= 0x3040 && code <= 0x30ff)
+  );
+}
+
 module.exports = {
   listRolloutFiles,
   listClaudeProjectFiles,
@@ -6200,4 +6566,12 @@ module.exports = {
   resolveGrokBuildHome,
   resolveGrokBuildSessions,
   parseGrokBuildIncremental,
+
+  // Antigravity (Google Gemini) - Session logs parser
+  resolveAntigravityBrainDirs,
+  listAntigravitySessionFiles,
+  listAntigravityTranscripts,
+  parseAntigravityIncremental,
+  estimateAntigravityTokens,
+  isCjkCodePoint,
 };

package/src/lib/usage-limits.js

@@ -1129,11 +1129,12 @@ function parseProcessLine(line) {
 
 function isAntigravityCommandLine(command) {
   const lower = String(command || "").toLowerCase();
-  return lower.includes("language_server_macos")
+  return lower.includes("language_server")
     && (
       (lower.includes("--app_data_dir") && lower.includes("antigravity"))
       || lower.includes("/antigravity/")
       || lower.includes("\\antigravity\\")
+      || lower.includes("--override_ide_name antigravity")
     );
 }