tokentracker-cli 0.64.2 → 0.64.3

package/src/lib/project-usage-purge.js

@@ -8,9 +8,10 @@ async function purgeProjectUsage({
   projectQueuePath,
   projectQueueStatePath,
   projectState,
+  cursors,
 }) {
   if (!projectKey || !projectQueuePath || !projectQueueStatePath || !projectState) {
-    return { removed: 0, kept: 0, removedBuckets: 0 };
+    return { removed: 0, kept: 0, removedBuckets: 0, removedProjectCursors: 0 };
   }
 
   let previousOffset = 0;
@@ -37,6 +38,16 @@ async function purgeProjectUsage({
   }
   projectState.buckets = buckets;
 
+  let removedProjectCursors = 0;
+  const files = cursors?.files && typeof cursors.files === "object" ? cursors.files : {};
+  for (const cursor of Object.values(files)) {
+    if (!cursor || typeof cursor !== "object") continue;
+    if (cursor.project?.projectKey === projectKey) {
+      delete cursor.project;
+      removedProjectCursors += 1;
+    }
+  }
+
   let removed = 0;
   let kept = 0;
   let nextOffset = 0;
@@ -100,7 +111,7 @@ async function purgeProjectUsage({
 
   await fsp.writeFile(projectQueueStatePath, JSON.stringify({ offset: nextOffset }), "utf8");
 
-  return { removed, kept, removedBuckets };
+  return { removed, kept, removedBuckets, removedProjectCursors };
 }
 
 module.exports = { purgeProjectUsage };

package/src/lib/rollout.js

@@ -290,7 +290,32 @@ async function parseClaudeIncremental({
     const truncated = sameInode && prevOffset > st.size;
     const startOffset = sameInode && !truncated ? prevOffset : 0;
 
-    if (!projectEnabled && sameInode && !truncated && startOffset >= st.size) {
+    // Claude's launch cwd is fixed for a session file's lifetime, so once
+    // resolved (found, or confirmed absent) from content it never needs
+    // re-extracting. Cache it — and the resolved project's git-config
+    // freshness fingerprint — on the cursor so idle files with project
+    // tracking enabled don't re-walk the filesystem on every sync.
+    //
+    // "No cwd found" / "cwd not inside a git checkout" only count as settled
+    // for genuinely idle files (no new bytes) — there's nothing new to
+    // attribute either way. A file that's still growing gets retried: an
+    // early sync can catch a session file before its cwd-bearing line lands,
+    // and treating that as permanent would silently drop the rest of the
+    // session's usage from the project queue.
+    const idle = sameInode && !truncated && startOffset >= st.size;
+    const cachedCwd = sameInode && !truncated ? prev?.claudeCwd : undefined;
+    const cachedProjectFileContext =
+      sameInode && !truncated ? prev?.projectFileContext || null : null;
+    const cachedContextAbsent = cachedProjectFileContext?.absent === true;
+    const projectContextFresh =
+      projectEnabled && cachedProjectFileContext && !cachedContextAbsent
+        ? await isProjectFileContextFresh(cachedProjectFileContext)
+        : false;
+    const projectKnownAbsent = cachedCwd === null || cachedContextAbsent;
+    const projectSettled =
+      !projectEnabled || (idle && projectKnownAbsent) || projectContextFresh;
+
+    if (idle && projectSettled) {
       if (cb) {
         cb({
           index: idx + 1,
@@ -304,17 +329,32 @@ async function parseClaudeIncremental({
       continue;
     }
 
-    const projectContext = projectEnabled
-      ? await resolveProjectContextForFile({
-          filePath,
+    let projectRef = sameInode && !truncated ? prev?.projectRef || null : null;
+    let projectKey = sameInode && !truncated ? prev?.projectKey || null : null;
+    let nextCwd = cachedCwd;
+    let nextProjectFileContext = cachedProjectFileContext;
+
+    if (projectEnabled && !projectSettled) {
+      if (nextCwd === undefined || nextCwd === null) {
+        nextCwd = await resolveClaudeFileCwd(filePath);
+      }
+      if (nextCwd) {
+        const projectContext = await resolveProjectContextForPath({
+          startDir: nextCwd,
           projectMetaCache,
           publicRepoCache,
           publicRepoResolver,
           projectState,
-        })
-      : null;
-    const projectRef = projectContext?.projectRef || null;
-    const projectKey = projectContext?.projectKey || null;
+        });
+        projectRef = projectContext?.projectRef || null;
+        projectKey = projectContext?.projectKey || null;
+        nextProjectFileContext = buildProjectFileContext(projectContext);
+      } else {
+        projectRef = null;
+        projectKey = null;
+        nextProjectFileContext = { absent: true };
+      }
+    }
 
     const result = await parseClaudeFile({
       filePath,
@@ -334,6 +374,14 @@ async function parseClaudeIncremental({
       inode,
       offset: result.endOffset,
       updatedAt: new Date().toISOString(),
+      ...(projectEnabled
+        ? {
+            claudeCwd: nextCwd === undefined ? null : nextCwd,
+            projectFileContext: nextProjectFileContext,
+            projectRef,
+            projectKey,
+          }
+        : {}),
     };
 
     filesProcessed += 1;
@@ -412,6 +460,26 @@ async function parseGeminiIncremental({
     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 sameFileMetadata =
+      prev &&
+      prev.inode === inode &&
+      prev.size === size &&
+      prev.mtimeMs === mtimeMs;
+    if (!projectEnabled && sameFileMetadata) {
+      if (cb) {
+        cb({
+          index: idx + 1,
+          total: totalFiles,
+          filePath,
+          filesProcessed,
+          eventsAggregated,
+          bucketsQueued: touchedBuckets.size,
+        });
+      }
+      continue;
+    }
     let startIndex = prev && prev.inode === inode ? Number(prev.lastIndex || -1) : -1;
     let lastTotals = prev && prev.inode === inode ? prev.lastTotals || null : null;
     let lastModel = prev && prev.inode === inode ? prev.lastModel || null : null;
@@ -427,12 +495,38 @@ async function parseGeminiIncremental({
       : null;
     const projectRef = projectContext?.projectRef || null;
     const projectKey = projectContext?.projectKey || null;
+    const projectCursor =
+      projectKey &&
+      prev?.project &&
+      prev.project.projectKey === projectKey &&
+      prev.project.projectRef === projectRef
+        ? prev.project
+        : null;
+    const projectUpToDate =
+      projectKey &&
+      sameFileMetadata &&
+      projectCursor &&
+      Number(projectCursor.lastIndex ?? -1) >= Number(prev?.lastIndex ?? -1);
+    if (projectUpToDate) {
+      if (cb) {
+        cb({
+          index: idx + 1,
+          total: totalFiles,
+          filePath,
+          filesProcessed,
+          eventsAggregated,
+          bucketsQueued: touchedBuckets.size,
+        });
+      }
+      continue;
+    }
 
     const result = await parseGeminiFile({
       filePath,
       startIndex,
       lastTotals,
       lastModel,
+      projectCursor,
       hourlyState,
       touchedBuckets,
       source: fileSource,
@@ -444,11 +538,25 @@ async function parseGeminiIncremental({
 
     cursors.files[key] = {
       inode,
+      size,
+      mtimeMs,
       lastIndex: result.lastIndex,
       lastTotals: result.lastTotals,
       lastModel: result.lastModel,
       updatedAt: new Date().toISOString(),
     };
+    if (projectKey) {
+      cursors.files[key].project = {
+        projectKey,
+        projectRef,
+        lastIndex: result.projectLastIndex,
+        lastTotals: result.projectLastTotals,
+        lastModel: result.projectLastModel,
+        updatedAt: new Date().toISOString(),
+      };
+    } else if (prev?.project) {
+      cursors.files[key].project = prev.project;
+    }
 
     filesProcessed += 1;
     eventsAggregated += result.eventsAggregated;
@@ -1070,6 +1178,7 @@ async function parseGeminiFile({
   startIndex,
   lastTotals,
   lastModel,
+  projectCursor,
   hourlyState,
   touchedBuckets,
   source,
@@ -1098,57 +1207,96 @@ async function parseGeminiFile({
   let eventsAggregated = 0;
   let model = typeof lastModel === "string" ? lastModel : null;
   let totals = lastTotals && typeof lastTotals === "object" ? lastTotals : null;
-  const begin = Number.isFinite(startIndex) ? startIndex + 1 : 0;
+  const projectActive = Boolean(projectKey && projectState && projectTouchedBuckets);
+  let projectStartIndex =
+    projectActive && Number.isFinite(projectCursor?.lastIndex)
+      ? Number(projectCursor.lastIndex)
+      : -1;
+  let projectModel =
+    projectActive && typeof projectCursor?.lastModel === "string"
+      ? projectCursor.lastModel
+      : null;
+  let projectTotals =
+    projectActive && projectCursor?.lastTotals && typeof projectCursor.lastTotals === "object"
+      ? projectCursor.lastTotals
+      : null;
+  if (projectActive && projectStartIndex >= messages.length) {
+    projectStartIndex = -1;
+    projectTotals = null;
+    projectModel = null;
+  }
+  const hourlyBegin = Number.isFinite(startIndex) ? startIndex + 1 : 0;
+  const projectBegin = projectActive ? projectStartIndex + 1 : Number.POSITIVE_INFINITY;
+  const begin = Math.min(hourlyBegin, projectBegin);
 
   for (let idx = begin; idx < messages.length; idx++) {
     const msg = messages[idx];
     if (!msg || typeof msg !== "object") continue;
 
     const normalizedModel = normalizeModelInput(msg.model);
-    if (normalizedModel) model = normalizedModel;
+    if (normalizedModel && idx >= hourlyBegin) model = normalizedModel;
+    if (normalizedModel && idx >= projectBegin) projectModel = normalizedModel;
 
     const timestamp = typeof msg.timestamp === "string" ? msg.timestamp : null;
     const currentTotals = normalizeGeminiTokens(msg.tokens);
-    if (!timestamp || !currentTotals) {
+    if (idx >= hourlyBegin && (!timestamp || !currentTotals)) {
       totals = currentTotals || totals;
-      continue;
     }
-
-    const delta = diffGeminiTotals(currentTotals, totals);
-    if (!delta || isAllZeroUsage(delta)) {
-      totals = currentTotals;
+    if (idx >= projectBegin && (!timestamp || !currentTotals)) {
+      projectTotals = currentTotals || projectTotals;
+    }
+    if (!timestamp || !currentTotals) {
       continue;
     }
-    delta.conversation_count = 1;
 
-    const bucketStart = toUtcHalfHourStart(timestamp);
-    if (!bucketStart) {
-      totals = currentTotals;
-      continue;
+    let bucketStart = null;
+    if (idx >= hourlyBegin) {
+      const delta = diffGeminiTotals(currentTotals, totals);
+      if (!delta || isAllZeroUsage(delta)) {
+        totals = currentTotals;
+      } else {
+        delta.conversation_count = 1;
+        bucketStart = toUtcHalfHourStart(timestamp);
+        if (bucketStart) {
+          const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+          addTotals(bucket.totals, delta);
+          touchedBuckets.add(bucketKey(source, model, bucketStart));
+          eventsAggregated += 1;
+        }
+        totals = currentTotals;
+      }
     }
 
-    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));
+    if (idx >= projectBegin) {
+      const projectDelta = diffGeminiTotals(currentTotals, projectTotals);
+      if (!projectDelta || isAllZeroUsage(projectDelta)) {
+        projectTotals = currentTotals;
+        continue;
+      }
+      projectDelta.conversation_count = 1;
+      bucketStart = bucketStart || toUtcHalfHourStart(timestamp);
+      if (bucketStart) {
+        const projectBucket = getProjectBucket(
+          projectState,
+          projectKey,
+          source,
+          bucketStart,
+          projectRef,
+        );
+        addTotals(projectBucket.totals, projectDelta);
+        projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+      }
+      projectTotals = currentTotals;
     }
-    eventsAggregated += 1;
-    totals = currentTotals;
   }
 
   return {
     lastIndex: messages.length - 1,
     lastTotals: totals,
     lastModel: model,
+    projectLastIndex: projectActive ? messages.length - 1 : null,
+    projectLastTotals: projectTotals,
+    projectLastModel: projectModel,
     eventsAggregated,
   };
 }
@@ -1989,7 +2137,15 @@ async function resolveProjectMetaForPath(startDir, cache) {
     if (configPath) {
       const remoteUrl = await readGitRemoteUrl(configPath);
       const projectRef = canonicalizeProjectRef(remoteUrl);
-      const meta = { projectRef: projectRef || null, repoRoot: current };
+      const configStat = await fs.stat(configPath).catch(() => null);
+      const meta = {
+        projectRef: projectRef || null,
+        repoRoot: current,
+        configPath,
+        configMtimeMs:
+          configStat && Number.isFinite(configStat.mtimeMs) ? configStat.mtimeMs : null,
+        configSize: configStat && Number.isFinite(configStat.size) ? configStat.size : null,
+      };
       if (cache) {
         for (const entry of visited) cache.set(entry, meta);
       }
@@ -2129,16 +2285,86 @@ async function resolveProjectContextForPath({
     repoRootHash: meta?.repoRootHash || repoRootHash,
   };
   recordProjectMeta(projectState, normalized);
+  const configFields = {
+    configPath: projectMeta.configPath || null,
+    configMtimeMs: projectMeta.configMtimeMs ?? null,
+    configSize: projectMeta.configSize ?? null,
+  };
   if (normalized.status !== "public_verified") {
-    return { projectRef: normalized.projectRef, projectKey: null, status: normalized.status };
+    return {
+      projectRef: normalized.projectRef,
+      projectKey: null,
+      status: normalized.status,
+      ...configFields,
+    };
   }
   return {
     projectRef: normalized.projectRef,
     projectKey: normalized.projectKey,
     status: normalized.status,
+    ...configFields,
   };
 }
 
+// Builds a small, cursor-persistable freshness fingerprint for a resolved
+// project context's git config file, so a later sync can tell whether the
+// resolution is still valid without re-walking the filesystem.
+function buildProjectFileContext(context) {
+  const configPath = typeof context?.configPath === "string" ? context.configPath : null;
+  if (!configPath) return { absent: true };
+  return {
+    configPath,
+    configMtimeMs: Number.isFinite(context.configMtimeMs) ? context.configMtimeMs : null,
+    configSize: Number.isFinite(context.configSize) ? context.configSize : null,
+  };
+}
+
+async function isProjectFileContextFresh(projectFileContext) {
+  if (!projectFileContext || typeof projectFileContext !== "object") return false;
+  if (projectFileContext.absent === true) return false;
+  const configPath =
+    typeof projectFileContext.configPath === "string" ? projectFileContext.configPath : null;
+  if (!configPath) return false;
+  const st = await fs.stat(configPath).catch(() => null);
+  if (!st || !st.isFile()) return false;
+  return st.mtimeMs === projectFileContext.configMtimeMs && st.size === projectFileContext.configSize;
+}
+
+// Claude Code session files log the launch cwd on message lines (top-level
+// "cwd" field) — unlike the file's on-disk location under
+// ~/.claude/projects/<dash-encoded-cwd>/, which is not itself inside the
+// real project's git checkout and can never resolve a project via directory
+// walk. The encoded name can't be decoded reliably either (dashes in the
+// real path collide with the path-separator encoding), so read the real cwd
+// from content instead. It's set once at session start and bounded scan is
+// cheap since it's a top-level field on the first several lines.
+const CLAUDE_CWD_SCAN_MAX_BYTES = 65536;
+
+async function resolveClaudeFileCwd(filePath) {
+  const stream = fssync.createReadStream(filePath, {
+    encoding: "utf8",
+    start: 0,
+    end: CLAUDE_CWD_SCAN_MAX_BYTES,
+  });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line || !line.includes('"cwd"')) continue;
+      let obj;
+      try {
+        obj = JSON.parse(line);
+      } catch (_e) {
+        continue;
+      }
+      if (typeof obj?.cwd === "string" && obj.cwd.trim()) return obj.cwd.trim();
+    }
+  } finally {
+    rl.close();
+    stream.close?.();
+  }
+  return null;
+}
+
 async function resolveGitConfigPath(rootDir) {
   const gitPath = path.join(rootDir, ".git");
   const st = await fs.stat(gitPath).catch(() => null);
@@ -3210,28 +3436,119 @@ async function parseKiroIncremental({ dbPath, jsonlPath, cursors, queuePath, onP
 // Hermes Agent — SQLite-based (sessions table in ~/.hermes/state.db)
 // ─────────────────────────────────────────────────────────────────────────────
 
-function resolveHermesPath(env = process.env) {
+function resolveHermesPath(env = process.env, deps = {}) {
   const override = env.TOKENTRACKER_HERMES_HOME;
   if (typeof override === "string" && override.trim().length > 0) {
     return override.trim();
   }
   const home = require("node:os").homedir();
   const defaultPath = path.join(home, ".hermes");
-  // Hermes official Windows installer (install.ps1) writes state to
-  // %LOCALAPPDATA%\hermes, not ~/.hermes. Prefer it when present so native
-  // Windows users don't need to set TOKENTRACKER_HERMES_HOME manually.
+  // On Windows, scan BOTH the native install (%LOCALAPPDATA%\hermes) and
+  // any WSL distros running Hermes Agent. Each install has its own independent
+  // state.db with different sessions, so there is no double-counting risk.
+  // WSL is preferred when both exist because development happens in WSL (#87).
   if (process.platform === "win32") {
+    let nativePath = null;
     const localAppData = typeof env.LOCALAPPDATA === "string" ? env.LOCALAPPDATA.trim() : "";
     if (localAppData.length > 0) {
-      const winNative = path.join(localAppData, "hermes");
+      const candidate = path.join(localAppData, "hermes");
       try {
-        if (fssync.existsSync(winNative)) return winNative;
+        if (fssync.existsSync(candidate)) nativePath = candidate;
       } catch (_e) { }
     }
+    const wslPath = discoverWslHermesHome(deps);
+    if (wslPath) return wslPath;
+    if (nativePath) return nativePath;
   }
   return defaultPath;
 }
 
+// ── WSL auto-discovery (Windows host, Hermes installed inside a distro) ──────
+// `wsl.exe -l -v` prints UTF-16LE; the per-distro `whoami` runs a Linux process
+// so its stdout is UTF-8. We capture buffers and decode per-call.
+function defaultRunWsl(args, { utf16 = false } = {}) {
+  const { execFileSync } = require("node:child_process");
+  const buf = execFileSync("wsl.exe", args, {
+    timeout: 5000,
+    windowsHide: true,
+    maxBuffer: 1024 * 1024,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return utf16 ? buf.toString("utf16le") : buf.toString("utf8");
+}
+
+// Parse `wsl.exe -l -v` output into [{ name, version, isDefault }]. The default
+// distro is prefixed with `*`; the VERSION column (1 or 2) decides which UNC
+// alias to try first (simonlpaige, #87).
+function parseWslListVerbose(raw) {
+  if (typeof raw !== "string") return [];
+  const distros = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const clean = line.replace(//g, "").replace(//g, "").trim();
+    if (!clean) continue;
+    const cells = clean.split(/\s+/);
+    let isDefault = false;
+    let idx = 0;
+    if (cells[0] === "*") {
+      isDefault = true;
+      idx = 1;
+    }
+    const name = cells[idx];
+    if (!name || name === "NAME") continue; // skip header row
+    const version = parseInt(cells[cells.length - 1], 10);
+    distros.push({
+      name,
+      version: Number.isFinite(version) ? version : null,
+      isDefault,
+    });
+  }
+  return distros;
+}
+
+// Default distro first, then listed order — matches what a user expects when
+// they have one primary distro plus extras.
+function probeWslDistros(deps = {}) {
+  const runWsl = deps.runWsl || defaultRunWsl;
+  let raw;
+  try {
+    raw = runWsl(["-l", "-v"], { utf16: true });
+  } catch (_e) {
+    return [];
+  }
+  const distros = parseWslListVerbose(raw);
+  return distros.sort((a, b) => (b.isDefault ? 1 : 0) - (a.isDefault ? 1 : 0));
+}
+
+// Probe each WSL distro for ~/.hermes via UNC. The Linux username rarely equals
+// %USERNAME%, so we ask the distro directly with `whoami` rather than guessing
+// (simonlpaige, #87).
+function discoverWslHermesHome(deps = {}) {
+  const runWsl = deps.runWsl || defaultRunWsl;
+  const existsSync = deps.existsSync || fssync.existsSync;
+  const distros = probeWslDistros(deps);
+  for (const distro of distros) {
+    let user;
+    try {
+      user = String(runWsl(["-d", distro.name, "-e", "whoami"], { utf16: false }) || "").trim();
+    } catch (_e) {
+      user = "";
+    }
+    if (!user) continue;
+    // \\wsl$\ is the legacy alias, \\wsl.localhost\ the newer one. WSL1 distros
+    // sometimes only resolve via \\wsl.localhost\, so order by version.
+    const roots = distro.version === 1
+      ? ["\\\\wsl.localhost\\", "\\\\wsl$\\"]
+      : ["\\\\wsl$\\", "\\\\wsl.localhost\\"];
+    for (const root of roots) {
+      const candidate = `${root}${distro.name}\\home\\${user}\\.hermes`;
+      try {
+        if (existsSync(candidate)) return candidate;
+      } catch (_e) { }
+    }
+  }
+  return null;
+}
+
 function resolveHermesDbPath(env = process.env) {
   return path.join(resolveHermesPath(env), "state.db");
 }
@@ -9165,6 +9482,9 @@ module.exports = {
   resolveKiroJsonlPath,
   resolveHermesPath,
   resolveHermesDbPath,
+  parseWslListVerbose,
+  probeWslDistros,
+  discoverWslHermesHome,
   resolveCopilotOtelPaths,
   parseRolloutIncremental,
   parseClaudeIncremental,