@hasna/statusline 0.0.7 → 0.0.8

package/dist/cli.js

@@ -1,6 +1,36 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -30,6 +60,7 @@ function defaultConfig() {
       "loc",
       "model-context",
       "context-remaining",
+      "cache-rate",
       "cost"
     ]
   };
@@ -95,7 +126,7 @@ function numberOr(v) {
 }
 
 // src/segments/index.ts
-import { hostname } from "os";
+import { homedir as homedir5, hostname } from "os";
 
 // src/format.ts
 function compactAge(seconds) {
@@ -135,10 +166,10 @@ function compactDuration(ms) {
     return `${s}s`;
   if (s < 3600) {
     const rem2 = s % 60;
-    return rem2 ? `${Math.floor(s / 60)}m${rem2}s` : `${Math.floor(s / 60)}m`;
+    return rem2 ? `${Math.floor(s / 60)}m ${rem2}s` : `${Math.floor(s / 60)}m`;
   }
   const rem = Math.floor(s % 3600 / 60);
-  return rem ? `${Math.floor(s / 3600)}h${rem}m` : `${Math.floor(s / 3600)}h`;
+  return rem ? `${Math.floor(s / 3600)}h ${rem}m` : `${Math.floor(s / 3600)}h`;
 }
 
 // src/git.ts
@@ -195,14 +226,145 @@ function trackedLineCount(cwd) {
 }
 
 // src/context-window.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-function contextUsage(ctx) {
-  const path = ctx.transcriptPath;
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+
+// src/providers/codex.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function latestCodexSessionPath(home = homedir2()) {
+  const root = join2(home, ".codex", "sessions");
+  if (!existsSync2(root))
+    return null;
+  let newest = null;
+  let newestMtime = 0;
+  try {
+    for (const year of readdirSync(root)) {
+      const yearDir = join2(root, year);
+      if (!statSync(yearDir, { throwIfNoEntry: false })?.isDirectory())
+        continue;
+      for (const month of readdirSync(yearDir)) {
+        const monthDir = join2(yearDir, month);
+        if (!statSync(monthDir, { throwIfNoEntry: false })?.isDirectory())
+          continue;
+        for (const day of readdirSync(monthDir)) {
+          const dayDir = join2(monthDir, day);
+          if (!statSync(dayDir, { throwIfNoEntry: false })?.isDirectory())
+            continue;
+          for (const file of readdirSync(dayDir)) {
+            if (!file.startsWith("rollout-") || !file.endsWith(".jsonl"))
+              continue;
+            const full = join2(dayDir, file);
+            const mtime = statSync(full, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+            if (mtime > newestMtime) {
+              newestMtime = mtime;
+              newest = full;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+  return newest;
+}
+function codexCacheRate(sessionPath) {
+  const path = sessionPath ?? latestCodexSessionPath();
   if (!path || !existsSync2(path))
     return null;
   let lines;
   try {
     lines = readFileSync2(path, "utf8").split(`
+`);
+  } catch {
+    return null;
+  }
+  let usage = null;
+  for (const line of lines) {
+    if (!line || !line.includes("token_count"))
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry?.type !== "event_msg")
+        continue;
+      if (entry?.payload?.type !== "token_count")
+        continue;
+      const info = entry?.payload?.info?.total_token_usage;
+      if (info && typeof info === "object")
+        usage = info;
+    } catch {
+      continue;
+    }
+  }
+  if (!usage)
+    return null;
+  const read = usage.cached_input_tokens || 0;
+  const input = usage.input_tokens || 0;
+  const write = usage.cache_write_input_tokens || 0;
+  const divisor = input + read + write;
+  if (divisor <= 0)
+    return null;
+  return Math.min(1, Math.max(0, read / divisor));
+}
+
+// src/providers/opencode.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { Database } from "bun:sqlite";
+function opencodeCacheRate(opts = {}) {
+  const dbPath = opts.dbPath ?? join3(homedir3(), ".local", "share", "opencode", "opencode.db");
+  if (!existsSync3(dbPath))
+    return null;
+  let db;
+  try {
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return null;
+  }
+  try {
+    let row = tokenRow(db, "session", opts.sessionId);
+    if (!row)
+      row = tokenRow(db, "session_v2", opts.sessionId);
+    if (!row)
+      return null;
+    const input = row.tokens_input ?? 0;
+    const read = row.tokens_cache_read ?? 0;
+    const write = row.tokens_cache_write ?? 0;
+    const divisor = input + read + write;
+    if (divisor <= 0)
+      return null;
+    return Math.min(1, Math.max(0, read / divisor));
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function tokenRow(db, table, sessionId) {
+  try {
+    if (sessionId) {
+      return db.query(`SELECT tokens_input, tokens_cache_read, tokens_cache_write
+           FROM ${table} WHERE id = ? LIMIT 1`).get(sessionId);
+    }
+    return db.query(`SELECT tokens_input, tokens_cache_read, tokens_cache_write
+         FROM ${table}
+         WHERE tokens_input > 0 OR tokens_cache_read > 0 OR tokens_cache_write > 0
+         ORDER BY time_updated DESC LIMIT 1`).get();
+  } catch {
+    return null;
+  }
+}
+
+// src/context-window.ts
+function lastUsageBlock(ctx) {
+  const path = ctx.transcriptPath;
+  if (!path || !existsSync4(path))
+    return null;
+  let lines;
+  try {
+    lines = readFileSync3(path, "utf8").split(`
 `);
   } catch {
     return null;
@@ -216,26 +378,48 @@ function contextUsage(ctx) {
       const usage = entry?.message?.usage;
       if (!usage || typeof usage.input_tokens !== "number")
         continue;
-      const used = usage.input_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
-      return {
-        used,
-        output: usage.output_tokens || 0,
-        window: windowSize(ctx)
-      };
+      return usage;
     } catch {
       continue;
     }
   }
   return null;
 }
+function contextUsage(ctx) {
+  const usage = lastUsageBlock(ctx);
+  if (!usage)
+    return null;
+  const used = usage.input_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+  return {
+    used,
+    output: usage.output_tokens || 0,
+    window: windowSize(ctx)
+  };
+}
+function cacheRate(ctx) {
+  if (ctx.provider === "codex")
+    return codexCacheRate();
+  if (ctx.provider === "opencode")
+    return opencodeCacheRate();
+  const usage = lastUsageBlock(ctx);
+  if (!usage)
+    return null;
+  const read = usage.cache_read_input_tokens || 0;
+  const creation = usage.cache_creation_input_tokens || 0;
+  const input = usage.input_tokens || 0;
+  const divisor = input + creation + read;
+  if (divisor <= 0)
+    return null;
+  return read / divisor;
+}
 function windowSize(ctx) {
   return ctx.model?.id?.includes("[1m]") ? 1e6 : 200000;
 }
 
 // src/accounts.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, resolve, sep } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4, resolve, sep } from "path";
 var CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
 var DEFAULT_CONFIG_SUBDIR = ".claude";
 var STORE_PATH_ENV = "ACCOUNTS_STORE_PATH";
@@ -259,10 +443,10 @@ function str(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function home(env) {
-  return str(env.HOME) ?? homedir2();
+  return str(env.HOME) ?? homedir4();
 }
 function expandHome(path, env) {
-  return path === "~" || path.startsWith(`~${sep}`) ? join2(home(env), path.slice(1)) : path;
+  return path === "~" || path.startsWith(`~${sep}`) ? join4(home(env), path.slice(1)) : path;
 }
 function canonical(path, env) {
   const abs = resolve(expandHome(path, env));
@@ -274,7 +458,7 @@ function canonical(path, env) {
 }
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
@@ -295,14 +479,14 @@ async function accountsPaths(env) {
         return { store: storage.storePath(), profiles: storage.profilesDir() };
     } catch {}
   }
-  const base = homeOverride ?? join2(home(env), ...DEFAULT_ACCOUNTS_HOME);
+  const base = homeOverride ?? join4(home(env), ...DEFAULT_ACCOUNTS_HOME);
   return {
-    store: storeOverride ?? join2(base, STORE_FILE),
-    profiles: join2(base, PROFILES_SUBDIR)
+    store: storeOverride ?? join4(base, STORE_FILE),
+    profiles: join4(base, PROFILES_SUBDIR)
   };
 }
 function registryEntry(store, configDir, env, tool) {
-  if (!existsSync3(store))
+  if (!existsSync5(store))
     return null;
   const entries = readJson(store)?.profiles;
   if (!Array.isArray(entries))
@@ -323,7 +507,7 @@ function registryEntry(store, configDir, env, tool) {
   return tool ? untyped : first;
 }
 function layoutProfile(profilesRoot, configDir, env) {
-  if (!existsSync3(configDir))
+  if (!existsSync5(configDir))
     return null;
   const prefix = canonical(profilesRoot, env) + sep;
   if (!configDir.startsWith(prefix))
@@ -337,7 +521,7 @@ function layoutProfile(profilesRoot, configDir, env) {
   return { configDir, profile, tool, source: "layout" };
 }
 function switchedOccupant(configDir) {
-  const raw = readJson(join2(configDir, AUTH_STATE_SUBDIR, SWITCHED_ACCOUNT_MARKER_FILE));
+  const raw = readJson(join4(configDir, AUTH_STATE_SUBDIR, SWITCHED_ACCOUNT_MARKER_FILE));
   if (!raw)
     return null;
   const profile = str(raw.profile);
@@ -345,17 +529,17 @@ function switchedOccupant(configDir) {
   return profile || email ? { profile, email } : null;
 }
 function sessionConfigDir(env = process.env) {
-  return canonical(str(env[CONFIG_DIR_ENV]) ?? join2(home(env), DEFAULT_CONFIG_SUBDIR), env);
+  return canonical(str(env[CONFIG_DIR_ENV]) ?? join4(home(env), DEFAULT_CONFIG_SUBDIR), env);
 }
 function sessionStateFile(env = process.env) {
   const base = canonical(str(env[CONFIG_DIR_ENV]) ?? home(env), env);
-  const preferred = join2(base, STATE_FILE_PREFERRED);
-  if (existsSync3(preferred))
+  const preferred = join4(base, STATE_FILE_PREFERRED);
+  if (existsSync5(preferred))
     return preferred;
   const variants = str(env[CUSTOM_OAUTH_ENV]) ? ["-custom-oauth", ...OAUTH_VARIANTS] : OAUTH_VARIANTS;
   for (const variant of variants) {
-    const candidate = join2(base, `${STATE_FILE_PREFIX}${variant}${STATE_FILE_SUFFIX}`);
-    if (existsSync3(candidate))
+    const candidate = join4(base, `${STATE_FILE_PREFIX}${variant}${STATE_FILE_SUFFIX}`);
+    if (existsSync5(candidate))
       return candidate;
   }
   return null;
@@ -403,7 +587,7 @@ async function sessionAccountEmail(env = process.env, tool) {
 }
 function accountsHomeDir(env) {
   const override = str(env[ACCOUNTS_HOME_ENV]);
-  return override ? expandHome(override, env) : join2(home(env), ...DEFAULT_ACCOUNTS_HOME);
+  return override ? expandHome(override, env) : join4(home(env), ...DEFAULT_ACCOUNTS_HOME);
 }
 function sessionAccountUuid(env = process.env) {
   try {
@@ -476,8 +660,8 @@ function sessionUsage(env = process.env, now = new Date) {
     const uuid = sessionAccountUuid(env);
     if (!uuid)
       return empty;
-    const path = join2(accountsHomeDir(env), CACHE_SUBDIR, USAGE_CACHE_SUBDIR, `${uuid}.json`);
-    if (!existsSync3(path))
+    const path = join4(accountsHomeDir(env), CACHE_SUBDIR, USAGE_CACHE_SUBDIR, `${uuid}.json`);
+    if (!existsSync5(path))
       return empty;
     const entry = readJson(path);
     if (!entry || entry.accountUuid !== uuid)
@@ -492,11 +676,11 @@ function sessionUsage(env = process.env, now = new Date) {
 }
 
 // src/settings.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
 function sessionFastMode(env = process.env) {
   try {
-    const raw = readFileSync4(join3(sessionConfigDir(env), "settings.json"), "utf8");
+    const raw = readFileSync5(join5(sessionConfigDir(env), "settings.json"), "utf8");
     return JSON.parse(raw)?.fastMode === true;
   } catch {
     return false;
@@ -520,6 +704,29 @@ function friendlyModel(id) {
   return { name: name || mid, tag };
 }
 var dir = (ctx) => ctx.cwd || process.cwd();
+function abbreviateHome(path) {
+  const home2 = homedir5();
+  if (!home2 || home2 === "/")
+    return path;
+  if (path === home2)
+    return "~";
+  return path.startsWith(`${home2}/`) ? `~${path.slice(home2.length)}` : path;
+}
+var CWD_MAX = 40;
+function truncateLeft(path, max) {
+  return path.length <= max ? path : `\u2026${path.slice(path.length - (max - 1))}`;
+}
+function contextColor(ctx) {
+  const u = contextUsage(ctx);
+  if (!u || !u.window)
+    return null;
+  const pct = Math.min(100, Math.round(u.used / u.window * 100));
+  if (pct >= 80)
+    return "red";
+  if (pct >= 50)
+    return "yellow";
+  return "green";
+}
 function modelName(ctx) {
   if (ctx.model?.displayName)
     return ctx.model.displayName.toLowerCase();
@@ -528,6 +735,12 @@ function modelName(ctx) {
 function limitPercent(pct) {
   return typeof pct === "number" ? pct : 0;
 }
+function anthropicSession(ctx) {
+  if (ctx.rateLimits)
+    return true;
+  const id = ctx.model?.id;
+  return typeof id === "string" && /claude/i.test(id);
+}
 function usageLabel(prefix, headroom) {
   return headroom === null ? `${prefix} \u2014` : `${prefix} ${headroom}%`;
 }
@@ -597,10 +810,23 @@ var segments = [
     defaultEnabled: false,
     render: (ctx) => dir(ctx).split("/").pop() || null
   },
+  {
+    id: "cwd",
+    description: "Current working directory (full path)",
+    defaultEnabled: false,
+    color: "blue",
+    render(ctx) {
+      const path = ctx.cwd;
+      if (typeof path !== "string" || !path)
+        return null;
+      return truncateLeft(abbreviateHome(path), CWD_MAX);
+    }
+  },
   {
     id: "model",
     description: "Current model name",
     defaultEnabled: false,
+    color: "dim",
     render(ctx) {
       if (!ctx.model?.id)
         return null;
@@ -611,6 +837,7 @@ var segments = [
     id: "model-context",
     description: "Model name with context-size tag (e.g. [1m])",
     defaultEnabled: true,
+    color: "dim",
     render(ctx) {
       if (!ctx.model?.id)
         return null;
@@ -622,7 +849,7 @@ var segments = [
     id: "model-with-reasoning",
     description: "Model name with its reasoning effort (or thinking, when on)",
     defaultEnabled: false,
-    color: "cyan",
+    color: "dim",
     render(ctx) {
       const name = modelName(ctx);
       if (!name)
@@ -682,15 +909,15 @@ var segments = [
     id: "usage-session",
     description: "Session (5-hour) usage remaining for this pane's own account, from the local accounts usage cache",
     defaultEnabled: false,
-    color: () => usageColor(sessionUsage(process.env).sessionHeadroom),
-    render: () => usageLabel("5h", sessionUsage(process.env).sessionHeadroom)
+    color: (ctx) => anthropicSession(ctx) ? usageColor(sessionUsage(process.env).sessionHeadroom) : null,
+    render: (ctx) => anthropicSession(ctx) ? usageLabel("5h", sessionUsage(process.env).sessionHeadroom) : null
   },
   {
     id: "usage-weekly",
     description: "Weekly usage remaining for this pane's own account \u2014 the binding limit \u2014 from the local accounts usage cache",
     defaultEnabled: false,
-    color: () => usageColor(sessionUsage(process.env).weeklyHeadroom, true),
-    render: () => usageLabel("7d", sessionUsage(process.env).weeklyHeadroom)
+    color: (ctx) => anthropicSession(ctx) ? usageColor(sessionUsage(process.env).weeklyHeadroom, true) : null,
+    render: (ctx) => anthropicSession(ctx) ? usageLabel("7d", sessionUsage(process.env).weeklyHeadroom) : null
   },
   {
     id: "thread-title",
@@ -703,17 +930,19 @@ var segments = [
     id: "context-used",
     description: "Percentage of context window used (omitted when unknown)",
     defaultEnabled: false,
+    color: contextColor,
     render(ctx) {
       const u = contextUsage(ctx);
       if (!u)
         return null;
-      return `${Math.min(100, Math.round(u.used / u.window * 100))}%`;
+      return `ctx ${Math.min(100, Math.round(u.used / u.window * 100))}%`;
     }
   },
   {
     id: "context-remaining",
     description: "Percentage of context window remaining (omitted when unknown)",
     defaultEnabled: true,
+    color: contextColor,
     render(ctx) {
       const u = contextUsage(ctx);
       if (!u)
@@ -732,10 +961,20 @@ var segments = [
       return `${compactNum(u.used + u.output)} tok`;
     }
   },
+  {
+    id: "cache-rate",
+    description: "Percentage of input tokens served from cache (omitted when unknown)",
+    defaultEnabled: true,
+    render(ctx) {
+      const r = cacheRate(ctx);
+      return r === null ? null : `${Math.round(r * 100)}% cached`;
+    }
+  },
   {
     id: "cost",
     description: "Session cost in USD (omitted when zero)",
     defaultEnabled: true,
+    color: "dim",
     render(ctx) {
       const c = ctx.cost?.totalCostUsd;
       return c ? money(c) : null;
@@ -745,6 +984,7 @@ var segments = [
     id: "duration",
     description: "Session wall-clock duration",
     defaultEnabled: false,
+    color: "dim",
     render(ctx) {
       const ms = ctx.cost?.totalDurationMs;
       return ms ? compactDuration(ms) : null;
@@ -839,7 +1079,7 @@ async function renderLine(ctx, cfg) {
 // package.json
 var package_default = {
   name: "@hasna/statusline",
-  version: "0.0.7",
+  version: "0.0.8",
   description: "Tiny composable statusline CLI for AI coding agents \u2014 pre-built toggleable segments for Claude Code, with a provider model for others",
   license: "Apache-2.0",
   type: "module",
@@ -878,11 +1118,12 @@ var package_default = {
   },
   repository: {
     type: "git",
-    url: "git+https://github.com/hasna/statusline.git"
+    url: "https://github.com/hasna/apps.git",
+    directory: "apps/statusline"
   },
-  homepage: "https://github.com/hasna/statusline#readme",
+  homepage: "https://github.com/hasna/apps/tree/main/apps/statusline#readme",
   bugs: {
-    url: "https://github.com/hasna/statusline/issues"
+    url: "https://github.com/hasna/apps/issues"
   },
   keywords: [
     "statusline",
@@ -899,36 +1140,37 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
-    "@modelcontextprotocol/sdk": "1.12.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     zod: "3.25.76"
   },
   devDependencies: {
-    "@types/bun": "^1.2.4",
-    typescript: "5.9.3"
+    "@types/bun": "1.3.14",
+    typescript: "5.9.3",
+    "bun-types": "1.3.14"
   }
 };
 // src/install.ts
-import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname2, join as join6, resolve as resolve2 } from "path";
 function defaultSettingsPath(env) {
-  return join4(env.HOME || homedir3(), ".claude", "settings.json");
+  return join6(env.HOME || homedir6(), ".claude", "settings.json");
 }
 function claudeSettingsPath(env = process.env) {
-  const home2 = env.HOME || homedir3();
+  const home2 = env.HOME || homedir6();
   const raw = env.CLAUDE_CONFIG_DIR?.trim();
   if (!raw)
     return defaultSettingsPath(env);
-  const configDir = raw === "~" || raw.startsWith("~/") ? join4(home2, raw.slice(1)) : raw;
-  return join4(configDir, "settings.json");
+  const configDir = raw === "~" || raw.startsWith("~/") ? join6(home2, raw.slice(1)) : raw;
+  return join6(configDir, "settings.json");
 }
 function installClaude(settingsPath, env = process.env) {
   const target = settingsPath ?? claudeSettingsPath(env);
   const binary = Bun.which("statusline") || "statusline";
   let settings = {};
-  if (existsSync4(target)) {
+  if (existsSync6(target)) {
     try {
-      settings = JSON.parse(readFileSync5(target, "utf8"));
+      settings = JSON.parse(readFileSync6(target, "utf8"));
     } catch (error) {
       throw new Error(`${target} is not valid JSON \u2014 fix or move it first`);
     }
@@ -936,7 +1178,7 @@ function installClaude(settingsPath, env = process.env) {
   }
   settings.statusLine = { ...settings.statusLine, type: "command", command: `${binary} render` };
   const configDir = dirname2(target);
-  if (!existsSync4(configDir)) {
+  if (!existsSync6(configDir)) {
     if (resolve2(target) !== resolve2(defaultSettingsPath(env))) {
       throw new Error(`config dir ${configDir} does not exist \u2014 create the profile first`);
     }
@@ -1003,6 +1245,14 @@ function resetStatuslineConfig() {
   return defaultConfig();
 }
 async function renderStatusline(input = {}, config = loadConfig()) {
+  const provider = process.env.STATUSLINE_PROVIDER;
+  if (provider === "codex" || provider === "opencode") {
+    const ctx = {
+      provider,
+      cwd: typeof input.cwd === "string" ? input.cwd : process.cwd()
+    };
+    return renderLine(ctx, config);
+  }
   return renderLine(parseClaudeInput(input), config);
 }
 function sampleClaudeInput(cwd = process.cwd()) {

package/dist/context-window.d.ts

@@ -7,8 +7,30 @@ export interface ContextUsage {
     /** Context window size in tokens. */
     window: number;
 }
+/** The raw `message.usage` object of the last assistant entry that carries one. */
+export interface UsageBlock {
+    input_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    output_tokens?: number;
+}
+/**
+ * Scan the session transcript (JSONL) from the end and return the raw usage
+ * block of the last assistant entry that carries one — the block that
+ * reflects what the context window currently holds. Lines that are malformed
+ * or whose usage block lacks a numeric `input_tokens` are skipped, exactly
+ * like `contextUsage` used to skip them inline.
+ */
+export declare function lastUsageBlock(ctx: StatusContext): UsageBlock | null;
 /**
  * Derive context usage from the session transcript (JSONL). The last
  * assistant entry's usage block reflects what the context window holds.
  */
 export declare function contextUsage(ctx: StatusContext): ContextUsage | null;
+/**
+ * Fraction of input-side tokens served from cache, dispatched on the
+ * context's provider: the Claude transcript usage block, the Codex session
+ * rollout's latest token_count, or the OpenCode sessions DB. Null when the
+ * source is absent or the divisor is zero — never a wrong number.
+ */
+export declare function cacheRate(ctx: StatusContext): number | null;

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 import { type StatuslineConfig } from "./config.js";
 export { sessionAccount, sessionAccountEmail, sessionConfigDir, sessionStateFile, type SessionAccount, } from "./accounts.js";
 export { defaultConfig, loadConfig, saveConfig, configPath, type StatuslineConfig } from "./config.js";
-export { contextUsage, type ContextUsage } from "./context-window.js";
+export { cacheRate, contextUsage, lastUsageBlock, type ContextUsage, type UsageBlock } from "./context-window.js";
 export { compactAge, compactDuration, compactNum, money } from "./format.js";
 export { gitBranch, gitProjectName, gitRoot, lastCommitEpoch, trackedLineCount } from "./git.js";
 export { claudeSettingsPath, installClaude } from "./install.js";
+export { codexCacheRate, latestCodexSessionPath, type TotalTokenUsage } from "./providers/codex.js";
+export { opencodeCacheRate, type OpenCodeCacheRateOptions } from "./providers/opencode.js";
 export { parseClaudeInput } from "./providers/claude.js";
 export type { Segment, SegmentColor, StatusContext } from "./providers/types.js";
 export { renderLine } from "./render.js";