codebyplan 1.10.3 → 1.11.0

package/templates/hooks/cbp-subagent-statusline.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked via the cbp-subagent-statusline.sh dispatcher)
+# Claude Code Subagent Status Line — python renderer. Byte-identical output to the
+# bash renderer in cbp-subagent-statusline.sh and the node renderer in
+# cbp-subagent-statusline.mjs. Output protocol: one {"id":...,"content":...} JSON
+# line per task. See the .sh file for the full option/env/seam contract.
+# Never throws to stdout.
+
+import json
+import math
+import os
+import sys
+import time
+
+
+def main():
+    raw_input = sys.stdin.read()
+    try:
+        data = json.loads(raw_input)
+    except Exception:
+        data = {}
+    if not isinstance(data, dict):
+        data = {}
+
+    root = os.environ.get("CBP_STATUSLINE_ROOT") or (sys.argv[1] if len(sys.argv) > 1 else "")
+    if not root:
+        root = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))
+
+    try:
+        columns = math.trunc(float(data.get("columns") or 0))
+    except (TypeError, ValueError):
+        columns = 0
+    tasks = data.get("tasks")
+    if not isinstance(tasks, list):
+        tasks = []
+
+    # ---- Config: no_color from statusline.json -------------------------------
+    cfg_no_color = False
+    try:
+        with open(os.path.join(root, ".codebyplan", "statusline.json"), "r", encoding="utf-8") as fh:
+            parsed = json.load(fh)
+        if isinstance(parsed, dict) and isinstance(parsed.get("no_color"), bool):
+            cfg_no_color = parsed["no_color"]
+    except Exception:
+        pass
+
+    no_color = (
+        (os.environ.get("NO_COLOR") not in (None, ""))
+        or os.environ.get("CBP_SUBAGENT_STATUSLINE_NO_COLOR") == "1"
+        or cfg_no_color is True
+    )
+    if no_color:
+        RST = DIM = BOLD = GREEN = RED = BLUE = ""
+    else:
+        RST = "\x1b[0m"
+        DIM = "\x1b[2m"
+        BOLD = "\x1b[1m"
+        GREEN = "\x1b[32m"
+        RED = "\x1b[31m"
+        BLUE = "\x1b[34m"
+
+    def fmt_k(val):
+        v = float(val)
+        if v >= 1000000:
+            t = math.floor((v + 50000) / 100000)
+            return "%d.%dM" % (t // 10, t % 10)
+        elif v >= 1000:
+            t = math.floor((v + 50) / 100)
+            return "%d.%dK" % (t // 10, t % 10)
+        return str(int(v))
+
+    def cbp_now():
+        nv = os.environ.get("CBP_STATUSLINE_NOW")
+        if nv not in (None, ""):
+            return math.trunc(float(nv))
+        return math.floor(time.time())
+
+    def fmt_age_secs(start):
+        delta = cbp_now() - math.trunc(float(start))
+        if delta < 0:
+            delta = 0
+        if delta >= 3600:
+            return "%dh%dm" % (delta // 3600, (delta % 3600) // 60)
+        if delta >= 60:
+            return "%dm%ds" % (delta // 60, delta % 60)
+        return "%ds" % delta
+
+    def is_ascii_letter(b):
+        return (0x41 <= b <= 0x5A) or (0x61 <= b <= 0x7A)
+
+    def truncate(rendered):
+        # ANSI-aware byte-based truncation — mirrors the bash byte walk exactly.
+        if not (columns > 0):
+            return rendered
+        buf = rendered.encode("utf-8")
+        raw_len = len(buf)
+        target = columns - 3
+        if target < 0:
+            target = 0
+        vis = 0
+        i = 0
+        in_esc = False
+        while i < raw_len and vis < target:
+            b = buf[i]
+            if in_esc:
+                if is_ascii_letter(b):
+                    in_esc = False
+            elif b == 0x1B:
+                in_esc = True
+            else:
+                vis += 1
+            i += 1
+        while i < raw_len:
+            b = buf[i]
+            if in_esc:
+                if is_ascii_letter(b):
+                    in_esc = False
+                i += 1
+            elif b == 0x1B:
+                in_esc = True
+                i += 1
+            else:
+                break
+        if i < raw_len:
+            head = buf[:i]
+            tail = (RST + "...").encode("utf-8")
+            return (head + tail).decode("utf-8", errors="replace")
+        return rendered
+
+    out = []
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        t_id = "" if task.get("id") is None else str(task.get("id"))
+        if t_id == "":
+            continue
+        t_name = "" if task.get("name") is None else str(task.get("name"))
+        t_type = "" if task.get("type") is None else str(task.get("type"))
+        t_status = "" if task.get("status") is None else str(task.get("status"))
+        t_desc = "" if task.get("description") is None else str(task.get("description"))
+        try:
+            t_start = math.trunc(float(task.get("startTime") or 0))
+        except (TypeError, ValueError):
+            t_start = 0
+        try:
+            t_tokens = math.trunc(float(task.get("tokenCount") or 0))
+        except (TypeError, ValueError):
+            t_tokens = 0
+
+        if t_status == "running":
+            icon = "%s●%s" % (GREEN, RST)
+        elif t_status == "pending":
+            icon = "%s○%s" % (DIM, RST)
+        elif t_status == "completed":
+            icon = "%s✓%s" % (BLUE, RST)
+        elif t_status == "failed":
+            icon = "%s✗%s" % (RED, RST)
+        else:
+            icon = "%s•%s" % (DIM, RST)
+
+        row = "%s %s%s%s" % (icon, BOLD, t_name, RST)
+        if t_type:
+            row += " %s(%s)%s" % (DIM, t_type, RST)
+        if os.environ.get("CBP_SUBAGENT_STATUSLINE_HIDE_DESCRIPTION") != "1" and t_desc:
+            row += " %s—%s %s" % (DIM, RST, t_desc)
+        if os.environ.get("CBP_SUBAGENT_STATUSLINE_HIDE_TOKENS") != "1" and t_tokens > 0:
+            row += " %s·%s %stokens:%s%s" % (DIM, RST, DIM, RST, fmt_k(t_tokens))
+        if t_start > 0:
+            row += " %s·%s %sage:%s%s" % (DIM, RST, DIM, RST, fmt_age_secs(t_start))
+
+        rendered = truncate(row)
+        out.append(
+            '{"id":%s,"content":%s}'
+            % (json.dumps(t_id, ensure_ascii=False), json.dumps(rendered, ensure_ascii=False))
+        )
+
+    sys.stdout.write(("\n".join(out) + "\n") if out else "")
+
+
+try:
+    main()
+except Exception:
+    sys.exit(0)

package/templates/hooks/cbp-subagent-statusline.sh

@@ -1,22 +1,65 @@
 #!/bin/bash
 # Portability: bash 3.2+ (macOS default /bin/bash). UTF-8 multibyte chars in
 # user-controlled fields are byte-iterated under 3.2 (over-counts visible width
-# for non-ASCII content); acceptable safe-direction approximation.
-# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked by settings.json subagentStatusLine.command)
-# Claude Code Subagent Status Line — one JSON line per active subagent
-# Purpose: Renders one row per running subagent. Output protocol per upstream docs:
+# for non-ASCII content); acceptable safe-direction approximation — and the node
+# (.mjs) / python (.py) renderers iterate the SAME UTF-8 bytes so all three agree.
+# @hook: NOT-A-HOOK (subagentStatusLine renderer, invoked via settings.json subagentStatusLine.command)
+# Claude Code Subagent Status Line — multi-runtime dispatcher + bash renderer.
+# One JSON line per active subagent. Output protocol per upstream docs:
 #   {"id": "<task_id>", "content": "<rendered_body>"}
 #   - Omitted tasks keep their default Claude Code rendering
 #   - Empty content strings hide the row
 # NOT a PreToolUse/PostToolUse/Notification hook — do NOT register in hooks[].
 #
-# ENV-VAR TOGGLES — set to 1 to suppress a column / color
+# RENDERER SELECTION (per-device, gitignored .codebyplan/statusline.local.json):
+#   { "renderer": "bash" | "node" | "python" }  — default bash, falls back to bash
+#   when the chosen runtime is unavailable. Set via `codebyplan statusline …`.
+#
+# CONFIG: honours `no_color` from the committed .codebyplan/statusline.json. The six
+#   main-statusline line toggles do NOT apply to subagent rows.
+#
+# ENV-VAR OVERRIDES (env > config > default)
 #   CBP_SUBAGENT_STATUSLINE_HIDE_DESCRIPTION=1   omit DESCRIPTION segment
 #   CBP_SUBAGENT_STATUSLINE_HIDE_TOKENS=1        omit tokens:N segment
 #   CBP_SUBAGENT_STATUSLINE_NO_COLOR=1           strip all ANSI codes (also honoured by $NO_COLOR)
+#
+# TEST SEAMS (no effect in normal use)
+#   CBP_STATUSLINE_ROOT=<dir>   override the .codebyplan/ lookup root (default: repo root)
+#   CBP_STATUSLINE_NOW=<epoch>  override "now" for age rendering (determinism)
+
+# ============================================================
+# DISPATCHER — resolve root + renderer, delegate when possible
+# ============================================================
+CBP_HOOK_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd 2>/dev/null)" || CBP_HOOK_DIR="."
+CBP_ROOT="${CBP_STATUSLINE_ROOT:-}"
+if [ -z "$CBP_ROOT" ]; then
+  CBP_ROOT="$(cd "$CBP_HOOK_DIR/../.." && pwd 2>/dev/null)" || CBP_ROOT="$PWD"
+fi
+
+CBP_RENDERER="bash"
+CBP_LOCAL_CFG="$CBP_ROOT/.codebyplan/statusline.local.json"
+if [ -f "$CBP_LOCAL_CFG" ] && command -v jq >/dev/null 2>&1; then
+  _r="$(jq -r '.renderer // empty' "$CBP_LOCAL_CFG" 2>/dev/null)"
+  case "$_r" in bash|node|python) CBP_RENDERER="$_r" ;; esac
+fi
+
+if [ "$CBP_RENDERER" = "node" ] && command -v node >/dev/null 2>&1 \
+   && [ -f "$CBP_HOOK_DIR/cbp-subagent-statusline.mjs" ]; then
+  CBP_STATUSLINE_ROOT="$CBP_ROOT" exec node "$CBP_HOOK_DIR/cbp-subagent-statusline.mjs"
+fi
+if [ "$CBP_RENDERER" = "python" ] && command -v python3 >/dev/null 2>&1 \
+   && [ -f "$CBP_HOOK_DIR/cbp-subagent-statusline.py" ]; then
+  CBP_STATUSLINE_ROOT="$CBP_ROOT" exec python3 "$CBP_HOOK_DIR/cbp-subagent-statusline.py"
+fi
+# Fall through → inline bash renderer (default + universal fallback).
 
 INPUT=$(cat)
 
+# Byte-deterministic string ops: force the C locale so the truncation walk below
+# counts UTF-8 BYTES (locale-independent), matching the .mjs/.py byte iteration.
+# Output bytes are unaffected (multibyte content passes through verbatim).
+export LC_ALL=C
+
 # One jq pass for base fields (cwd, session_id, columns)
 eval "$(echo "$INPUT" | jq -r '
   @sh "CWD=\(.cwd // "")",
@@ -24,9 +67,17 @@ eval "$(echo "$INPUT" | jq -r '
   @sh "COLUMNS=\(.columns // 0)"
 ')"
 
-# ---- Colour setup ----------------------------------------------------------
+# ---- Config: no_color from .codebyplan/statusline.json -----------------------
+CFG_NO_COLOR=false
+CBP_CFG="$CBP_ROOT/.codebyplan/statusline.json"
+if [ -f "$CBP_CFG" ] && command -v jq >/dev/null 2>&1; then
+  # `== true` (NOT jq `//`): only an explicit true enables no_color.
+  eval "$(jq -r '"CFG_NO_COLOR=\(.no_color == true)"' "$CBP_CFG" 2>/dev/null)"
+fi
+
+# ---- Colour setup (env > config) ---------------------------------------------
 # Only the colours referenced by the render block below are defined here.
-if [ -n "${NO_COLOR:-}" ] || [ "${CBP_SUBAGENT_STATUSLINE_NO_COLOR:-0}" = "1" ]; then
+if [ -n "${NO_COLOR:-}" ] || [ "${CBP_SUBAGENT_STATUSLINE_NO_COLOR:-0}" = "1" ] || [ "$CFG_NO_COLOR" = "true" ]; then
   RST=''; DIM=''; BOLD=''; GREEN=''; RED=''; BLUE=''
 else
   RST='\033[0m'
@@ -37,25 +88,29 @@ else
   BLUE='\033[34m'
 fi
 
-# ---- Token/size formatter K / M (verbatim from cbp-statusline.sh L96-105) ---
+# ---- Token/size formatter K / M — integer round-half-up (cross-runtime) ------
 fmt_k() {
   local val=$1
   if [ "$val" -ge 1000000 ] 2>/dev/null; then
-    printf "%.1fM" "$(echo "$val / 1000000" | bc -l)"
+    local t=$(( (val + 50000) / 100000 ))
+    printf "%d.%dM" $(( t / 10 )) $(( t % 10 ))
   elif [ "$val" -ge 1000 ] 2>/dev/null; then
-    printf "%.1fK" "$(echo "$val / 1000" | bc -l)"
+    local t=$(( (val + 50) / 100 ))
+    printf "%d.%dK" $(( t / 10 )) $(( t % 10 ))
   else
     printf "%d" "$val"
   fi
 }
 
-# ---- Age formatter: epoch seconds → "Xs" / "XmYs" / "XhYm" -----------------
-# NEW helper — cannot reuse fmt_dur (which divides by 1000 for ms input).
-# startTime is a Unix epoch in seconds, same as rate_limits.*.resets_at.
+# ---- "now" with test seam ----------------------------------------------------
+cbp_now() {
+  if [ -n "${CBP_STATUSLINE_NOW:-}" ]; then printf '%s' "$CBP_STATUSLINE_NOW"; else date +%s; fi
+}
+
+# ---- Age formatter: epoch seconds → "Xs" / "XmYs" / "XhYm" ------------------
 fmt_age_secs() {
   local start=$1
-  local now
-  now=$(date +%s)
+  local now; now=$(cbp_now)
   local delta=$(( now - start ))
   [ "$delta" -lt 0 ] && delta=0
   if [ "$delta" -ge 3600 ]; then
@@ -67,18 +122,16 @@ fmt_age_secs() {
   fi
 }
 
-# ---- Strip ANSI codes for visible-length measurement (column truncation) ----
-strip_ansi() {
-  printf '%s' "$1" | sed $'s/\033\\[[0-9;]*m//g'
-}
-
 # ---- JSON-string-escape a bash variable (embed in {"id":..., "content":...}) -
 json_escape() {
   printf '%s' "$1" | jq -Rs '.'
 }
 
-# ---- Per-task render: one jq TSV emission, looped in bash ------------------
-# Single jq pass for tasks[] (locked decision #3 — two jq calls total).
+# ---- Per-task render: one jq US-delimited emission, looped in bash ----------
+# Join with the Unit Separator (U+001F, non-whitespace) rather than @tsv: a tab is
+# IFS-whitespace, so `IFS=$'\t' read` collapses consecutive tabs and an EMPTY field
+# (e.g. blank description) would shift every later field. US is non-whitespace, so
+# empty fields are preserved — matching the .mjs/.py object iteration.
 echo "$INPUT" | jq -r '
   .tasks // [] | .[] | [
     .id // "",
@@ -88,8 +141,8 @@ echo "$INPUT" | jq -r '
     .description // "",
     (.startTime // 0 | tostring),
     (.tokenCount // 0 | tostring)
-  ] | @tsv
-' | while IFS=$'\t' read -r T_ID T_NAME T_TYPE T_STATUS T_DESC T_START T_TOKENS; do
+  ] | join("\u001f")
+' | while IFS=$'\037' read -r T_ID T_NAME T_TYPE T_STATUS T_DESC T_START T_TOKENS; do
   # Skip blank rows (empty tasks[] → no output)
   [ -z "$T_ID" ] && continue
 
@@ -123,14 +176,12 @@ echo "$INPUT" | jq -r '
   # Apply printf to interpret escape sequences, then truncate to $COLUMNS
   RENDERED=$(printf '%b' "$ROW")
   if [ "$COLUMNS" -gt 0 ] 2>/dev/null; then
-    # ANSI-aware iterative truncation: walk RENDERED char-by-char treating
-    # \033[...letter escape sequences as zero-width and ordinary chars as
+    # ANSI-aware iterative truncation: walk RENDERED byte-by-byte treating
+    # \033[...letter escape sequences as zero-width and ordinary bytes as
     # one-width. Stop when the visible counter reaches COLUMNS - 3, then
-    # append RST + ellipsis. Correct under any ANSI-density distribution,
-    # unlike a single OVERHEAD-add formula which assumes uniform spread.
-    # Pure bash (no awk/perl subprocess); byte-based slicing means non-ASCII
-    # multi-byte UTF-8 in user-controlled descriptions counts as multiple
-    # visible units — acceptable approximation for the ASCII-dominant case.
+    # append RST + ellipsis. Byte-based slicing means non-ASCII multi-byte
+    # UTF-8 counts as multiple visible units — the .mjs/.py renderers iterate
+    # the same UTF-8 bytes, so all three stay byte-identical.
     TARGET=$(( COLUMNS - 3 ))
     [ "$TARGET" -lt 0 ] && TARGET=0
     RAW_LEN=${#RENDERED}
@@ -150,12 +201,11 @@ echo "$INPUT" | jq -r '
       fi
       i=$(( i + 1 ))
     done
-    # Post-loop drain: every rendered row ends with a trailing ${RST} from the
-    # last segment. Without this drain, a row whose visible content fits within
-    # COLUMNS still has `i < RAW_LEN` (pointing inside the trailing reset),
-    # which would spuriously trigger truncation. Walk past any in-progress
-    # escape and any further escape sequences until we hit a real visible byte
-    # or end-of-string.
+    # Post-loop drain: every rendered row ends with a trailing ${RST}. Without
+    # this drain a row whose visible content fits within COLUMNS still has
+    # `i < RAW_LEN` (pointing inside the trailing reset), spuriously triggering
+    # truncation. Walk past any in-progress escape and any further escapes until
+    # a real visible byte or end-of-string.
     while [ $i -lt $RAW_LEN ]; do
       ch="${RENDERED:$i:1}"
       if [ "$in_esc" = "1" ]; then
@@ -171,8 +221,6 @@ echo "$INPUT" | jq -r '
       fi
     done
     if [ $i -lt $RAW_LEN ]; then
-      # printf '%b' converts the literal-text RST (`\033[0m`) into an actual
-      # ESC byte sequence, matching the byte semantics of RENDERED's prefix.
       RENDERED="${RENDERED:0:$i}$(printf '%b' "$RST")..."
     fi
   fi