@alyibrahim/claude-statusline 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# @alyibrahim/claude-statusline
+
+A zero-dependency statusline for [Claude Code](https://claude.ai/code). Shows model, git branch, context usage, subscription rate limits, and session cost — updating after every response.
+
+## Requirements
+
+- **Node.js >=16** — the only hard requirement (installed with npm)
+- **git** — optional, used for branch display; gracefully absent if not installed
+
+No `jq`, `bc`, `ccusage`, or other external tools needed.
+
+## Install
+
+```bash
+npm install -g @alyibrahim/claude-statusline
+```
+
+That's it. The statusline is configured automatically. Restart Claude Code to see it.
+
+**Manual setup** (if auto-setup failed):
+```bash
+claude-statusline setup
+```
+
+## What it shows
+
+**Line 1:** Model · Effort level · Active agents · Current task · Directory `[git branch]` · Context bar
+
+**Line 2:** Weekly usage · 5h usage · Reset countdown *(subscription)*  or  Session cost *(API key)*
+
+## Why this one
+
+| | This package | Others |
+|---|---|---|
+| Zero dependencies | ✓ no `jq`, `bc`, etc. | Require external tools |
+| No API calls | ✓ reads stdin directly | Poll OAuth endpoint, hit rate limits |
+| Subscription vs API aware | ✓ | Show cost for everyone |
+| Context bar normalized | ✓ usable % | Raw remaining % |
+| Active agent counter | ✓ | — |
+
+## Uninstall
+
+```bash
+npm uninstall -g @alyibrahim/claude-statusline
+```
+
+> If using yarn/pnpm/bun, run `claude-statusline uninstall` **before** removing the package.
+
+## Notes
+
+- **Switched Node versions?** Re-run `claude-statusline setup` — the Node path is baked in at install time.
+- Writes only the `statusLine` key in `~/.claude/settings.json` — all other settings are preserved.
+- Respects `$CLAUDE_CONFIG_DIR` if set.
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+'use strict';
+const { setup } = require('../scripts/setup');
+const { uninstall } = require('../scripts/uninstall');
+const { getSettingsPath } = require('../scripts/config');
+
+const USAGE = `
+claude-statusline <command>
+
+Commands:
+  setup      Configure ~/.claude/settings.json to use this statusline
+  uninstall  Remove this statusline from ~/.claude/settings.json
+`.trim();
+
+const cmd = process.argv[2];
+
+if (cmd === 'setup') {
+  const result = setup({ force: true });
+  if (!result.ok) {
+    console.error('Error:', result.error);
+    process.exit(1);
+  }
+  console.log(`✓ Configured at ${result.settingsPath}. Restart Claude Code to see it.`);
+
+} else if (cmd === 'uninstall') {
+  const result = uninstall();
+  if (!result.ok) {
+    console.error('Error:', result.error);
+    process.exit(1);
+  }
+  console.log(`✓ Removed statusline from ${getSettingsPath()}`);
+
+} else if (cmd === undefined) {
+  console.log(USAGE);
+  process.exit(0);
+
+} else {
+  console.error(`Unknown command: ${cmd}`);
+  console.log('\n' + USAGE);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@alyibrahim/claude-statusline",
+  "version": "1.0.0",
+  "description": "A zero-dependency Claude Code statusline — reads rate limits from stdin, no API calls",
+  "engines": { "node": ">=16" },
+  "bin": { "claude-statusline": "bin/cli.js" },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "preuninstall": "node scripts/preuninstall.js",
+    "test": "jest"
+  },
+  "files": ["statusline.js", "bin/", "scripts/", "README.md"],
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.0.0"
+  }
+}

package/scripts/config.js

@@ -0,0 +1,26 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getSettingsPath() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  const base = (configDir && configDir.trim())
+    ? configDir
+    : path.join(os.homedir(), '.claude');
+  return path.join(base, 'settings.json');
+}
+
+function atomicWrite(filePath, obj) {
+  const tmpPath = filePath + '.tmp';
+  if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+  fs.writeFileSync(tmpPath, JSON.stringify(obj, null, 2));
+  try {
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath); } catch (e) {}
+    throw err;
+  }
+}
+
+module.exports = { getSettingsPath, atomicWrite };

