ctxline-claude 0.0.2 → 0.0.6

package/README.md

@@ -105,14 +105,15 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 | **Weekly** | Weekly usage allowance + time until the weekly reset (subscription users) |
 | **Task** | The in-progress todo, when there is one |
 
-> \[!NOTE\] Usage bars change color automatically as you approach your
-> limits.
+> [!NOTE]
+> Usage bars change color automatically as you approach your limits.
 
 ## How it works
 
-- **Source** — context comes from Claude Code's session data; both usage bars are fetched from `https://api.anthropic.com/api/oauth/usage` (the `/usage` data — 5-hour and weekly limits). API-key users skip the usage fetch.
-- **Adaptive timing** — 1.5s timeout on the first prompt (cold start), 1.2s after (connection reused).
-- **Caching** — usage is cached at `~/.claude/cache/usage-cache.json`, shared across sessions. Within 30s the cache renders directly (the API call is skipped); if a live call fails, the last value (up to 10 min old) is shown so the bar never vanishes. The reset countdown recomputes every render.
+- **Source** — context comes from Claude Code's session data. Usage bars are read straight from the `rate_limits` field Claude Code pipes in (no network), falling back to `https://api.anthropic.com/api/oauth/usage` (the same `/usage` data — 5-hour and weekly limits) when that field isn't present yet. API-key users skip usage entirely.
+- **No network on the fast path** — when `rate_limits` is in the session data, there's no API call at all. The fetch below only runs as a fallback (e.g. the first render of a session, before the field appears).
+- **Adaptive timing** — for the fallback fetch: 1.5s timeout on the first prompt (cold start), 1.2s after (connection reused).
+- **Caching** — the fallback fetch is cached at `~/.claude/cache/usage-cache.json`, shared across sessions. Within 30s the cache renders directly (the API call is skipped); if a live call fails, the last value (up to 10 min old) is shown so the bar never vanishes. The reset countdown recomputes every render.
 - **Never breaks** — every failure path falls back silently; the statusline always prints.
 
 ## FAQ
@@ -120,7 +121,7 @@ Remove-Item "$env:USERPROFILE\.claude\cache\usage-cache.json" -ErrorAction Silen
 <details>
 <summary>Does this use the same data as /usage?</summary>
 
-Yes. Usage information comes directly from Anthropic's usage API.
+Yes — the same 5-hour and weekly limits. It reads them from the session data Claude Code provides when available, and falls back to Anthropic's usage API (the endpoint `/usage` uses) otherwise.
 
 </details>
 
@@ -141,7 +142,7 @@ No. All failures are handled silently and the statusline always renders.
 <details>
 <summary>Does it expose my API keys / auth tokens?</summary>
 
-No. Your credentials never leave your machine. The OAuth token is read locally (from `~/.claude/.credentials.json` or the macOS keychain) only to authenticate the request to Anthropic's own usage API — the same endpoint `/usage` uses. Nothing is sent to any third party, logged, or cached; only the resulting usage percentages are stored locally.
+No. Your credentials never leave your machine. On the fast path no token is read at all — usage comes straight from the session data. Only on the fallback fetch is the OAuth token read locally (from `~/.claude/.credentials.json` or the macOS keychain), used solely to authenticate the request to Anthropic's own usage API — the same endpoint `/usage` uses. Nothing is sent to any third party, logged, or cached; only the resulting usage percentages are stored locally.
 
 </details>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxline-claude",
