@daliovic/cc-statusline 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,94 @@
+# Claude Code Statusline
+
+A minimal, informative statusline for [Claude Code](https://claude.ai/claude-code) CLI.
+
+```
+🤖 Opus 4.5 │ 📊 53% 106K │ ⏱ 26% 2h09 ▼1h32/46% 2d15 ▼1d04
+```
+
+## Features
+
+- **Model indicator** - Shows current model (Opus, Sonnet, Haiku)
+- **Context usage** - Percentage + token count (turns orange at 75%)
+- **Usage limits** - 5-hour session and 7-day limits with reset times
+- **Budget delta** - Shows if you're under (▼ green) or over (▲ red) your expected usage rate
+
+## Installation
+
+### npm (recommended)
+
+```bash
+npm install -g @daliovic/claude-statusline
+```
+
+### From source
+
+```bash
+git clone https://github.com/YOUR_USERNAME/claude-statusline.git
+cd claude-statusline
+npm install
+npm run build
+```
+
+## Configuration
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "claude-statusline",
+    "padding": 0
+  }
+}
+```
+
+Or if installed from source:
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node /path/to/claude-statusline/dist/statusline.js",
+    "padding": 0
+  }
+}
+```
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `STATUSLINE_CACHE_TTL_MS` | `300000` | API cache duration (5 min) |
+
+## How It Works
+
+- Reads session data from Claude Code via stdin
+- Calculates context usage from transcript file
+- Fetches usage limits from Anthropic OAuth API (cached)
+- Budget delta shows time ahead/behind ideal linear usage
+
+## Output Format
+
+```
+🤖 Model │ 📊 Context% Tokens │ ⏱ 5hr% Time Delta/7day% Time Delta
+```
+
+**Colors:**
+- Cyan: Model name and icons
+- Gray: Percentages and times
+- Orange: Context at 75%+
+- Green ▼: Under budget
+- Red ▲: Over budget
+
+## License
+
+MIT License - Do whatever you want with this. Attribution appreciated but not required.
+
+## Credits
+
+Inspired by:
+- [claude-dashboard](https://github.com/uppinote20/claude-dashboard)
+- [claude-statusline-powerline](https://github.com/spences10/claude-statusline-powerline)
+- [ccstatusline](https://github.com/sirmalloc/ccstatusline)
+- [Claude Usage Reticle](https://github.com/KatsuJinCode/claude-usage-reticle) (budget delta concept)

package/dist/statusline.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// === Configuration ===
+const CONFIG = {
+    cacheTtlMs: parseInt(process.env.STATUSLINE_CACHE_TTL_MS || "300000"), // 5 minutes default
+    cacheFile: join(homedir(), ".claude", "statusline-cache.json"),
+    credentialsFile: join(homedir(), ".claude", ".credentials.json"),
+};
+// === ANSI Colors ===
+const color = {
+    reset: "\x1b[0m",
+    orange: "\x1b[38;5;208m",
+    dim: "\x1b[2m",
+    gray: "\x1b[38;5;248m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+};
+// === Helpers ===
+function formatTokens(tokens) {
+    if (tokens >= 1000) {
+        return `${Math.round(tokens / 1000)}K`;
+    }
+    return String(tokens);
+}
+function formatContext(ctx) {
+    if (ctx === undefined)
+        return "";
+    const c = ctx.percent >= 75 ? color.orange : color.gray;
+    return `${c}\u{1F4CA} ${Math.round(ctx.percent)}%${color.dim} ${formatTokens(ctx.tokens)}${color.reset}`;
+}
+function formatTimeHoursMinutes(isoDate) {
+    const diffMs = new Date(isoDate).getTime() - Date.now();
+    if (diffMs <= 0)
+        return "0h00";
+    const totalMins = Math.floor(diffMs / (1000 * 60));
+    const hours = Math.floor(totalMins / 60);
+    const mins = totalMins % 60;
+    return `${hours}h${String(mins).padStart(2, "0")}`;
+}
+function formatTimeDaysHours(isoDate) {
+    const diffMs = new Date(isoDate).getTime() - Date.now();
+    if (diffMs <= 0)
+        return "0d00";
+    const totalHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const days = Math.floor(totalHours / 24);
+    const hours = totalHours % 24;
+    return `${days}d${String(hours).padStart(2, "0")}`;
+}
+function calcDelta(utilization, resetAt, windowHours) {
+    const resetMs = new Date(resetAt).getTime();
+    const nowMs = Date.now();
+    const timeLeftMs = resetMs - nowMs;
+    const windowMs = windowHours * 60 * 60 * 1000;
+    const elapsedMs = windowMs - timeLeftMs;
+    const expectedPct = (elapsedMs / windowMs) * 100;
+    return utilization - expectedPct; // negative = under, positive = over
+}
+function formatDeltaTime(delta, windowHours) {
+    const absDelta = Math.abs(delta);
+    if (absDelta < 1)
+        return "";
+    // Convert percentage delta to hours
+    const deltaHours = (absDelta / 100) * windowHours;
+    let timeStr;
+    if (windowHours <= 5) {
+        // 5-hour window: show hours and minutes
+        const hours = Math.floor(deltaHours);
+        const mins = Math.round((deltaHours - hours) * 60);
+        timeStr = `${hours}h${String(mins).padStart(2, "0")}`;
+    }
+    else {
+        // 7-day window: show days and hours
+        const days = Math.floor(deltaHours / 24);
+        const hours = Math.round(deltaHours % 24);
+        timeStr = `${days}d${String(hours).padStart(2, "0")}`;
+    }
+    if (delta < 0) {
+        return ` ${color.dim}${color.green}\u{25BC}${timeStr}${color.reset}`;
+    }
+    else {
+        return ` ${color.dim}${color.red}\u{25B2}${timeStr}${color.reset}`;
+    }
+}
+// Context window sizes by model
+const CONTEXT_SIZES = {
+    "opus": 200000,
+    "sonnet": 200000,
+    "haiku": 200000,
+};
+function getContextFromTranscript(transcriptPath, modelId) {
+    try {
+        if (!existsSync(transcriptPath))
+            return undefined;
+        const content = readFileSync(transcriptPath, "utf-8");
+        const lines = content.trim().split("\n");
+        // Find last line with usage data
+        let lastUsage;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const entry = JSON.parse(lines[i]);
+                if (entry.message?.usage) {
+                    lastUsage = entry.message.usage;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!lastUsage)
+            return undefined;
+        // Calculate total tokens
+        const totalTokens = (lastUsage.input_tokens || 0) +
+            (lastUsage.output_tokens || 0) +
+            (lastUsage.cache_read_input_tokens || 0) +
+            (lastUsage.cache_creation_input_tokens || 0);
+        // Get context size for model
+        const modelKey = modelId?.split("-")[1]?.toLowerCase() || "opus";
+        const contextSize = CONTEXT_SIZES[modelKey] || 200000;
+        return {
+            percent: (totalTokens / contextSize) * 100,
+            tokens: totalTokens,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+// === OAuth Usage API ===
+async function fetchUsageFromApi() {
+    try {
+        if (!existsSync(CONFIG.credentialsFile))
+            return null;
+        const creds = JSON.parse(readFileSync(CONFIG.credentialsFile, "utf-8"));
+        const token = creds.claudeAiOauth?.accessToken;
+        if (!token)
+            return null;
+        const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "anthropic-beta": "oauth-2025-04-20",
+            },
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+async function getUsageData() {
+    // Check cache
+    if (existsSync(CONFIG.cacheFile)) {
+        try {
+            const cache = JSON.parse(readFileSync(CONFIG.cacheFile, "utf-8"));
+            if (cache.timestamp && Date.now() - cache.timestamp < CONFIG.cacheTtlMs) {
+                return cache.usage;
+            }
+        }
+        catch {
+            // Cache invalid, fetch fresh
+        }
+    }
+    // Fetch fresh data
+    const usage = await fetchUsageFromApi();
+    if (usage) {
+        const cacheData = { timestamp: Date.now(), usage };
+        try {
+            writeFileSync(CONFIG.cacheFile, JSON.stringify(cacheData));
+        }
+        catch {
+            // Ignore cache write errors
+        }
+    }
+    return usage;
+}
+// === Main ===
+async function main() {
+    // Read stdin
+    let stdin = {};
+    try {
+        const input = readFileSync(0, "utf-8");
+        stdin = JSON.parse(input);
+    }
+    catch {
+        // No stdin or invalid JSON
+    }
+    // Extract model info
+    const modelName = stdin.model?.display_name || stdin.model?.id?.split("-")[1] || "?";
+    const modelDisplay = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+    // Extract context usage from transcript
+    let contextInfo;
+    if (stdin.transcript_path) {
+        contextInfo = getContextFromTranscript(stdin.transcript_path, stdin.model?.id);
+    }
+    // Get usage limits (async)
+    const usage = await getUsageData();
+    // Build segments
+    const segments = [];
+    // Model
+    segments.push(`${color.cyan}\u{1F916} ${modelDisplay}${color.reset}`);
+    // Context %
+    if (contextInfo !== undefined) {
+        segments.push(formatContext(contextInfo));
+    }
+    // Combined usage limits: ⏱ 18% 180 / 45% 48
+    if (usage?.five_hour || usage?.seven_day) {
+        const fiveHr = usage.five_hour;
+        const sevenDay = usage.seven_day;
+        const parts = [];
+        if (fiveHr?.utilization !== undefined && fiveHr.resets_at) {
+            const time = formatTimeHoursMinutes(fiveHr.resets_at);
+            const delta = calcDelta(fiveHr.utilization, fiveHr.resets_at, 5);
+            const deltaStr = formatDeltaTime(delta, 5);
+            parts.push(`${color.gray}${Math.round(fiveHr.utilization)}%${color.dim} ${time}${deltaStr}${color.reset}`);
+        }
+        if (sevenDay?.utilization !== undefined && sevenDay.resets_at) {
+            const time = formatTimeDaysHours(sevenDay.resets_at);
+            const delta = calcDelta(sevenDay.utilization, sevenDay.resets_at, 168);
+            const deltaStr = formatDeltaTime(delta, 168);
+            parts.push(`${color.gray}${Math.round(sevenDay.utilization)}%${color.dim} ${time}${deltaStr}${color.reset}`);
+        }
+        if (parts.length > 0) {
+            segments.push(`${color.cyan}\u{23F1}${color.reset} ${parts.join(`${color.dim}/${color.reset}`)}`);
+        }
+    }
+    // Output
+    console.log(segments.join(` ${color.dim}\u{2502}${color.reset} `));
+}
+main().catch(() => process.exit(1));

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@daliovic/cc-statusline",
+  "version": "1.0.0",
+  "description": "Minimal Claude Code statusline with usage limits and budget tracking",
+  "type": "module",
+  "main": "dist/statusline.js",
+  "bin": {
+    "cc-statusline": "dist/statusline.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daliovic/cc-statusline.git"
+  },
+  "author": "daliovic",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "cli",
+    "anthropic"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/daliovic/cc-statusline/issues"
+  },
+  "homepage": "https://github.com/daliovic/cc-statusline#readme",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}