@hasna/statusline 0.0.7 → 0.0.9

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) {
@@ -126,6 +157,23 @@ function compactNum(n) {
     return `${trimmed(n / 1000)}k`;
   return `${n}`;
 }
+var BYTE_UNITS = ["K", "M", "G", "T", "P"];
+function compactBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0)
+    return "";
+  if (bytes < 1024)
+    return `${Math.floor(bytes)}B`;
+  let value = bytes / 1024;
+  let unit = 0;
+  while (unit < BYTE_UNITS.length - 1) {
+    const rounded = Number(value.toFixed(1));
+    if (rounded < 1024)
+      break;
+    value /= 1024;
+    unit += 1;
+  }
+  return `${trimmed(value)}${BYTE_UNITS[unit]}`;
+}
 function money(n) {
   return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
 }
@@ -135,10 +183,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 +243,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 +395,137 @@ 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/disk.ts
+import { statfsSync } from "fs";
+var DISK_MEMO = Symbol("statusline.disk-free");
+var DISK_WARN_PERCENT = 20;
+var DISK_CRITICAL_PERCENT = 10;
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readDiskStats(path) {
+  if (typeof statfsSync !== "function")
+    return null;
+  try {
+    const stats = statfsSync(path);
+    if (!stats)
+      return null;
+    return {
+      bsize: Number(stats.bsize),
+      blocks: Number(stats.blocks),
+      bavail: Number(stats.bavail)
+    };
+  } catch {
+    return null;
+  }
+}
+function diskFree(path, reader = readDiskStats) {
+  let stats;
+  try {
+    stats = reader(path);
+  } catch {
+    return null;
+  }
+  if (!stats)
+    return null;
+  const bsize = finiteNonNegative(stats.bsize);
+  const blocks = finiteNonNegative(stats.blocks);
+  const bavail = finiteNonNegative(stats.bavail);
+  if (bsize === null || blocks === null || bavail === null)
+    return null;
+  if (bsize <= 0 || blocks <= 0)
+    return null;
+  const available = Math.min(bavail, blocks);
+  const totalBytes = bsize * blocks;
+  const freeBytes = bsize * available;
+  if (!Number.isFinite(totalBytes) || !Number.isFinite(freeBytes))
+    return null;
+  return {
+    freeBytes,
+    totalBytes,
+    freePercent: available / blocks * 100
+  };
+}
+function diskFreeFor(path, memo, reader = readDiskStats) {
+  if (!memo)
+    return diskFree(path, reader);
+  const hit = memo.get(DISK_MEMO);
+  if (hit && hit.path === path)
+    return hit.value;
+  const value = diskFree(path, reader);
+  memo.set(DISK_MEMO, { path, value });
+  return value;
+}
+function diskLevel(freePercent) {
+  if (!Number.isFinite(freePercent))
+    return null;
+  if (freePercent < DISK_CRITICAL_PERCENT)
+    return "critical";
+  if (freePercent < DISK_WARN_PERCENT)
+    return "low";
+  return null;
+}
+function formatDiskFree(disk) {
+  const value = compactBytes(disk.freeBytes);
+  if (!value)
+    return "";
+  return diskLevel(disk.freePercent) ? `disk ${value} low` : `disk ${value}`;
+}
+function diskColor(disk) {
+  if (!disk)
+    return null;
+  switch (diskLevel(disk.freePercent)) {
+    case "critical":
+      return "red";
+    case "low":
+      return "yellow";
+    default:
+      return "dim";
+  }
+}
+
 // 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 +549,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 +564,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 +585,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 +613,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 +627,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 +635,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 +693,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 +766,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 +782,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 +810,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 +841,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}%`;
 }
@@ -591,16 +910,39 @@ var segments = [
       return n ? compactNum(n) : null;
     }
   },
+  {
+    id: "disk-free",
+    description: "Free space on the volume holding the working directory",
+    defaultEnabled: false,
+    color: (ctx, memo) => diskColor(diskFreeFor(dir(ctx), memo)),
+    render(ctx, memo) {
+      const disk = diskFreeFor(dir(ctx), memo);
+      return disk ? formatDiskFree(disk) || null : null;
+    }
+  },
   {
     id: "current-dir",
     description: "Current working directory (basename)",
     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 +953,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 +965,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 +1025,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 +1046,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 +1077,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 +1100,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;
@@ -811,13 +1167,14 @@ function colorsEnabled(cfg, env = process.env) {
     return false;
   return cfg.colors !== false;
 }
-function paint(segment, text, ctx) {
-  const color = typeof segment.color === "function" ? segment.color(ctx) : segment.color;
+function paint(segment, text, ctx, memo) {
+  const color = typeof segment.color === "function" ? segment.color(ctx, memo) : segment.color;
   const code = color ? ANSI[color] : undefined;
   return code ? `${code}${text}${RESET}` : text;
 }
 async function renderLine(ctx, cfg) {
   const colorize = colorsEnabled(cfg);
+  const memo = new Map;
   const rows = [[]];
   for (const id of cfg.segments) {
     if (id === "newline") {
@@ -828,9 +1185,9 @@ async function renderLine(ctx, cfg) {
     if (!segment)
       continue;
     try {
-      const out = await segment.render(ctx);
+      const out = await segment.render(ctx, memo);
       if (out)
-        rows[rows.length - 1].push(colorize ? paint(segment, out, ctx) : out);
+        rows[rows.length - 1].push(colorize ? paint(segment, out, ctx, memo) : out);
     } catch {}
   }
   return rows.map((parts) => parts.join(cfg.separator)).filter((row) => row.length > 0).join(`
@@ -839,7 +1196,7 @@ async function renderLine(ctx, cfg) {
 // package.json
 var package_default = {
   name: "@hasna/statusline",
-  version: "0.0.7",
+  version: "0.0.9",
   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 +1235,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 +1257,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 +1295,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 +1362,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()) {