-  "version": "0.0.2",
+  "version": "0.0.6",
   "description": "A customizable statusline for Claude Code that tracks context usage and session limits",
   "bin": {
     "ctxline-claude": "bin/install.js"

package/statusline.js

@@ -15,6 +15,10 @@ const IS_API_KEY = !!process.env.ANTHROPIC_API_KEY;
 // Shared width (cells) for all progress bars: context, current, weekly.
 const BAR_WIDTH = 6;
 
+// Max characters shown for the git branch; longer names are tail-truncated with "…".
+// Tail-truncation keeps the start (ticket IDs like "TAMA5-32796" live there) visible.
+const MAX_BRANCH_LEN = 24;
+
 // Cache configuration
 const CACHE_DIR = path.join(os.homedir(), '.claude', 'cache');
 const USAGE_CACHE_FILE = path.join(CACHE_DIR, 'usage-cache.json');
@@ -33,9 +37,20 @@ const colors = {
   yellow: '\x1b[33m',
   orange: '\x1b[38;5;208m',
   red: '\x1b[31m',
+  purple: '\x1b[38;5;135m',
   blink: '\x1b[5m'
 };
 
+// Color for the thinking-effort indicator. Levels rank low < medium < high < xhigh < max
+// < ultracode; only the top two are highlighted — "max" red, "ultracode" purple. Every
+// other level (including xhigh) renders dim like the rest of the metadata.
+function getEffortColor(level) {
+  const lvl = String(level).toLowerCase();
+  if (lvl === 'max') return colors.red;
+  if (lvl === 'ultracode') return colors.purple;
+  return colors.dim;
+}
+
 function getUsageColor(percentage) {
   if (percentage < 50) return colors.green;
   if (percentage < 75) return colors.yellow;
@@ -48,11 +63,50 @@ function shortenModel(name) {
   return name.replace(/\s+context\)/i, ')');
 }
 
+// Tail-truncate an over-long branch name, preserving the leading ticket ID.
+function truncateBranch(name) {
+  return name.length > MAX_BRANCH_LEN ? name.slice(0, MAX_BRANCH_LEN - 1) + '…' : name;
+}
+
+// Resolve the current git branch by reading .git/HEAD directly (no `git` subprocess —
+// keeps the render fast and dependency-free). Walks up from `dir` to find the repo,
+// handles worktrees (.git as a file) and detached HEAD (short sha). Best-effort: '' on any failure.
+function getGitBranch(dir) {
+  try {
+    let cur = dir;
+    let gitPath = '';
+    for (let i = 0; i < 50 && cur; i++) {
+      const candidate = path.join(cur, '.git');
+      if (fs.existsSync(candidate)) { gitPath = candidate; break; }
+      const parent = path.dirname(cur);
+      if (parent === cur) break;        // reached filesystem root
+      cur = parent;
+    }
+    if (!gitPath) return '';
+
+    let gitDir = gitPath;
+    if (fs.statSync(gitPath).isFile()) {
+      // Worktree/submodule: ".git" is a file like "gitdir: /path/to/.git/worktrees/x".
+      const m = fs.readFileSync(gitPath, 'utf8').match(/gitdir:\s*(.+)/);
+      if (!m) return '';
+      gitDir = path.resolve(path.dirname(gitPath), m[1].trim());
+    }
+
+    const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+    const ref = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+    if (ref) return truncateBranch(ref[1]);
+    if (/^[0-9a-f]{7,40}$/i.test(head)) return head.slice(0, 7);  // detached HEAD -> short sha
+    return '';
+  } catch (e) {
+    return '';
+  }
+}
+
 function getContextBar(remaining) {
   const effectiveRemaining = remaining ?? 100;
   const used = Math.max(0, Math.min(100, 100 - Math.round(effectiveRemaining)));
 
-  const filled = Math.floor((used / 100) * BAR_WIDTH);
+  const filled = Math.round((used / 100) * BAR_WIDTH);
   const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(BAR_WIDTH - filled);
 
   let coloredBar;
@@ -109,6 +163,37 @@ function normalizePercentage(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
 
+// Build usage bars from stdin `rate_limits` (Claude.ai Pro/Max, present only after the
+// first API response of a session). Same data as the OAuth usage API, so reading it here
+// skips the network/credentials/cache path entirely. `resets_at` is a Unix epoch in
+// SECONDS (not ISO) — ×1000 before Date. Returns { current, weekly } bars, or null when
+// rate_limits is absent or the required five_hour segment is unusable (caller falls back).
+function buildUsageFromStdin(data) {
+  const rl = data?.rate_limits;
+  if (!rl) return null;
+
+  const toEntry = (seg) => {
+    if (!seg) return null;
+    const pct = normalizePercentage(seg.used_percentage);
+    if (pct == null) return null;
+    // resets_at is a Unix epoch in SECONDS. Coerce + validate defensively: a non-numeric
+    // or out-of-range value would make new Date(...).toISOString() throw, and this path
+    // runs outside outputStatus's try/catch. Fall back to resetsAt: null on anything bad.
+    let resetsAt = null;
+    const epoch = Number(seg.resets_at);
+    if (Number.isFinite(epoch) && epoch > 0) {
+      const d = new Date(epoch * 1000);
+      if (!Number.isNaN(d.getTime())) resetsAt = d.toISOString();
+    }
+    return { percentage: pct, resetsAt };
+  };
+
+  const fiveHour = toEntry(rl.five_hour);
+  if (!fiveHour) return null;          // five_hour is the required bar
+  const weekly = toEntry(rl.seven_day);
+  return buildUsageBars(fiveHour, weekly);
+}
+
 // Validate a single usage entry ({ percentage, resetsAt }). Returns true only for a
 // finite 0-100 percentage and a parseable (or absent) resetsAt.
 function isValidUsageEntry(entry) {
@@ -309,14 +394,16 @@ function outputStatus(data, usage) {
     const model = shortenModel(data?.model?.display_name || 'Claude');
     const dir = data?.workspace?.current_dir || process.cwd();
     const dirname = path.basename(dir);
+    const branch = getGitBranch(dir);
+    const effort = data?.effort?.level || '';
     const sessionId = data?.session_id || '';
     const remaining = data?.context_window?.remaining_percentage;
 
     const contextBar = getContextBar(remaining);
     const task = getCurrentTask(sessionId);
     const parts = [];
-    parts.push(dirname);
-    parts.push(model);
+    parts.push(branch ? `${dirname} ${colors.dim}⎇ ${branch}${colors.reset}` : dirname);
+    parts.push(effort ? `${model}${getEffortColor(effort)} · ${effort}${colors.reset}` : model);
     parts.push(`CTX ${contextBar}`);
 
     if (usage?.current) parts.push(`5h ${usage.current}`);
@@ -337,21 +424,45 @@ function outputFallback(usage) {
   process.stdout.write(parts.join(' \u2502 '));
 }
 
-// Wrapper that skips usage fetch for API key users
-function getUsage(callback) {
+// Resolve usage bars for a (possibly null) parsed stdin payload.
+// Order: API-key users get none; otherwise prefer stdin `rate_limits` (no network),
+// then fall back to the cache+API flow when stdin lacks it (cold start / non-Pro/Max).
+function resolveUsage(data, callback) {
   if (IS_API_KEY) {
-    callback(null);
-  } else {
-    getUsageWithCache(callback);
+    return callback(null);
   }
+  const fromStdin = buildUsageFromStdin(data);
+  if (fromStdin) {
+    return callback(fromStdin);
+  }
+  getUsageWithCache(callback);
 }
 
 // Process with timeout
-if (process.stdin.isTTY) {
-  getUsage((usage) => {
-    outputFallback(usage);
+// Parse the accumulated stdin into a payload object, or null if empty/unparseable.
+function parseInput(input) {
+  if (!input || input.length === 0) return null;
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return null;
+  }
+}
+
+// Resolve usage for `data` (preferring stdin rate_limits), then render and exit.
+function emit(data) {
+  resolveUsage(data, (usage) => {
+    if (data) {
+      outputStatus(data, usage);
+    } else {
+      outputFallback(usage);
+    }
     process.exit(0);
   });
+}
+
+if (process.stdin.isTTY) {
+  emit(null);
 } else {
   let input = '';
   let timeoutReached = false;
@@ -360,19 +471,7 @@ if (process.stdin.isTTY) {
 
   const timeout = setTimeout(() => {
     timeoutReached = true;
-    getUsage((usage) => {
-      if (input.length > 0) {
-        try {
-          const data = JSON.parse(input);
-          outputStatus(data, usage);
-        } catch (e) {
-          outputFallback(usage);
-        }
-      } else {
-        outputFallback(usage);
-      }
-      process.exit(0);
-    });
+    emit(parseInput(input));
   }, overallTimeout);
 
   process.stdin.setEncoding('utf8');
@@ -380,15 +479,6 @@ if (process.stdin.isTTY) {
   process.stdin.on('end', () => {
     if (timeoutReached) return;
     clearTimeout(timeout);
-
-    getUsage((usage) => {
-      try {
-        const data = JSON.parse(input);
-        outputStatus(data, usage);
-      } catch (e) {
-        outputFallback(usage);
-      }
-      process.exit(0);
-    });
+    emit(parseInput(input));
   });
 }