@matt82198/aesop 0.1.0-beta.5 → 0.1.0

package/ui/sse.py

@@ -5,18 +5,24 @@ import json
 import queue
 import sys
 import threading
+import time
 
 import config
 import cost
 from collectors import (parse_audit_backlog, _snapshot_data, _snapshot_tracker,
                         _snapshot_orchestrator_status, drain_tracker_inbox)
-from agents import get_fleet_agents, _transcripts_fingerprint
+from agents import get_fleet_agents, _transcripts_fingerprint, sanitize_agents_for_broadcast
 
 
+HEARTBEAT_EVENT_NAME = 'heartbeat'
+HEARTBEAT_INTERVAL = 15  # seconds; emit every 15s to detect collector thread death
+
 _sse_lock = threading.Lock()
 
 _sse_clients = []  # list[queue.Queue]
 
+_dropped_counts = {}  # dict[queue.Queue, int] — track dropped events per client
+
 _latest_lock = threading.Lock()
 
 _latest_snapshots = {"data": None, "backlog": None, "agents": None,
@@ -49,6 +55,7 @@ def reset_state():
             _latest_snapshots[k] = None
     with _sse_lock:
         _sse_clients.clear()
+        _dropped_counts.clear()
 
 
 def register_sse_client():
@@ -65,12 +72,17 @@ def unregister_sse_client(q):
     with _sse_lock:
         if q in _sse_clients:
             _sse_clients.remove(q)
+        _dropped_counts.pop(q, None)  # Clean up dropped count for this client
 
 def broadcast_sse(event_name, payload):
     """Push (event_name, payload) onto every currently-registered client queue.
 
     If a client queue is full, drop the oldest event to make room (bounded backpressure).
     This prevents one slow client from blocking the broadcast.
+
+    Tracks dropped events: when a client's queue overflows, we increment the dropped counter
+    and attach a "dropped": N field to the event being queued, so the frontend can detect
+    that it missed updates.
     """
     with _sse_lock:
         clients = list(_sse_clients)
@@ -78,10 +90,27 @@ def broadcast_sse(event_name, payload):
         try:
             q.put_nowait((event_name, payload))
         except queue.Full:
-            # Queue is full: drop the oldest event and retry
+            # Queue is full: drop oldest, track the drop, and add dropped field to new event
+            with _sse_lock:
+                _dropped_counts[q] = _dropped_counts.get(q, 0) + 1
+                dropped = _dropped_counts[q]
+
+            # Try to parse payload and add dropped field
+            effective_payload = payload
             try:
-                q.get_nowait()  # Remove oldest
-                q.put_nowait((event_name, payload))  # Add new
+                data = json.loads(payload)
+                data["dropped"] = dropped
+                effective_payload = json.dumps(data, default=str, sort_keys=True)
+            except (json.JSONDecodeError, TypeError):
+                # If payload is not JSON, can't attach dropped count; use original
+                pass
+
+            try:
+                q.get_nowait()  # Remove oldest event
+                q.put_nowait((event_name, effective_payload))  # Add new event with dropped field
+                # Reset the dropped counter after successful queue
+                with _sse_lock:
+                    _dropped_counts[q] = 0
             except Exception as e:
                 print(f"[collector_loop] Exception: {type(e).__name__}: {e}", file=sys.stderr, flush=True)
         except Exception:
@@ -106,15 +135,59 @@ def collector_loop(stop_event):
     cached_backlog_snapshot = {"tiers": []}
     cached_agents_snapshot = []
     last_tracker_mtime = object()
+    last_tracker_size = object()
     last_status_mtime = object()
+    last_status_size = object()
     last_cost_mtime = object()
+    last_cost_size = object()
     cached_tracker_snapshot = {'items': []}
     cached_status_snapshot = {'orchestrators': []}
     cached_cost_snapshot = {}
+    # Wave-19: Gate data section sources on mtime to avoid expensive reads every tick
+    last_backup_log_mtime = object()  # sentinel
+    last_backup_log_size = object()
+    last_alerts_log_mtime = object()  # sentinel
+    last_alerts_log_size = object()
+    cached_data_snapshot = {}
+    # Wave-20: heartbeat emission to detect collector thread death
+    last_heartbeat_time = 0.0
 
     while not stop_event.is_set():
         try:
-            _maybe_emit("data", _snapshot_data(), last_hashes)
+            current_time = time.time()
+
+            # Wave-20: Emit heartbeat every 15s to signal collector thread is alive
+            if current_time - last_heartbeat_time >= HEARTBEAT_INTERVAL:
+                last_heartbeat_time = current_time
+                heartbeat_payload = json.dumps({"timestamp": int(current_time * 1000)}, default=str)
+                broadcast_sse(HEARTBEAT_EVENT_NAME, heartbeat_payload)
+
+            # Wave-19: Gate data section on mtimes+sizes to avoid expensive file reads every tick.
+            # Only regenerate the snapshot if one of the underlying log files changed.
+            try:
+                backup_log_stat = config.BACKUP_LOG.stat() if config.BACKUP_LOG.exists() else None
+                backup_log_mtime = backup_log_stat.st_mtime if backup_log_stat else None
+                backup_log_size = backup_log_stat.st_size if backup_log_stat else None
+            except OSError:
+                backup_log_mtime = None
+                backup_log_size = None
+            try:
+                alerts_log_stat = config.ALERTS_LOG.stat() if config.ALERTS_LOG.exists() else None
+                alerts_log_mtime = alerts_log_stat.st_mtime if alerts_log_stat else None
+                alerts_log_size = alerts_log_stat.st_size if alerts_log_stat else None
+            except OSError:
+                alerts_log_mtime = None
+                alerts_log_size = None
+
+            if ((backup_log_mtime, backup_log_size) != (last_backup_log_mtime, last_backup_log_size) or
+                (alerts_log_mtime, alerts_log_size) != (last_alerts_log_mtime, last_alerts_log_size)):
+                last_backup_log_mtime = backup_log_mtime
+                last_backup_log_size = backup_log_size
+                last_alerts_log_mtime = alerts_log_mtime
+                last_alerts_log_size = alerts_log_size
+                cached_data_snapshot = _snapshot_data()
+
+            _maybe_emit("data", cached_data_snapshot, last_hashes)
 
             try:
                 backlog_mtime = config.AUDIT_BACKLOG_FILE.stat().st_mtime if config.AUDIT_BACKLOG_FILE.exists() else None
@@ -128,37 +201,50 @@ def collector_loop(stop_event):
             fingerprint = _transcripts_fingerprint()
             if fingerprint != last_agents_fingerprint:
                 last_agents_fingerprint = fingerprint
-                cached_agents_snapshot = get_fleet_agents()
+                agents = get_fleet_agents()
+                # Wave-19: strip large prompt fields before broadcast
+                cached_agents_snapshot = sanitize_agents_for_broadcast(agents)
             _maybe_emit("agents", cached_agents_snapshot, last_hashes)
 
-            # Emit tracker section (mtime-gated)
+            # Emit tracker section (mtime+size-gated)
             try:
-                tracker_mtime = (config.STATE_DIR / "tracker.json").stat().st_mtime if (config.STATE_DIR / "tracker.json").exists() else None
+                tracker_stat = (config.STATE_DIR / "tracker.json").stat() if (config.STATE_DIR / "tracker.json").exists() else None
+                tracker_mtime = tracker_stat.st_mtime if tracker_stat else None
+                tracker_size = tracker_stat.st_size if tracker_stat else None
             except OSError:
                 tracker_mtime = None
-            if tracker_mtime != last_tracker_mtime:
+                tracker_size = None
+            if (tracker_mtime, tracker_size) != (last_tracker_mtime, last_tracker_size):
                 last_tracker_mtime = tracker_mtime
+                last_tracker_size = tracker_size
                 cached_tracker_snapshot = _snapshot_tracker()
             _maybe_emit("tracker", cached_tracker_snapshot, last_hashes)
 
-            # Emit status section (mtime-gated)
+            # Emit status section (mtime+size-gated)
             try:
-                status_mtime = (config.STATE_DIR / "orchestrator-status.json").stat().st_mtime if (config.STATE_DIR / "orchestrator-status.json").exists() else None
+                status_stat = (config.STATE_DIR / "orchestrator-status.json").stat() if (config.STATE_DIR / "orchestrator-status.json").exists() else None
+                status_mtime = status_stat.st_mtime if status_stat else None
+                status_size = status_stat.st_size if status_stat else None
             except OSError:
                 status_mtime = None
-            if status_mtime != last_status_mtime:
+                status_size = None
+            if (status_mtime, status_size) != (last_status_mtime, last_status_size):
                 last_status_mtime = status_mtime
+                last_status_size = status_size
                 cached_status_snapshot = _snapshot_orchestrator_status()
             _maybe_emit("status", cached_status_snapshot, last_hashes)
 
-            # Emit cost section (wave-14 6th section; mtime-gated on the
-            # outcomes ledger, mirroring the tracker gate above)
+            # Emit cost section (mtime+size-gated on the outcomes ledger)
             try:
-                cost_mtime = config.LEDGER_FILE.stat().st_mtime if config.LEDGER_FILE.exists() else None
+                cost_stat = config.LEDGER_FILE.stat() if config.LEDGER_FILE.exists() else None
+                cost_mtime = cost_stat.st_mtime if cost_stat else None
+                cost_size = cost_stat.st_size if cost_stat else None
             except OSError:
                 cost_mtime = None
-            if cost_mtime != last_cost_mtime:
+                cost_size = None
+            if (cost_mtime, cost_size) != (last_cost_mtime, last_cost_size):
                 last_cost_mtime = cost_mtime
+                last_cost_size = cost_size
                 cached_cost_snapshot = cost.get_cost_summary()
             _maybe_emit("cost", cached_cost_snapshot, last_hashes)
 

package/ui/wave_prs.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Wave PR board collector — read-only snapshot of open PRs + feat/* branches.
+
+Gathers the current wave's pull-request / branch status so the dashboard can
+show CI, mergeability, age, and the top blocker at a glance without a trip to
+GitHub. Read-only: only `gh pr list` and `git for-each-ref` are ever run, both
+with a short timeout and cwd pinned to the repo root.
+
+Robustness (wave-27 lesson): every subprocess text read passes
+encoding='utf-8', errors='replace'. Missing `gh`, an un-authenticated `gh`, a
+non-git cwd, or simply zero PRs all degrade to a well-formed empty payload
+(available flag + human error), never an exception that 500s the endpoint.
+
+A tiny module-level cache (default 5s) keeps repeated polls snappy — `gh pr
+list` hits the network, so we do not want to run it on every dashboard tick.
+"""
+import json
+import os
+import subprocess
+import time
+
+import config
+
+# gh fields we request. statusCheckRollup carries per-check conclusions; we
+# roll them up into one of passing/failing/pending/none client-agnostic states.
+_GH_FIELDS = (
+    "number,title,headRefName,mergeable,isDraft,url,createdAt,"
+    "reviewDecision,statusCheckRollup"
+)
+
+_CACHE_TTL_SECONDS = 5.0
+_SUBPROCESS_TIMEOUT_SECONDS = 12
+
+# Module-level cache: (expires_at_epoch, payload_dict). Guarded by the GIL for
+# the simple read-modify-write here; the collector is I/O bound, not a hot loop.
+_cache = {"expires": 0.0, "payload": None}
+
+
+def _gh_bin():
+    """Path to the GitHub CLI binary.
+
+    Defaults to `gh` (resolved on PATH). Override with AESOP_GH_BIN to point at
+    a specific install or a wrapper — read at call time so it stays live.
+    """
+    return os.environ.get("AESOP_GH_BIN", "gh")
+
+
+def _run(cmd):
+    """Run a subprocess, return (ok, stdout, stderr).
+
+    ok is False on a missing binary, a non-zero exit, or a timeout. Text is
+    decoded utf-8 with errors='replace' so undecodable bytes never raise.
+    """
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(config.AESOP_ROOT),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=_SUBPROCESS_TIMEOUT_SECONDS,
+        )
+    except FileNotFoundError:
+        return False, "", f"{cmd[0]}: command not found"
+    except subprocess.TimeoutExpired:
+        return False, "", f"{cmd[0]}: timed out"
+    except OSError as e:
+        return False, "", f"{cmd[0]}: {e}"
+    return proc.returncode == 0, proc.stdout or "", proc.stderr or ""
+
+
+def _rollup_ci(status_check_rollup):
+    """Reduce gh's statusCheckRollup list to one state.
+
+    Returns one of: 'passing', 'failing', 'pending', 'none'. Color-independent
+    label; the frontend pairs it with an icon + text so status never rides on
+    color alone.
+    """
+    if not status_check_rollup:
+        return "none"
+    saw_pending = False
+    for check in status_check_rollup:
+        # CheckRun uses `status`/`conclusion`; StatusContext uses `state`.
+        state = (check.get("state") or "").upper()
+        status = (check.get("status") or "").upper()
+        conclusion = (check.get("conclusion") or "").upper()
+
+        if state in ("FAILURE", "ERROR") or conclusion in (
+            "FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "STARTUP_FAILURE",
+        ):
+            return "failing"
+        if state == "PENDING" or status in ("QUEUED", "IN_PROGRESS", "PENDING", "WAITING"):
+            saw_pending = True
+    return "pending" if saw_pending else "passing"
+
+
+def _blocker(ci, mergeable, is_draft, review_decision):
+    """Top single blocker for a PR, or None when it looks ready to merge."""
+    if is_draft:
+        return "Draft — not ready for review"
+    if ci == "failing":
+        return "CI failing"
+    if (mergeable or "").upper() == "CONFLICTING":
+        return "Merge conflict"
+    if ci == "pending":
+        return "CI pending"
+    if (review_decision or "").upper() == "CHANGES_REQUESTED":
+        return "Changes requested"
+    if (review_decision or "").upper() == "REVIEW_REQUIRED":
+        return "Review required"
+    return None
+
+
+def _collect_prs():
+    """Return (available, error, prs). Never raises."""
+    ok, out, err = _run([
+        _gh_bin(), "pr", "list", "--state", "open", "--limit", "50", "--json", _GH_FIELDS,
+    ])
+    if not ok:
+        low = (err or "").lower()
+        if "command not found" in low:
+            return False, "GitHub CLI (gh) is not installed.", []
+        if "auth" in low or "not logged" in low or "gh auth login" in low:
+            return False, "GitHub CLI is not authenticated (run: gh auth login).", []
+        if "not a git" in low or "no git repository" in low:
+            return False, "Not a GitHub repository.", []
+        # Any other failure: surface a trimmed reason, degrade to empty.
+        reason = (err or "gh pr list failed").strip().splitlines()
+        return False, reason[0] if reason else "gh pr list failed", []
+
+    try:
+        raw = json.loads(out) if out.strip() else []
+    except (ValueError, TypeError):
+        return False, "Could not parse gh output.", []
+
+    prs = []
+    for item in raw:
+        ci = _rollup_ci(item.get("statusCheckRollup"))
+        mergeable = item.get("mergeable") or "UNKNOWN"
+        is_draft = bool(item.get("isDraft"))
+        review = item.get("reviewDecision") or ""
+        prs.append({
+            "number": item.get("number"),
+            "title": item.get("title") or "(untitled)",
+            "branch": item.get("headRefName") or "",
+            "url": item.get("url") or "",
+            "ci": ci,
+            "mergeable": mergeable,
+            "is_draft": is_draft,
+            "review_decision": review,
+            "created_at": item.get("createdAt") or "",
+            "blocker": _blocker(ci, mergeable, is_draft, review),
+            "has_pr": True,
+        })
+    return True, None, prs
+
+
+def _collect_branch_only(pr_branches):
+    """feat/* branches (local + remote) that have no open PR yet.
+
+    Best-effort: a git failure just yields nothing extra (PRs still render).
+    """
+    ok, out, _err = _run([
+        "git", "for-each-ref", "--format=%(refname:short)",
+        "refs/heads/feat/", "refs/remotes/origin/feat/",
+    ])
+    if not ok:
+        return []
+    seen = set()
+    rows = []
+    for line in out.splitlines():
+        name = line.strip()
+        if not name:
+            continue
+        # Normalize origin/feat/x -> feat/x so local+remote of one branch dedupe.
+        branch = name[len("origin/"):] if name.startswith("origin/") else name
+        if branch in seen or branch in pr_branches:
+            continue
+        seen.add(branch)
+        rows.append({
+            "number": None,
+            "title": branch,
+            "branch": branch,
+            "url": "",
+            "ci": "none",
+            "mergeable": "UNKNOWN",
+            "is_draft": False,
+            "review_decision": "",
+            "created_at": "",
+            "blocker": "No PR opened yet",
+            "has_pr": False,
+        })
+    return rows
+
+
+def get_wave_prs(force=False):
+    """Snapshot of open PRs + PR-less feat/* branches for the PR board.
+
+    Shape:
+        {
+          "available": bool,      # False when gh is missing/unauthed
+          "error": str | None,    # human reason when available is False
+          "generated_at": str,    # ISO 8601 UTC
+          "prs": [ {number, title, branch, url, ci, mergeable, is_draft,
+                    review_decision, created_at, blocker, has_pr}, ... ]
+        }
+
+    Cached for _CACHE_TTL_SECONDS so rapid polls don't re-run gh. Never raises.
+    """
+    now = time.time()
+    if not force and _cache["payload"] is not None and now < _cache["expires"]:
+        return _cache["payload"]
+
+    available, error, prs = _collect_prs()
+    if available:
+        pr_branches = {p["branch"] for p in prs if p.get("branch")}
+        prs = prs + _collect_branch_only(pr_branches)
+        # Sort: PRs first (by number desc), then branch-only rows by name.
+        prs.sort(key=lambda p: (p["number"] is None, -(p["number"] or 0), p["branch"]))
+
+    payload = {
+        "available": available,
+        "error": error,
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now)),
+        "prs": prs,
+    }
+    _cache["payload"] = payload
+    _cache["expires"] = now + _CACHE_TTL_SECONDS
+    return payload