@seanyao/roll 3.609.2 → 3.610.2

package/lib/roll-loop-story.py

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""
-roll-loop-story — compact per-story rollup for `roll loop story <ID>`.
-
-Loads the same event / cron / runs / git-merge sources as roll-loop-status,
-filters cycles to one story id (case-insensitive), and renders a single
-panel covering cycles count, span, duration, tokens, cost, model, PR list,
-and recent cycle lines.
-
-Usage:
-  roll loop story US-LOOP-004
-  roll loop story us-loop-004                # case-insensitive
-  roll loop story US-LOOP-004 --json         # machine-readable
-  roll loop story US-LOOP-004 --days 30      # widen window (default 30)
-
-Exit codes:
-  0 — at least one cycle found
-  2 — story id has no cycles in the event window
-"""
-from __future__ import annotations
-import argparse, importlib.util, json, os, sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, List
-
-_LIB_DIR = os.path.dirname(os.path.realpath(__file__))
-
-# Reuse the loaders + aggregator from roll-loop-status.py. importlib because the
-# filename has a hyphen and isn't import-safe.
-_spec = importlib.util.spec_from_file_location(
-    "_rls", os.path.join(_LIB_DIR, "roll-loop-status.py")
-)
-rls = importlib.util.module_from_spec(_spec)
-_spec.loader.exec_module(rls)
-
-
-def collect_cycles(days: int) -> List[Dict[str, Any]]:
-    slug = rls.project_slug()
-    events = rls.load_events(slug, days)
-    cron = rls.load_cron_log(slug)
-    runs = rls.load_runs(slug)
-    git_merges = rls.load_pr_merges_from_git(days)
-    cycles = rls.aggregate(events, cron)
-    if runs:
-        rls.merge_runs_into_cycles(cycles, runs)
-    if git_merges:
-        rls.repair_orphan_cycles_from_git(cycles, git_merges)
-    rls.backfill_usage_from_claude_sessions(cycles, slug)
-    return cycles
-
-
-def _outcome_glyph(o: str) -> str:
-    return {"fail": "✗", "running": "⏵", "idle": "·"}.get(o, "✓")
-
-
-def _fmt_dt(dt: datetime) -> str:
-    return dt.astimezone().strftime("%Y-%m-%d %H:%M")
-
-
-def _fmt_dur(s: int) -> str:
-    if not s:
-        return "—"
-    h, rem = divmod(s, 3600)
-    m, _ = divmod(rem, 60)
-    return f"{h}h {m:02d}m" if h else f"{m}m"
-
-
-def _fmt_tokens(n: int) -> str:
-    if not n:
-        return "0"
-    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_pr(p: Dict[str, Any]) -> str:
-    g = {"merged": "✓", "closed": "✗"}.get(p["outcome"], "⏵")
-    return f"#{p['num']} {g}"
-
-
-def render_panel(r: Dict[str, Any], description: str = "") -> str:
-    head = f"── {r['story_id']}"
-    if description:
-        head += f" · {description}"
-    head += " " + "─" * max(0, 78 - len(head))
-
-    cycles = r["cycles"]
-    span = "—"
-    if r.get("span_start") and r.get("span_end"):
-        span = f"{_fmt_dt(r['span_start'])}  →  {_fmt_dt(r['span_end'])}"
-    elif r.get("span_start"):
-        span = f"{_fmt_dt(r['span_start'])}  →  (running)"
-
-    counts = f"  cycles    {r['count']}  (✓ {r['ok_count']}  ✗ {r['fail_count']}  ⏵ {r['running_count']})"
-    line_span = f"  span      {span}"
-    line_dur = (f"  duration  {_fmt_dur(r['duration_s'])}"
-                f"   tokens  in {_fmt_tokens(r['input_tokens'])}"
-                f"  out {_fmt_tokens(r['output_tokens'])}"
-                f"  cache w {_fmt_tokens(r['cache_creation_tokens'])}"
-                f"  r {_fmt_tokens(r['cache_read_tokens'])}")
-    model = r.get("model") or "—"
-    line_cost = f"  cost      ${r['cost']:.2f}    model  {model}"
-
-    prs = r.get("prs") or []
-    line_prs = "  PRs       " + (" ".join(_fmt_pr(p) for p in prs[:8]) if prs else "—")
-
-    # Recent 3 cycles (oldest → newest of the matched set; mirror confirmed layout).
-    recent = sorted(cycles, key=lambda c: c.get("start") or datetime.min.replace(tzinfo=timezone.utc))[-3:]
-    recent_lines: List[str] = []
-    for i, cy in enumerate(recent):
-        label = cy.get("label", "—")
-        glyph = _outcome_glyph(cy.get("outcome", ""))
-        cost = cy.get("cost_list")
-        cost_s = f"${cost:.2f}" if cost is not None else "—"
-        prefix = "  recent   " if i == 0 else "           "
-        recent_lines.append(f"{prefix} {label}  {glyph}  {cost_s}")
-    if not recent_lines:
-        recent_lines.append("  recent    —")
-
-    return "\n".join([head, counts, line_span, line_dur, line_cost, line_prs] + recent_lines)
-
-
-def to_json(r: Dict[str, Any]) -> str:
-    def conv(o: Any) -> Any:
-        if isinstance(o, datetime):
-            return o.astimezone(timezone.utc).isoformat()
-        raise TypeError(f"{type(o)} not serializable")
-
-    payload = {k: v for k, v in r.items() if k != "cycles"}
-    payload["cycles"] = [
-        {
-            "label": cy.get("label"),
-            "start": cy.get("start"),
-            "end": cy.get("end"),
-            "outcome": cy.get("outcome"),
-            "duration_s": cy.get("duration_s"),
-            "input_tokens": cy.get("input_tokens"),
-            "output_tokens": cy.get("output_tokens"),
-            "cache_creation_tokens": cy.get("cache_creation_tokens"),
-            "cache_read_tokens": cy.get("cache_read_tokens"),
-            "cost_list": cy.get("cost_list"),
-            "model": cy.get("model"),
-            "pr_num": cy.get("pr_num"),
-            "pr_outcome": cy.get("pr_outcome"),
-        }
-        for cy in r.get("cycles", [])
-    ]
-    return json.dumps(payload, default=conv, indent=2)
-
-
-def _backlog_description(story_id: str) -> str:
-    bl = rls.load_backlog()
-    return bl.get(story_id.upper(), "")
-
-
-def main(argv=None) -> int:
-    p = argparse.ArgumentParser(
-        description="roll loop story — per-story cycle rollup")
-    p.add_argument("story_id", help="Story ID (case-insensitive, e.g. US-LOOP-004)")
-    p.add_argument("--days", type=int, default=30,
-                   help="event window in days (default 30)")
-    p.add_argument("--json", action="store_true",
-                   help="emit machine-readable JSON instead of the panel")
-    args = p.parse_args(argv)
-
-    cycles = collect_cycles(args.days)
-    r = rls.rollup_for_story(cycles, args.story_id)
-
-    if args.json:
-        print(to_json(r))
-        return 0 if r["count"] > 0 else 2
-
-    if r["count"] == 0:
-        sys.stderr.write(
-            f"roll loop story: no cycles found for {args.story_id} "
-            f"in the last {args.days} days\n"
-            f"未找到 {args.story_id} 在最近 {args.days} 天内的循环\n"
-        )
-        return 2
-
-    print(render_panel(r, _backlog_description(args.story_id.upper())))
-    return 0
-
-
-if __name__ == "__main__":
-    try:
-        sys.exit(main())
-    except BrokenPipeError:
-        pass

package/lib/roll-peer.py

@@ -1,252 +0,0 @@
-#!/usr/bin/env python3
-"""roll-peer — v2 terminal view for `roll peer` (US-VIEW-009).
-
-Renders a cross-agent review log as a turn-based ROUND transcript:
-eyebrow + subject + proposer/reviewer overview + ROUND N sections
-(each carrying agent turns with weight chips) + final VERDICT line
-+ artifact path / next-step hint.
-
-NO_COLOR=1 falls through to glyph + weight + spacing only.
-"""
-from __future__ import annotations
-
-import argparse
-import os
-import sys
-
-_LIB_DIR = os.path.dirname(os.path.realpath(__file__))
-if _LIB_DIR not in sys.path:
-    sys.path.insert(0, _LIB_DIR)
-import roll_render
-from roll_render import c, row, COLS
-
-# ════════════════════════════════════════════════════════════════════════════
-# Agent palette — each agent gets a stable color so reviewer/proposer pairs
-# read at a glance across rounds. Unknown agents fall back to fg.
-# ════════════════════════════════════════════════════════════════════════════
-
-_AGENT_COLOR = {
-    "claude":   "blue",
-    "codex":    "pink",
-    "kimi":     "amber",
-    "deepseek": "green",
-    "agy":      "purple",   # Antigravity (formerly Gemini CLI)
-    "pi":       "yellow",
-    "opencode": "muted",
-    "trae":     "fg",
-}
-
-# Weight chip — (glyph, color, label) per turn.weight
-_WEIGHTS = {
-    "concern": ("●", "amber", "concern"),
-    "nit":     ("○", "dim",   "nit"),
-    "ack":     ("✓", "green", "ack"),
-    "block":   ("✗", "red",   "block"),
-}
-
-
-def _agent_c(name: str) -> str:
-    return _AGENT_COLOR.get(name.lower(), "fg")
-
-
-# ════════════════════════════════════════════════════════════════════════════
-# Fixture data (test-only; opt in via ROLL_RENDER_FIXTURE=1)
-# Illustrative cross-agent review: claude proposes, codex reviews
-# ════════════════════════════════════════════════════════════════════════════
-
-_FIXTURE_SUBJECT = {
-    "story":     "US-AUTH-014",
-    "title":     "Session refresh fallback when refresh-token API 5xx",
-    "pr":        "#412",
-    "diff_stat": "+184 −37 · 6 files",
-    "trigger":   "complexity=large",
-    "proposer":  "claude",
-    "reviewer":  "codex",
-}
-
-_FIXTURE_ROUNDS = [
-    {
-        "n": 1,
-        "hint": "first pass — proposer ships, reviewer probes",
-        "turns": [
-            ("claude", "concern",
-             "Refresh path swallows 503 silently — caller sees a stale session "
-             "without any signal that re-auth is needed."),
-            ("codex",  "nit",
-             "Naming: `tryRefresh` reads as best-effort, but the retry budget "
-             "actually escalates. Suggest `refreshWithBackoff`."),
-            ("codex",  "block",
-             "Backoff jitter uses Math.random — flakes integration tests. "
-             "Inject the rng so tests can pin it."),
-        ],
-    },
-    {
-        "n": 2,
-        "hint": "proposer revises, reviewer signs off",
-        "turns": [
-            ("claude", "ack",
-             "Renamed to `refreshWithBackoff`; threaded `rng` through the "
-             "config object. Added a test that pins seed 42."),
-            ("codex",  "ack",
-             "Looks right — retries fire 3× with jitter, surfaces 503 to "
-             "caller after budget exhausted. Approving."),
-        ],
-    },
-]
-
-_FIXTURE_VERDICT = {
-    "outcome": "approved",
-    "reason":  "2 rounds · 5 turns · all blocks resolved",
-}
-
-_FIXTURE_ARTIFACT = ".roll/peer/logs/20260519_213700_claude_codex.md"
-_FIXTURE_NEXT = [
-    ("Continue execution",   "claude resumes work on US-AUTH-014"),
-    ("Inspect log",          "open the artifact above to replay the transcript"),
-]
-
-
-# ════════════════════════════════════════════════════════════════════════════
-# Render primitives
-# ════════════════════════════════════════════════════════════════════════════
-
-def _divider(char: str = "─") -> None:
-    print(c("dim", char * min(COLS, 80)))
-
-
-def _eyebrow(trigger: str) -> None:
-    left = ("  " + c("blue", "PEER", bold=True) +
-            c("dim", "  ·  ") +
-            c("dim", "roll peer · cross-agent review"))
-    right = c("purple", trigger, bold=True) + "  "
-    print(row(left, right))
-
-
-def _subject(subj: dict) -> None:
-    story = c("blue", subj["story"], bold=True)
-    title = c("fg",   subj["title"])
-    pr    = c("amber", subj["pr"], bold=True)
-    diff  = c("muted", subj["diff_stat"])
-    line  = "  " + story + c("muted", "  ·  ") + title
-    print(line)
-    print("  " + pr + c("muted", "   ") + diff)
-
-
-def _pair_overview(subj: dict) -> None:
-    p_name = subj["proposer"]
-    r_name = subj["reviewer"]
-    p_c = _agent_c(p_name)
-    r_c = _agent_c(r_name)
-    proposer = c("dim", "proposer ") + c(p_c, p_name, bold=True)
-    reviewer = c("dim", "reviewer ") + c(r_c, r_name, bold=True)
-    sep = c("muted", "  →  ")
-    print("  " + proposer + sep + reviewer)
-
-
-def _round_header(n: int, hint: str) -> None:
-    label = c("pink", f"ROUND {n}", bold=True)
-    print()
-    print("  " + label + c("muted", "  ·  ") + c("dim", hint))
-
-
-def _weight_chip(weight: str) -> str:
-    glyph, color, label = _WEIGHTS.get(weight, ("·", "muted", weight))
-    return c(color, glyph + " " + label, bold=(weight in ("ack", "block")))
-
-
-def _turn(agent: str, weight: str, body: str) -> None:
-    agent_c = _agent_c(agent)
-    name = c(agent_c, agent, bold=True)
-    chip = _weight_chip(weight)
-    # First line: agent  chip
-    print("    " + name + c("muted", "  ") + chip)
-    # Body wrapped with hanging indent so long sentences stay readable.
-    _print_wrapped(body, indent=6, width=min(COLS, 80))
-
-
-def _print_wrapped(s: str, *, indent: int, width: int) -> None:
-    avail = max(20, width - indent)
-    line = ""
-    pad = " " * indent
-    for word in s.split():
-        if line and len(line) + 1 + len(word) > avail:
-            print(pad + c("dim", line))
-            line = word
-        else:
-            line = (line + " " + word) if line else word
-    if line:
-        print(pad + c("dim", line))
-
-
-def _verdict(v: dict) -> None:
-    outcome = v["outcome"]
-    if outcome == "approved":
-        glyph, color, label = "✓", "green", "approved"
-    else:
-        glyph, color, label = "✗", "red", "changes requested"
-    head = c(color, f"{glyph} VERDICT", bold=True) + c("muted", "  ·  ") + c(color, label)
-    print()
-    print("  " + head)
-    print("  " + c("dim", v["reason"]))
-
-
-def _footer(artifact: str, next_steps: list) -> None:
-    print()
-    print("  " + c("dim", "artifact ") + c("muted", artifact))
-    print()
-    print("  " + c("pink", "NEXT", bold=True) + c("dim", "  ·  下一步"))
-    for i, (label, hint) in enumerate(next_steps, start=1):
-        num = c("dim", f"  {i}.")
-        print(f"{num} {c('fg', label, bold=True)}")
-        print("     " + c("dim", hint))
-    _divider("═")
-
-
-# ════════════════════════════════════════════════════════════════════════════
-# Top-level render
-# ════════════════════════════════════════════════════════════════════════════
-
-def render_fixture() -> None:
-    _eyebrow(_FIXTURE_SUBJECT["trigger"])
-    _divider()
-    print()
-    _subject(_FIXTURE_SUBJECT)
-    print()
-    _pair_overview(_FIXTURE_SUBJECT)
-    for rd in _FIXTURE_ROUNDS:
-        _round_header(rd["n"], rd["hint"])
-        for agent, weight, body in rd["turns"]:
-            _turn(agent, weight, body)
-    _verdict(_FIXTURE_VERDICT)
-    _footer(_FIXTURE_ARTIFACT, _FIXTURE_NEXT)
-
-
-# ════════════════════════════════════════════════════════════════════════════
-# Entry point
-# ════════════════════════════════════════════════════════════════════════════
-
-def main() -> None:
-    ap = argparse.ArgumentParser(add_help=False)
-    ap.add_argument("--no-color", dest="no_color", action="store_true")
-    ap.add_argument("--en",       action="store_true")
-    ap.add_argument("--zh",       action="store_true")
-    args, _ = ap.parse_known_args()
-
-    if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
-        roll_render.USE_COLOR = False
-
-    # FIX-076: this standalone entrypoint only knows how to render the fixture
-    # transcript (for UI tests). Real peer review is orchestrated by bin/roll
-    # and never invokes this main(). Require an explicit opt-in so a stray
-    # `python3 lib/roll-peer.py` invocation can't masquerade as live output.
-    if not os.environ.get("ROLL_RENDER_FIXTURE"):
-        print("Error: lib/roll-peer.py only renders fixture data; "
-              "set ROLL_RENDER_FIXTURE=1 to use it (test-only).",
-              file=sys.stderr)
-        sys.exit(2)
-
-    render_fixture()
-
-
-if __name__ == "__main__":
-    main()

package/lib/roll-setup.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-"""roll-setup — v2 terminal view for `roll setup`.
-
-Reads a single JSON document from stdin describing the real outcomes of
-`bin/roll cmd_setup`'s step sequence (detect platform / install skills /
-sync conventions / etc). Renders the v2 UI preserving the visual style
-of US-VIEW-007 while reflecting actual results.
-
-Input schema matches `lib/roll-init.py` (see that file for details).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-
-_LIB_DIR = os.path.dirname(os.path.realpath(__file__))
-if _LIB_DIR not in sys.path:
-    sys.path.insert(0, _LIB_DIR)
-import roll_render
-from roll_render import c, row, COLS
-
-
-def _divider(char: str = "─") -> None:
-    print(c("dim", char * min(COLS, 80)))
-
-
-def _step_icon(status: str) -> str:
-    if status == "ok":
-        return c("green", "✓")
-    if status == "skip":
-        return c("amber", "↷")
-    if status == "forced":
-        return c("blue", "~")
-    if status == "fail":
-        return c("red", "✗", bold=True)
-    return c("dim", "·")
-
-
-def render(payload: dict) -> None:
-    header_label = payload.get("header_label", "SETUP")
-    subtitle = payload.get("subtitle", "初始化")
-    right_text = payload.get("project_path") or payload.get("right", "")
-
-    left = "  " + c("blue", header_label, bold=True) + c("dim", "  ·  ") + c("dim", subtitle)
-    right = c("dim", right_text) + "  " if right_text else ""
-    print(row(left, right))
-    _divider()
-    print()
-
-    for step in payload.get("steps", []):
-        num = c("dim", f"  {step.get('num', 0)}.")
-        icon = _step_icon(step.get("status", "ok"))
-        label = step.get("label", "")
-        print(f"{num} {icon}  {label}")
-        note = step.get("note") or step.get("error")
-        if note:
-            tone = "red" if step.get("status") == "fail" else "dim"
-            print("       " + c(tone, str(note)))
-
-    print()
-    _divider()
-
-    footer = payload.get("footer") or {}
-    f_status = footer.get("status", "ok")
-    f_label = footer.get("label", "Setup complete")
-    icon_color = "green" if f_status == "ok" else "red"
-    msg = c(icon_color, f_label)
-    next_hint = footer.get("hint")
-    if next_hint:
-        print(f"  {msg}  —  {next_hint}")
-    else:
-        print(f"  {msg}")
-    _divider("═")
-
-
-def _read_payload() -> dict:
-    raw = sys.stdin.read()
-    if not raw.strip():
-        sys.stderr.write("roll-setup.py: expected JSON on stdin\n")
-        sys.exit(1)
-    try:
-        return json.loads(raw)
-    except json.JSONDecodeError as exc:
-        sys.stderr.write(f"roll-setup.py: invalid JSON on stdin: {exc}\n")
-        sys.exit(1)
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(add_help=False)
-    ap.add_argument("--no-color", dest="no_color", action="store_true")
-    args, _ = ap.parse_known_args()
-
-    if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
-        roll_render.USE_COLOR = False
-
-    render(_read_payload())
-
-
-if __name__ == "__main__":
-    main()