My custom Claude Code Statusline (via claudeline)

{
  "env": {
    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "850000"
  }
}

mkdir -p ~/.claude/bin
curl -fsSL -o /tmp/claudeline.tar.gz \
  https://github.com/fredrikaverpil/claudeline/releases/latest/download/claudeline_darwin_arm64.tar.gz
tar -xzf /tmp/claudeline.tar.gz -C ~/.claude/bin/
chmod +x ~/.claude/bin/claudeline

#!/usr/bin/env python3
"""Custom statusline wrapper around claudeline.

Layout (left to right):

  session-duration │ plan │ model │ ctx-bar │ 5h-bar │ 7d-bar │ folder │ branch │ todo-summary

Transformations vs. raw claudeline:

  1. Drop the sonnet 7-day quota bar.
  2. Context window: bar % overridden to tokens / TRUE_CONTEXT_WINDOW (default 1M),
     computed from the latest `usage` block in the transcript jsonl. Color zone preserved.
  3. 5h and 7d quotas: show remaining % (bars fill toward 100%).
  4. Round times to nearest hour, lowercase 12-hour (1am, 2pm).
  5. Double-width context window bar (5 -> 10 cells).
  6. Strip claudeline's 🥵 (fires at 200k) unless context tokens >= EXTENDED_TOKEN_THRESHOLD (300k).
  7. Folder name and git branch on the right, with dirty-repo indicator.
  8. Session duration on the far left, parsed from the transcript jsonl.
  9. TODO summary on the far right (▶ in_progress, ⏳ pending), hidden when empty.

Falls back to silent exit on any error (Claude Code keeps the previous line).
"""

from __future__ import annotations

import json
import os
import re
import subprocess
import sys
from datetime import datetime, timezone

CLAUDELINE_BIN = os.path.expanduser("~/.claude/bin/claudeline")

ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
SEP_RE = re.compile(r"\x1b\[2m\s*[│·]\s*\x1b\[0m")
COLOR_RE = re.compile(r"\x1b\[(?:3[0-7]|9[0-7])m")
BAR_RE = re.compile(r"([█░]+)\s+(\d+)%")
TIME_RE = re.compile(r"\(([^)]+)\)")

CYAN = "\x1b[36m"
YELLOW = "\x1b[33m"
BLUE = "\x1b[94m"
DIM = "\x1b[2m"
RESET = "\x1b[0m"

CTX_WIDTH = 10
QUOTA_WIDTH = 5

EXTENDED_TOKEN_THRESHOLD = 300_000
TRUE_CONTEXT_WINDOW = 1_000_000
TRANSCRIPT_TAIL_BYTES = 512 * 1024


def render_bar(pct: int, width: int, color: str) -> str:
    filled = round(pct / 100 * width)
    filled = max(0, min(width, filled))
    empty = width - filled
    return f"{color}{'█' * filled}{DIM}{'░' * empty}{RESET}"


def round_to_hour(hhmm: str) -> str:
    h_str, m_str = hhmm.split(":")
    h, m = int(h_str), int(m_str)
    if m >= 30:
        h = (h + 1) % 24
    if h == 0:
        return "12am"
    if h < 12:
        return f"{h}am"
    if h == 12:
        return "12pm"
    return f"{h - 12}pm"


def format_time(t: str) -> str:
    tokens = t.split()
    try:
        if len(tokens) == 1 and ":" in tokens[0]:
            return round_to_hour(tokens[0])
        if len(tokens) == 2 and ":" in tokens[1]:
            return f"{tokens[0]} {round_to_hour(tokens[1])}"
    except Exception:
        pass
    return t


