claude-token-saver 3.5.3 → 3.6.1

package/src/route-scan.js

@@ -19,7 +19,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { userDataDir } from './paths.js';
 import { discoverSessionFiles } from './parser.js';
 import { collectSessionRecords } from './session-records.js';
 
@@ -68,36 +68,42 @@ const CATEGORIES = [
   {
     id: 'paste',
     label: '붙여넣은 화면·로그 질문',
+    labelEn: 'questions about pasted screens/logs',
     agent: 'haiku-explore',
     kw: null, // matched by length, see categorize()
   },
   {
     id: 'translate',
     label: '배치 번역·정형 텍스트 변환',
+    labelEn: 'batch translation / mechanical text transforms',
     agent: 'haiku-translate',
     kw: [[/번역|translate/i, 2], [/변환해|표로 정리|포맷팅/i, 1]],
   },
   {
     id: 'explore',
     label: '탐색·조회 (파일/값 찾기)',
+    labelEn: 'lookup (finding files/values)',
     agent: 'haiku-explore',
     kw: [[/grep|검색|search|find/i, 2], [/찾아|어디|위치|목록|살펴/i, 1]],
   },
   {
     id: 'read',
     label: '읽기·요약·설명',
+    labelEn: 'reading / summarizing / explaining',
     agent: 'haiku-explore',
     kw: [[/요약|summar|explain/i, 2], [/읽어|설명|정리해|보여줘|알려줘|뭐야|what/i, 1]],
   },
   {
     id: 'check',
     label: '상태 확인·검증',
+    labelEn: 'status checks / verification',
     agent: 'haiku-explore',
     kw: [[/확인|검증|verify|점검/i, 2], [/맞아\?|되나|됐나|됐어|되는지|괜찮|체크|check|status/i, 1]],
   },
   {
     id: 'run',
     label: '명령 실행 (빌드·테스트·git)',
+    labelEn: 'running commands (build/test/git)',
     agent: 'haiku-runner',
     kw: [[/git |commit|push|npm |pip|빌드해|빌드 돌/i, 2], [/실행|돌려|run |build|빌드|테스트|설치/i, 1]],
   },
@@ -153,16 +159,10 @@ function keywordScore(cat, text) {
 const SKIP_RE = /^(계속|이어서|continue|다음|proceed|진행|응|네|넵|ok|okay|yes|ㄱ+|고고)\b/i;
 const SKIP_PREFIX = ['<task-notification', '<system', '[Image:', '<local-command'];
 
-function stateDir() {
-  if (process.platform === 'win32') {
-    return join(process.env.APPDATA || homedir(), 'claude-token-saver');
-  }
-  if (process.platform === 'darwin') {
-    return join(homedir(), 'Library', 'Application Support', 'claude-token-saver');
-  }
-  const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
-  return join(xdg, 'claude-token-saver');
-}
+// Single source of truth for the state dir (paths.js). A local copy used to
+// live here and honored XDG_CONFIG_HOME on Linux only, so on macOS/Windows an
+// XDG override split this cache away from config.json and the session cache.
+const stateDir = userDataDir;
 
 export function routeScanCachePath() {
   return join(stateDir(), 'route-scan.json');
@@ -335,6 +335,7 @@ export async function runRouteScan({ days = 14 } = {}) {
       tier,
       category: cat.id,
       label: cat.label,
+      labelEn: cat.labelEn,
       agent: tier === 'T2' ? cat.agent : 'sonnet',
       project: projectDir,
       projectPath: '',
@@ -368,9 +369,15 @@ export async function runRouteScan({ days = 14 } = {}) {
     r.tier === g.tier && r.category === g.category &&
     (r.scope === 'global' || r.project === g.project));
 
+  // Both languages are computed at scan time and stored on the candidate, so
+  // switching `language` later re-renders (and promotes) correctly without
+  // waiting for a rescan.
   const ruleText = (g) => g.tier === 'T2'
     ? `"${g.label}" 유형의 단순 요청(예: "${g.example}")은 ${g.agent}(haiku) 서브에이전트로 위임한다 (설계 판단·배포·스토어 제출 같은 비가역 작업이 섞이면 위임하지 않음)`
     : `"${g.label}" 유형의 중간 난도 요청(예: "${g.example}")은 model: sonnet 서브에이전트로 위임한다 (설계 판단·비가역 작업·반복 에러 발생 시 메인 모델이 이어받음)`;
+  const ruleTextEn = (g) => g.tier === 'T2'
+    ? `Delegate simple "${g.labelEn}" requests (e.g. "${g.example}") to the ${g.agent} (haiku) subagent — never when the request mixes in design judgement or irreversible work like deploy/release/submission`
+    : `Delegate moderate "${g.labelEn}" requests (e.g. "${g.example}") to a model: sonnet subagent — hand back to the main model on design judgement, irreversible work, or repeated errors`;
 
   const candidates = [...groups.values()]
     .filter((g) => g.count >= MIN_RECURRENCE && !hasRule(g))
@@ -382,6 +389,7 @@ export async function runRouteScan({ days = 14 } = {}) {
       tier: g.tier,
       category: g.category,
       label: g.label,
+      labelEn: g.labelEn,
       agent: g.agent,
       project: g.project,
       // Real session cwd for the project (munged `project` is lossy) — lets
@@ -396,6 +404,7 @@ export async function runRouteScan({ days = 14 } = {}) {
       // the same category recurs across 2+ projects (then 'global').
       suggestedScope: 'project',
       rule: ruleText(g),
+      ruleEn: ruleTextEn(g),
     }));
 
   // Same category appearing in 2+ projects → suggest global for each.

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/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;
+}