@buckits/claude-statusline 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# @buckits/claude-statusline
+
+A gradient color statusline for Claude Code featuring a visual progress bar that transitions from green to red as your context fills up.
+
+## Installation
+
+```bash
+npx @buckits/claude-statusline
+```
+
+## Features
+
+- **Gradient Progress Bar** - Visual bar that smoothly transitions green → yellow → orange → red as context fills
+- **Color-coded Token Count** - Used tokens match the progress gradient color
+- **Auto-compact Indicator** - Shows `⚡X% until compact` with color warnings (green when safe, red when critical)
+- **Git Integration** - Displays current branch name
+- **Project Name** - Shows current working directory name
+
+## Screenshot
+
+```
+Opus 4.5 [████████████░░░░░░░░] 98.2k/200.0k ⚡15% until compact  main my-project
+```
+
+## What it looks like
+
+| Context Usage | Progress Bar Color | Compact Indicator |
+|---------------|-------------------|-------------------|
+| 0-33% | Green | Green (25%+) |
+| 34-66% | Yellow/Orange | Yellow (15-24%) |
+| 67-100% | Orange/Red | Red (< 4%) |
+
+## Manual Installation
+
+If you prefer to install manually:
+
+1. Copy `statusline.sh` to `~/.claude/statusline.sh`
+2. Make it executable: `chmod +x ~/.claude/statusline.sh`
+3. Add to `~/.claude/settings.json`:
+
+```json
+{
+  "status_line": {
+    "script": "/home/YOUR_USERNAME/.claude/statusline.sh"
+  }
+}
+```
+
+## Requirements
+
+- Claude Code CLI
+- `jq` (for JSON parsing)
+- Bash
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
+const STATUSLINE_DEST = path.join(CLAUDE_DIR, 'statusline.sh');
+const STATUSLINE_SRC = path.join(__dirname, '..', 'statusline.sh');
+
+console.log('\n🎨 Installing @buckits/claude-statusline...\n');
+
+// Ensure ~/.claude directory exists
+if (!fs.existsSync(CLAUDE_DIR)) {
+  console.log('📁 Creating ~/.claude directory...');
+  fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+}
+
+// Copy statusline.sh
+console.log('📄 Copying statusline.sh...');
+fs.copyFileSync(STATUSLINE_SRC, STATUSLINE_DEST);
+fs.chmodSync(STATUSLINE_DEST, '755');
+
+// Update settings.json
+console.log('⚙️  Updating settings.json...');
+let settings = {};
+
+if (fs.existsSync(SETTINGS_FILE)) {
+  try {
+    const content = fs.readFileSync(SETTINGS_FILE, 'utf8');
+    settings = JSON.parse(content);
+  } catch (e) {
+    console.warn('⚠️  Could not parse existing settings.json, creating new one');
+  }
+}
+
+// Set the status_line configuration
+settings.status_line = settings.status_line || {};
+settings.status_line.script = STATUSLINE_DEST;
+
+fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+
+console.log('\n✅ Installation complete!\n');
+console.log('Your Claude Code statusline now features:');
+console.log('  • Gradient progress bar (green → yellow → orange → red)');
+console.log('  • Color-coded token count matching progress');
+console.log('  • Auto-compact countdown with color warnings');
+console.log('  • Git branch and project name display');
+console.log('\nRestart Claude Code to see the new statusline.\n');

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@buckits/claude-statusline",
+  "version": "1.0.0",
+  "description": "A gradient color statusline for Claude Code with progress bar, token counts, and auto-compact indicator",
+  "bin": {
+    "claude-statusline": "./bin/install.js"
+  },
+  "files": [
+    "bin/",
+    "statusline.sh"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "cli",
+    "terminal"
+  ],
+  "author": "Buckits",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Buckits/claude-statusline"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/statusline.sh

