@z80020100/claude-code-statusline 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cliff Wu
+
+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.ja.md

@@ -0,0 +1,113 @@
+# claude-code-statusline
+
+[English](README.md) | [繁體中文](README.zh-TW.md) | [日本語](README.ja.md)
+
+[Claude Code](https://docs.anthropic.com/en/docs/claude-code) 用カスタムステータスライン — モデル情報、コンテキスト使用量グラデーションバー、トークン統計、コスト、Git ステータス、レート制限を表示します。
+
+![Demo](assets/claude-code-statusline-demo.png)
+
+## 機能
+
+- **コンテキスト使用量グラデーションバー** — 緑から赤への4段階カラースペクトラム
+- **トークンとコスト追跡** — 入出力トークン数、キャッシュヒット率、セッションコスト
+- **セッションタイミング** — 実時間と API 応答時間を並列表示
+- **Git 連携** — ブランチ名、変更フラグ、worktree インジケーター、main との差分統計
+- **レート制限モニタリング** — 現在 (5h) と週間 (7d) の使用量およびリセット時刻
+- **Sandbox インジケーター** — sandbox モードのオフ、オン、自動を表示
+- **パス圧縮** — 長いパスを自動短縮して80カラムに収める
+- **ランタイム依存ゼロ** — Node.js 組み込みモジュールのみ使用
+
+## インストール
+
+```sh
+npm install -g @z80020100/claude-code-statusline
+```
+
+## セットアップ
+
+```sh
+claude-code-statusline setup
+```
+
+`~/.claude/settings.json` に `statusLine` 設定を書き込みます：
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "claude-code-statusline"
+  }
+}
+```
+
+設定を削除する場合：
+
+```sh
+claude-code-statusline setup --uninstall
+```
+
+## 表示レイアウト
+
+全フィールドを最大幅で表示した場合：
+
+![全フィールド](assets/claude-code-statusline-simulation.png)
+
+ステータスラインは最大6行で表示されます — 各行は80文字以内に制限されます：
+
+| 行  | 内容                                                                                             |
+| --- | ------------------------------------------------------------------------------------------------ |
+| 1   | バージョン、sandbox モード、セッション名と ID                                                    |
+| 2   | モデル名、effort レベル、コンテキスト使用量バーとパーセンテージ、最終更新時刻                    |
+| 3   | トークン数 (入力/出力)、キャッシュヒット率、コスト、セッション/API 所要時間、増減行数、200K 警告 |
+| 4   | プロジェクトディレクトリ、git ブランチ、変更フラグ、worktree インジケーター、main との差分       |
+| 5   | 現在の作業ディレクトリ（プロジェクトルートと異なる場合のみ表示）                                 |
+| 6   | レート制限 — 現在 (5h) と週間 (7d) の使用量およびリセット時刻                                    |
+
+### カラーゾーン
+
+コンテキストとレート制限のバーは4段階グラデーションを使用します：
+
+| 範囲    | 色       | 意味   |
+| ------- | -------- | ------ |
+| 0–49%   | グリーン | 正常   |
+| 50–69%  | ゴールド | 中程度 |
+| 70–89%  | コーラル | やや高 |
+| 90–100% | レッド   | 危険   |
+
+## 動作原理
+
+Claude Code は各レンダリングサイクルで stdin を通じて `statusLine` コマンドに JSON オブジェクトを送信します。JSON には現在のセッション状態（モデル、トークン、コスト、ワークスペース、レート制限など）が含まれます。本ツールはそれを解析し ANSI カラーテキストを stdout に出力します。
+
+設計上の決定事項：
+
+- **依存関係ゼロ** — Node.js 組み込みモジュールのみ使用 (`fs`, `path`, `os`, `child_process`)
+- **Git キャッシュ** — ブランチと差分統計を5秒間キャッシュしサブプロセス呼び出しを削減
+- **設定キャッシュ** — effort レベルと sandbox モードは mtime ベースのキャッシュで冗長なファイル読み込みを回避
+- **80カラム制限** — 自動テストで強制；長いパスは自動的に圧縮
+- **256色 ANSI** — ターミナル間で一貫した描画；Claude ブランドオレンジは24ビットトゥルーカラーを使用
+
+## 動作要件
+
+| 依存関係    | Tier 1（CI テスト済）                       | Tier 2（best-effort） |
+| ----------- | ------------------------------------------- | --------------------- |
+| Node.js     | >= 20                                       | 18                    |
+| Claude Code | >= 2.1.80（`rate_limits` フィールドが必要） |                       |
+
+## 開発
+
+```sh
+git clone https://github.com/z80020100/claude-code-statusline.git
+cd claude-code-statusline
+npm install                 # prepare で pre-commit hooks も自動有効化
+
+npm run check               # lint + フォーマットチェック + 幅チェック + CLI テスト
+npm run fix                 # lint とフォーマットの問題を自動修正
+npm test                    # 幅チェック + CLI テストのみ
+npm run lint                # ESLint + shellcheck + actionlint
+npm run simulate            # worst-case ステータスラインを描画し幅レポートを表示
+npm run ci:local            # act で CI ワークフローをローカル実行（Docker が必要）
+```
+
+## ライセンス
+
+[MIT](LICENSE)

package/README.md

@@ -0,0 +1,113 @@
+# claude-code-statusline
+
+[English](https://github.com/z80020100/claude-code-statusline/blob/main/README.md) | [繁體中文](https://github.com/z80020100/claude-code-statusline/blob/main/README.zh-TW.md) | [日本語](https://github.com/z80020100/claude-code-statusline/blob/main/README.ja.md)
+
+Custom status line for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) — model info, context usage gradient bar, token stats, cost, git status, and rate limits.
+
+![Demo](https://raw.githubusercontent.com/z80020100/claude-code-statusline/main/assets/claude-code-statusline-demo.png)
+
+## Features
+
+- **Context usage gradient bar** — 4-zone color spectrum from green to red
+- **Token and cost tracking** — input/output tokens, cache hit ratio, session cost
+- **Session timing** — wall-clock and API duration side by side
+- **Git integration** — branch, dirty flag, worktree indicator, diff stats vs main
+- **Rate limit monitoring** — current (5h) and weekly (7d) usage with reset times
+- **Sandbox indicator** — shows whether sandbox mode is off, on, or auto
+- **Path compression** — long paths auto-shorten to fit within 80 columns
+- **Zero runtime dependencies** — Node.js built-ins only
+
+## Installation
+
+```sh
+npm install -g @z80020100/claude-code-statusline
+```
+
+## Setup
+
+```sh
+claude-code-statusline setup
+```
+
+This writes the `statusLine` entry to `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "claude-code-statusline"
+  }
+}
+```
+
+To remove:
+
+```sh
+claude-code-statusline setup --uninstall
+```
+
+## Display Layout
+
+All fields at maximum width:
+
+![All fields](https://raw.githubusercontent.com/z80020100/claude-code-statusline/main/assets/claude-code-statusline-simulation.png)
+
+The status line renders up to 6 lines — each constrained to 80 visible columns:
+
+| Line | Content                                                                                           |
+| ---- | ------------------------------------------------------------------------------------------------- |
+| 1    | Version, sandbox mode, session name and ID                                                        |
+| 2    | Model name, effort level, context usage bar with percentage, last updated time                    |
+| 3    | Token counts (in/out), cache hit %, cost, session/API duration, lines added/removed, 200K warning |
+| 4    | Project directory, git branch, dirty flag, worktree indicator, diff vs main                       |
+| 5    | Current working directory (only when different from project root)                                 |
+| 6    | Rate limit usage — current (5h) and weekly (7d) with reset times                                  |
+
+### Color Zones
+
+Context and rate limit bars use a 4-zone gradient:
+
+| Range   | Color | Meaning  |
+| ------- | ----- | -------- |
+| 0–49%   | Green | Normal   |
+| 50–69%  | Gold  | Moderate |
+| 70–89%  | Coral | Elevated |
+| 90–100% | Red   | Critical |
+
+## How It Works
+
+Claude Code pipes a JSON object to the `statusLine` command via stdin on each render cycle. The JSON contains the current session state (model, tokens, cost, workspace, rate limits, etc.). This tool parses it and returns ANSI-colored lines to stdout.
+
+Design decisions:
+
+- **Zero dependencies** — only Node.js built-ins (`fs`, `path`, `os`, `child_process`)
+- **Git caching** — branch and diff stats are cached for 5 seconds to avoid repeated subprocess calls
+- **Settings caching** — effort level and sandbox mode use mtime-based caching to skip redundant file reads
+- **80-column constraint** — enforced by automated tests; long paths are compressed automatically
+- **256-color ANSI** — consistent rendering across terminals; Claude brand orange uses 24-bit true color
+
+## Requirements
+
+| Dependency  | Tier 1 (CI-tested)                  | Tier 2 (best-effort) |
+| ----------- | ----------------------------------- | -------------------- |
+| Node.js     | >= 20                               | 18                   |
+| Claude Code | >= 2.1.80 (for `rate_limits` field) |                      |
+
+## Development
+
+```sh
+git clone https://github.com/z80020100/claude-code-statusline.git
+cd claude-code-statusline
+npm install                 # also enables pre-commit hooks via prepare
+
+npm run check               # lint + format check + width check + CLI tests
+npm run fix                 # auto-fix lint and format issues
+npm test                    # width check + CLI tests only
+npm run lint                # ESLint + shellcheck + actionlint
+npm run simulate            # render worst-case status line with width report
+npm run ci:local            # run CI workflow locally via act (requires Docker)
+```
+
+## License
+
+[MIT](LICENSE)

package/README.zh-TW.md

@@ -0,0 +1,113 @@
+# claude-code-statusline
+
+[English](README.md) | [繁體中文](README.zh-TW.md) | [日本語](README.ja.md)
+
+[Claude Code](https://docs.anthropic.com/en/docs/claude-code) 的自訂狀態列 — 顯示模型資訊、上下文使用量漸層條、Token 統計、費用、Git 狀態和速率限制。
+
+![Demo](assets/claude-code-statusline-demo.png)
+
+## 功能
+
+- **上下文使用量漸層條** — 綠到紅的 4 段色彩頻譜
+- **Token 與費用追蹤** — 輸入/輸出 Token 數、快取命中率、Session 費用
+- **Session 計時** — 同時顯示實際時間與 API 回應時間
+- **Git 整合** — 分支名稱、修改標記、worktree 指示器、與 main 的差異統計
+- **速率限制監控** — 當前 (5h) 和每週 (7d) 使用量及重置時間
+- **Sandbox 指示器** — 顯示 sandbox 模式為關閉、開啟或自動
+- **路徑壓縮** — 長路徑自動縮短以符合 80 欄限制
+- **零執行時期依賴** — 僅使用 Node.js 內建模組
+
+## 安裝
+
+```sh
+npm install -g @z80020100/claude-code-statusline
+```
+
+## 設定
+
+```sh
+claude-code-statusline setup
+```
+
+這會將 `statusLine` 寫入 `~/.claude/settings.json`：
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "claude-code-statusline"
+  }
+}
+```
+
+移除設定：
+
+```sh
+claude-code-statusline setup --uninstall
+```
+
+## 顯示配置
+
+所有欄位最大寬度的呈現：
+
+![所有欄位](assets/claude-code-statusline-simulation.png)
+
+狀態列最多顯示 6 行 — 每行限制在 80 個可見字元內：
+
+| 行  | 內容                                                                              |
+| --- | --------------------------------------------------------------------------------- |
+| 1   | 版本、sandbox 模式、session 名稱和 ID                                             |
+| 2   | 模型名稱、effort 等級、上下文使用量條與百分比、最後更新時間                       |
+| 3   | Token 數 (輸入/輸出)、快取命中率、費用、session/API 持續時間、增減行數、200K 警告 |
+| 4   | 專案目錄、git 分支、修改標記、worktree 指示器、與 main 的差異                     |
+| 5   | 目前工作目錄（僅在與專案根目錄不同時顯示）                                        |
+| 6   | 速率限制 — 當前 (5h) 和每週 (7d) 使用量及重置時間                                 |
+
+### 色彩區間
+
+上下文和速率限制的進度條使用 4 段漸層：
+
+| 範圍    | 顏色 | 意義 |
+| ------- | ---- | ---- |
+| 0–49%   | 綠色 | 正常 |
+| 50–69%  | 金色 | 中等 |
+| 70–89%  | 珊瑚 | 偏高 |
+| 90–100% | 紅色 | 危險 |
+
+## 運作原理
+
+Claude Code 在每次渲染時透過 stdin 傳入 JSON 物件給 `statusLine` 指令。JSON 包含目前的 session 狀態（模型、Token、費用、工作區、速率限制等）。本工具解析後輸出 ANSI 彩色文字到 stdout。
+
+設計決策：
+
+- **零依賴** — 僅使用 Node.js 內建模組 (`fs`, `path`, `os`, `child_process`)
+- **Git 快取** — 分支和差異統計快取 5 秒以避免重複呼叫子程序
+- **設定快取** — effort 等級和 sandbox 模式使用 mtime 快取以減少檔案讀取
+- **80 欄限制** — 由自動化測試強制執行；長路徑自動壓縮
+- **256 色 ANSI** — 跨終端一致性渲染；Claude 品牌橘色使用 24-bit true color
+
+## 系統需求
+
+| 依賴        | Tier 1（CI 測試）                    | Tier 2（best-effort） |
+| ----------- | ------------------------------------ | --------------------- |
+| Node.js     | >= 20                                | 18                    |
+| Claude Code | >= 2.1.80（需要 `rate_limits` 欄位） |                       |
+
+## 開發
+
+```sh
+git clone https://github.com/z80020100/claude-code-statusline.git
+cd claude-code-statusline
+npm install                 # 同時透過 prepare 啟用 pre-commit hooks
+
+npm run check               # lint + 格式檢查 + 寬度檢查 + CLI 測試
+npm run fix                 # 自動修正 lint 和格式問題
+npm test                    # 寬度檢查 + CLI 測試
+npm run lint                # ESLint + shellcheck + actionlint
+npm run simulate            # 渲染 worst-case 狀態列並顯示寬度報告
+npm run ci:local            # 透過 act 在本地執行 CI（需要 Docker）
+```
+
+## 授權
+
+[MIT](LICENSE)

