@andespindola/crow-skills 0.8.0 → 0.10.0

package/crow_skills/cli.py

@@ -7,11 +7,13 @@ import sys
 
 from . import __version__
 from . import autoupdate
+from . import broadcast
 from . import events
 from . import guide
 from . import hook
 from . import integrations
 from . import progress
+from . import resources
 from .agents import AGENTS, destinations, inventory
 from .source import CrowError, Source, valid_name
 from .storage import Store, checked
@@ -77,6 +79,23 @@ def parser():
     child.add_argument("action", nargs="?", default="snapshot", choices=("snapshot", "tail"))
     child.add_argument("--limit", type=int, default=50, help="tail: quantos eventos (padrão 50; 0 = todos os retidos)")
     child.add_argument("--follow", action="store_true", help="tail: transmitir eventos novos em JSONL até Ctrl-C")
+    child = sub.add_parser("broadcast", parents=[common],
+                           help="crow-broadcast: sessões vivas dos CLIs, arquivos em edição, conflitos e reservas")
+    child.add_argument("action", nargs="?", default="status", choices=("status", "list", "claim", "release", "watch"))
+    child.add_argument("targets", nargs="*", help="claim: caminhos, globs ou área; release: ids das reservas")
+    child.add_argument("--ttl", default="30m", help="claim: validade (ex.: 30m, 2h; máximo 24h)")
+    child.add_argument("--note", help="claim: nota curta (o que será feito)")
+    child.add_argument("--session", help="claim/release/status: id da sessão dona; padrão: detectada pelo processo pai")
+    child.add_argument("--host", help="claim/release/status: CLI da sessão (claude, codex, gemini, agy, devin)")
+    child.add_argument("--cwd", help="Diretório de referência; padrão: o atual")
+    child.add_argument("--force", action="store_true",
+                       help="claim: registrar mesmo com reserva conflitante; release: liberar reserva de outra sessão (decisão do usuário)")
+    child.add_argument("--all", action="store_true", help="release: todas as reservas desta sessão")
+    child.add_argument("--interval", type=float, default=2.0, help=argparse.SUPPRESS)
+    child.add_argument("--max-frames", type=int, default=None, help=argparse.SUPPRESS)
+    child = sub.add_parser("resources", parents=[common],
+                           help="Memória, pressão, agentes em execução e paralelismo recomendado (somente leitura)")
+    child.add_argument("--no-processes", action="store_true", help="Não varrer os processos dos CLIs de agente (mais rápido)")
     child = sub.add_parser("autoupdate", parents=[common], help="Atualização diária e no login do crow-skills e das skills gerenciadas")
     child.add_argument("action", choices=("on", "off", "status", "run"))
     child.add_argument("--git-pull", action="store_true", help="on: também atualizar um checkout git limpo em main/master (git pull --ff-only)")
@@ -357,6 +376,146 @@ def events_command(args, home, store):
     return data
 
 
