claude-token-saver 3.5.2 → 3.6.0

package/src/session-cache.js

@@ -0,0 +1,153 @@
+/**
+ * Parsed-session cache — keyed by (path, mtimeMs, size).
+ *
+ * The statusline re-runs the whole report pipeline on every refresh
+ * (`refreshInterval=5` is what `install` configures), and without a cache
+ * that means re-reading every session JSONL in the window line by line.
+ * Measured on a 217MB / 226-file 30-day window: 3.0s per refresh, of which
+ * effectively all is spent re-parsing files that cannot have changed —
+ * between two refreshes only the CURRENT session's file grows.
+ *
+ * Session transcripts are append-only and never rewritten, so (mtimeMs, size)
+ * is a sound identity for "this file's parse result is still valid". A stale
+ * or corrupt cache is never fatal: every read path falls back to a full parse.
+ *
+ * Only the aggregate summary is stored, never the per-request array — that is
+ * internal to the parser's aggregation and no consumer reads it (see
+ * parseAllSessions, which drops it on the fresh-parse path too so cache hits
+ * and misses return identically shaped objects).
+ */
+
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { userDataDir } from './paths.js';
+import { debug } from './debug.js';
+
+const CACHE_PATH = join(userDataDir(), 'session-cache.json');
+// Bump when the cached summary's shape changes — old entries are dropped
+// wholesale rather than migrated.
+const CACHE_VERSION = 1;
+// Entries for transcripts this old are pruned on write. Keeps the file
+// bounded without an existence check per entry (which would cost the syscalls
+// the cache exists to avoid).
+const PRUNE_AFTER_MS = 90 * 24 * 60 * 60 * 1000;
+
+/**
+ * @typedef {object} SessionSummary
+ * @property {string|null} sessionId
+ * @property {string} filePath
+ * @property {Date|null} startTime
+ * @property {Date|null} endTime
+ * @property {number} requestCount
+ * @property {object} totals
+ * @property {number} maxContextPerRequest
+ * @property {string} model
+ * @property {string} [projectDir]
+ */
+
+/** Dates don't survive JSON — store epoch ms, rehydrate on read. */
+function serialize(session) {
+  return {
+    sessionId: session.sessionId,
+    startTime: session.startTime ? session.startTime.getTime() : null,
+    endTime: session.endTime ? session.endTime.getTime() : null,
+    requestCount: session.requestCount,
+    totals: session.totals,
+    maxContextPerRequest: session.maxContextPerRequest,
+    model: session.model,
+  };
+}
+
+function deserialize(stored, filePath, projectDir) {
+  return {
+    sessionId: stored.sessionId ?? null,
+    filePath,
+    projectDir,
+    startTime: typeof stored.startTime === 'number' ? new Date(stored.startTime) : null,
+    endTime: typeof stored.endTime === 'number' ? new Date(stored.endTime) : null,
+    requestCount: stored.requestCount || 0,
+    totals: stored.totals,
+    maxContextPerRequest: stored.maxContextPerRequest || 0,
+    model: stored.model || 'unknown',
+  };
+}
+
+/**
+ * Load the cache into a plain object. Any problem (missing file, bad JSON,
+ * version bump) yields an empty cache — the caller just re-parses.
+ *
+ * @returns {{ entries: Record<string, {mtimeMs:number,size:number,s:object}> }}
+ */
+export function loadCache() {
+  try {
+    if (!existsSync(CACHE_PATH)) return { entries: {} };
+    const data = JSON.parse(readFileSync(CACHE_PATH, 'utf8'));
+    if (!data || data.version !== CACHE_VERSION || !data.entries || typeof data.entries !== 'object') {
+      return { entries: {} };
+    }
+    return { entries: data.entries };
+  } catch (e) {
+    debug('session-cache:load', e);
+    return { entries: {} };
+  }
+}
+
+/**
+ * Look up a parsed session for a discovered file.
+ *
+ * @param {{entries:object}} cache
+ * @param {{path:string, size:number, mtime:number, projectDir:string}} file
+ * @returns {SessionSummary|null} null on miss
+ */
+export function getCached(cache, file) {
+  const e = cache.entries[file.path];
+  if (!e || e.mtimeMs !== file.mtime || e.size !== file.size || !e.s) return null;
+  try {
+    return deserialize(e.s, file.path, file.projectDir);
+  } catch (err) {
+    debug('session-cache:deserialize', err);
+    return null;
+  }
+}
+
+/**
+ * Record a freshly parsed session against the stat values observed BEFORE the
+ * parse. Keying on the pre-parse stat is deliberate: if the file grew while we
+ * were reading it, the entry is keyed to a size that will never be seen again,
+ * so the next run re-parses. The opposite (keying on the post-parse stat)
+ * would let a hit serve a summary that missed the tail.
+ */
+export function putCached(cache, file, session) {
+  cache.entries[file.path] = {
+    mtimeMs: file.mtime,
+    size: file.size,
+    s: serialize(session),
+  };
+}
+
+/**
+ * Atomically persist the cache (tmp + rename), pruning long-dead transcripts.
+ * Concurrent statusline refreshes are expected — rename is atomic on POSIX and
+ * on Windows for same-volume replaces, so a reader never sees a partial file.
+ * Best-effort: a write failure just means the next run re-parses.
+ */
+export function saveCache(cache) {
+  try {
+    const dir = userDataDir();
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const cutoff = Date.now() - PRUNE_AFTER_MS;
+    const entries = {};
+    for (const [path, e] of Object.entries(cache.entries)) {
+      if (e && typeof e.mtimeMs === 'number' && e.mtimeMs >= cutoff) entries[path] = e;
+    }
+    const tmp = `${CACHE_PATH}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: CACHE_VERSION, entries }) + '\n');
+    renameSync(tmp, CACHE_PATH);
+  } catch (e) {
+    debug('session-cache:save', e); // best-effort — never block a report
+  }
+}
+
+export function sessionCachePath() {
+  return CACHE_PATH;
+}

package/src/session-records.js

@@ -39,6 +39,16 @@ const DELEGATION_TOOLS = new Set(['Task', 'Agent']);
 // classifier denials out of 142 is_error results (~25% of the numerator).
 const REJECTION_RE = /doesn't want to proceed|tool use was rejected|doesn't want to take this action|denied by the claude code auto mode classifier|permission for this action was denied|requires approval/i;
 
+// Harness-mechanical / self-corrected tool errors also arrive as is_error
+// tool_results, but they reflect edit-ordering mechanics and the agent's own
+// immediate correction loop — not task difficulty. Counting them poisons the
+// rule-health error rate the same way permission denials do (v3.4.2). Measured
+// on a 14-day window they dominate the numerator (e.g. "File has not been read
+// yet" was 7/65 real errors in one project, edit-races + Task-lifecycle several
+// more). Kept NARROW on purpose: ambiguous shell failures ("Exit code N", "File
+// does not exist" on a Read) stay counted — those are genuine difficulty signal.
+const SELF_CORRECTED_RE = /File has not been read yet|has been modified since read|String to replace not found|is not running \(status:|<tool_use_error>Blocked:/i;
+
 function toolResultText(content) {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
@@ -46,8 +56,9 @@ function toolResultText(content) {
 }
 
 function isRealToolError(block) {
-  return block && block.type === 'tool_result' && block.is_error &&
-    !REJECTION_RE.test(toolResultText(block.content));
+  if (!block || block.type !== 'tool_result' || !block.is_error) return false;
+  const txt = toolResultText(block.content);
+  return !REJECTION_RE.test(txt) && !SELF_CORRECTED_RE.test(txt);
 }
 
 export async function collectSessionRecords(filePath, { includeContent = true } = {}) {

package/src/stdin-payload.js

@@ -0,0 +1,106 @@
+/**
+ * Claude Code's statusline contract feeds this tool a JSON blob on stdin every
+ * refresh. These helpers own reading and interpreting that payload; everything
+ * else in the CLI takes the extracted values.
+ */
+
+import { readFileSync } from 'node:fs';
+
+/**
+ * Read the JSON blob Claude Code feeds the statusline command on stdin.
+ * Returns null when stdin is a TTY or empty (e.g. user invokes `--statusline`
+ * by hand) so callers can fall back to flag/env config.
+ *
+ * The blob shape (subset we consume):
+ *   {
+ *     "transcript_path": "...",
+ *     "rate_limits": {
+ *       "five_hour":  { "used_percentage": 94, "resets_at": 1777099200 },
+ *       "seven_day":  { "used_percentage": 7,  "resets_at": 1777521600 }
+ *     }
+ *   }
+ *
+ * extractCaps treats `rate_limits` as a generic object so any future window
+ * Anthropic adds (e.g. a Sonnet-only weekly bucket) flows through without code
+ * changes — known keys get curated labels, unknowns get derived ones.
+ */
+export function readStdinJson() {
+  if (process.stdin.isTTY) return null;
+  try {
+    const raw = readFileSync(0, 'utf8');
+    if (!raw || !raw.trim()) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function extractCaps(stdinJson) {
+  if (!stdinJson || !stdinJson.rate_limits || typeof stdinJson.rate_limits !== 'object') return null;
+  const windows = [];
+  for (const [key, value] of Object.entries(stdinJson.rate_limits)) {
+    if (!value || typeof value !== 'object') continue;
+    const usedPct = Number(value.used_percentage);
+    if (!Number.isFinite(usedPct)) continue;
+    const resetsAt = Number(value.resets_at);
+    windows.push({
+      key,
+      usedPct,
+      resetsAt: Number.isFinite(resetsAt) ? resetsAt : null,
+    });
+  }
+  return windows.length ? { windows } : null;
+}
+
+/**
+ * Pull the human-friendly model name out of Claude Code's stdin payload.
+ * `model.display_name` is the contract; fall back to `model.id` when it's
+ * absent. Returns null when nothing usable is in the JSON.
+ */
+// Bedrock/litellm proxies pass model IDs like
+//   global.anthropic.claude-opus-4-7-20251001-v1:0
+//   anthropic.claude-sonnet-4-6-20250930-v1:0
+//   bedrock/anthropic.claude-haiku-4-5
+// while Claude Code's `display_name` collapses these to a generic family
+// label ("Opus 4", "Sonnet 4") that hides the actual minor version. Pull the
+// version out of the id when we can spot it so the statusline shows the real
+// model in use (Opus 4.7 vs 4.6 matters a lot for token budgeting).
+export function bedrockDisplayFromId(id) {
+  if (typeof id !== 'string') return null;
+  const m = id.match(/claude[-_](opus|sonnet|haiku)[-_](\d+)[-_](\d+)/i);
+  if (!m) return null;
+  const family = m[1].charAt(0).toUpperCase() + m[1].slice(1).toLowerCase();
+  return `${family} ${m[2]}.${m[3]}`;
+}
+
+/**
+ * Live context usage from Claude Code's stdin payload (`context_window`).
+ * More accurate than inferring from transcripts: it's the CURRENT session's
+ * real fill level, updated every refresh. Shape (subset):
+ *   "context_window": { "context_window_size": 200000, "used_percentage": 68 }
+ */
+export function extractContextUsage(stdinJson) {
+  const cw = stdinJson && stdinJson.context_window;
+  if (!cw || typeof cw !== 'object') return null;
+  const usedPct = Number(cw.used_percentage);
+  const size = Number(cw.context_window_size);
+  if (!Number.isFinite(usedPct)) return null;
+  return {
+    usedPct,
+    size: Number.isFinite(size) && size > 0 ? size : null,
+  };
+}
+
+export function extractModel(stdinJson) {
+  if (!stdinJson || !stdinJson.model) return null;
+  const m = stdinJson.model;
+  if (typeof m === 'string') return bedrockDisplayFromId(m) || m;
+  // Prefer the id when it carries a precise version (e.g. Bedrock IDs); fall
+  // back to display_name for the standard Claude Code path where display_name
+  // already says "Claude Opus 4.7".
+  const idDerived = bedrockDisplayFromId(m.id);
+  if (idDerived) return idDerived;
+  if (typeof m.display_name === 'string' && m.display_name) return m.display_name;
+  if (typeof m.id === 'string' && m.id) return m.id;
+  return null;
+}