@andespindola/crow-skills 0.7.1 → 0.9.0

package/crow_skills/progress.py

@@ -31,6 +31,20 @@ MAX_LEDGER = 2 * 1024 * 1024
 MAX_LOG_LINE = 8 * 1024 * 1024
 RECENT_DONE = 300  # seconds a finished run stays visible in compact views
 STALE = 2 * 3600  # a "running" ledger untouched for this long is treated as abandoned
+MAX_AGENT_ROWS = 6  # process rows shown in a status line before "+N"
+
+
+def hook_module():
+    """The mode/event helpers: the package module, or crow_hook.py copied beside this script."""
+    try:
+        from . import hook  # type: ignore[attr-defined]
+        return hook
+    except ImportError:
+        try:
+            import crow_hook as hook  # sibling copy in the integrations directory
+            return hook
+        except ImportError:
+            return None
 
 
 # --- ledger -------------------------------------------------------------------------
@@ -69,7 +83,7 @@ def validate(data):
            "status": data.get("status") if data.get("status") in ("running",) + FINISHED else "running",
            "startedAt": data.get("startedAt"), "updatedAt": data.get("updatedAt"), "endedAt": data.get("endedAt"),
            "session": data.get("session") if isinstance(data.get("session"), dict) else {},
-           "phases": [], "units": []}
+           "phases": [], "units": [], "resources": resources_decision(data.get("resources"))}
     for phase in phases:
         if isinstance(phase, dict) and isinstance(phase.get("id"), str):
             run["phases"].append({"id": phase["id"], "title": safe(phase.get("title") or phase["id"]),
@@ -93,6 +107,42 @@ def validate(data):
     return run
 
 
+RESOURCE_MODES = ("parallel", "reduced", "sequential")
+RESOURCE_LEVELS = ("normal", "warn", "critical", "unknown")
+RESOURCE_SOURCES = ("probe", "os", "assumed")
+
+
+def resources_decision(value):
+    """The optional run-level ``resources`` field (0.9.0): the parallelism decision recorded
+    before a fan-out. Ledgers without it, or with an invalid one, read as None."""
+    if not isinstance(value, dict) or value.get("mode") not in RESOURCE_MODES:
+        return None
+
+    def count(key):
+        number = value.get(key)
+        return number if isinstance(number, int) and not isinstance(number, bool) and 0 <= number <= 256 else None
+
+    return {"mode": value["mode"], "pressure": value.get("pressure") if value.get("pressure") in RESOURCE_LEVELS else None,
+            "source": value.get("source") if value.get("source") in RESOURCE_SOURCES else None,
+            "maxParallelAgents": count("maxParallelAgents"), "maxParallelHeavyJobs": count("maxParallelHeavyJobs"),
+            "maxWorkersPerJob": count("maxWorkersPerJob"),
+            "checkedAt": value.get("checkedAt") if isinstance(value.get("checkedAt"), str) else None,
+            "note": safe(value.get("note") or "", 160)}
+
+
+def resources_line(decision, unicode=True):
+    if not decision:
+        return ""
+    parts = [decision["mode"]]
+    if decision["maxParallelAgents"] is not None:
+        parts.append(("≤" if unicode else "<=") + str(decision["maxParallelAgents"]) + " agente(s)")
+    if decision["maxParallelHeavyJobs"] is not None:
+        parts.append(("≤" if unicode else "<=") + str(decision["maxParallelHeavyJobs"]) + " job(s) pesado(s)")
+    if decision["pressure"]:
+        parts.append("pressão " + decision["pressure"])
+    return "recursos: " + (" · " if unicode else " - ").join(parts) + (" (" + decision["note"] + ")" if decision["note"] else "")
+
+
 def load(path):
     path = Path(path)
     if path.is_symlink() or not path.is_file() or path.stat().st_size > MAX_LEDGER:
@@ -501,6 +551,9 @@ def render(run, usage=None, now=None, color=False, unicode=True, width=20):
              bar(info["progress"], width, unicode) + " " + str(int(info["progress"] * 100)).rjust(3) + "%  " +
              str(info["done"]) + "/" + str(info["total"]) + " unidades" +
              (" - " + str(info["failed"]) + " falha(s)" if info["failed"] else "") + "  " + token_text(usage, unicode)]
+    if run.get("resources"):
+        lines.append(paint("dim", resources_line(run["resources"], unicode)))
+    lines += ["", *agent_rows(run, unicode, counts=False), ""]
     phase_ids = [p["id"] for p in run["phases"]]
     groups = [(p, [u for u in run["units"] if u["phase"] == p["id"]]) for p in run["phases"]]
     loose = [u for u in run["units"] if u["phase"] not in phase_ids]
@@ -527,6 +580,50 @@ def render(run, usage=None, now=None, color=False, unicode=True, width=20):
     return "\n".join(lines)
 
 
+def owner_label(owner):
+    """subagent:leitor -> leitor; workflow:x and sequential stay as written."""
+    owner = owner or "main"
+    return owner.split(":", 1)[1] if owner.startswith("subagent:") and owner[9:] else owner
+
+
+def agent_rows(run, unicode=True, limit=None, counts=True):
+    """Live process list, like the host's own agent list:
+
+        ● main  <what the coordinator is doing>
+        ○ <owner>  <running unit>
+        ✓ 3 concluídas · ✗ 1 falhou · 2 pendentes
+
+    Rows come only from the ledger (units the coordinator recorded); nothing is invented.
+    """
+    dot, ring = ("●", "○") if unicode else ("*", "o")
+    sep = " · " if unicode else " - "
+    running = [u for u in run["units"] if u["status"] == "running"]
+    mine = [u for u in running if owner_label(u["owner"]) in ("main", "sequential")]
+    others = [u for u in running if u not in mine]
+    head = dot + " main"
+    if mine:
+        head += "  " + safe(mine[0]["title"], 60) + (" (+" + str(len(mine) - 1) + ")" if len(mine) > 1 else "")
+    elif run["status"] == "running":
+        head += "  " + safe(run["title"], 60)
+    lines = [head]
+    shown = others if limit is None else others[:limit]
+    for unit in shown:
+        lines.append(ring + " " + safe(owner_label(unit["owner"]), 32) + "  " + safe(unit["title"], 60))
+    if limit is not None and len(others) > limit:
+        lines.append(ring + " +" + str(len(others) - limit))
+    if counts:
+        done = sum(u["status"] == "done" for u in run["units"])
+        failed = sum(u["status"] == "failed" for u in run["units"])
+        pending = sum(u["status"] == "pending" for u in run["units"])
+        parts = [("✓ " if unicode else "ok ") + str(done) + " concluída(s)"]
+        if failed:
+            parts.append(("✗ " if unicode else "x ") + str(failed) + " falha(s)")
+        if pending:
+            parts.append(str(pending) + " pendente(s)")
+        lines.append(sep.join(parts))
+    return lines
+
+
 def compact(run, usage=None, unicode=True, width=10):
     info = summary(run)
     mark = "✓" if run["status"] == "done" else ("✗" if run["status"] in ("failed", "cancelled") else "▸")
@@ -580,19 +677,53 @@ def watch(cwd, home, run_id=None, interval=1.0, stream=None, linger=5.0, max_fra
         return 0
 
 
-def statusline(home, stdin_text, chain=None):
-    """Claude Code statusLine: one line; the previous status line (if chained) comes first."""
+def mode_text(home, unicode=True):
+    hook = hook_module()
+    if hook is None:
+        return ""
+    try:
+        return hook.indicator(hook.read_mode(home)["mode"], unicode)
+    except (OSError, ValueError, KeyError):
+        return ""
+
+
+def memory_text(home, unicode=True):
+    """'mem ▲ 85% ×2' when the machine is under pressure or parallelism is reduced; else ''."""
+    hook = hook_module()
+    module = hook.resources_module() if hook is not None and hasattr(hook, "resources_module") else None
+    if module is None:
+        return ""
+    try:
+        return module.segment(module.probe(home, processes=False, use_cache=True), unicode)
+    except Exception:  # noqa: BLE001 - the probe never breaks a status line
+        return ""
+
+
+def statusline(home, stdin_text, chain=None, host="claude"):
+    """Status line for Claude Code and Antigravity (agy).
+
+    First line: the previous (chained) status line, the mode indicator and the compact
+    run; then one row per running unit of the ledger, like the host's agent list. agy
+    stacks it under its default line (stack_with_default), so no chain is needed there.
+    """
     try:
         payload = json.loads(stdin_text) if stdin_text.strip() else {}
     except ValueError:
         payload = {}
     if not isinstance(payload, dict):
         payload = {}
-    cwd = (payload.get("workspace") or {}).get("current_dir") or payload.get("cwd") or os.getcwd()
+    workspace = payload.get("workspace") if isinstance(payload.get("workspace"), dict) else {}
+    cwd = workspace.get("current_dir") or payload.get("cwd") or os.getcwd()
     transcript = payload.get("transcript_path")
-    session = payload.get("session_id")
+    session = payload.get("session_id") or payload.get("conversation_id")
     if not (isinstance(session, str) and session):
         session = Path(transcript).stem if isinstance(transcript, str) and transcript.endswith(".jsonl") else None
+    hook = hook_module()
+    if hook is not None:
+        try:
+            hook.update_metrics(home, host, payload)
+        except Exception:  # noqa: BLE001 - metrics never break the status line
+            pass
     previous = ""
     if chain:
         try:
@@ -603,9 +734,10 @@ def statusline(home, stdin_text, chain=None):
         except (OSError, subprocess.SubprocessError):
             previous = ""
     run = select(discover(cwd, home), cwd, strict=True, session=session)
-    ours = ""
+    parts = [p for p in (mode_text(home), memory_text(home)) if p]
+    rows = []
     if active(run):
-        if run["host"] == "claude" and not run["session"].get("id") and session:
+        if run["host"] == "claude" and host == "claude" and not run["session"].get("id") and session:
             # The status line knows its own session: exact usage instead of every session in the directory.
             try:
                 usage = claude_tokens(dict(run, session={"id": session}), Path(home), *window(run))
@@ -613,19 +745,28 @@ def statusline(home, stdin_text, chain=None):
                 usage = None
         else:
             usage = tokens(run, home)
-        ours = compact(run, usage)
+        parts.append(compact(run, usage))
+        if run["status"] == "running":
+            rows = agent_rows(run, limit=MAX_AGENT_ROWS, counts=False)
+            if len(rows) == 1:
+                rows = []  # only "● main": the compact segment already says it
+    ours = " │ ".join(parts)
     if not previous.strip():
-        return ours
-    if not ours:
-        return previous
-    return previous + " │ " + ours
+        first_line = ours
+    elif not ours:
+        first_line = previous
+    else:
+        first_line = previous + " │ " + ours
+    return "\n".join([first_line, *rows]) if rows else first_line
 
 
 def tmux_segment(home, cwd):
+    head = " · ".join(p for p in (mode_text(home), memory_text(home)) if p)
     run = select(discover(cwd, home), cwd, strict=True)
     if not active(run):
-        return ""
-    return compact(run, tokens(run, home), unicode=True, width=8).replace("#", "##")
+        return head.replace("#", "##")
+    text = compact(run, tokens(run, home), unicode=True, width=8)
+    return ((head + " · " if head else "") + text).replace("#", "##")
 
 
 def main(argv=None):
@@ -636,6 +777,7 @@ def main(argv=None):
     p.add_argument("--cwd", default=None)
     p.add_argument("--home", default=None)
     p.add_argument("--chain-file", default=None, help="JSON com o comando de status line anterior, encadeado antes do crow")
+    p.add_argument("--host", default="claude", choices=("claude", "agy"), help="CLI que chama a status line")
     args = p.parse_args(argv)
     home = Path(args.home).expanduser() if args.home else Path.home()
     cwd = args.cwd or os.getcwd()
@@ -646,7 +788,7 @@ def main(argv=None):
                 chain = json.loads(Path(args.chain_file).read_text(encoding="utf-8")).get("command")
             except (OSError, ValueError, AttributeError):
                 chain = None
-        print(statusline(home, sys.stdin.read() if not sys.stdin.isatty() else "", chain))
+        print(statusline(home, sys.stdin.read() if not sys.stdin.isatty() else "", chain, args.host))
         return 0
     if args.mode == "tmux":
         print(tmux_segment(home, cwd))