@seanyao/roll 3.608.1 → 3.610.1

package/lib/i18n.sh

@@ -1,211 +0,0 @@
-#!/usr/bin/env bash
-# Roll i18n engine — US-I18N-001.
-#
-# Provides:
-#   _i18n_resolve_lang     — resolve user's language per precedence
-#   msg <key> [args...]    — look up message catalog with EN fallback
-#   _i18n_set <lang> <key> <value>  — fill the catalog (used by modules)
-#
-# Storage is bash 3.2-compatible (macOS default ships 3.2): each catalog entry
-# is held in a plain variable named `MSG_<LANG>_<key>`, looked up via indirect
-# reference. Bash 4 assoc arrays would be cleaner but break macOS default bash
-# (see AGENTS.md §4: single bash script, no runtime).
-#
-# Precedence: ROLL_LANG env > ~/.roll/config.yaml `lang` > LC_ALL > LANG
-#             > (macOS) AppleLanguages > 'en'.
-# Decision:   value starting with `zh` → "zh", everything else → "en".
-
-# Fill the catalog. Modules call this at source-time:
-#   _i18n_set en hello "Hello, %s!"
-#   _i18n_set zh hello "你好，%s！"
-# No subshell forks: lang uppercasing uses a case statement (bash 3.2-safe;
-# ${var^^} requires bash 4+), key sanitization uses inline param-expansion.
-_i18n_set() {
-  local lang="$1" key="$2" val="$3"
-  local upper safe varname
-  case "$lang" in
-    en|EN) upper=EN ;;
-    zh|ZH) upper=ZH ;;
-    *)     upper="$(printf '%s' "$lang" | tr '[:lower:]' '[:upper:]')" ;;
-  esac
-  safe="${key//[^A-Za-z0-9_]/_}"        # inline param-expansion — no subshell fork
-  varname="MSG_${upper}_${safe}"
-  printf -v "$varname" '%s' "$val"
-  export "$varname"
-}
-
-# Decide "zh" or "en" from a free-form locale string.
-_i18n_classify() {
-  case "${1:-}" in
-    zh*) echo zh ;;
-    *)   echo en ;;
-  esac
-}
-
-# Resolve the active language. Caches in ROLL_LANG_RESOLVED so later calls are
-# free.
-_i18n_resolve_lang() {
-  if [[ -n "${ROLL_LANG_RESOLVED:-}" ]]; then
-    echo "$ROLL_LANG_RESOLVED"
-    return
-  fi
-
-  local lang=""
-
-  if [[ -n "${ROLL_LANG:-}" ]]; then
-    lang=$(_i18n_classify "$ROLL_LANG")
-  fi
-
-  if [[ -z "$lang" && -n "${ROLL_CONFIG:-}" && -f "${ROLL_CONFIG}" ]]; then
-    local cfg
-    cfg=$(grep -E '^lang:' "$ROLL_CONFIG" 2>/dev/null | head -1 \
-            | sed 's/^lang:[[:space:]]*//' \
-            | sed 's/[[:space:]]*#.*$//' \
-            | sed 's/[[:space:]]*$//')
-    [[ -n "$cfg" ]] && lang=$(_i18n_classify "$cfg")
-  fi
-
-  if [[ -z "$lang" && -n "${LC_ALL:-}" ]]; then
-    lang=$(_i18n_classify "$LC_ALL")
-  fi
-
-  if [[ -z "$lang" && -n "${LANG:-}" ]]; then
-    lang=$(_i18n_classify "$LANG")
-  fi
-
-  if [[ -z "$lang" ]] && command -v defaults >/dev/null 2>&1; then
-    local apple
-    apple=$(defaults read -g AppleLanguages 2>/dev/null | head -2 | tail -1 \
-              | tr -d ' ",()' | head -1 || true)
-    [[ -n "$apple" ]] && lang=$(_i18n_classify "$apple")
-  fi
-
-  [[ -z "$lang" ]] && lang="en"
-
-  ROLL_LANG_RESOLVED="$lang"
-  echo "$lang"
-}
-
-# Look up message catalog entry. Falls back to EN, then to the key itself so
-# missing translations stay visible without crashing the caller.
-msg() {
-  local key="$1"; shift || true
-  local lang safe
-  # FIX: avoid subshell forks — check cached value first, inline key sanitize
-  if [[ -n "${ROLL_LANG_RESOLVED:-}" ]]; then
-    lang="$ROLL_LANG_RESOLVED"
-  else
-    lang=$(_i18n_resolve_lang)
-  fi
-  safe="${key//[^A-Za-z0-9_]/_}"       # FIX: inline — no subshell fork
-
-  local zh_var="MSG_ZH_${safe}"
-  local en_var="MSG_EN_${safe}"
-  local tmpl=""
-
-  if [[ "$lang" == "zh" && -n "${!zh_var:-}" ]]; then
-    tmpl="${!zh_var}"
-  elif [[ -n "${!en_var:-}" ]]; then
-    tmpl="${!en_var}"
-  else
-    tmpl="$key"
-  fi
-
-  # shellcheck disable=SC2059 — template comes from our own catalog
-  printf "$tmpl" "$@"
-  echo
-}
-
-# Look up message catalog entry with an explicit language, bypassing ROLL_LANG env.
-# Usage: msg_lang <lang> <key> [printf-args...]
-# Useful when the caller tracks language independently of the process env (e.g.
-# _loop_schedule_desc passes an explicit lang= parameter).
-msg_lang() {
-  local lang="$1" key="$2"; shift 2 || true
-  local upper safe varname tmpl
-  case "$lang" in
-    en|EN) upper=EN ;;
-    zh|ZH) upper=ZH ;;
-    *)     upper="$(printf '%s' "$lang" | tr '[:lower:]' '[:upper:]')" ;;
-  esac
-  safe="${key//[^A-Za-z0-9_]/_}"
-  varname="MSG_${upper}_${safe}"
-  tmpl="${!varname:-}"
-  if [[ -z "$tmpl" ]]; then
-    varname="MSG_EN_${safe}"
-    tmpl="${!varname:-$key}"
-  fi
-  # shellcheck disable=SC2059 — template comes from our own catalog
-  printf "$tmpl" "$@"
-  echo
-}
-
-# ── CJK display-width helpers (US-I18N-006) ──────────────────────────────
-# Compute visual display width of a string (CJK fullwidth = 2 cells,
-# ASCII = 1 cell). Delegates to python3 which is already a dependency.
-_strw() {
-  python3 -c "
-import sys
-from unicodedata import east_asian_width
-s = sys.argv[1]
-w = sum(2 if east_asian_width(c) in ('F','W') else 1 for c in s)
-print(w)
-" "$1"
-}
-
-# Left-pad a string to a target visual display width (CJK-aware).
-_pad_l() {
-  local s="$1" target="$2"
-  local sw
-  sw=$(_strw "$s")
-  local pad=$((target - sw))
-  if ((pad <= 0)); then
-    printf '%s' "$s"
-  else
-    printf '%s%*s' "$s" "$pad" ''
-  fi
-}
-
-# Right-pad a string to a target visual display width (CJK-aware).
-_pad_r() {
-  local s="$1" target="$2"
-  local sw
-  sw=$(_strw "$s")
-  local pad=$((target - sw))
-  if ((pad <= 0)); then
-    printf '%s' "$s"
-  else
-    printf '%*s%s' "$pad" '' "$s"
-  fi
-}
-
-# ── Load per-command message catalogs (US-I18N-002) ──
-# Source all lib/i18n/*.sh files (skip self). Called once at bin/roll startup.
-_i18n_load_catalogs() {
-  # FIX: guard — skip re-load when catalogs already loaded in this shell.
-  # Each bats test sources bin/roll in its own subshell so the guard resets
-  # automatically; but within a single shell (e.g. integration tests) this
-  # prevents 2.6s of catalog I/O on every subsequent source.
-  [[ -n "${_I18N_CATALOGS_LOADED:-}" ]] && return 0
-  local i18n_dir
-  i18n_dir="$(dirname "${BASH_SOURCE[0]:-$0}")/i18n"
-  if [[ -d "$i18n_dir" ]]; then
-    local f
-    # Load per-command catalogs
-    for f in "$i18n_dir"/*.sh; do
-      [[ -f "$f" ]] || continue
-      # shellcheck source=/dev/null
-      source "$f"
-    done
-    # Load skill catalogs (US-I18N-003)
-    if [[ -d "$i18n_dir/skills" ]]; then
-      for f in "$i18n_dir/skills"/*.sh; do
-        [[ -f "$f" ]] || continue
-        # shellcheck source=/dev/null
-        source "$f"
-      done
-    fi
-  fi
-  _I18N_CATALOGS_LOADED=1
-}
-_i18n_load_catalogs

package/lib/loop-exit-summary.py

@@ -1,393 +0,0 @@
-#!/usr/bin/env python3
-"""Render a one-cycle exit summary block for the loop's .command window (US-LOOP-040).
-
-When a `roll loop` cycle ends, the macOS `.command` Terminal window that was
-attached to the tmux session is left showing only a `press enter to close`
-prompt. The full Cycle Phase Breakdown / runs.jsonl data already exists on disk
-but the user has to scroll back through tmux scrollback or open
-``~/.shared/roll/loop/cron-<slug>.log`` to see what the cycle did.
-
-This helper renders a compact ``─── Cycle <CYCLE_ID> Summary ───`` block to
-stdout, consumed by the ``.command`` shell *before* the `press enter` prompt.
-It is a pure read-side view: it never writes new files and never mutates loop
-state.
-
-Five signals (per the US-LOOP-040 issue):
-
-  1. result   — runs.jsonl latest row's ``status`` + ``built[]`` + ``tcr_count``
-                (idle cycle → ``idle: no story picked``)
-  2. ci       — newest ``ci`` event outcome from events.ndjson tail
-                (``ok``→green, ``red``→red, ``heal-attempting`` passthrough,
-                no event → ``ci: n/a``)
-  3. todo     — count of ``📋 Todo`` lines in .roll/backlog.md
-  4. phases   — runs.jsonl ``phases`` map, top 5 by duration desc
-  5. alerts   — raw failure / alert text placeholder
-
-US-LOOP-041 layers failure / alert *highlighting* on top of the US-LOOP-040
-renderer. The relevant signal lines are flagged with a severity prefix and
-ANSI colour:
-
-  * RED + ``✗`` — runs.jsonl ``status`` is ``failed`` / ``aborted``; the latest
-    ``ci`` outcome is ``red``; or the events tail has a ``cycle_end`` whose
-    outcome is not ``ok`` / ``idle``.
-  * YELLOW + ``⚠`` — latest ``ci`` outcome is ``heal-attempting``; an
-    ``ALERT-<slug>.md`` exists and is non-empty; or ``tcr_count == 0`` while
-    ``built[]`` is non-empty (suspected zero-diff).
-  * default colour, no prefix — a fully green cycle (built/idle + ci green +
-    no alert).
-
-ANSI escapes are only emitted when stdout is a TTY (``sys.stdout.isatty()``)
-and ``NO_COLOR`` is unset (see https://no-color.org). Pipes, redirects and
-test captures get plain text — no escape codes are written.
-
-Data-source priority: runs.jsonl latest matching row > events.ndjson tail >
-fall back to the cron log's last 30 lines. Any missing source degrades
-silently — the renderer never errors and never blocks `press enter`.
-
-When no usable data exists at all (idle/aborted early-exit, runs.jsonl not yet
-flushed) it prints a single
-``(summary unavailable — see log: <cron-log>)`` line instead.
-
-Invocation::
-
-    python3 loop-exit-summary.py \
-        --runs   <runs.jsonl> \
-        --events <events.ndjson> \
-        --backlog <.roll/backlog.md> \
-        --cron-log <cron-<slug>.log> \
-        --alert  <ALERT-<slug>.md> \
-        [--cycle-id <id>] [--color {auto,always,never}]
-
-All paths are optional; a missing / unreadable file is treated as absent.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-from typing import Any, Dict, List, Optional
-
-
-def _read_last_json_line(path: Optional[str], cycle_id: str = "") -> Optional[Dict[str, Any]]:
-    """Return the last well-formed JSON object from a .jsonl file.
-
-    When ``cycle_id`` is given, prefer the last row whose ``cycle_id`` matches;
-    otherwise fall back to the last parseable row. Returns None when the file
-    is absent, empty, or has no parseable rows.
-    """
-    if not path or not os.path.isfile(path):
-        return None
-    last: Optional[Dict[str, Any]] = None
-    matched: Optional[Dict[str, Any]] = None
-    try:
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            for line in fh:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    obj = json.loads(line)
-                except (ValueError, TypeError):
-                    continue
-                if not isinstance(obj, dict):
-                    continue
-                last = obj
-                if cycle_id and obj.get("cycle_id") == cycle_id:
-                    matched = obj
-    except OSError:
-        return None
-    return matched if matched is not None else last
-
-
-def _read_json_lines(path: Optional[str]) -> List[Dict[str, Any]]:
-    """Return all well-formed JSON objects from a .ndjson file (in order)."""
-    out: List[Dict[str, Any]] = []
-    if not path or not os.path.isfile(path):
-        return out
-    try:
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            for line in fh:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    obj = json.loads(line)
-                except (ValueError, TypeError):
-                    continue
-                if isinstance(obj, dict):
-                    out.append(obj)
-    except OSError:
-        return out
-    return out
-
-
-def _latest_ci_outcome(events: List[Dict[str, Any]]) -> Optional[str]:
-    """Newest ``ci`` event outcome from an events stream, or None."""
-    for ev in reversed(events):
-        if ev.get("stage") == "ci":
-            outcome = ev.get("outcome")
-            if outcome:
-                return str(outcome)
-    return None
-
-
-def _latest_cycle_end_outcome(events: List[Dict[str, Any]]) -> Optional[str]:
-    """Newest ``cycle_end`` event outcome from an events stream, or None."""
-    for ev in reversed(events):
-        if ev.get("stage") == "cycle_end":
-            outcome = ev.get("outcome")
-            if outcome:
-                return str(outcome)
-    return None
-
-
-def _alert_active(path: Optional[str]) -> bool:
-    """True when an ALERT-<slug>.md file exists and has non-whitespace content."""
-    if not path or not os.path.isfile(path):
-        return False
-    try:
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            return bool(fh.read().strip())
-    except OSError:
-        return False
-
-
-# ── ANSI colouring (US-LOOP-041) ─────────────────────────────────────────────
-# Severity ranks: 0 = none/green, 1 = warn (yellow), 2 = fail (red).
-_SEV_NONE = 0
-_SEV_WARN = 1
-_SEV_FAIL = 2
-
-_ANSI = {_SEV_WARN: "\033[33m", _SEV_FAIL: "\033[31m"}
-_ANSI_RESET = "\033[0m"
-_PREFIX = {_SEV_NONE: "", _SEV_WARN: "⚠ ", _SEV_FAIL: "✗ "}
-
-
-def _color_enabled(mode: str) -> bool:
-    """Decide whether ANSI escapes should be emitted.
-
-    ``always`` forces colour, ``never`` forces plain text, ``auto`` (default)
-    honours NO_COLOR (https://no-color.org) and only colours a real TTY.
-    """
-    if mode == "always":
-        return True
-    if mode == "never":
-        return False
-    if os.environ.get("NO_COLOR") is not None:
-        return False
-    try:
-        return bool(sys.stdout.isatty())
-    except (ValueError, AttributeError):
-        return False
-
-
-def _decorate(text: str, sev: int, color: bool) -> str:
-    """Apply severity prefix + (optional) ANSI colour to a single line.
-
-    The leading indentation is preserved; the prefix and colour wrap only the
-    non-indented payload so columns still line up.
-    """
-    if sev == _SEV_NONE:
-        return text
-    stripped = text.lstrip(" ")
-    indent = text[: len(text) - len(stripped)]
-    payload = _PREFIX[sev] + stripped
-    if color:
-        payload = _ANSI[sev] + payload + _ANSI_RESET
-    return indent + payload
-
-
-def _count_todo(path: Optional[str]) -> Optional[int]:
-    """Count lines bearing the 📋 Todo marker in backlog.md. None if absent."""
-    if not path or not os.path.isfile(path):
-        return None
-    count = 0
-    try:
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            for line in fh:
-                if "📋" in line and "Todo" in line:
-                    count += 1
-    except OSError:
-        return None
-    return count
-
-
-def _tail_lines(path: Optional[str], n: int) -> List[str]:
-    """Last ``n`` non-empty lines of a text file, or [] when absent."""
-    if not path or not os.path.isfile(path):
-        return []
-    try:
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            lines = [ln.rstrip("\n") for ln in fh]
-    except OSError:
-        return []
-    return lines[-n:]
-
-
-def _fmt_ci(outcome: Optional[str]) -> str:
-    if outcome is None:
-        return "ci: n/a"
-    mapping = {"ok": "green", "green": "green", "red": "red",
-               "heal-attempting": "heal-attempting"}
-    return "ci: " + mapping.get(outcome, outcome)
-
-
-def _fmt_result(row: Dict[str, Any]) -> str:
-    status = row.get("status", "")
-    built = row.get("built") or []
-    tcr = row.get("tcr_count", 0)
-    if status == "idle" or (not built and status in ("", "idle")):
-        return "idle: no story picked"
-    if built:
-        built_str = " ".join(str(b) for b in built)
-        return "built: {0} · tcr commits: {1}".format(built_str, tcr)
-    # non-idle terminal with no built[] (failed/aborted/blocked/orphan)
-    return "{0} · tcr commits: {1}".format(status or "unknown", tcr)
-
-
-def _fmt_phases(phases: Dict[str, Any], limit: int = 5) -> List[str]:
-    rows: List[tuple] = []
-    for name, dur in phases.items():
-        try:
-            rows.append((int(dur), str(name)))
-        except (ValueError, TypeError):
-            continue
-    rows.sort(key=lambda r: (-r[0], r[1]))
-    out = []
-    for dur, name in rows[:limit]:
-        out.append("  {0:<22} {1:>5}s".format(name, dur))
-    return out
-
-
-def _result_severity(row: Dict[str, Any]) -> int:
-    """Severity for the result line (US-LOOP-041)."""
-    status = str(row.get("status", ""))
-    if status in ("failed", "aborted"):
-        return _SEV_FAIL
-    built = row.get("built") or []
-    tcr = row.get("tcr_count", 0)
-    if built and tcr == 0:  # suspected zero-diff: built something but no commit
-        return _SEV_WARN
-    return _SEV_NONE
-
-
-def _ci_severity(outcome: Optional[str]) -> int:
-    """Severity for the ci line (US-LOOP-041)."""
-    if outcome == "red":
-        return _SEV_FAIL
-    if outcome == "heal-attempting":
-        return _SEV_WARN
-    return _SEV_NONE
-
-
-def render(runs: Optional[str], events: Optional[str], backlog: Optional[str],
-           cron_log: Optional[str], cycle_id: str = "",
-           alert: Optional[str] = None, color: bool = False) -> str:
-    """Build the summary block as a string.
-
-    ``color`` toggles ANSI escapes; severity prefixes (``✗`` / ``⚠``) are
-    always applied to flagged lines regardless of ``color`` (US-LOOP-041).
-    """
-    row = _read_last_json_line(runs, cycle_id)
-    ev_list = _read_json_lines(events)
-    ci_outcome = _latest_ci_outcome(ev_list)
-    cycle_end_outcome = _latest_cycle_end_outcome(ev_list)
-    alert_on = _alert_active(alert)
-    todo = _count_todo(backlog)
-
-    # Source priority: a usable runs.jsonl row is the primary feed. With no
-    # row AND no events, fall back to the cron log's tail; if even that is
-    # empty, emit the single "unavailable" placeholder line.
-    have_primary = row is not None
-    have_events = bool(ev_list)
-
-    cid = cycle_id or (row.get("cycle_id") if row else "") or "unknown"
-    lines: List[str] = []
-    title = "─── Cycle {0} Summary ───".format(cid)
-
-    if not have_primary and not have_events:
-        tail = _tail_lines(cron_log, 30)
-        if not tail:
-            log_hint = cron_log or "~/.shared/roll/loop/cron-<slug>.log"
-            return "(summary unavailable — see log: {0})".format(log_hint)
-        # Degraded view: header + raw cron tail so the user still sees output.
-        lines.append(title)
-        lines.append("  (runs.jsonl + events unavailable — showing cron log tail)")
-        for ln in tail:
-            lines.append("  " + ln)
-        return "\n".join(lines)
-
-    lines.append(title)
-
-    # cycle_end fail severity applies to the result line when it's worse than
-    # what the runs.jsonl status alone implies.
-    cycle_end_sev = _SEV_NONE
-    if cycle_end_outcome is not None and cycle_end_outcome not in ("ok", "idle"):
-        cycle_end_sev = _SEV_FAIL
-
-    # 1. result
-    if row is not None:
-        result_sev = max(_result_severity(row), cycle_end_sev)
-        lines.append(_decorate("  " + _fmt_result(row), result_sev, color))
-    else:
-        lines.append(_decorate("  result: n/a", cycle_end_sev, color))
-
-    # 2. ci
-    lines.append(_decorate("  " + _fmt_ci(ci_outcome),
-                           _ci_severity(ci_outcome), color))
-
-    # 3. todo
-    if todo is not None:
-        lines.append("  todo remaining: {0}".format(todo))
-    else:
-        lines.append("  todo remaining: n/a")
-
-    # 4. phases (top 5 by duration desc)
-    phases = (row.get("phases") if row else None) or {}
-    if isinstance(phases, dict) and phases:
-        phase_rows = _fmt_phases(phases)
-        if phase_rows:
-            lines.append("  phases (top 5 by time):")
-            lines.extend(phase_rows)
-
-    # 5. alerts / failure highlight (US-LOOP-041)
-    alerts = (row.get("alerts") if row else None) or []
-    if isinstance(alerts, list) and alerts:
-        lines.append(_decorate("  alerts:", _SEV_FAIL, color))
-        for a in alerts:
-            lines.append(_decorate("    " + str(a), _SEV_FAIL, color))
-    if alert_on:
-        lines.append(_decorate("  alert: ALERT file active — see log",
-                               _SEV_WARN, color))
-
-    return "\n".join(lines)
-
-
-def main(argv: Optional[List[str]] = None) -> int:
-    parser = argparse.ArgumentParser(
-        description="Render a loop cycle exit summary block.")
-    parser.add_argument("--runs", default=None, help="path to runs.jsonl")
-    parser.add_argument("--events", default=None, help="path to events.ndjson")
-    parser.add_argument("--backlog", default=None, help="path to .roll/backlog.md")
-    parser.add_argument("--cron-log", default=None, help="path to cron-<slug>.log")
-    parser.add_argument("--cycle-id", default="", help="cycle id to prefer")
-    parser.add_argument("--alert", default=None, help="path to ALERT-<slug>.md")
-    parser.add_argument("--color", choices=("auto", "always", "never"),
-                        default="auto", help="ANSI colour mode (default: auto)")
-    args = parser.parse_args(argv)
-
-    try:
-        color = _color_enabled(args.color)
-        out = render(args.runs, args.events, args.backlog,
-                     args.cron_log, args.cycle_id,
-                     alert=args.alert, color=color)
-    except Exception:  # noqa: BLE001 — silent fallback per AC: never error
-        return 0
-    sys.stdout.write(out + "\n")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())