package/bin/claude-code-statusline.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const arg = process.argv[2];
+
+if (arg === "setup") {
+  require("../lib/setup.js").run(process.argv.slice(3));
+} else if (arg === "--version" || arg === "-v") {
+  console.log(require("../package.json").version);
+} else if (arg === "--help" || arg === "-h" || process.stdin.isTTY) {
+  const pkg = require("../package.json");
+  const repo = pkg.repository.url.replace(/^git\+/, "").replace(/\.git$/, "");
+  console.log(`${pkg.name} v${pkg.version}
+${pkg.description}
+
+Usage:
+  claude-code-statusline                    Read JSON from stdin and render status line
+  claude-code-statusline setup              Configure Claude Code to use this status line
+  claude-code-statusline setup --uninstall  Remove status line configuration
+  claude-code-statusline --help             Show this help message
+  claude-code-statusline --version          Show version
+
+Author:  ${pkg.author}
+License: ${pkg.license}
+Repository: ${repo}`);
+} else {
+  const fs = require("fs");
+  const { render } = require("../lib/statusline.js");
+  try {
+    const data = JSON.parse(fs.readFileSync(0, "utf8"));
+    const lines = render(data);
+    for (const line of lines) {
+      console.log(line);
+    }
+  } catch {
+    // Silent fail — Claude Code expects no output on error
+  }
+}