+def ancestors(limit=16):
+    """Process ids above this CLI (best effort): the agent CLI that runs it is one of them."""
+    pids, pid = [], os.getpid()
+    for _ in range(limit):
+        parent = None
+        try:
+            with open("/proc/" + str(pid) + "/stat", "rb") as handle:
+                parent = int(handle.read().rsplit(b")", 1)[1].split()[1])
+        except (OSError, ValueError, IndexError):
+            try:
+                import subprocess
+                done = subprocess.run(["ps", "-o", "ppid=", "-p", str(pid)], capture_output=True, text=True, timeout=2)
+                parent = int(done.stdout.strip() or 0)
+            except (OSError, ValueError, subprocess.SubprocessError):
+                parent = None
+        if not parent or parent <= 1 or parent in pids:
+            break
+        pids.append(parent)
+        pid = parent
+    return pids
+
+
+def broadcast_owner(args, home, cwd):
+    """The session that runs this command: --session/--host, else the live session whose CLI pid is an ancestor."""
+    live = broadcast.live_sessions(home)
+    host = getattr(args, "host", None)
+    if host and host not in hook.HOSTS:
+        raise CrowError("usage", "--host deve ser um de: " + ", ".join(hook.HOSTS))
+    if getattr(args, "session", None):
+        session = hook.token(args.session, 128)
+        matches = [s for s in live if s.get("session") == session and (not host or s.get("host") == host)]
+        if matches:
+            s = matches[0]
+            return {"key": s["key"], "host": s.get("host"), "session": s.get("session"), "detected": "session"}
+        if not host:
+            raise CrowError("not_found", "Sessão " + str(session) + " não está viva no broadcast; informe também --host.")
+        return {"key": broadcast.session_key(host, session, None), "host": host, "session": session, "detected": "session"}
+    chain = ancestors()
+    for s in live:
+        pid = broadcast.presence_of(s).get("pid")
+        if pid and pid in chain and (not host or s.get("host") == host):
+            return {"key": s["key"], "host": s.get("host"), "session": s.get("session"), "detected": "pid"}
+    return None
+
+
+def broadcast_text(view, full=False):
+    me = view.get("me") or {}
+    repo = me.get("repo") or {}
+    lines = ["crow-broadcast · " + str(len(view["sessions"])) + " outra(s) sessão(ões) viva(s) · " + str(len(view["claims"])) +
+             " reserva(s)"]
+    if me:
+        lines.append("aqui: " + (repo.get("remote") or repo.get("root") or me.get("cwd") or "?") +
+                     (" · branch " + str(me.get("branch")) if me.get("branch") else "") +
+                     (" · sessão " + str(view.get("owner", {}).get("host")) if view.get("owner") else ""))
+    shown = view["sessions"] if full else broadcast.relevant(view)
+    now = broadcast.parse_time(view["generatedAt"]) or 0
+    for s in shown:
+        lines += broadcast.session_lines(s, view["_home"], now)
+    if not full and len(shown) < len(view["sessions"]):
+        lines.append("(+" + str(len(view["sessions"]) - len(shown)) + " em outros repositórios; crow-skills broadcast list)")
+    live = {s.get("key"): s for s in view["_live"]}
+    for claim in view["claims"]:
+        lines.append(broadcast.claim_line(claim, live, now))
+    if not shown and not view["claims"]:
+        lines.append("Nenhuma outra sessão viva neste repositório." if not full else "Nenhuma outra sessão viva.")
+    return "\n".join(lines)
+
+
+def broadcast_view(args, home, owner=None):
+    cwd = os.path.abspath(getattr(args, "cwd", None) or os.getcwd())
+    owner = owner if owner is not None else broadcast_owner(args, home, cwd)
+    me_key = owner["key"] if owner else None
+    view = broadcast.overview(home, me_key, cwd=cwd)
+    if view["me"] is not None and view["me"].get("cwd") is None:
+        view["me"]["cwd"] = cwd
+    view["owner"] = owner
+    return view
+
+
+def public(view):
+    return {k: v for k, v in view.items() if not k.startswith("_")}
+
+
+def broadcast_command(args, home):
+    action = args.action
+    cwd = os.path.abspath(getattr(args, "cwd", None) or os.getcwd())
+    if action in ("status", "list"):
+        view = broadcast_view(args, home)
+        view["_home"] = home
+        text = broadcast_text(view, full=action == "list")
+        data = public(view)
+        if action == "status":
+            data["relevant"] = [s["key"] for s in broadcast.relevant(view)]
+        data["text"] = text
+        return data
+    if action == "watch":
+        if getattr(args, "json", False):
+            raise CrowError("usage", "watch redesenha em texto; para JSON use status --json em polling.")
+        frames = 0
+        try:
+            while True:
+                view = broadcast_view(args, home)
+                view["_home"] = home
+                sys.stdout.write("\x1b[H\x1b[2J" + broadcast_text(view) + "\n")
+                sys.stdout.flush()
+                frames += 1
+                if args.max_frames is not None and frames >= args.max_frames:
+                    return None
+                import time as _time
+                _time.sleep(max(0.2, args.interval))
+        except KeyboardInterrupt:
+            return None
+    owner = broadcast_owner(args, home, cwd)
+    if action == "claim":
+        if not args.targets:
+            raise CrowError("usage", "Informe o que reservar: caminhos, globs ou área (ex.: crow-skills broadcast claim src/api --ttl 30m).")
+        try:
+            ttl = broadcast.parse_ttl(args.ttl)
+        except ValueError:
+            raise CrowError("usage", "--ttl inválido: use 30m, 2h, 90s (máximo 24h).") from None
+        try:
+            claim, conflicts = broadcast.add_claim(home, args.targets, ttl, owner=owner, cwd=cwd, note=args.note, force=args.force)
+        except ValueError:
+            raise CrowError("usage", "Nenhum alvo válido para reservar.") from None
+        if claim is None:
+            holders = "; ".join(broadcast.claim_line(c, {}, broadcast.time.time()).lstrip("- ") for c in conflicts[:3])
+            raise CrowError("claim_conflict", "Área já reservada por outra sessão viva: " + holders +
+                            ". Coordene com ela ou use --force se o usuário decidir seguir.")
+        return {"claim": claim, "owner": owner, "conflicts": conflicts,
+                "note": None if owner else "Sessão dona não detectada; a reserva expira só pelo TTL. Use --session/--host."}
+    if not owner and (args.all or not args.targets):
+        raise CrowError("usage", "Sessão dona não detectada: informe --session/--host (ou os ids das reservas).")
+    removed, refused = broadcast.release_claims(home, ids=set(args.targets), owner_key=owner["key"] if owner else None,
+                                                everything=args.all or not args.targets, force=args.force)
+    if refused and not removed:
+        raise CrowError("claim_owner", "Reserva(s) de outra sessão: " + ", ".join(refused) +
+                        ". Só a sessão dona libera; --force só por decisão do usuário.")
+    return {"released": [c["id"] for c in removed], "refused": refused, "owner": owner}
+
+
 def autoupdate_command(args, home, store, interactive):
     if args.action == "status":
         return autoupdate.status(store, home)