package/scripts/postinstall.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+const { setup } = require('./setup');
+try {
+  const result = setup({ force: false });
+  if (result.settingsPath === null) process.exit(0); // non-global install, skip silently
+  if (!result.ok) {
+    console.warn('\n⚠  claude-statusline: auto-setup failed:', result.error);
+    console.warn('   Run manually: claude-statusline setup\n');
+  } else {
+    console.log('\n✓  claude-statusline configured. Restart Claude Code to see it.\n');
+  }
+} catch (e) {
+  // Fully silent on any error — postinstall must never fail npm install
+}
+process.exit(0); // always exit 0 — never fail npm install

package/scripts/preuninstall.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+'use strict';
+const { uninstall } = require('./uninstall');
+try { uninstall(); } catch (e) {} // fully silent — best-effort cleanup
+process.exit(0);

package/scripts/setup.js

@@ -0,0 +1,47 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const { getSettingsPath, atomicWrite } = require('./config');
+
+const UNSAFE_CHARS = /["`$!()\\]/;
+
+function setup({ force = false } = {}) {
+  // CI guard: skip during local/CI npm installs unless forced (e.g. from CLI)
+  if (!force && process.env.npm_config_global !== 'true') {
+    return { ok: true, settingsPath: null };
+  }
+
+  const scriptPath = path.resolve(__dirname, '../statusline.js');
+  if (!fs.existsSync(scriptPath)) {
+    return { ok: false, error: `Could not locate statusline.js at ${scriptPath}` };
+  }
+
+  if (UNSAFE_CHARS.test(process.execPath) || UNSAFE_CHARS.test(scriptPath)) {
+    return { ok: false, error: 'Node.js path or install path contains unsupported characters.' };
+  }
+
+  const settingsPath = getSettingsPath();
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      return { ok: false, error: 'settings.json contains invalid JSON — fix manually then re-run.' };
+    }
+  }
+
+  const command = `"${process.execPath}" "${scriptPath}"`;
+  settings.statusLine = { type: 'command', command };
+
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+
+  try {
+    atomicWrite(settingsPath, settings);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+
+  return { ok: true, settingsPath };
+}
+
+module.exports = { setup };

package/scripts/uninstall.js

