contextbricks-universal 4.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jeremy Dawes (Jezweb)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# ContextBricks Universal
+
+> Cross-platform statusline for [Claude Code](https://claude.ai/code) CLI with real-time context brick visualization.
+
+**Works on Windows, Linux, and macOS** — pure Node.js, no bash or jq required.
+
+```
+[Sonnet 4.5] claude-skills:main *↑2 | +145/-23
+[5f2ce67] Remove auth-js skill
+[■■■■■■■■■■■■■□□□□□□□□□□□□□□□□□] 43% | 113k free | 0h12m | $0.87
+5h:64% ~23m | 7d:57% ~1d23h | sonnet:9% ~3d23h
+```
+
+## Features
+
+- **Real-time context tracking** — brick visualization of context window usage
+- **Rate limit tracking** — 5-hour and 7-day utilization with reset timers (Max/Pro subscribers)
+- **Official percentage fields** (Claude Code 2.1.6+) with fallback calculation (2.0.70+)
+- **Git integration** — repo, branch, commit hash, message, dirty/ahead/behind indicators
+- **Session metrics** — model name, lines changed, duration, cost (hidden for Max subscribers)
+- **Environment config** — `CONTEXTBRICKS_SHOW_DIR`, `CONTEXTBRICKS_BRICKS`, `CONTEXTBRICKS_SHOW_LIMITS`
+
+## Installation
+
+### Quick Install (Recommended)
+
+```bash
+npm install -g contextbricks-universal
+contextbricks install
+```
+
+Or one-liner via npx (installs and runs automatically):
+
+```bash
+npx contextbricks-universal
+```
+
+Node.js is the only requirement (already present if you use Claude Code).
+
+### From GitHub (without npm)
+
+```bash
+npm install -g github:thebtf/contextbricks-universal
+contextbricks install
+```
+
+### From Source
+
+```bash
+git clone https://github.com/thebtf/contextbricks-universal.git
+cd contextbricks-universal
+node bin/cli.js install
+```
+
+### What the Installer Does
+
+1. Copies `statusline.js` to `~/.claude/statusline.js`
+2. Updates `~/.claude/settings.json` with the `statusLine` command
+3. Backs up existing configuration before any changes
+
+## Display Layout
+
+### Line 1 — Model + Git + Changes
+
+```
+[Sonnet 4.5] claude-skills:main *↑2 | +145/-23
+```
+
+### Line 2 — Commit Details
+
+```
+[5f2ce67] Remove auth-js skill
+```
+
+### Line 3 — Context Bricks
+
+```
+[■■■■■■■■■■■■■□□□□□□□□□□□□□□□□□] 43% | 113k free | 0h12m | $0.87
+```
+
+### Line 4 — Rate Limits (Max/Pro subscribers)
+
+```
+5h:64% ~23m | 7d:57% ~1d23h | sonnet:9% ~3d23h
+```
+
+| Symbol | Meaning |
+|--------|---------|
+| `■` (cyan) | Used context |
+| `□` (dim) | Free space |
+| `*` | Uncommitted changes |
+| `↑3` | Ahead of remote by 3 |
+| `↓2` | Behind remote by 2 |
+| `5h:X%` | 5-hour rolling limit utilization |
+| `7d:X%` | 7-day overall limit utilization |
+| `sonnet:X%` | 7-day Sonnet sub-limit (if applicable) |
+| `opus:X%` | 7-day Opus sub-limit (if applicable) |
+| `~22m` / `~1d23h` | Time until limit resets (exact by default) |
+
+## Configuration
+
+| Environment Variable | Default | Description |
+|---|---|---|
+| `CONTEXTBRICKS_SHOW_DIR` | `1` | Show current subdirectory (`0` to hide) |
+| `CONTEXTBRICKS_BRICKS` | `30` | Number of bricks in the visualization |
+| `CONTEXTBRICKS_SHOW_LIMITS` | `1` | Show rate limit utilization (`0` to hide) |
+| `CONTEXTBRICKS_RESET_EXACT` | `1` | Exact reset times `~1d23h` (`0` for approximate `~1d`) |
+
+## How It Works
+
+### Context Tracking (Claude Code 2.1.6+)
+
+Uses pre-calculated percentage fields:
+
+```json
+{
+  "context_window": {
+    "context_window_size": 200000,
+    "used_percentage": 43.5,
+    "remaining_percentage": 56.5
+  }
+}
+```
+
+### Fallback (Claude Code 2.0.70+)
+
+Calculates from `current_usage` token counts when percentage fields are unavailable.
+
+### Settings
+
+The installer configures `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node ~/.claude/statusline.js",
+    "padding": 0
+  }
+}
+```
+
+## Rate Limit Tracking
+
+Line 4 shows your current utilization of Claude's rate limits — useful for Max and Pro subscribers to avoid hitting caps.
+
+### How It Works
+
+1. Reads your OAuth token from Claude Code credentials (`~/.claude/.credentials.json`, or macOS keychain)
+2. Fetches usage data from `api.anthropic.com/api/oauth/usage`
+3. Caches the response for 5 minutes (`~/.claude/.usage-cache.json`)
+4. Displays utilization percentages with color coding:
+   - **Green** (0-49%) — plenty of capacity
+   - **Yellow** (50-79%) — approaching limit
+   - **Red** (80-100%) — near or at limit
+
+### Requirements
+
+- Active Claude Max or Pro subscription with OAuth credentials
+- API-only users will not see Line 4 (gracefully skipped)
+
+### Privacy
+
+- Your OAuth token is never logged or exposed in command arguments
+- Token is passed to the HTTPS subprocess via environment variable
+- Cache file (`~/.claude/.usage-cache.json`) is stored locally
+
+### Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Line 4 not showing | Verify `~/.claude/.credentials.json` exists with `claudeAiOauth.accessToken` |
+| Stale data | Delete `~/.claude/.usage-cache.json` to force refresh |
+| Want to hide Line 4 | Set `CONTEXTBRICKS_SHOW_LIMITS=0` |
+
+## Testing
+
+```bash
+contextbricks test
+```
+
+## Requirements
+
+- **Node.js** >= 14
+- **git** (optional, for git info display)
+
+No bash, jq, bc, sed, cut, or any other Unix tools required.
+
+## Bash vs Node.js
+
+| | Bash (v3.5) | Node.js (v4.x) |
+|---|---|---|
+| **Platform** | Linux/macOS only | Windows + Linux + macOS |
+| **Dependencies** | bash, jq, git, bc, sed, cut | Node.js only (git optional) |
+| **JSON parsing** | External `jq` | Native `JSON.parse()` |
+| **Install** | Shell scripts | `npm i -g contextbricks-universal` |
+| **Output** | Identical | Identical |
+
+## Uninstallation
+
+```bash
+contextbricks uninstall
+```
+
+Or manually:
+1. Delete `~/.claude/statusline.js`
+2. Remove the `statusLine` section from `~/.claude/settings.json`
+3. Restart Claude Code
+
+## Acknowledgements
+
+This project is a cross-platform Node.js rewrite of [ContextBricks](https://github.com/jezweb/claude-skills/tree/main/tools/statusline) created by [Jeremy Dawes](https://github.com/jezweb) ([jezweb.com.au](https://jezweb.com.au)). The original bash implementation provided the foundation for the statusline format, brick visualization, and git integration.
+
+Also inspired by [ccstatusline](https://github.com/sirmalloc/ccstatusline).
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2025 Jeremy Dawes (Jezweb)

package/bin/cli.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const command = process.argv[2];
+const STATUSLINE_SCRIPT = path.join(__dirname, '..', 'scripts', 'statusline.js');
+
+// Colors for terminal output
+const c = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+};
+
+// Paths
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const INSTALL_PATH = path.join(CLAUDE_DIR, 'statusline.js');
+const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
+
+function checkDependencies() {
+  // git is optional but recommended
+  const gitResult = spawnSync('git', ['--version'], { stdio: 'pipe', windowsHide: true, timeout: 5000 });
+  if (gitResult.status !== 0) {
+    console.warn(`${c.yellow}Warning: git not found. Git info will not be available.${c.reset}`);
+  }
+
+  console.log(`${c.green}Dependencies OK${c.reset} (Node.js ${process.version})`);
+}
+
+function backupFile(filePath) {
+  if (fs.existsSync(filePath)) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+    const backupPath = `${filePath}.backup-${timestamp}`;
+    fs.copyFileSync(filePath, backupPath);
+    return backupPath;
+  }
+  return null;
+}
+
+function install() {
+  console.log(`\n${c.cyan}${c.bold}ContextBricks${c.reset} - Claude Code Status Line Installer\n`);
+
+  console.log('Checking dependencies...');
+  checkDependencies();
+  console.log('');
+
+  // Ensure ~/.claude exists
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    console.log(`Created: ${CLAUDE_DIR}`);
+  }
+
+  // Backup existing statusline script
+  const scriptBackup = backupFile(INSTALL_PATH);
+  if (scriptBackup) {
+    console.log(`Backed up existing script: ${scriptBackup}`);
+  }
+
+  // Copy statusline.js
+  console.log('Installing status line script...');
+  if (!fs.existsSync(STATUSLINE_SCRIPT)) {
+    console.error(`${c.red}Error: Source script not found: ${STATUSLINE_SCRIPT}${c.reset}`);
+    process.exit(1);
+  }
+  fs.copyFileSync(STATUSLINE_SCRIPT, INSTALL_PATH);
+  console.log(`   Installed: ${INSTALL_PATH}`);
+  console.log('');
+
+  // Build the command string for settings.json
+  // Use forward slashes for cross-platform compatibility
+  const homedir = os.homedir().replace(/\\/g, '/');
+  const statuslineCommand = `node ${homedir}/.claude/statusline.js`;
+
+  // Update settings.json
+  const settingsBackup = backupFile(SETTINGS_FILE);
+  if (settingsBackup) {
+    console.log(`Backed up settings: ${settingsBackup}`);
+  }
+
+  let settings = {};
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+    } catch {
+      console.warn(`${c.yellow}Warning: Could not parse settings.json, creating new one${c.reset}`);
+    }
+  }
+
+  settings.statusLine = {
+    type: 'command',
+    command: statuslineCommand,
+    padding: 0,
+  };
+
+  try {
+    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    console.log('   Settings updated');
+  } catch (err) {
+    console.error(`${c.red}Error: Could not write settings.json: ${err.message}${c.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`
+${c.green}Installation complete!${c.reset}
+
+${c.bold}Your status line will show:${c.reset}
+   - Model name (Sonnet 4.5, Opus 4, etc.)
+   - Git repo:branch [commit] message
+   - Git status indicators (*uncommitted, ↑ahead, ↓behind)
+   - Lines changed this session (+added/-removed)
+   - Real-time context usage with brick visualization
+   - Session duration and cost
+
+${c.cyan}Restart Claude Code to see your new status line!${c.reset}
+
+   To uninstall: contextbricks uninstall
+`);
+}
+
+function uninstall() {
+  console.log(`\n${c.cyan}${c.bold}ContextBricks${c.reset} - Uninstaller\n`);
+
+  // Remove statusline script
+  if (fs.existsSync(INSTALL_PATH)) {
+    console.log('Removing status line script...');
+    fs.unlinkSync(INSTALL_PATH);
+    console.log(`   Removed: ${INSTALL_PATH}`);
+  } else {
+    console.log(`${c.yellow}Status line script not found (already removed?)${c.reset}`);
+  }
+
+  console.log('');
+
+  // Update settings.json - remove statusLine key
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+      if (settings.statusLine) {
+        delete settings.statusLine;
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+        console.log('Removed statusLine from settings.json');
+      }
+    } catch {
+      console.warn(`${c.yellow}Warning: Could not update settings.json${c.reset}`);
+    }
+  }
+
+  // List backups for manual cleanup
+  const backups = [];
+  try {
+    const files = fs.readdirSync(CLAUDE_DIR);
+    for (const file of files) {
+      if (file.startsWith('statusline.js.backup-') || file.startsWith('settings.json.backup-')) {
+        backups.push(path.join(CLAUDE_DIR, file));
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  if (backups.length > 0) {
+    console.log(`\nFound ${backups.length} backup file(s).`);
+    console.log('Keeping backups (delete manually if needed):');
+    for (const b of backups) {
+      console.log(`   ${b}`);
+    }
+  }
+
+  console.log(`\n${c.green}Uninstallation complete!${c.reset}`);
+  console.log(`${c.cyan}Restart Claude Code for changes to take effect.${c.reset}\n`);
+}
+
+function showHelp() {
+  console.log(`
+${c.cyan}${c.bold}ContextBricks${c.reset} - Claude Code Status Line (Cross-Platform)
+
+${c.green}Usage:${c.reset}
+  contextbricks                 Install status line (default)
+  contextbricks install         Install status line
+  contextbricks uninstall       Uninstall status line
+  contextbricks test            Test with sample data
+  contextbricks --help          Show this help
+  contextbricks --version       Show version
+
+${c.green}Features:${c.reset}
+  - Real-time context tracking with brick visualization
+  - Git integration (repo, branch, commit, status)
+  - Session metrics (duration, cost, lines changed)
+  - Works on ${c.bold}Windows${c.reset}, Linux, and macOS (no bash/jq required)
+
+${c.green}More Info:${c.reset}
+  GitHub: https://github.com/thebtf/contextbricks-universal
+  Issues: https://github.com/thebtf/contextbricks-universal/issues
+`);
+}
+
+function test() {
+  console.log(`${c.cyan}Testing statusline with sample data...${c.reset}\n`);
+
+  const now = Date.now();
+  const sampleData = JSON.stringify({
+    model: { display_name: 'Sonnet 4.5' },
+    workspace: { current_dir: process.cwd() },
+    context_window: {
+      context_window_size: 200000,
+      used_percentage: 43.5,
+      remaining_percentage: 56.5,
+    },
+    cost: {
+      total_duration_ms: 765000,
+      total_cost_usd: 0.87,
+      total_lines_added: 145,
+      total_lines_removed: 23,
+    },
+    _mock_rate_limits: {
+      five_hour: { utilization: 64.0, resets_at: new Date(now + 23 * 60000).toISOString() },
+      seven_day: { utilization: 57.0, resets_at: new Date(now + 2 * 86400000).toISOString() },
+      seven_day_sonnet: { utilization: 9.0, resets_at: new Date(now + 4 * 86400000).toISOString() },
+      seven_day_opus: null,
+    },
+  });
+
+  const result = spawnSync(process.execPath, [STATUSLINE_SCRIPT], {
+    input: sampleData,
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 10000,
+  });
+
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+
+  console.log(`\n${c.dim}--- Test complete ---${c.reset}`);
+}
+
+// Main
+switch (command) {
+  case 'install':
+  case 'init':
+    install();
+    break;
+
+  case 'uninstall':
+    uninstall();
+    break;
+
+  case 'test':
+    test();
+    break;
+
+  case '--version':
+  case '-v': {
+    const pkg = require('../package.json');
+    console.log(`contextbricks-universal v${pkg.version}`);
+    break;
+  }
+
+  case '--help':
+  case '-h':
+  case 'help':
+    showHelp();
+    break;
+
+  default:
+    if (command) {
+      console.error(`${c.red}Unknown command: ${command}${c.reset}\n`);
+      showHelp();
+      process.exit(1);
+    } else {
+      install();
+    }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "contextbricks-universal",
+  "version": "4.2.0",
+  "description": "Universal cross-platform statusline for Claude Code CLI with context brick visualization. Windows, Linux, macOS. No bash or jq required.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "cli",
+    "context",
+    "bricks",
+    "git",
+    "tokens",
+    "terminal",
+    "visualization",
+    "windows",
+    "cross-platform"
+  ],
+  "bin": {
+    "contextbricks": "./bin/cli.js",
+    "contextbricks-universal": "./bin/cli.js"
+  },
+  "main": "./scripts/statusline.js",
+  "scripts": {
+    "test": "node bin/cli.js test",
+    "postinstall": "node bin/cli.js install"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "win32",
+    "linux",
+    "darwin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thebtf/contextbricks-universal.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thebtf/contextbricks-universal/issues"
+  },
+  "contributors": [
+    "Jeremy Dawes <jeremy@jezweb.net> (https://jezweb.com.au)"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/thebtf/contextbricks-universal"
+}

package/scripts/statusline.js

@@ -0,0 +1,513 @@
+#!/usr/bin/env node
+
+// Claude Code Custom Status Line (Node.js / Cross-Platform)
+// v4.2.0 - Node.js rewrite for Windows + Linux + macOS
+// Line 1: Model | Repo:Branch [subdir] | git status | lines changed
+// Line 2: [commit] commit message
+// Line 3: Context bricks | percentage | free | duration | cost
+// Line 4: Rate limit utilization (5h, 7d Sonnet, 7d Opus) — Max/Pro subscribers
+//
+// Configuration via environment variables:
+//   CONTEXTBRICKS_SHOW_DIR=1   Show current subdirectory (default: 1)
+//   CONTEXTBRICKS_SHOW_DIR=0   Hide subdirectory
+//   CONTEXTBRICKS_BRICKS=40    Number of bricks (default: 30)
+//   CONTEXTBRICKS_SHOW_LIMITS=0 Hide rate limit line (default: shown)
+//   CONTEXTBRICKS_RESET_EXACT=0 Approximate reset times (default: exact)
+//
+// Uses new percentage fields (Claude Code 2.1.6+) for accurate context display.
+// Falls back to current_usage calculation for older versions.
+// See: https://code.claude.com/docs/en/statusline
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const MAX_STDIN_BYTES = 1024 * 1024; // 1MB safety limit
+
+// Read all stdin synchronously
+function readStdin() {
+  const chunks = [];
+  const BUFSIZE = 4096;
+  const buf = Buffer.alloc(BUFSIZE);
+  let totalRead = 0;
+
+  try {
+    const fd = process.stdin.fd;
+    while (totalRead < MAX_STDIN_BYTES) {
+      try {
+        const bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null);
+        if (bytesRead === 0) break;
+        chunks.push(Buffer.from(buf.slice(0, bytesRead)));
+        totalRead += bytesRead;
+      } catch {
+        break; // EAGAIN or EOF
+      }
+    }
+  } catch {
+    // fd not readable
+  }
+
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+// Resolve the working directory for git commands
+function resolveGitCwd(currentDir) {
+  try {
+    if (currentDir && fs.statSync(currentDir).isDirectory()) {
+      return currentDir;
+    }
+  } catch {
+    // invalid path
+  }
+  return process.cwd();
+}
+
+// Run a git command using spawnSync (no shell injection possible)
+function git(args, cwd, fallback = '') {
+  try {
+    const result = spawnSync('git', args, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+      windowsHide: true,
+      cwd,
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// Safely traverse nested object path like 'a.b.c'
+function getPath(obj, dotPath) {
+  const parts = dotPath.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+// ANSI color helpers
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[1;36m',
+  green: '\x1b[1;32m',
+  blue: '\x1b[1;34m',
+  red: '\x1b[1;31m',
+  yellow: '\x1b[1;33m',
+  dimWhite: '\x1b[2;37m',
+  greenNorm: '\x1b[0;32m',
+  redNorm: '\x1b[0;31m',
+  cyanNorm: '\x1b[0;36m',
+  yellowNorm: '\x1b[0;33m',
+};
+
+// Read OAuth token from Claude Code credentials
+function readOAuthToken() {
+  try {
+    if (process.platform === 'darwin') {
+      // macOS: try keychain first
+      const result = spawnSync('security', [
+        'find-generic-password',
+        '-s', 'Claude Code-credentials',
+        '-w',
+      ], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 3000,
+        windowsHide: true,
+      });
+      if (result.status === 0 && result.stdout) {
+        try {
+          const creds = JSON.parse(result.stdout.trim());
+          const token = getPath(creds, 'claudeAiOauth.accessToken');
+          if (token) return token;
+        } catch {
+          // keychain data not valid JSON, fall through to file
+        }
+      }
+    }
+
+    // Win/Linux (and macOS fallback): read credentials file
+    const credPath = path.join(os.homedir(), '.claude', '.credentials.json');
+    const raw = fs.readFileSync(credPath, 'utf8');
+    const creds = JSON.parse(raw);
+    return getPath(creds, 'claudeAiOauth.accessToken') || null;
+  } catch {
+    return null;
+  }
+}
+
+// Fetch usage data from Anthropic API with file-based caching
+function fetchUsageData(token, input) {
+  // Check for mock data in input (test mode)
+  const mockData = getPath(input, '_mock_rate_limits');
+  if (mockData) return mockData;
+
+  if (!token) return null;
+
+  const cacheFile = path.join(os.homedir(), '.claude', '.usage-cache.json');
+  const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+  // Try cache first
+  try {
+    const cacheRaw = fs.readFileSync(cacheFile, 'utf8');
+    const cache = JSON.parse(cacheRaw);
+    if (cache.timestamp && (Date.now() - cache.timestamp) < CACHE_TTL_MS) {
+      return cache.data;
+    }
+  } catch {
+    // no cache or invalid
+  }
+
+  // Fetch from API using sync subprocess (token via env var for security)
+  const httpsScript = `
+    const https = require('https');
+    const options = {
+      hostname: 'api.anthropic.com',
+      path: '/api/oauth/usage',
+      method: 'GET',
+      headers: {
+        'Authorization': 'Bearer ' + process.env.ANTHROPIC_TOKEN,
+        'anthropic-beta': 'oauth-2025-04-20',
+        'Accept': 'application/json',
+      },
+    };
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          process.stdout.write(body);
+        }
+      });
+    });
+    req.on('error', () => {});
+    req.end();
+  `;
+
+  try {
+    const result = spawnSync(process.execPath, ['-e', httpsScript], {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 4000,
+      windowsHide: true,
+      env: { ...process.env, ANTHROPIC_TOKEN: token },
+    });
+
+    if (result.status === 0 && result.stdout) {
+      const data = JSON.parse(result.stdout);
+      // Only cache valid usage data (not error responses)
+      if (data && (data.five_hour || data.seven_day || data.seven_day_sonnet || data.seven_day_opus)) {
+        try {
+          fs.writeFileSync(cacheFile, JSON.stringify({ timestamp: Date.now(), data }), {
+            encoding: 'utf8',
+            mode: 0o600,
+          });
+        } catch {
+          // cache write failure is non-fatal
+        }
+      }
+      return data;
+    }
+  } catch {
+    // API call failed — try stale cache
+    try {
+      const cacheRaw = fs.readFileSync(cacheFile, 'utf8');
+      const cache = JSON.parse(cacheRaw);
+      if (cache.data) return cache.data;
+    } catch {
+      // no stale cache
+    }
+  }
+
+  return null;
+}
+
+// Return 256-color ANSI code for smooth green → yellow → red gradient
+function getColorForUtilization(pct) {
+  // 256-color: green(46) → yellow(226) → red(196), 11 stops at ~10% intervals
+  const gradient = [46, 82, 118, 154, 190, 226, 220, 214, 208, 202, 196];
+  const clamped = Math.max(0, Math.min(100, pct));
+  const idx = Math.min(Math.round(clamped / 10), gradient.length - 1);
+  return `\x1b[38;5;${gradient[idx]}m`;
+}
+
+// Format ISO reset time string to human-readable relative time
+// exact=true: "1h30m", "2d5h"  |  exact=false: "1h", "2d"
+function formatResetTime(isoStr, exact) {
+  if (!isoStr) return '';
+  try {
+    const resetMs = new Date(isoStr).getTime();
+    const diffMs = resetMs - Date.now();
+    if (diffMs <= 0) return '0m';
+
+    const totalMin = Math.floor(diffMs / 60000);
+    const totalHours = Math.floor(totalMin / 60);
+    const remainMin = totalMin % 60;
+    const days = Math.floor(totalHours / 24);
+    const remainHours = totalHours % 24;
+
+    if (!exact) {
+      if (totalMin < 60) return `${totalMin}m`;
+      if (totalHours < 24) return `${totalHours}h`;
+      return `${days}d`;
+    }
+
+    // Exact mode: combined units
+    if (totalMin < 60) return `${totalMin}m`;
+    if (totalHours < 24) {
+      return remainMin > 0 ? `${totalHours}h${remainMin}m` : `${totalHours}h`;
+    }
+    return remainHours > 0 ? `${days}d${remainHours}h` : `${days}d`;
+  } catch {
+    return '';
+  }
+}
+
+// Build a single rate limit segment like "5h:23% ~1h30m"
+function buildLimitSegment(data, key, label, exact) {
+  const pct = getPath(data, `${key}.utilization`);
+  if (pct == null) return null;
+  const color = getColorForUtilization(pct);
+  const resetStr = formatResetTime(getPath(data, `${key}.resets_at`), exact);
+  let segment = `${c.dimWhite}${label}:${c.reset}${color}${Math.round(pct)}%${c.reset}`;
+  if (resetStr) segment += ` ${c.dim}~${resetStr}${c.reset}`;
+  return segment;
+}
+
+// Assemble rate limit Line 4 from usage data
+function formatRateLimitLine(data) {
+  if (!data) return '';
+  const exact = process.env.CONTEXTBRICKS_RESET_EXACT !== '0'; // default: exact
+  const segments = [
+    buildLimitSegment(data, 'five_hour', '5h', exact),
+    buildLimitSegment(data, 'seven_day', '7d', exact),
+    buildLimitSegment(data, 'seven_day_sonnet', 'sonnet', exact),
+    buildLimitSegment(data, 'seven_day_opus', 'opus', exact),
+  ].filter(Boolean);
+  return segments.length > 0 ? segments.join(' | ') : '';
+}
+
+function main() {
+  // Read JSON from stdin
+  const raw = readStdin();
+  if (!raw) {
+    process.stdout.write('ContextBricks: no input\n');
+    return;
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.stdout.write('ContextBricks: invalid JSON\n');
+    return;
+  }
+
+  // Parse Claude data
+  const model = (getPath(input, 'model.display_name') || 'Claude').replace('Claude ', '');
+  const currentDir = getPath(input, 'workspace.current_dir') || process.cwd();
+  const linesAdded = Number(getPath(input, 'cost.total_lines_added')) || 0;
+  const linesRemoved = Number(getPath(input, 'cost.total_lines_removed')) || 0;
+
+  // Configuration from environment variables
+  const showDir = process.env.CONTEXTBRICKS_SHOW_DIR !== '0'; // default: on
+  const totalBricks = Math.max(1, Number(process.env.CONTEXTBRICKS_BRICKS) || 30);
+
+  // Resolve working directory (no process.chdir — pass cwd to git instead)
+  const cwd = resolveGitCwd(currentDir);
+
+  // Get git information
+  let repoName = '';
+  let branch = '';
+  let commitShort = '';
+  let commitMsg = '';
+  let gitStatus = '';
+  let subDir = ''; // path relative to repo root
+
+  const gitDir = git(['rev-parse', '--git-dir'], cwd);
+  if (gitDir) {
+    const toplevel = git(['rev-parse', '--show-toplevel'], cwd);
+    repoName = toplevel ? path.basename(toplevel) : '';
+    branch = git(['branch', '--show-current'], cwd) || 'detached';
+
+    // Compute subdirectory relative to repo root
+    if (showDir && toplevel) {
+      const rel = path.relative(toplevel, cwd).replace(/\\/g, '/');
+      if (rel && rel !== '.') {
+        subDir = rel;
+      }
+    }
+    commitShort = git(['rev-parse', '--short', 'HEAD'], cwd);
+
+    // Fetch commit message once, reuse for both lines
+    commitMsg = git(['log', '-1', '--pretty=format:%s'], cwd);
+
+    // Git status indicators
+    const porcelain = git(['status', '--porcelain'], cwd);
+    if (porcelain) {
+      gitStatus = '*';
+    }
+
+    // Check ahead/behind remote
+    const upstream = git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], cwd);
+    if (upstream) {
+      const ahead = Number(git(['rev-list', '--count', `${upstream}..HEAD`], cwd)) || 0;
+      const behind = Number(git(['rev-list', '--count', `HEAD..${upstream}`], cwd)) || 0;
+      if (ahead > 0) gitStatus += `\u2191${ahead}`;
+      if (behind > 0) gitStatus += `\u2193${behind}`;
+    }
+  }
+
+  // === Build Line 1: Model + Repo:Branch + Status + Changes ===
+  let line1 = '';
+
+  // Model in brackets
+  line1 += `${c.cyan}[${model}]${c.reset} `;
+
+  // Repo:Branch + subdirectory
+  if (repoName) {
+    line1 += `${c.green}${repoName}${c.reset}`;
+    if (branch) {
+      line1 += `:${c.blue}${branch}${c.reset}`;
+    }
+    if (subDir) {
+      line1 += ` ${c.dim}${subDir}${c.reset}`;
+    }
+  } else if (showDir) {
+    // No git repo — show tilde-compressed path
+    const home = os.homedir();
+    let displayPath = cwd.replace(/\\/g, '/');
+    const homeNorm = home.replace(/\\/g, '/');
+    if (displayPath.startsWith(homeNorm)) {
+      displayPath = '~' + displayPath.slice(homeNorm.length);
+    }
+    line1 += `${c.dim}${displayPath}${c.reset}`;
+  }
+
+  // Git status indicators
+  if (gitStatus) {
+    line1 += ` ${c.red}${gitStatus}${c.reset}`;
+  }
+
+  // Lines changed
+  if (linesAdded > 0 || linesRemoved > 0) {
+    line1 += ` | ${c.greenNorm}+${linesAdded}${c.reset}/${c.redNorm}-${linesRemoved}${c.reset}`;
+  }
+
+  // === Build Line 2: Commit hash + message ===
+  let line2 = '';
+  if (commitShort) {
+    line2 += `${c.yellow}[${commitShort}]${c.reset}`;
+    if (commitMsg) {
+      const truncatedMsg = commitMsg.length > 55 ? commitMsg.substring(0, 55) + '...' : commitMsg;
+      line2 += ` ${truncatedMsg}`;
+    }
+  }
+
+  // === Build Line 3: Context bricks + session info ===
+
+  // Session duration
+  const durationMs = Number(getPath(input, 'cost.total_duration_ms')) || 0;
+  const durationHours = Math.floor(durationMs / 3600000);
+  const durationMin = Math.floor((durationMs % 3600000) / 60000);
+
+  // Session cost
+  const costUsd = Number(getPath(input, 'cost.total_cost_usd')) || 0;
+
+  // Context window data
+  const totalTokens = Number(getPath(input, 'context_window.context_window_size')) || 200000;
+
+  // Try new percentage fields first (Claude Code 2.1.6+)
+  const usedPctRaw = getPath(input, 'context_window.used_percentage');
+  const remainingPctRaw = getPath(input, 'context_window.remaining_percentage');
+
+  let usagePct, usedTokens, freeTokens;
+
+  if (usedPctRaw != null && usedPctRaw !== '') {
+    // Use official percentage (more accurate)
+    usagePct = Math.floor(Number(usedPctRaw));
+    const remainingPct = Math.floor(Number(remainingPctRaw) || (100 - usagePct));
+    usedTokens = Math.floor((totalTokens * usagePct) / 100);
+    freeTokens = Math.floor((totalTokens * remainingPct) / 100);
+  } else {
+    // Fallback: Calculate from current_usage (Claude Code 2.0.70+)
+    const currentUsage = getPath(input, 'context_window.current_usage');
+
+    if (currentUsage && typeof currentUsage === 'object') {
+      const inputTokens = Number(currentUsage.input_tokens) || 0;
+      const cacheCreation = Number(currentUsage.cache_creation_input_tokens) || 0;
+      const cacheRead = Number(currentUsage.cache_read_input_tokens) || 0;
+      usedTokens = inputTokens + cacheCreation + cacheRead;
+    } else {
+      usedTokens = 0;
+    }
+
+    freeTokens = totalTokens - usedTokens;
+    usagePct = totalTokens > 0 ? Math.floor((usedTokens * 100) / totalTokens) : 0;
+  }
+
+  // Convert to 'k' format
+  const freeK = Math.floor(freeTokens / 1000);
+
+  // Generate brick visualization
+  const usedBricks = totalTokens > 0 ? Math.floor((usedTokens * totalBricks) / totalTokens) : 0;
+  const freeBricks = totalBricks - usedBricks;
+
+  // Build brick line
+  let brickLine = '[';
+
+  // Used bricks (cyan)
+  for (let i = 0; i < usedBricks; i++) {
+    brickLine += `${c.cyanNorm}\u25A0${c.reset}`;
+  }
+
+  // Free bricks (dim/gray hollow squares)
+  for (let i = 0; i < freeBricks; i++) {
+    brickLine += `${c.dimWhite}\u25A1${c.reset}`;
+  }
+
+  brickLine += ']';
+
+  // Compact stats
+  brickLine += ` ${c.bold}${usagePct}%${c.reset}`;
+  brickLine += ` | ${c.greenNorm}${freeK}k free${c.reset}`;
+  brickLine += ` | ${durationHours}h${durationMin}m`;
+
+  // Cost (only if non-zero)
+  if (costUsd > 0) {
+    const costFormatted = costUsd.toFixed(2);
+    brickLine += ` | ${c.yellowNorm}$${costFormatted}${c.reset}`;
+  }
+
+  // Output all lines
+  process.stdout.write(line1 + '\n');
+  if (line2) {
+    process.stdout.write(line2 + '\n');
+  }
+  process.stdout.write(brickLine + '\n');
+
+  // Line 4: Rate limit utilization
+  const showLimits = process.env.CONTEXTBRICKS_SHOW_LIMITS !== '0';
+  if (showLimits) {
+    const token = readOAuthToken();
+    const usageData = fetchUsageData(token, input);
+    const line4 = formatRateLimitLine(usageData);
+    if (line4) {
+      process.stdout.write(line4 + '\n');
+    }
+  }
+}
+
+main();