@@ -460,6 +619,12 @@ def run(args):
         return mode_command(args, home)
     if args.command == "events":
         return events_command(args, home, store)
+    if args.command == "broadcast":
+        return broadcast_command(args, home)
+    if args.command == "resources":
+        data = resources.probe(home, processes=not args.no_processes)
+        data["text"] = resources.render(data)
+        return data
     if args.command == "autoupdate":
         return autoupdate_command(args, home, store, interactive)
     if args.command in ("status", "doctor"):
@@ -586,6 +751,17 @@ def emit(command, data, machine):
     elif command == "progress":
         if data is not None:
             print(data["text"] or "crow: nenhuma execução registrada neste diretório.")
+    elif command == "resources":
+        print(data["text"])
+    elif command == "broadcast":
+        if data is not None:
+            if "text" in data:
+                print(data["text"])
+            elif "claim" in data:
+                print("reserva " + data["claim"]["id"] + ": " + ", ".join(data["claim"]["patterns"]) + " até " +
+                      data["claim"]["expiresAt"] + ("" if data["owner"] else " (" + data["note"] + ")"))
+            else:
+                print("liberadas: " + (", ".join(data["released"]) or "nenhuma"))
     elif command == "mode":
         print(data["indicator"] + " — " + data["applies"])
     elif command == "events":

package/crow_skills/events.py

@@ -11,7 +11,7 @@ import json
 import sys
 import time
 
-from . import autoupdate, hook, progress
+from . import autoupdate, broadcast, hook, progress, resources
 from .source import CrowError
 
 SNAPSHOT_SCHEMA = "crow-snapshot/1"
@@ -29,7 +29,7 @@ def ledger_runs(home, cwds):
             runs.append({"id": run["id"], "title": run["title"], "host": run["host"], "cwd": run["cwd"], "status": run["status"],
                          "session": run["session"].get("id"), "path": run["path"], "updatedAt": run.get("updatedAt"),
                          "done": info["done"], "failed": info["failed"], "total": info["total"], "running": info["running"],
-                         "progress": info["progress"],
+                         "progress": info["progress"], "resources": run.get("resources"),
                          "agents": [{"owner": progress.owner_label(u["owner"]), "unit": u["id"], "activity": u["title"]}
                                     for u in run["units"] if u["status"] == "running"]})
     return runs
@@ -54,9 +54,58 @@ def snapshot(home, store):
     except CrowError as exc:
         update = {"enabled": None, "error": exc.code}
     mode = hook.read_mode(home)