@@ -0,0 +1,28 @@
+'use strict';
+const fs = require('fs');
+const { getSettingsPath, atomicWrite } = require('./config');
+
+function uninstall() {
+  const settingsPath = getSettingsPath();
+  if (!fs.existsSync(settingsPath)) return { ok: true };
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (e) {
+    return { ok: false, error: 'settings.json contains invalid JSON — cannot safely modify.' };
+  }
+
+  if (!settings.statusLine) return { ok: true };
+  delete settings.statusLine;
+
+  try {
+    atomicWrite(settingsPath, settings);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+
+  return { ok: true };
+}
+
+module.exports = { uninstall };

package/statusline.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+// Claude Code Statusline
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// Read JSON from stdin
+let input = '';
+// Timeout guard: if stdin doesn't close within 3s (e.g. pipe issues on
+// Windows/Git Bash), exit silently instead of hanging.
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const sanitize = s => String(s).replace(/\x1b\[[0-9;]*[mGKHFABCDJ]/g, '');
+    const data = JSON.parse(input);
+    const model = sanitize(data.model?.display_name || 'Claude');
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to usable context)
+    // Claude Code reserves ~16.5% for autocompact buffer, so usable context
+    // is 83.5% of the total window. We normalize to show 100% at that point.
+    const AUTO_COMPACT_BUFFER_PCT = 16.5;
+    let ctx = '';
+    if (remaining != null) {
+      // Normalize: subtract buffer from remaining, scale to usable range
+      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on usable context thresholds
+      if (used < 50) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 65) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 80) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    let activeAgents = 0;
+    const homeDir = os.homedir();
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude');
+    const todosDir = path.join(claudeDir, 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        for (const f of files) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, f.name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) {
+              activeAgents++;
+              if (!task) task = sanitize(inProgress.activeForm || '');
+            }
+          } catch (e) {}
+        }
+      } catch (e) {
+        // Silently fail on file system errors - don't break statusline
+      }
+    }
+
+    // Session cost — only show for API key users; rate_limits presence means subscription
+    const isSubscription = data.rate_limits !== undefined;
+    const sessionCost = !isSubscription ? (data.cost?.total_cost_usd ?? null) : null;
+
+    // Usage limits — provided by Claude Code in stdin; no API call needed
+    const pct5h      = data.rate_limits?.five_hour?.used_percentage ?? null;
+    const pctWeek    = data.rate_limits?.seven_day?.used_percentage ?? null;
+    const resetsAt5h = data.rate_limits?.five_hour?.resets_at ?? null; // Unix epoch seconds
+
+    function usageLine(label, pct, suffix = '') {
+      if (pct === null) return '';
+      const p = Math.round(pct);
+      const color = p < 50 ? '\x1b[32m' : p < 75 ? '\x1b[33m' : '\x1b[31m';
+      return `\x1b[0m\x1b[97m${label}:\x1b[0m ${color}${p}%\x1b[0m${suffix}`;
+    }
+
+    let resetSuffix = '';
+    if (resetsAt5h) {
+      const resetDate = new Date(resetsAt5h * 1000); // stdin gives epoch seconds
+      if (!isNaN(resetDate)) {
+        const minsLeft = Math.max(0, Math.round((resetDate - Date.now()) / 60_000));
+        const h = Math.floor(minsLeft / 60), m = minsLeft % 60;
+        resetSuffix = ` \x1b[2m↺ ${h}h${String(m).padStart(2, '0')}m\x1b[0m`;
+      }
+    }
+
+    // Git branch (command is a fixed string; dir is passed as cwd, not interpolated — no injection risk)
+    let branch = '';
+    try {
+      branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: dir, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    } catch (e) {}
+
+    // Output
+    const dirname = sanitize(path.basename(dir));
+    const safeBranch = sanitize(branch);
+    // dirname is bright; branch stays cyan; surrounding prefix/suffix stay dim
+    const dirDisplay = safeBranch
+      ? `\x1b[1m\x1b[97m${dirname}\x1b[0m\x1b[2m \x1b[36m[${safeBranch}]\x1b[0m`
+      : `\x1b[1m\x1b[97m${dirname}\x1b[0m`;
+    const u5h = usageLine('Current', pct5h, resetSuffix), u7d = usageLine('Weekly', pctWeek);
+    const costDisplay = sessionCost !== null
+      ? `  \x1b[33m$${sessionCost < 0.01 ? sessionCost.toFixed(4) : sessionCost.toFixed(2)}\x1b[0m`
+      : '';
+    const usageContent = [u7d, u5h].filter(Boolean).join('  ');
+    const line2 = (usageContent || costDisplay)
+      ? `\x1b[0m\x1b[32mUsage\x1b[0m \x1b[2m│\x1b[0m ${[usageContent, costDisplay].filter(Boolean).join('  ')}`
+      : '';
+    // Effort level: read from env var first, then settings.json, then fall back to
+    // model-based default (sonnet-4/opus-4 default to "medium" in Claude Code).
+    const effortLetters = { low: 'L', medium: 'M', high: 'H' };
+    let effortSuffix = '';
+    try {
+      let rawEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL
+        || JSON.parse(fs.readFileSync(path.join(claudeDir, 'settings.json'), 'utf8'))?.effortLevel
+        || '';
+      if (!rawEffort) {
+        const m = model.toLowerCase();
+        if (m.includes('sonnet-4') || m.includes('opus-4')) rawEffort = 'medium';
+      }
+      const effortColors = { low: '\x1b[32m', medium: '\x1b[33m', high: '\x1b[38;5;208m', max: '\x1b[31m' };
+      const level = rawEffort?.toLowerCase();
+      const color = effortColors[level] || '';
+      if (level === 'max') {
+        effortSuffix = ` \x1b[0m${color}[MAXX]\x1b[0m`;
+      } else {
+        const letter = effortLetters[level];
+        if (letter) effortSuffix = ` \x1b[0m${color}[${letter}]\x1b[0m`;
+      }
+    } catch (e) {}
+
+    const agentDisplay = activeAgents > 0 ? ` \x1b[0m\x1b[36m↪ ${activeAgents}\x1b[0m` : '';
+    const modelDisplay = `\x1b[0m\x1b[94m${model}\x1b[0m` + effortSuffix + agentDisplay;
+    const line1 = task
+      ? `${modelDisplay} \x1b[2m│\x1b[0m \x1b[1m${task}\x1b[0m \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`
+      : `${modelDisplay} \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`;
+    const visibleLen = line1.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const sep = `\x1b[2m${'─'.repeat(visibleLen)}\x1b[0m`;
+    process.stdout.write(line2 ? `${line1}\n${sep}\n${line2}` : line1);
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});