package/lib/setup.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+
+const SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const STATUS_LINE_VALUE = {
+  type: "command",
+  command: "claude-code-statusline",
+};
+
+function readSettings() {
+  try {
+    return JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+
+function writeSettings(data) {
+  const dir = path.dirname(SETTINGS_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(data, null, 2) + "\n");
+}
+
+function setup() {
+  const settings = readSettings();
+
+  // Already configured
+  if (
+    settings.statusLine &&
+    settings.statusLine.command === "claude-code-statusline"
+  ) {
+    console.log("Already configured. No changes needed.");
+    return;
+  }
+
+  // Existing different value — ask to overwrite
+  if (settings.statusLine) {
+    console.log("Current statusLine setting:");
+    console.log("  " + JSON.stringify(settings.statusLine));
+    console.log();
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question("Overwrite? (y/N) ", (answer) => {
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Aborted.");
+        return;
+      }
+      applySetup(settings);
+    });
+    return;
+  }
+
+  applySetup(settings);
+}
+
+function applySetup(settings) {
+  console.log("Before:");
+  console.log("  " + JSON.stringify(settings.statusLine ?? null));
+  settings.statusLine = STATUS_LINE_VALUE;
+  writeSettings(settings);
+  console.log("After:");
+  console.log("  " + JSON.stringify(settings.statusLine));
+  console.log();
+  console.log("Wrote " + SETTINGS_PATH);
+}
+
+function uninstall() {
+  const settings = readSettings();
+  if (!settings.statusLine) {
+    console.log("No statusLine setting found. No changes needed.");
+    return;
+  }
+  console.log("Removing statusLine:");
+  console.log("  " + JSON.stringify(settings.statusLine));
+  delete settings.statusLine;
+  writeSettings(settings);
+  console.log();
+  console.log("Wrote " + SETTINGS_PATH);
+}
+
+function run(args) {
+  try {
+    if (args.includes("--uninstall")) {
+      uninstall();
+    } else {
+      setup();
+    }
+  } catch (err) {
+    console.error("Error: " + err.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { run };

package/lib/statusline.js

@@ -0,0 +1,478 @@
+"use strict";
+
+const fs = require("fs");
+const { execSync } = require("child_process");
+const path = require("path");
+const os = require("os");
+
+/**
+ * Render Claude Code status line.
+ * @param {object} data - JSON data from Claude Code stdin
+ * @param {object} [options] - Overrides for testability and cross-platform
+ * @param {object} [options.git] - { branch, dirty, isWorktree, diffAdded, diffRemoved }
+ * @param {string} [options.effort] - Effort level override
+ * @param {string} [options.sandboxMode] - Sandbox mode override ("", "auto", "on")
+ * @param {string} [options.home] - Home directory override
+ * @param {Date}   [options.now] - Current time override
+ * @returns {string[]} Array of ANSI-colored lines
+ */
+function render(data, options = {}) {
+  const model = data.model?.display_name || "?";
+  const usedPct = data.context_window?.used_percentage ?? 0;
+  const cost = data.cost?.total_cost_usd ?? 0;
+  const linesAdded = data.cost?.total_lines_added ?? 0;
+  const linesRemoved = data.cost?.total_lines_removed ?? 0;
+  const exceeds200k = data.exceeds_200k_tokens ?? false;
+  const totalInput = data.context_window?.total_input_tokens ?? 0;
+  const totalOutput = data.context_window?.total_output_tokens ?? 0;
+  const uncachedInput = data.context_window?.current_usage?.input_tokens ?? 0;
+  const cacheRead =
+    data.context_window?.current_usage?.cache_read_input_tokens ?? 0;
+  const cacheCreate =
+    data.context_window?.current_usage?.cache_creation_input_tokens ?? 0;
+  const ctxSize = data.context_window?.context_window_size ?? 0;
+  const durationMs = data.cost?.total_duration_ms ?? 0;
+  const apiDurationMs = data.cost?.total_api_duration_ms ?? 0;
+  const projectDir = data.workspace?.project_dir || "";
+  const cwd = data.workspace?.current_dir || "";
+  const version = data.version || "";
+  const sessionName = data.session_name || "";
+  const sessionId = data.session_id || "";
+
+  // ANSI styles — 256-color for cross-terminal consistency
+  // Palette: Developer Tool / Modern Dark (desaturated, semantic)
+  // Exception: claudeOrange uses 24-bit true color for brand accuracy (#da7756)
+  const reset = "\x1b[0m";
+  const bold = "\x1b[1m";
+  const dim = "\x1b[2m";
+  // Foreground hierarchy
+  const white = "\x1b[38;5;255m"; // headlines, key values
+  const softWhite = "\x1b[38;5;252m"; // secondary values
+  const gray = "\x1b[38;5;247m"; // muted labels, token counts
+  const darkGray = "\x1b[38;5;239m"; // separators, empty bar segments
+  // Semantic accent
+  const violet = "\x1b[38;5;141m"; // primary accent: effort, branch
+  const blue = "\x1b[38;5;75m"; // info: cwd path, agent
+  const dimBlue = "\x1b[38;5;68m"; // subdued: project path
+  const teal = "\x1b[38;5;116m"; // secondary: cost, worktree
+  // Status spectrum (progress bars, +/- lines)
+  const green = "\x1b[38;5;114m"; // good / positive
+  const gold = "\x1b[38;5;179m"; // moderate
+  const coral = "\x1b[38;5;209m"; // elevated
+  const red = "\x1b[38;5;167m"; // critical
+  // Identity
+  const claudeOrange = "\x1b[38;2;218;119;86m"; // #da7756, 24-bit true color
+
+  // ── Helpers ──────────────────────────────────────────
+
+  // Shared thresholds: single source of truth for color zones
+  const pctZones = [
+    { at: 90, color: red },
+    { at: 70, color: coral },
+    { at: 50, color: gold },
+    { at: 0, color: green },
+  ];
+
+  function colorForPct(pct) {
+    for (const z of pctZones) {
+      if (pct >= z.at) return z.color;
+    }
+    return green;
+  }
+
+  // Gradient bar — each filled segment colored by its zone position
+  function buildBar(pct, width) {
+    const clamped = Math.max(0, Math.min(100, pct));
+    const filled = Math.round((clamped / 100) * width);
+    let s = "";
+    for (let i = 0; i < width; i++) {
+      if (i < filled) {
+        s += colorForPct((i / width) * 100) + "\u2501";
+      } else {
+        s += darkGray + "\u2501";
+      }
+    }
+    return s + reset;
+  }
+
+  function fmt(n) {
+    if (n >= 999950) return (n / 1e6).toFixed(1) + "M";
+    if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+    return String(n);
+  }
+
+  function fmtDuration(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor((totalSec % 3600) / 60);
+    const s = totalSec % 60;
+    if (h > 0) return `${h}h${String(m).padStart(2, "0")}m`;
+    if (m > 0) return `${m}m${String(s).padStart(2, "0")}s`;
+    return `${s}s`;
+  }
+
+  const now = options.now ?? new Date();
+
+  function fmtResetTime(epochSec) {
+    if (!epochSec) return "";
+    const d = new Date(epochSec * 1000);
+    if (isNaN(d.getTime())) return "";
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    // Same day → time only; different day → date + time
+    if (
+      d.getFullYear() === now.getFullYear() &&
+      d.getMonth() === now.getMonth() &&
+      d.getDate() === now.getDate()
+    ) {
+      return `${hh}:${mm}`;
+    }
+    return `${d.getMonth() + 1}/${d.getDate()} ${hh}:${mm}`;
+  }
+
+  const ansiRe = /\x1b\[[0-9;]*m/g;
+  function visibleLen(s) {
+    return s.replace(ansiRe, "").length;
+  }
+
+  function compressPath(p, maxLen) {
+    if (p.length <= maxLen) return p;
+    const parts = p.split("/");
+    // Abbreviate from left (skip ~ at index 0 and last component)
+    for (let i = 1; i < parts.length - 1; i++) {
+      if (parts[i].length > 1) {
+        parts[i] = parts[i][0];
+        const result = parts.join("/");
+        if (result.length <= maxLen) return result;
+      }
+    }
+    return parts.join("/");
+  }
+
+  const maxCols = 80;
+  const sep = ` ${darkGray}\u2502${reset} `;
+  const barWidth = 10;
+
+  // ── Directory paths ──────────────────────────────────
+  const home = options.home ?? os.homedir();
+  function tildify(p) {
+    return home && p.startsWith(home) ? "~" + p.slice(home.length) : p;
+  }
+  const dirPath = projectDir ? tildify(projectDir) : "";
+  const cwdPath = cwd && cwd !== projectDir ? tildify(cwd) : "";
+
+  // ── Git branch + dirty + worktree + diff vs main (cached) ──
+  let branch = "";
+  let dirty = "";
+  let isWorktree = false;
+  let diffAdded = 0;
+  let diffRemoved = 0;
+  if (options.git) {
+    ({
+      branch = "",
+      dirty = "",
+      isWorktree = false,
+      diffAdded = 0,
+      diffRemoved = 0,
+    } = options.git);
+  } else if (cwd) {
+    const cacheFile = path.join(os.tmpdir(), ".claude-statusline-git.json");
+    const cacheMaxAge = 5000;
+    let useCache = false;
+    try {
+      const stat = fs.statSync(cacheFile);
+      const cached = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
+      if (cached.cwd === cwd && Date.now() - stat.mtimeMs < cacheMaxAge) {
+        branch = cached.branch;
+        dirty = cached.dirty;
+        isWorktree = cached.isWorktree ?? false;
+        diffAdded = cached.diffAdded ?? 0;
+        diffRemoved = cached.diffRemoved ?? 0;
+        useCache = true;
+      }
+    } catch {}
+    if (!useCache) {
+      try {
+        const statusOut = execSync("git status --short --branch", {
+          cwd,
+          timeout: 2000,
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+        const lines = statusOut.split("\n");
+        // First line: "## branch...tracking" or "## HEAD (no branch)"
+        const branchMatch = lines[0].match(/^## (\S+?)(?:\.\.\.|$)/);
+        branch = branchMatch ? branchMatch[1] : "";
+        // Remaining lines = changed files
+        dirty = lines.length > 1 ? "*" : "";
+        // Detect git worktree: git-dir differs from git-common-dir
+        try {
+          const revOut = execSync(
+            "git rev-parse --path-format=absolute --git-dir --git-common-dir",
+            {
+              cwd,
+              timeout: 1000,
+              encoding: "utf8",
+              stdio: ["pipe", "pipe", "ignore"],
+            },
+          ).trim();
+          const [gitDir, commonDir] = revOut.split("\n");
+          isWorktree = gitDir !== commonDir;
+        } catch {}
+        // Diff stats relative to main (or master) branch
+        for (const base of ["main", "master"]) {
+          try {
+            const diffOut = execSync(`git diff ${base} --shortstat`, {
+              cwd,
+              timeout: 2000,
+              encoding: "utf8",
+              stdio: ["pipe", "pipe", "ignore"],
+            }).trim();
+            const insMatch = diffOut.match(/(\d+) insertion/);
+            const delMatch = diffOut.match(/(\d+) deletion/);
+            if (insMatch) diffAdded = Number(insMatch[1]);
+            if (delMatch) diffRemoved = Number(delMatch[1]);
+            break;
+          } catch {}
+        }
+        fs.writeFileSync(
+          cacheFile,
+          JSON.stringify({
+            cwd,
+            branch,
+            dirty,
+            isWorktree,
+            diffAdded,
+            diffRemoved,
+          }),
+          "utf8",
+        );
+      } catch {}
+    }
+  }
+
+  // ── Effort level (cached by mtime) ─────────────────
+  // Priority: env CLAUDE_CODE_EFFORT_LEVEL → settings.effortLevel → "default"
+  let effort = "default";
+  if (options.effort !== undefined) {
+    effort = options.effort;
+  } else {
+    const settingsPath = path.join(home, ".claude", "settings.json");
+    const settingsCacheFile = path.join(
+      os.tmpdir(),
+      ".claude-statusline-settings.json",
+    );
+    try {
+      const mtime = fs.statSync(settingsPath).mtimeMs;
+      let useSettingsCache = false;
+      try {
+        const cached = JSON.parse(fs.readFileSync(settingsCacheFile, "utf8"));
+        if (cached.mtime === mtime) {
+          effort = cached.effort;
+          useSettingsCache = true;
+        }
+      } catch {}
+      if (!useSettingsCache) {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+        const envEffort =
+          process.env.CLAUDE_CODE_EFFORT_LEVEL ||
+          settings.env?.CLAUDE_CODE_EFFORT_LEVEL;
+        effort = envEffort || settings.effortLevel || "default";
+        fs.writeFileSync(
+          settingsCacheFile,
+          JSON.stringify({ mtime, effort }),
+          "utf8",
+        );
+      }
+    } catch {}
+  }
+
+  // ── Sandbox state (cached by mtime) ─────────────────
+  // mtime = 0 when file absent so the cache still works (measure script seeds mtime: 0)
+  let sandboxMode = ""; // "", "auto", "on"
+  if (options.sandboxMode !== undefined) {
+    sandboxMode = options.sandboxMode;
+  } else if (projectDir) {
+    const localSettingsPath = path.join(
+      projectDir,
+      ".claude",
+      "settings.local.json",
+    );
+    const sandboxCacheFile = path.join(
+      os.tmpdir(),
+      ".claude-statusline-sandbox.json",
+    );
+    let fileMtime = 0;
+    try {
+      fileMtime = fs.statSync(localSettingsPath).mtimeMs;
+    } catch {}
+    let useSandboxCache = false;
+    try {
+      const cached = JSON.parse(fs.readFileSync(sandboxCacheFile, "utf8"));
+      if (cached.mtime === fileMtime && cached.projectDir === projectDir) {
+        sandboxMode = cached.sandboxMode;
+        useSandboxCache = true;
+      }
+    } catch {}
+    if (!useSandboxCache) {
+      try {
+        const localSettings = JSON.parse(
+          fs.readFileSync(localSettingsPath, "utf8"),
+        );
+        if (localSettings.sandbox?.enabled) {
+          sandboxMode = localSettings.sandbox.autoAllowBashIfSandboxed
+            ? "auto"
+            : "on";
+        }
+      } catch {}
+      try {
+        fs.writeFileSync(
+          sandboxCacheFile,
+          JSON.stringify({ mtime: fileMtime, projectDir, sandboxMode }),
+          "utf8",
+        );
+      } catch {}
+    }
+  }
+
+  const effortDisplay = {
+    max: `${red}\u25CF ${effort}${reset}`,
+    high: `${violet}\u25CF ${effort}${reset}`,
+    medium: `${dim}\u25D1 ${effort}${reset}`,
+    default: `${dim}\u25D1 ${effort}${reset}`,
+    low: `${dim}\u25D4 ${effort}${reset}`,
+  };
+  const effortStr = effortDisplay[effort] ?? effortDisplay.default;
+
+  // ── Rate limit usage (native field, v2.1.80+) ──────
+  const usageData = data.rate_limits || null;
+
+  // ── Build output ────────────────────────────────────
+
+  const ctxLabel = ctxSize > 0 ? fmt(ctxSize) : "";
+  const costStr = cost < 0.01 && cost > 0 ? "<0.01" : cost.toFixed(2);
+  const pctColor = colorForPct(usedPct);
+
+  // Sandbox indicator for version line (always shown)
+  const sandboxIcons = {
+    auto: `${green}\uf132\uf0e7${reset}`,
+    on: `${teal}\uf132${reset}`,
+    "": `${dim}\uf132${reset}`,
+  };
+  const sandboxStr = sandboxIcons[sandboxMode];
+
+  // Version banner: ✻ (U+273B) matches Claude Code startup style
+  const shortId = sessionId ? sessionId.slice(0, 7) : "";
+  const sessionSuffix = shortId
+    ? sessionName
+      ? `${sep}${softWhite}${sessionName}${reset} ${gray}(${shortId})${reset}`
+      : `${sep}${gray}(${shortId})${reset}`
+    : "";
+  const versionLine = version
+    ? `${claudeOrange}\u273B ${bold}${claudeOrange}Claude Code${reset} ${dim}v${version}${reset} ${sandboxStr}${sessionSuffix}`
+    : "";
+
+  // Model line: identity, effort │ bar, ctx size │ updated
+  // Usage line: tokens, cache │ cost, duration, diff │ warning
+  const identityGroup = `${bold}${white}${model}${reset} ${effortStr}`;
+  const currentTurnInput = uncachedInput + cacheCreate + cacheRead;
+  const cacheStr =
+    currentTurnInput > 0 && cacheRead > 0
+      ? ` ${teal}\uf1c0 ${softWhite}${Math.round((cacheRead / currentTurnInput) * 100)}%${reset}`
+      : "";
+  const barGroup =
+    `${buildBar(usedPct, barWidth)} ${pctColor}${bold}${usedPct}%${reset}` +
+    (ctxLabel ? ` ${darkGray}(${gray}${ctxLabel}${darkGray})${reset}` : "");
+  const tokenGroup =
+    `${gray}${fmt(totalInput)}\u2191 ${fmt(totalOutput)}\u2193${reset}` +
+    cacheStr;
+  const costParts = [`${teal}$${costStr}${reset}`];
+  if (durationMs > 0) {
+    let timeStr = `${gray}\uf253 ${fmtDuration(durationMs)}${reset}`;
+    if (apiDurationMs > 0) {
+      timeStr += ` ${gold}\uf0e7 ${gray}${fmtDuration(apiDurationMs)}${reset}`;
+    }
+    costParts.push(timeStr);
+  }
+  const hhmm = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+  const updatedStr = `${gray}updated${reset} ${darkGray}\uf017${reset} ${softWhite}${hhmm}${reset}`;
+  const modelParts = [identityGroup, barGroup, updatedStr];
+  const usageParts = [tokenGroup, costParts.join(" ")];
+  if (linesAdded > 0 || linesRemoved > 0) {
+    usageParts.push(
+      `${green}+${linesAdded}${reset} ${red}-${linesRemoved}${reset}`,
+    );
+  }
+  if (exceeds200k) {
+    usageParts.push(`${red}${bold}\u26A0 200K+${reset}`);
+  }
+
+  // Workspace line: path, branch, diff vs main
+  const workspaceParts = [];
+  if (dirPath) {
+    workspaceParts.push(`${blue}\uf041 ${dirPath}${reset}`);
+  }
+  if (branch) {
+    const dirtyStr = dirty ? `${coral}${dirty}${reset}` : "";
+    const diffStr =
+      diffAdded > 0 || diffRemoved > 0
+        ? ` ${green}+${diffAdded}${reset} ${red}-${diffRemoved}${reset}`
+        : "";
+    const wtStr = isWorktree ? ` ${teal}\uf1bb${reset}` : "";
+    workspaceParts.push(
+      `${violet}\ue725 ${branch}${dirtyStr}${wtStr}${diffStr}${reset}`,
+    );
+  }
+  // Compress leading path in a parts array when line exceeds maxCols
+  function compressLeadingPath(parts, rawPath, prefix) {
+    if (!rawPath || parts.length === 0) return;
+    const totalWidth = visibleLen(parts.join(sep));
+    if (totalWidth <= maxCols) return;
+    const maxPathLen = Math.max(1, maxCols - (totalWidth - rawPath.length));
+    parts[0] = `${prefix}${compressPath(rawPath, maxPathLen)}${reset}`;
+  }
+  compressLeadingPath(workspaceParts, dirPath, `${blue}\uf041 `);
+
+  // CWD line: shown only when cwd differs from project_dir
+  const cwdParts = [];
+  if (cwdPath) {
+    cwdParts.push(`${dimBlue}\uf124 ${cwdPath}${reset}`);
+  }
+  compressLeadingPath(cwdParts, cwdPath, `${dimBlue}\uf124 `);
+
+  // Rate limits line: current │ weekly │ updated
+  function fmtRate(rateWindow, label) {
+    if (
+      !rateWindow ||
+      rateWindow.used_percentage === undefined ||
+      rateWindow.used_percentage === null
+    ) {
+      const bar = buildBar(0, barWidth);
+      return `${gray}${label}${reset} ${bar} ${darkGray}--% \uf017 --:--${reset}`;
+    }
+    const pct = Math.round(rateWindow.used_percentage);
+    const rs = fmtResetTime(rateWindow.resets_at);
+    const bar = `${buildBar(pct, barWidth)} ${colorForPct(pct)}${String(pct).padStart(3)}%${reset}`;
+    const resetStr = rs
+      ? ` ${darkGray}\uf017${reset} ${softWhite}${rs}${reset}`
+      : "";
+    return `${gray}${label}${reset} ${bar}${resetStr}`;
+  }
+  const rateParts = [
+    fmtRate(usageData?.five_hour, "current"),
+    fmtRate(usageData?.seven_day, "weekly"),
+  ];
+
+  // ── Collect output lines ────────────────────────────
+  const output = [];
+  if (versionLine) output.push(versionLine);
+  output.push(modelParts.join(sep));
+  output.push(usageParts.join(sep));
+  if (workspaceParts.length > 0) output.push(workspaceParts.join(sep));
+  if (cwdParts.length > 0) output.push(cwdParts.join(sep));
+  output.push(rateParts.join(sep));
+
+  return output;
+}
+
+module.exports = { render };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@z80020100/claude-code-statusline",
+  "version": "0.1.0",
+  "description": "Custom status line for Claude Code — model info, context usage gradient bar, token stats, cost, git status, and rate limits",
+  "main": "lib/statusline.js",
+  "bin": {
+    "claude-code-statusline": "bin/claude-code-statusline.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "npm run lint && npm run format:check && npm run test",
+    "fix": "npm run lint:fix && npm run format:fix",
+    "test": "node test/measure-width.js --check && node test/cli.js",
+    "simulate": "node test/measure-width.js",
+    "ci:local": "act push --container-architecture linux/amd64",
+    "lint": "npm run lint:js && npm run lint:sh && npm run lint:yml",
+    "lint:js": "npx --yes eslint .",
+    "lint:sh": "shellcheck .githooks/pre-commit",
+    "lint:yml": "actionlint .github/workflows/*.yml",
+    "lint:fix": "npx --yes eslint --fix .",
+    "format:check": "npm run format:check:js && npm run format:check:sh",
+    "format:check:js": "npx --yes prettier --check .",
+    "format:check:sh": "shfmt -i 4 -d .githooks/pre-commit",
+    "format:fix": "npm run format:fix:js && npm run format:fix:sh",
+    "format:fix:js": "npx --yes prettier --write .",
+    "format:fix:sh": "shfmt -i 4 -w .githooks/pre-commit",
+    "prepare": "git config --local core.hooksPath .githooks",
+    "postinstall": "node -e \"console.log('\\n  Run setup to configure Claude Code automatically:\\n    claude-code-statusline setup\\n')\"",
+    "prepublishOnly": "npm run test"
+  },
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "status-line",
+    "cli",
+    "terminal",
+    "ansi"
+  ],
+  "license": "MIT",
+  "author": "Cliff Wu <z800201002005@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/z80020100/claude-code-statusline.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}