+    try:
+        machine = resources_field(home)
+    except Exception:  # noqa: BLE001 - the snapshot never fails because of the probe
+        machine = None
+    try:
+        presence = broadcast_field(home)
+    except Exception:  # noqa: BLE001 - the snapshot never fails because of the broadcast
+        presence = None
     return {"schema": SNAPSHOT_SCHEMA, "generatedAt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
             "mode": {k: mode[k] for k in ("mode", "updatedAt", "updatedBy", "source")}, "indicator": hook.indicator(mode["mode"]),
-            "sessions": live, "runs": runs, "autoupdate": update}
+            "sessions": live, "runs": runs, "autoupdate": update, "resources": machine, "broadcast": presence}
+
+
+def broadcast_field(home):
+    """crow-broadcast/1 for terminals: live sessions grouped by repository, recent files, claims, conflicts.
+
+    Added in 0.10.0 without changing crow-snapshot/1 (consumers ignore unknown fields); the
+    field carries its own schema. ``conflicts`` lists files touched by two or more live
+    sessions within the conflict window and clones used by two or more live sessions.
+    """
+    view = broadcast.overview(home)
+    window = view["config"]["conflict_window_minutes"] * 60
+    now = broadcast.parse_time(view["generatedAt"]) or 0
+    repos, files, clones = {}, {}, {}
+    for s in view["sessions"]:
+        repo = s.get("repo") or {}
+        if repo.get("id"):
+            repos.setdefault(repo["id"], {"id": repo["id"], "remote": repo.get("remote"), "sessions": []})["sessions"].append(s["key"])
+            clones.setdefault(repo.get("root"), []).append(s["key"])
+        for f in s["files"]:
+            if now - (broadcast.parse_time(f.get("ts")) or 0) <= window:
+                label = (f.get("repo") + ":" + f["rel"]) if f.get("repo") and f.get("rel") else f["path"]
+                keys = files.setdefault(label, [])
+                if s["key"] not in keys:
+                    keys.append(s["key"])
+    conflicts = [{"kind": "file", "file": k, "sessions": v} for k, v in files.items() if len(v) > 1] + \
+                [{"kind": "clone", "root": k, "sessions": v} for k, v in clones.items() if k and len(v) > 1]
+    return {"schema": view["schema"], "generatedAt": view["generatedAt"], "config": view["config"],
+            "sessions": [{k: v for k, v in s.items() if k != "relation"} for s in view["sessions"]],
+            "repos": list(repos.values()), "claims": view["claims"], "conflicts": conflicts}
+
+
+def resources_field(home):
+    """crow-resources/1 subset for terminals: memory, pressure and the recommendation.
+
+    Added in 0.9.0 without changing crow-snapshot/1: consumers that do not know the
+    field ignore it; the field carries its own schema for future changes.
+    """
+    data = resources.probe(home, processes=False, use_cache=True)
+    return {"schema": data["schema"], "generatedAt": data["generatedAt"], "cached": data["cached"],
+            "memory": data["memory"], "pressure": {"level": data["pressure"]["level"], "reasons": data["pressure"]["reasons"]},
+            "recommendation": data["recommendation"], "alert": resources.alert(data), "segment": resources.segment(data)}
 
 
 def render(data, unicode=True):
@@ -75,6 +124,18 @@ def render(data, unicode=True):
                                      unicode, counts=False)
         lines.append(("✓ " if unicode else "ok ") + str(run["done"]) + "/" + str(run["total"]) + "  " + run["title"])
     update = data["autoupdate"]
+    machine = data.get("resources")
+    if machine and machine.get("alert"):
+        rec = machine["recommendation"]
+        lines.append("")
+        lines.append("memória: " + (machine["segment"] or "") + " · pressão " + machine["pressure"]["level"] + " · " + rec["mode"] +
+                     " (até " + str(rec["maxParallelAgents"]) + " agente(s), " + str(rec["maxParallelHeavyJobs"]) + " job(s) pesado(s))")
+    shared = data.get("broadcast")
+    if shared and (shared.get("conflicts") or shared.get("claims")):
+        lines.append("")
+        lines.append("broadcast: " + str(len([c for c in shared["conflicts"] if c["kind"] == "file"])) + " arquivo(s) em mais de uma sessão · " +
+                     str(len([c for c in shared["conflicts"] if c["kind"] == "clone"])) + " clone(s) compartilhado(s) · " +
+                     str(len(shared["claims"])) + " reserva(s) (crow-skills broadcast list)")
     lines.append("")
     lines.append("autoupdate: " + ("ligado" if update.get("enabled") else "desligado") +
                  ((" · última execução " + str(update["lastRun"]["startedAt"]) + (" ok" if update["lastRun"]["ok"] else " com falha"))