@@ -0,0 +1,254 @@
+#!/bin/bash
+
+# Claude Code Status Line Script
+# Read JSON input from stdin
+
+input=$(cat)
+
+# Extract values from JSON
+cwd=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // empty')
+model=$(echo "$input" | jq -r '.model.display_name // empty')
+
+# Extract token information from context_window
+# The actual context usage includes cache tokens from prompt caching
+total_input=$(echo "$input" | jq -r '.context_window.total_input_tokens // 0')
+total_output=$(echo "$input" | jq -r '.context_window.total_output_tokens // 0')
+cache_read=$(echo "$input" | jq -r '.context_window.current_usage.cache_read_input_tokens // 0')
+
+# Total used = input + output + cached tokens being used
+used_tokens=$((total_input + total_output + cache_read))
+max_tokens=$(echo "$input" | jq -r '.context_window.context_window_size // 200000')
+
+# Use the pre-calculated percentage if available (more accurate)
+percent_precalc=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
+if [ -n "$percent_precalc" ]; then
+    percent=$percent_precalc
+    # Recalculate used_tokens from percentage for display accuracy
+    used_tokens=$((max_tokens * percent / 100))
+else
+    # Fallback: calculate percentage from tokens
+    if [ "$max_tokens" -gt 0 ] 2>/dev/null; then
+        percent=$((used_tokens * 100 / max_tokens))
+    else
+        percent=0
+    fi
+fi
+
+# Clamp percent to 0-100
+[ "$percent" -lt 0 ] && percent=0
+[ "$percent" -gt 100 ] && percent=100
+
+# Progress bar settings
+bar_width=20
+filled=$((percent * bar_width / 100))
+empty=$((bar_width - filled))
+
+# Get color for a specific bar position (0 to bar_width-1)
+# Each bar position gets its own color based on progression
+get_bar_color_for_position() {
+    local pos=$1
+    local total=$2
+    # Calculate percentage for this specific bar position
+    local bar_pct=$((pos * 100 / total))
+
+    if [ "$bar_pct" -le 33 ]; then
+        # Green range: 0-33%
+        # Bright green (46) → yellow-green (154) → green (34)
+        if [ "$bar_pct" -le 16 ]; then
+            echo "38;5;46"  # Bright green
+        elif [ "$bar_pct" -le 25 ]; then
+            echo "38;5;118" # Green-yellow
+        else
+            echo "38;5;154" # Yellow-green
+        fi
+    elif [ "$bar_pct" -le 66 ]; then
+        # Orange range: 34-66%
+        # Yellow (226) → orange (214) → dark orange (208)
+        local adj_pct=$((bar_pct - 33))
+        if [ "$adj_pct" -le 11 ]; then
+            echo "38;5;226" # Yellow
+        elif [ "$adj_pct" -le 22 ]; then
+            echo "38;5;220" # Light orange
+        else
+            echo "38;5;214" # Orange
+        fi
+    else
+        # Red range: 67-100%
+        # Orange-red (208) → red (196) → dark red (160)
+        local adj_pct=$((bar_pct - 66))
+        if [ "$adj_pct" -le 11 ]; then
+            echo "38;5;208" # Orange-red
+        elif [ "$adj_pct" -le 22 ]; then
+            echo "38;5;202" # Red-orange
+        else
+            echo "38;5;196" # Bright red
+        fi
+    fi
+}
+
+# Build progress bar with gradient colors
+# Track the color of the rightmost filled bar for the percentage text
+bar="["
+rightmost_color="38;5;46"  # Default to bright green
+for ((i=0; i<filled; i++)); do
+    bar_color=$(get_bar_color_for_position $i $bar_width)
+    rightmost_color=$bar_color  # Keep updating to track the last one
+    bar+=$(printf "\033[${bar_color}m█\033[0m")
+done
+for ((i=0; i<empty; i++)); do
+    bar+="░"
+done
+bar+="]"
+
+# Get git branch if in a git repo
+git_branch=""
+if [ -n "$cwd" ] && git -C "$cwd" rev-parse --git-dir >/dev/null 2>&1; then
+    git_branch=$(git -C "$cwd" branch --show-current 2>/dev/null)
+fi
+
+# Get project name from directory
+project_name=""
+if [ -n "$cwd" ]; then
+    project_name=$(basename "$cwd")
+fi
+
+# Format tokens for display (e.g., 45.2k/200k)
+format_tokens() {
+    local tokens=$1
+    # Use pure bash arithmetic to avoid bc dependency
+    if [ "$tokens" -ge 1000000 ]; then
+        local millions=$((tokens / 1000000))
+        local remainder=$((tokens % 1000000))
+        local decimal=$((remainder / 100000))
+        printf "%d.%dM" "$millions" "$decimal"
+    elif [ "$tokens" -ge 1000 ]; then
+        local thousands=$((tokens / 1000))
+        local remainder=$((tokens % 1000))
+        local decimal=$((remainder / 100))
+        printf "%d.%dk" "$thousands" "$decimal"
+    else
+        echo "$tokens"
+    fi
+}
+
+used_fmt=$(format_tokens $used_tokens)
+max_fmt=$(format_tokens $max_tokens)
+
+# Extract "until compact" percentage
+# Auto-compact triggers at a threshold (appears to be around 78% usage / 22% remaining)
+# The "until compact" value = remaining_percentage - threshold_remaining
+# If threshold is 22%, and you have 24% remaining, then until_compact = 24% - 22% = 2%
+
+# First check if there's an explicit field (unlikely but worth checking)
+until_compact=$(echo "$input" | jq -r '.context_window.until_compact // .context_window.until_auto_compact // empty')
+
+if [ -z "$until_compact" ]; then
+    # Calculate based on auto-compact threshold
+    # Auto-compact threshold appears to be 22% remaining (78% used)
+    AUTO_COMPACT_THRESHOLD=22
+
+    remaining_pct=$(echo "$input" | jq -r '.context_window.remaining_percentage // 0')
+
+    if [ "$remaining_pct" -gt "$AUTO_COMPACT_THRESHOLD" ]; then
+        until_compact=$((remaining_pct - AUTO_COMPACT_THRESHOLD))
+    else
+        # Already past threshold or at it
+        until_compact=0
+    fi
+fi
+
+compact_indicator=""
+compact_color="38;5;46"
+if [ -n "$until_compact" ] && [ "$until_compact" != "null" ] && [ "$until_compact" != "0" ]; then
+    if [ "$until_compact" -ge 25 ]; then
+        compact_color="38;5;46"
+    elif [ "$until_compact" -ge 20 ]; then
+        compact_color="38;5;154"
+    elif [ "$until_compact" -ge 15 ]; then
+        compact_color="38;5;226"
+    elif [ "$until_compact" -ge 10 ]; then
+        compact_color="38;5;220"
+    elif [ "$until_compact" -ge 7 ]; then
+        compact_color="38;5;214"
+    elif [ "$until_compact" -ge 4 ]; then
+        compact_color="38;5;208"
+    else
+        compact_color="38;5;196"
+    fi
+    compact_indicator=$(printf "⚡%d%% until compact" "$until_compact")
+fi
+
+# Build the status line in requested order:
+# Model Name | Progress bar with % | Tokens | Git branch | Project name
+status=""
+
+# 1. Model name (cyan)
+if [ -n "$model" ]; then
+    status+=$(printf "\033[1;36m%s\033[0m" "$model")
+fi
+
+# 2. Progress bar
+status+=$(printf " %s" "$bar")
+
+# 3. Tokens with gradient color on used, cyan on total
+# Used tokens get gradient color matching progress bar (low=green, high=red)
+# The rightmost_color already has the gradient based on current usage
+# Slash and max tokens use cyan to match model name
+status+=$(printf " \033[${rightmost_color}m%s\033[1;36m/%s\033[0m" "$used_fmt" "$max_fmt")
+
+# 3.5. Remaining context percentage (gradient color)
+if [ -n "$compact_indicator" ]; then
+    # Don't use printf %s with the indicator as it contains % characters
+    status+=" $(printf "\033[${compact_color}m")${compact_indicator}$(printf "\033[0m")"
+fi
+
+# 4. Git branch (magenta)
+if [ -n "$git_branch" ]; then
+    status+=$(printf " \033[1;35m %s\033[0m" "$git_branch")
+fi
+
+# 5. Project name (blue)
+if [ -n "$project_name" ]; then
+    status+=$(printf " \033[1;34m%s\033[0m" "$project_name")
+fi
+
+# Extract context information for second line
+skills_count=$(echo "$input" | jq -r '[.context.skills // [] | length] | .[0] // 0')
+agents_count=$(echo "$input" | jq -r '[.context.agents // [] | length] | .[0] // 0')
+mcp_tools_count=$(echo "$input" | jq -r '[.context.mcp_tools // [] | length] | .[0] // 0')
+
+# Extract token counts for context items
+skills_tokens=$(echo "$input" | jq -r '.context.skills_tokens // 0')
+agents_tokens=$(echo "$input" | jq -r '.context.agents_tokens // 0')
+mcp_tokens=$(echo "$input" | jq -r '.context.mcp_tokens // 0')
+
+# Format tokens for context items
+skills_tokens_fmt=$(format_tokens $skills_tokens)
+agents_tokens_fmt=$(format_tokens $agents_tokens)
+mcp_tokens_fmt=$(format_tokens $mcp_tokens)
+
+# Build second line with context information
+status2=""
+
+# Skills (yellow)
+if [ "$skills_count" -gt 0 ]; then
+    status2+=$(printf "\033[1;33mSkills: %d (%s)\033[0m" "$skills_count" "$skills_tokens_fmt")
+fi
+
+# Agents (green)
+if [ "$agents_count" -gt 0 ]; then
+    [ -n "$status2" ] && status2+=" "
+    status2+=$(printf "\033[1;32mAgents: %d (%s)\033[0m" "$agents_count" "$agents_tokens_fmt")
+fi
+
+# MCP Tools (blue)
+if [ "$mcp_tools_count" -gt 0 ]; then
+    [ -n "$status2" ] && status2+=" "
+    status2+=$(printf "\033[1;34mMCP: %d (%s)\033[0m" "$mcp_tools_count" "$mcp_tokens_fmt")
+fi
+
+# Output the status lines
+echo "$status"
+if [ -n "$status2" ]; then
+    echo "$status2"
+fi