def git_branch(cwd: str) -> str:
    try:
        r = subprocess.run(
            ["git", "-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
            capture_output=True,
            text=True,
            timeout=2,
        )
        if r.returncode == 0:
            return r.stdout.strip()
    except Exception:
        pass
    return ""


def git_dirty_count(cwd: str) -> int:
    try:
        r = subprocess.run(
            ["git", "-C", cwd, "status", "--porcelain"],
            capture_output=True,
            text=True,
            timeout=2,
        )
        if r.returncode == 0:
            return sum(1 for line in r.stdout.splitlines() if line.strip())
    except Exception:
        pass
    return 0


def parse_bar_segment(raw_seg: str) -> dict | None:
    plain = ANSI_RE.sub("", raw_seg).strip()
    bar_match = BAR_RE.search(plain)
    if not bar_match:
        return None
    bar = bar_match.group(1)
    pct = int(bar_match.group(2))

    time_match = TIME_RE.search(plain)
    time_str = time_match.group(1) if time_match else None

    extras = plain
    extras = BAR_RE.sub("", extras, count=1)
    if time_match:
        extras = extras.replace(f"({time_match.group(1)})", "", 1)
    extras = re.sub(r"\bsonnet\b", "", extras)
    extras = re.sub(r"\s+", " ", extras).strip()

    color_match = COLOR_RE.search(raw_seg)
    color = color_match.group(0) if color_match else BLUE

    return {
        "width": len(bar),
        "pct": pct,
        "time": time_str,
        "extras": extras,
        "color": color,
    }


def render_segment(
    parsed: dict,
    width: int,
    mode: str,
    override_pct: int | None = None,
    strip_extended: bool = False,
) -> str:
    if override_pct is not None:
        shown = override_pct
    elif mode == "used":
        shown = parsed["pct"]
    else:
        shown = 100 - parsed["pct"]
    bar = render_bar(shown, width, parsed["color"])
    out = f"{bar} {shown}%"
    if parsed["time"]:
        out += f" ({format_time(parsed['time'])})"
    extras = parsed["extras"]
    if strip_extended:
        extras = extras.replace("🥵", "")
        extras = re.sub(r"\s+", " ", extras).strip()
    if extras:
        out += f" {extras}"
    return out


def latest_context_tokens(transcript_path: str) -> int:
    if not transcript_path or not os.path.exists(transcript_path):
        return 0
    try:
        size = os.path.getsize(transcript_path)
        offset = max(0, size - TRANSCRIPT_TAIL_BYTES)
        with open(transcript_path) as f:
            f.seek(offset)
            if offset > 0:
                f.readline()
            lines = f.readlines()
    except Exception:
        return 0
    last_usage = None
    for line in lines:
        try:
            ev = json.loads(line)
        except Exception:
            continue
        msg = ev.get("message")
        if not isinstance(msg, dict):
            continue
        u = msg.get("usage")
        if isinstance(u, dict):
            last_usage = u
    if not last_usage:
        return 0
    keys = ("input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens")
    return sum(int(last_usage.get(k, 0) or 0) for k in keys)


def session_duration(transcript_path: str) -> str:
    if not transcript_path or not os.path.exists(transcript_path):
        return ""
    start_ts = None
    try:
        with open(transcript_path) as f:
            for _ in range(50):
                line = f.readline()
                if not line:
                    break
                try:
                    ev = json.loads(line)
                except Exception:
                    continue
                ts = ev.get("timestamp")
                if isinstance(ts, str):
                    try:
                        start_ts = datetime.fromisoformat(
                            ts.replace("Z", "+00:00")
                        ).timestamp()
                        break
                    except Exception:
                        continue
    except Exception:
        return ""
    if start_ts is None:
        return ""
    seconds = max(0, int(datetime.now(timezone.utc).timestamp() - start_ts))
    h = seconds // 3600
    m = (seconds % 3600) // 60
    s = seconds % 60
    if h > 0:
        return f"{h}h{m:02d}m"
    if m > 0:
        return f"{m}m{s:02d}s"
    return f"{s}s"


def todo_counts(transcript_path: str) -> dict[str, int]:
    counts: dict[str, int] = {}
    if not transcript_path or not os.path.exists(transcript_path):
        return counts

    latest_todowrite = None
    create_count = 0
    statuses: dict[str, str] = {}

    try:
        with open(transcript_path) as f:
            for line in f:
                try:
                    ev = json.loads(line)
                except Exception:
                    continue
                msg = ev.get("message") or {}
                content = msg.get("content") or []
                if not isinstance(content, list):
                    continue
                for c in content:
                    if not isinstance(c, dict) or c.get("type") != "tool_use":
                        continue
                    name = c.get("name", "")
                    inp = c.get("input") or {}
                    if name == "TodoWrite":
                        latest_todowrite = inp.get("todos") or []
                    elif name == "TaskCreate":
                        create_count += 1
                        tid = str(create_count)
                        statuses.setdefault(tid, "pending")
                    elif name == "TaskUpdate":
                        tid = inp.get("taskId") or inp.get("id")
                        st = inp.get("status")
                        if tid:
                            statuses[str(tid)] = st or statuses.get(str(tid), "pending")
                    elif name == "TaskStop":
                        tid = inp.get("taskId") or inp.get("id")
                        if tid:
                            statuses[str(tid)] = "canceled"
    except Exception:
        return counts

    if latest_todowrite:
        for t in latest_todowrite:
            s = (t.get("status") or "pending").lower()
            counts[s] = counts.get(s, 0) + 1
        return counts

    for s in statuses.values():
        counts[s] = counts.get(s, 0) + 1
    return counts


def render_todos(counts: dict[str, int]) -> str:
    in_prog = counts.get("in_progress", 0)
    pending = counts.get("pending", 0)
    if in_prog == 0 and pending == 0:
        return "No tasks"
    parts = []
    if in_prog:
        parts.append(f"{YELLOW}▶{in_prog}{RESET}{DIM}")
    if pending:
        parts.append(f"⏳{pending}")
    return " ".join(parts)


def main() -> None:
    stdin_data = sys.stdin.read()

    try:
        payload = json.loads(stdin_data)
    except Exception:
        payload = {}

    workspace = payload.get("workspace") or {}
    cwd = workspace.get("project_dir") or payload.get("cwd") or os.getcwd()
    project = os.path.basename(cwd.rstrip("/")) if cwd else ""
    transcript_path = payload.get("transcript_path") or ""

    try:
        result = subprocess.run(
            [CLAUDELINE_BIN],
            input=stdin_data,
            capture_output=True,
            text=True,
            timeout=10,
        )
        raw = result.stdout.strip("\n")
    except Exception:
        return

    if not raw:
        return

    raw_segments = [s for s in SEP_RE.split(raw) if s.strip()]

    has_incident = "🔥" in raw

    text_segments: list[str] = []
    bar_parses: list[dict] = []
    for seg in raw_segments:
        plain = ANSI_RE.sub("", seg).strip()
        if "sonnet" in plain.lower():
            continue
        if "🔥" in plain:
            continue
        if "█" in plain or "░" in plain:
            parsed = parse_bar_segment(seg)
            if parsed:
                bar_parses.append(parsed)
        else:
            text_segments.append(plain)

    plan = text_segments[0] if len(text_segments) >= 1 else ""
    model = text_segments[1] if len(text_segments) >= 2 else ""
    extra_texts = text_segments[2:]

    parts: list[str] = []

    if has_incident:
        link = "\x1b]8;;https://status.claude.com\x07"
        link_close = "\x1b]8;;\x07"
        parts.append(f"{link}🔥{link_close}")

    duration = session_duration(transcript_path)
    if duration:
        parts.append(f"{DIM}{duration}{RESET}")

    if plan:
        parts.append(f"{CYAN}{plan}{RESET}")
    if model:
        parts.append(f"{CYAN}{model}{RESET}")

    if len(bar_parses) >= 1:
        ctx_tokens = latest_context_tokens(transcript_path)
        strip_ext = ctx_tokens < EXTENDED_TOKEN_THRESHOLD
        true_pct = min(100, round(ctx_tokens / TRUE_CONTEXT_WINDOW * 100)) if ctx_tokens else None
        parts.append(
            render_segment(
                bar_parses[0],
                CTX_WIDTH,
                mode="used",
                override_pct=true_pct,
                strip_extended=strip_ext,
            )
        )
    if len(bar_parses) >= 2:
        parts.append(render_segment(bar_parses[1], QUOTA_WIDTH, mode="remaining"))
    if len(bar_parses) >= 3:
        parts.append(render_segment(bar_parses[2], QUOTA_WIDTH, mode="remaining"))

    for extra in extra_texts:
        parts.append(f"{DIM}{extra}{RESET}")

    sep = f"{DIM} │ {RESET}"
    line = sep.join(parts)

    right: list[str] = []
    if project:
        right.append(f"{CYAN}{project}{RESET}")
    if cwd:
        branch = git_branch(cwd)
        if branch:
            dirty = git_dirty_count(cwd)
            label = branch if dirty == 0 else f"{branch} {YELLOW}{dirty}●{RESET}{DIM}"
            right.append(f"{DIM}{label}{RESET}")

    todo_summary = render_todos(todo_counts(transcript_path))
    if todo_summary:
        right.append(f"{DIM}{todo_summary}{RESET}")

    if right:
        line += sep + sep.join(right)

    sys.stdout.write(line)


if __name__ == "__main__":
    main()