{
  "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 │ model │ effort │ 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: show used % (bar grows with usage; 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. Preserve emoji warnings claudeline emits inside each segment.
  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.
 10. Replace claudeline's subscription-plan segment with the live reasoning
     effort level (payload effort.level), placed after the model.

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

# Display labels for the reasoning effort level (payload effort.level).
# Falls back to the raw value for anything not listed here.
EFFORT_LABELS = {
    "low": "Low",
    "medium": "Medium",
    "high": "High",
    "xhigh": "XHigh",
    "max": "Max",
}

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

HYPERLINK_RE = re.compile(r"\x1b\]8;[^\x07]*\x07")


def visible_len(s: str) -> int:
    s = ANSI_RE.sub("", s)
    s = HYPERLINK_RE.sub("", s)
    total = 0
    for ch in s:
        cp = ord(ch)
        if cp >= 0x1F000 or 0x2300 <= cp <= 0x23FF or 0x2B00 <= cp <= 0x2BFF:
            total += 2
        else:
            total += 1
    return total


def _size_from_tty(tty: str) -> int | None:
    if not tty or "?" in tty:
        return None
    try:
        fd = os.open(f"/dev/{tty}", os.O_RDONLY | os.O_NOCTTY | os.O_NONBLOCK)
    except Exception:
        return None
    try:
        cols = os.get_terminal_size(fd).columns
        return cols if cols > 0 else None
    except Exception:
        return None
    finally:
        try:
            os.close(fd)
        except Exception:
            pass


def terminal_width(default: int = 10000) -> int:
    for fd in (1, 2, 0):
        try:
            cols = os.get_terminal_size(fd).columns
            if cols > 0:
                return cols
        except Exception:
            continue

    try:
        fd = os.open("/dev/tty", os.O_RDONLY | os.O_NOCTTY)
        try:
            cols = os.get_terminal_size(fd).columns
            if cols > 0:
                return cols
        finally:
            os.close(fd)
    except Exception:
        pass

    candidates: list[int] = []
    pid_env = os.environ.get("CMUX_CLAUDE_PID")
    if pid_env and pid_env.isdigit():
        candidates.append(int(pid_env))
    candidates.append(os.getpid())

    seen: set[int] = set()
    for start in candidates:
        cur = start
        for _ in range(12):
            if cur <= 1 or cur in seen:
                break
            seen.add(cur)
            try:
                r = subprocess.run(
                    ["ps", "-p", str(cur), "-o", "tty=,ppid="],
                    capture_output=True,
                    text=True,
                    timeout=1,
                )
            except Exception:
                break
            parts = r.stdout.split()
            if not parts:
                break
            cols = _size_from_tty(parts[0])
            if cols:
                return cols
            if len(parts) >= 2 and parts[1].isdigit():
                cur = int(parts[1])
            else:
                break

    cols = os.environ.get("COLUMNS")
    if cols and cols.isdigit() and int(cols) > 0:
        return int(cols)

    return default


def wrap_line(parts: list[str], sep: str, width: int) -> str:
    if not parts:
        return ""
    sep_len = visible_len(sep)
    lines: list[list[str]] = []
    current: list[str] = []
    current_len = 0
    for p in parts:
        plen = visible_len(p)
        if not current:
            current.append(p)
            current_len = plen
            continue
        if current_len + sep_len + plen <= width:
            current.append(p)
            current_len += sep_len + plen
        else:
            lines.append(current)
            current = [p]
            current_len = plen
    if current:
        lines.append(current)
    return "\n".join(sep.join(line) for line in lines)


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)

    # text_segments[0] is claudeline's subscription-plan label (e.g. "Max").
    # We no longer display it; the effort level takes its place.
    model = text_segments[1] if len(text_segments) >= 2 else ""
    extra_texts = text_segments[2:]

    effort = ""
    eff = payload.get("effort")
    if isinstance(eff, dict):
        level = eff.get("level")
        if isinstance(level, str) and level:
            effort = EFFORT_LABELS.get(level.lower(), level)

    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 model:
        parts.append(f"{CYAN}{model}{RESET}")
    if effort:
        parts.append(f"{CYAN}{effort}{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}"

    if project:
        parts.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}"
            parts.append(f"{DIM}{label}{RESET}")

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

    width = terminal_width()
    sys.stdout.write(wrap_line(parts, sep, width))


if __name__ == "__main__":
    main()