@raavalabs/claude-statusline 1.0.0

package/powerline.py

@@ -0,0 +1,613 @@
+#!/usr/bin/env python3
+"""Claude Code Powerline Status Line.
+
+A customizable status line for Claude Code with 3 styles (powerline, capsule, tui)
+and 4 themes (dark, nord, tokyonight, gruvbox). Reads JSON from stdin,
+renders a 2-line status bar with model info, git status, context usage,
+rate limits, and session metrics.
+
+No external dependencies — uses only Python 3 stdlib.
+
+https://github.com/demigod97/claude-statusline
+"""
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+
+# ─── Nerd Font Glyphs ─────────────────────────────────────────────────────────
+
+PL_RIGHT = "\ue0b0"     # Powerline right arrow
+PL_RIGHT_THIN = "\ue0b1" # Powerline right thin arrow
+CAP_LEFT = "\ue0b6"     # Rounded left cap
+CAP_RIGHT = "\ue0b4"    # Rounded right cap
+GIT_BRANCH = "\ue0a0"   # Git branch icon
+
+# ─── Box Drawing (Heavy) ──────────────────────────────────────────────────────
+
+BOX_TL = "\u250f"  # ┏
+BOX_TR = "\u2513"  # ┓
+BOX_BL = "\u2517"  # ┗
+BOX_BR = "\u251b"  # ┛
+BOX_H  = "\u2501"  # ━
+BOX_V  = "\u2503"  # ┃
+BOX_TJ = "\u2533"  # ┳ (top T-junction for mid separator)
+BOX_BJ = "\u253b"  # ┻ (bottom T-junction)
+BOX_LJ = "\u2523"  # ┣ (left T-junction)
+BOX_RJ = "\u252b"  # ┫ (right T-junction)
+
+# ─── Bar Characters ───────────────────────────────────────────────────────────
+
+BAR_FULL  = "\u2588"  # █
+BAR_EMPTY = "\u2591"  # ░
+
+# ─── ANSI Helpers ─────────────────────────────────────────────────────────────
+
+RESET = "\x1b[0m"
+BOLD = "\x1b[1m"
+DIM = "\x1b[2m"
+
+def _hex_to_rgb(h: str) -> tuple:
+    h = h.lstrip("#")
+    return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+
+def ansi_fg(hex_color: str) -> str:
+    r, g, b = _hex_to_rgb(hex_color)
+    return f"\x1b[38;2;{r};{g};{b}m"
+
+def ansi_bg(hex_color: str) -> str:
+    r, g, b = _hex_to_rgb(hex_color)
+    return f"\x1b[48;2;{r};{g};{b}m"
+
+def styled(text: str, fg: str, bg: str) -> str:
+    return f"{ansi_fg(fg)}{ansi_bg(bg)} {text} {RESET}"
+
+# ─── Theme Definitions ────────────────────────────────────────────────────────
+
+THEMES = {
+    "dark": {
+        "dir":      {"bg": "#8b4513", "fg": "#ffffff"},
+        "git":      {"bg": "#444444", "fg": "#90EE90"},
+        "model":    {"bg": "#1a1a1a", "fg": "#87CEEB"},
+        "session":  {"bg": "#000000", "fg": "#00ffff"},
+        "context":  {"bg": "#1a1a1a", "fg": "#aaaaaa"},
+        "rate":     {"bg": "#1a1a1a", "fg": "#d0d0d0"},
+        "tokens":   {"bg": "#1a1a1a", "fg": "#888888"},
+        "lines":    {"bg": "#1a1a1a", "fg": "#aaaaaa"},
+        "vim":      {"bg": "#005f00", "fg": "#00ff00"},
+        "duration": {"bg": "#1a1a1a", "fg": "#666666"},
+    },
+    "nord": {
+        "dir":      {"bg": "#434c5e", "fg": "#d8dee9"},
+        "git":      {"bg": "#3b4252", "fg": "#a3be8c"},
+        "model":    {"bg": "#4c566a", "fg": "#81a1c1"},
+        "session":  {"bg": "#2e3440", "fg": "#88c0d0"},
+        "context":  {"bg": "#2e3440", "fg": "#d8dee9"},
+        "rate":     {"bg": "#2e3440", "fg": "#d8dee9"},
+        "tokens":   {"bg": "#2e3440", "fg": "#4c566a"},
+        "lines":    {"bg": "#2e3440", "fg": "#88c0d0"},
+        "vim":      {"bg": "#a3be8c", "fg": "#2e3440"},
+        "duration": {"bg": "#2e3440", "fg": "#4c566a"},
+    },
+    "tokyonight": {
+        "dir":      {"bg": "#2f334d", "fg": "#82aaff"},
+        "git":      {"bg": "#1e2030", "fg": "#c3e88d"},
+        "model":    {"bg": "#1a1b26", "fg": "#7aa2f7"},
+        "session":  {"bg": "#1a1b26", "fg": "#bb9af7"},
+        "context":  {"bg": "#1a1b26", "fg": "#a9b1d6"},
+        "rate":     {"bg": "#1a1b26", "fg": "#a9b1d6"},
+        "tokens":   {"bg": "#1a1b26", "fg": "#565f89"},
+        "lines":    {"bg": "#1a1b26", "fg": "#73daca"},
+        "vim":      {"bg": "#9ece6a", "fg": "#1a1b26"},
+        "duration": {"bg": "#1a1b26", "fg": "#565f89"},
+    },
+    "gruvbox": {
+        "dir":      {"bg": "#504945", "fg": "#ebdbb2"},
+        "git":      {"bg": "#3c3836", "fg": "#b8bb26"},
+        "model":    {"bg": "#665c54", "fg": "#83a598"},
+        "session":  {"bg": "#282828", "fg": "#8ec07c"},
+        "context":  {"bg": "#282828", "fg": "#ebdbb2"},
+        "rate":     {"bg": "#282828", "fg": "#ebdbb2"},
+        "tokens":   {"bg": "#282828", "fg": "#665c54"},
+        "lines":    {"bg": "#282828", "fg": "#fe8019"},
+        "vim":      {"bg": "#b8bb26", "fg": "#282828"},
+        "duration": {"bg": "#282828", "fg": "#665c54"},
+    },
+}
+
+# ─── Context Color Thresholds ─────────────────────────────────────────────────
+
+def context_fg(pct: float) -> str:
+    if pct >= 90:
+        return "#ff5050"   # red
+    if pct >= 75:
+        return "#ffc832"   # orange
+    if pct >= 50:
+        return "#ffff64"   # yellow
+    return "#64ff64"       # green
+
+def rate_fg(pct: float) -> str:
+    if pct >= 80:
+        return "#ff5050"
+    if pct >= 60:
+        return "#ffc832"
+    if pct >= 40:
+        return "#ffff64"
+    return "#64ff64"
+
+# ─── Token Formatting ─────────────────────────────────────────────────────────
+
+def fmt_tokens(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        return f"{n / 1_000:.0f}k"
+    return str(n)
+
+def fmt_duration(ms: int) -> str:
+    if ms <= 0:
+        return ""
+    secs = ms // 1000
+    mins = secs // 60
+    if mins < 60:
+        return f"{mins}m" if mins > 0 else "<1m"
+    hours = mins // 60
+    rem = mins % 60
+    return f"{hours}h {rem}m"
+
+def fmt_reset_time(resets_at) -> str:
+    if not resets_at:
+        return ""
+    now = time.time()
+    diff = resets_at - now
+    if diff <= 0:
+        return ""
+    mins = int(diff // 60)
+    if mins < 60:
+        return f"{mins}m"
+    hours = mins // 60
+    rem = mins % 60
+    return f"{hours}h {rem}m" if rem > 0 else f"{hours}h"
+
+# ─── Bar Rendering ────────────────────────────────────────────────────────────
+
+def render_bar(pct: float, width: int = 10) -> str:
+    p = min(100.0, max(0.0, pct))
+    filled = round(p / 100 * width)
+    return BAR_FULL * filled + BAR_EMPTY * (width - filled)
+
+def colored_bar(pct: float, width: int = 10) -> str:
+    bar = render_bar(pct, width)
+    color = context_fg(pct)
+    return f"{ansi_fg(color)}{bar}{RESET}"
+
+def rate_bar(pct: float, width: int = 4) -> str:
+    bar = render_bar(pct, width)
+    color = rate_fg(pct)
+    return f"{ansi_fg(color)}{bar}{RESET}"
+
+# ─── ANSI Visible Length ───────────────────────────────────────────────────────
+
+ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)")
+
+def visible_len(s: str) -> int:
+    stripped = ANSI_ESCAPE_RE.sub("", s)
+    width = 0
+    for ch in stripped:
+        cp = ord(ch)
+        if (0x1100 <= cp <= 0x115F or
+            cp in (0x2329, 0x232A) or
+            0x2E80 <= cp <= 0xA4CF or
+            0xAC00 <= cp <= 0xD7A3 or
+            0xF900 <= cp <= 0xFAFF or
+            0xFE10 <= cp <= 0xFE6F or
+            0xFF00 <= cp <= 0xFF60 or
+            0xFFE0 <= cp <= 0xFFE6 or
+            0x1F300 <= cp <= 0x1FAFF or
+            0x20000 <= cp <= 0x3FFFD):
+            width += 2
+        else:
+            width += 1
+    return width
+
+def pad_right(s: str, target_width: int) -> str:
+    current = visible_len(s)
+    if current >= target_width:
+        return s
+    return s + " " * (target_width - current)
+
+# ─── Git Cache ─────────────────────────────────────────────────────────────────
+
+GIT_CACHE_TTL = 5
+
+def _extract_session_id(transcript_path: str) -> str:
+    if transcript_path:
+        base = os.path.splitext(os.path.basename(transcript_path))[0]
+        if base:
+            return base
+    return ""
+
+def _run_git(args: list, cwd: str) -> str:
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True, text=True, timeout=1, cwd=cwd,
+        )
+        return result.stdout.strip() if result.returncode == 0 else ""
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return ""
+
+def _fetch_git_status(cwd: str) -> dict:
+    if not _run_git(["rev-parse", "--git-dir"], cwd):
+        return {}
+
+    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd) or ""
+    porcelain = _run_git(["--no-optional-locks", "status", "--porcelain"], cwd)
+
+    staged = 0
+    modified = 0
+    untracked = 0
+    for line in porcelain.splitlines():
+        if len(line) < 2:
+            continue
+        x, y = line[0], line[1]
+        if x == "?":
+            untracked += 1
+        else:
+            if x in "MADRC":
+                staged += 1
+            if y in "MD":
+                modified += 1
+
+    dirty = staged > 0 or modified > 0 or untracked > 0
+
+    ahead = behind = 0
+    ab = _run_git(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], cwd)
+    if ab and "\t" in ab:
+        parts = ab.split("\t")
+        if len(parts) == 2:
+            try:
+                behind, ahead = int(parts[0]), int(parts[1])
+            except ValueError:
+                pass
+
+    return {
+        "branch": branch,
+        "dirty": dirty,
+        "staged": staged,
+        "modified": modified,
+        "untracked": untracked,
+        "ahead": ahead,
+        "behind": behind,
+    }
+
+def get_git_info(cwd: str, session_id: str) -> dict:
+    if not cwd:
+        return {}
+
+    cache_path = os.path.join(
+        os.environ.get("TMPDIR", "/tmp"),
+        f"claude-powerline-git-{session_id}.json",
+    )
+
+    try:
+        st = os.stat(cache_path)
+        if time.time() - st.st_mtime < GIT_CACHE_TTL:
+            with open(cache_path) as f:
+                return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        pass
+
+    result = _fetch_git_status(cwd)
+
+    tmp = cache_path + ".tmp"
+    try:
+        with open(tmp, "w") as f:
+            json.dump(result, f)
+        os.replace(tmp, cache_path)
+    except OSError:
+        pass
+
+    return result
+
+# ─── Stdin Parsing ─────────────────────────────────────────────────────────────
+
+def parse_stdin() -> dict:
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return {}
+        return json.loads(raw)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+def get_model(data: dict) -> str:
+    return ((data.get("model") or {}).get("display_name") or "").strip() or "Unknown"
+
+def get_cwd(data: dict) -> str:
+    return data.get("cwd") or (data.get("workspace") or {}).get("current_dir") or ""
+
+def get_context_pct(data: dict) -> float:
+    cw = data.get("context_window") or {}
+    pct = cw.get("used_percentage")
+    if isinstance(pct, (int, float)):
+        return min(100.0, max(0.0, float(pct)))
+    return 0.0
+
+def get_rate_limits(data: dict) -> dict:
+    rl = data.get("rate_limits") or {}
+    result = {}
+    for key, field in [("5h", "five_hour"), ("7d", "seven_day")]:
+        window = rl.get(field)
+        if window and isinstance(window.get("used_percentage"), (int, float)):
+            result[key] = {
+                "pct": round(min(100, max(0, window["used_percentage"]))),
+                "resets_at": window.get("resets_at"),
+            }
+    return result
+
+def get_token_counts(data: dict) -> dict:
+    usage = ((data.get("context_window") or {}).get("current_usage")) or {}
+    inp = usage.get("input_tokens", 0) or 0
+    out = usage.get("output_tokens", 0) or 0
+    cache_create = usage.get("cache_creation_input_tokens", 0) or 0
+    cache_read = usage.get("cache_read_input_tokens", 0) or 0
+    total = inp + out + cache_create + cache_read
+    if total == 0:
+        return {}
+    return {"in": inp, "out": out, "cache": cache_create + cache_read}
+
+def get_lines_changed(data: dict) -> tuple:
+    cost = data.get("cost") or {}
+    added = cost.get("total_lines_added")
+    removed = cost.get("total_lines_removed")
+    if added is None and removed is None:
+        return (0, 0)
+    return (added or 0, removed or 0)
+
+def get_duration_ms(data: dict) -> int:
+    return (data.get("cost") or {}).get("total_duration_ms", 0) or 0
+
+def get_session_name(data: dict) -> str:
+    return (data.get("session_name") or "").strip()
+
+def get_vim_mode(data: dict) -> str:
+    vim = data.get("vim") or {}
+    return (vim.get("mode") or "").strip()
+
+# ─── Segment Data ──────────────────────────────────────────────────────────────
+
+class Segment:
+    __slots__ = ("text", "key")
+
+    def __init__(self, text: str, key: str):
+        self.text = text
+        self.key = key
+
+def build_line1_segments(data: dict, git: dict, config: dict) -> list:
+    segments = []
+    cwd = get_cwd(data)
+    path_levels = config.get("path_levels", 2)
+
+    if cwd:
+        parts = cwd.rstrip("/\\").split("/")
+        parts = [p for p in parts if p]
+        dir_text = "/".join(parts[-path_levels:]) if len(parts) >= path_levels else "/".join(parts) or "/"
+        segments.append(Segment(dir_text, "dir"))
+
+    if git and git.get("branch"):
+        git_parts = [f"{GIT_BRANCH} {git['branch']}"]
+        if git.get("dirty"):
+            git_parts.append("\u25cf")
+        if git.get("ahead", 0) > 0:
+            git_parts.append(f"\u2191{git['ahead']}")
+        if git.get("behind", 0) > 0:
+            git_parts.append(f"\u2193{git['behind']}")
+        if git.get("staged", 0) > 0:
+            git_parts.append(f"+{git['staged']}")
+        if git.get("modified", 0) > 0:
+            git_parts.append(f"~{git['modified']}")
+        if git.get("untracked", 0) > 0:
+            git_parts.append(f"?{git['untracked']}")
+        segments.append(Segment(" ".join(git_parts), "git"))
+
+    model = get_model(data)
+    segments.append(Segment(model, "model"))
+
+    session = get_session_name(data)
+    if session:
+        segments.append(Segment(session, "session"))
+
+    return segments
+
+def build_line2_parts(data: dict, theme: dict, config: dict) -> list:
+    parts = []
+    bar_width = config.get("bar_width", 10)
+
+    pct = get_context_pct(data)
+    ctx_color = context_fg(pct)
+    bar = render_bar(pct, bar_width)
+    parts.append(f"{ansi_fg(ctx_color)}{bar} {pct:.0f}%{RESET}")
+
+    rl = get_rate_limits(data)
+    rl_strs = []
+    for label, info in [("5h", rl.get("5h")), ("7d", rl.get("7d"))]:
+        if info:
+            rb = rate_bar(info["pct"], 4)
+            rl_strs.append(f"{label}: {rb} {ansi_fg(rate_fg(info['pct']))}{info['pct']}%{RESET}")
+    if rl_strs:
+        parts.append(" ".join(rl_strs))
+
+    tokens = get_token_counts(data)
+    if tokens:
+        t_parts = [f"in:{fmt_tokens(tokens['in'])}", f"out:{fmt_tokens(tokens['out'])}"]
+        if tokens["cache"] > 0:
+            t_parts.append(f"c:{fmt_tokens(tokens['cache'])}")
+        tok_color = theme.get("tokens", {}).get("fg", "#888888")
+        parts.append(f"{ansi_fg(tok_color)}{' '.join(t_parts)}{RESET}")
+
+    added, removed = get_lines_changed(data)
+    if added > 0 or removed > 0:
+        lc_parts = []
+        if added > 0:
+            lc_parts.append(f"{ansi_fg('#64ff64')}+{added}{RESET}")
+        if removed > 0:
+            lc_parts.append(f"{ansi_fg('#ff5050')}-{removed}{RESET}")
+        parts.append(" ".join(lc_parts))
+
+    vim_mode = get_vim_mode(data)
+    if vim_mode:
+        vim_colors = theme.get("vim", {})
+        vim_fg = vim_colors.get("fg", "#00ff00")
+        vim_bg = vim_colors.get("bg", "#005f00")
+        parts.append(f"{ansi_fg(vim_fg)}{ansi_bg(vim_bg)} {vim_mode} {RESET}")
+
+    dur = get_duration_ms(data)
+    dur_str = fmt_duration(dur)
+    if dur_str:
+        dur_color = theme.get("duration", {}).get("fg", "#666666")
+        parts.append(f"{ansi_fg(dur_color)}{dur_str}{RESET}")
+
+    return parts
+
+# ─── Style: Powerline ─────────────────────────────────────────────────────────
+
+def render_powerline_line(segments: list, theme: dict) -> str:
+    if not segments:
+        return ""
+    out = ""
+    for i, seg in enumerate(segments):
+        colors = theme.get(seg.key)
+        if not colors:
+            continue
+        s_fg = ansi_fg(colors["fg"])
+        s_bg = ansi_bg(colors["bg"])
+        out += f"{s_bg}{s_fg} {seg.text} "
+
+        if i + 1 < len(segments):
+            next_seg = segments[i + 1]
+            next_colors = theme.get(next_seg.key)
+            if next_colors:
+                out += f"{ansi_fg(colors['bg'])}{ansi_bg(next_colors['bg'])}{PL_RIGHT}"
+            else:
+                out += f"{RESET}{ansi_fg(colors['bg'])}{PL_RIGHT}"
+        else:
+            out += f"{RESET}{ansi_fg(colors['bg'])}{PL_RIGHT}"
+    out += RESET
+    return out
+
+# ─── Style: Capsule ───────────────────────────────────────────────────────────
+
+def render_capsule_line(segments: list, theme: dict) -> str:
+    if not segments:
+        return ""
+    pills = []
+    for seg in segments:
+        colors = theme.get(seg.key)
+        if not colors:
+            continue
+        pill = (
+            f"{ansi_fg(colors['bg'])}{CAP_LEFT}"
+            f"{ansi_bg(colors['bg'])}{ansi_fg(colors['fg'])} {seg.text} "
+            f"{RESET}{ansi_fg(colors['bg'])}{CAP_RIGHT}{RESET}"
+        )
+        pills.append(pill)
+    return " ".join(pills)
+
+# ─── Style: TUI ───────────────────────────────────────────────────────────────
+
+def get_terminal_width() -> int:
+    try:
+        return shutil.get_terminal_size(fallback=(80, 24)).columns
+    except (ValueError, OSError):
+        return 80
+
+def render_tui_box(line1: str, line2: str, theme: dict) -> str:
+    width = get_terminal_width()
+    inner = width - 4
+
+    border_fg = theme.get("model", {}).get("fg", "#87CEEB")
+    bc = ansi_fg(border_fg)
+
+    l1 = pad_right(line1, inner)
+    l2 = pad_right(line2, inner)
+
+    top = f"{bc}{BOX_TL}{BOX_H * (width - 2)}{BOX_TR}{RESET}"
+    mid1 = f"{bc}{BOX_V}{RESET} {l1} {bc}{BOX_V}{RESET}"
+    mid_sep = f"{bc}{BOX_LJ}{BOX_H * (width - 2)}{BOX_RJ}{RESET}"
+    mid2 = f"{bc}{BOX_V}{RESET} {l2} {bc}{BOX_V}{RESET}"
+    bottom = f"{bc}{BOX_BL}{BOX_H * (width - 2)}{BOX_BR}{RESET}"
+
+    return "\n".join([top, mid1, mid_sep, mid2, bottom])
+
+# ─── Config ────────────────────────────────────────────────────────────────────
+
+DEFAULT_CONFIG = {
+    "style": "powerline",
+    "theme": "dark",
+    "path_levels": 2,
+    "bar_width": 10,
+}
+
+def _find_config_path() -> str:
+    """Resolve config path: user home first, then script directory."""
+    home_config = os.path.expanduser("~/.claude/statusline/config.json")
+    if os.path.isfile(home_config):
+        return home_config
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    local_config = os.path.join(script_dir, "config.json")
+    if os.path.isfile(local_config):
+        return local_config
+    return home_config
+
+def load_config() -> dict:
+    config = dict(DEFAULT_CONFIG)
+    config_path = _find_config_path()
+    try:
+        with open(config_path) as f:
+            user = json.load(f)
+        config.update(user)
+    except (OSError, json.JSONDecodeError):
+        pass
+    return config
+
+# ─── Main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    config = load_config()
+    data = parse_stdin()
+
+    style = config.get("style", "powerline")
+    theme_name = config.get("theme", "dark")
+    theme = THEMES.get(theme_name, THEMES["dark"])
+
+    transcript_path = data.get("transcript_path", "")
+    session_id = _extract_session_id(transcript_path) or str(os.getpid())
+
+    cwd = get_cwd(data)
+    git = get_git_info(cwd, session_id) if cwd else {}
+
+    line1_segments = build_line1_segments(data, git, config)
+    line2_parts = build_line2_parts(data, theme, config)
+    line2_str = f" {DIM}\u2502{RESET} ".join(line2_parts)
+
+    if style == "tui":
+        tui_l1_parts = []
+        for seg in line1_segments:
+            colors = theme.get(seg.key)
+            if colors:
+                tui_l1_parts.append(f"{ansi_fg(colors['fg'])}{seg.text}{RESET}")
+        tui_line1 = f" {DIM}\u2502{RESET} ".join(tui_l1_parts)
+        print(render_tui_box(tui_line1, line2_str, theme))
+    elif style == "capsule":
+        print(render_capsule_line(line1_segments, theme))
+        print(line2_str)
+    else:
+        print(render_powerline_line(line1_segments, theme))
+        print(line2_str)
+
+if __name__ == "__main__":
+    main()