@matt82198/aesop 0.1.0 → 0.2.0

package/ui/wave_dispatch.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""
+Wave dispatch collector — live per-agent phase and activity visibility.
+
+Surfaces what a wave's workers are doing RIGHT NOW: per-agent phase (dispatch/thinking/tool-use/stall/done),
+last-activity age, and token burn estimates.
+
+Data sources:
+  - Agent transcripts: recursively scanned from {transcripts_root}/**/agent-*.jsonl (mtime + file size).
+    Real layout: ~/.claude/projects/*/subagents/agent-*.jsonl or {session}/subagents/agent-*.jsonl.
+    Filters to recent files only (<30 min) to avoid hundreds of stale entries.
+  - Orchestrator status: state/orchestrator-status.json (phase info)
+  - Workflow journal: state/workflow.journal.jsonl (per-agent state transitions, optional)
+
+Degrades to {available:false} when no active workflow.
+
+Performance: includes ~5s in-process cache to avoid re-reading transcripts on rapid polls.
+"""
+import json
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import config
+
+
+# Conservative token estimate: 4.5 bytes per token (empirical average)
+BYTES_PER_TOKEN = 4.5
+
+# Module-level cache: (expires_at_epoch, payload_dict). Avoids re-scanning transcripts
+# on rapid polls (typical dashboard: 2-3s interval). TTL matches wave_prs.py pattern.
+# Cache is invalidated if config paths change (important for test isolation).
+_CACHE_TTL_SECONDS = 5.0
+_cache = {"expires": 0.0, "payload": None, "transcripts_root": None}
+
+
+def _infer_agent_phase_from_transcript(transcript_path):
+    """Infer agent phase from transcript tail.
+
+    Reads the last ~10 lines of an NDJSON transcript to infer phase state.
+    Returns one of: 'dispatch', 'thinking', 'tool-use', 'stall', 'done'.
+
+    Args:
+        transcript_path: Path to agent-*.jsonl file
+
+    Returns:
+        str: phase label, or 'unknown' if inference fails
+    """
+    try:
+        if not transcript_path.exists():
+            return "unknown"
+
+        # Read last ~10 lines to infer phase
+        with open(transcript_path, 'rb') as f:
+            # Seek to end and read backwards to get tail
+            f.seek(0, 2)
+            file_size = f.tell()
+            if file_size == 0:
+                return "dispatch"  # Empty file, likely just dispatched
+
+            # Read last ~2KB to capture ~10 lines
+            read_size = min(2048, file_size)
+            f.seek(max(0, file_size - read_size))
+            tail = f.read().decode('utf-8', errors='replace')
+
+        # Count message types to infer phase
+        lines = tail.strip().split('\n')
+        message_types = []
+        for line in lines:
+            if not line.strip():
+                continue
+            try:
+                entry = json.loads(line)
+                if isinstance(entry, dict) and 'type' in entry:
+                    message_types.append(entry['type'].lower())
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        # Phase inference logic:
+        # - If last message is user: dispatch
+        # - If last message is assistant: thinking or tool-use
+        # - If we see [tool_use: ...]: tool-use
+        # - If we see [error] or timestamp recent: stall
+        # - If multiple completions: done
+        if not message_types:
+            return "unknown"
+
+        last_type = message_types[-1] if message_types else "unknown"
+
+        # Simple heuristic: check for tool_use markers in tail
+        tail_lower = tail.lower()
+        if '[tool_use:' in tail_lower or 'tool_use' in last_type:
+            return "tool-use"
+        elif '[error]' in tail_lower or 'error' in tail_lower:
+            return "stall"
+        elif last_type == 'assistant':
+            # Check if we have many completions (indicates done)
+            completion_count = tail.count('"type": "assistant"') + tail.count('"type":"assistant"')
+            if completion_count >= 3:
+                return "done"
+            return "thinking"
+        elif last_type == 'user':
+            return "dispatch"
+        else:
+            return "thinking"
+    except Exception as e:
+        print(f"[wave_dispatch] Error inferring phase from {transcript_path}: {e}", file=sys.stderr)
+        return "unknown"
+
+
+def _estimate_tokens_from_file_size(file_path):
+    """Estimate tokens from file size.
+
+    Uses conservative ratio: size (bytes) / 4.5 bytes-per-token.
+
+    Args:
+        file_path: Path to transcript file
+
+    Returns:
+        int: estimated token count, or 0 if file missing
+    """
+    try:
+        if not file_path.exists():
+            return 0
+        size = file_path.stat().st_size
+        return max(0, int(size / BYTES_PER_TOKEN))
+    except Exception:
+        return 0
+
+
+def _get_last_activity_age_sec(file_path):
+    """Get age of last file modification in seconds.
+
+    Args:
+        file_path: Path to transcript file
+
+    Returns:
+        int: seconds since last mtime, or -1 if file missing
+    """
+    try:
+        if not file_path.exists():
+            return -1
+        mtime = file_path.stat().st_mtime
+        now = time.time()
+        age_sec = int(now - mtime)
+        return max(0, age_sec)
+    except Exception:
+        return -1
+
+
+def get_wave_dispatch(force=False):
+    """Get consolidated wave dispatch snapshot.
+
+    Reads agent transcripts and orchestrator status at call time (not import time)
+    to ensure test isolation. Returns per-agent phase, activity age, and token burn.
+
+    Caches result for ~5s to avoid re-reading transcripts on rapid dashboard polls.
+    Pass force=True to bypass cache (mainly for testing).
+
+    Returns:
+        dict: {
+            "available": bool,
+            "wave_phase": str or None,
+            "agents": [
+                {
+                    "id": str,
+                    "phase": str,
+                    "last_activity_age_sec": int,
+                    "token_estimate": int,
+                    "warnings": [str] (optional)
+                }
+            ],
+            "at": str (ISO 8601)
+        }
+    """
+    # Cache check: if valid cached payload exists and config hasn't changed, return it
+    # (Invalidate cache if transcripts_root changed, important for test isolation)
+    now_epoch = time.time()
+    current_transcripts_root = str(config.TRANSCRIPTS_ROOT)
+    cached_transcripts_root = _cache.get("transcripts_root")
+
+    if (not force and
+        _cache["payload"] is not None and
+        now_epoch < _cache["expires"] and
+        current_transcripts_root == cached_transcripts_root):
+        return _cache["payload"]
+
+    try:
+        now = datetime.now(timezone.utc)
+        timestamp = now.isoformat(timespec='seconds').replace('+00:00', 'Z')
+
+        # Try to read orchestrator status to get wave phase
+        wave_phase = None
+        try:
+            orch_status_file = config.ORCH_STATUS_FILE
+            if orch_status_file.exists():
+                content = orch_status_file.read_text(encoding='utf-8')
+                orch_data = json.loads(content)
+                wave_phase = orch_data.get("phase")
+        except Exception as e:
+            print(f"[wave_dispatch] Error reading orchestrator status: {e}", file=sys.stderr)
+
+        # Find active agent transcripts
+        agents = []
+        transcripts_root = config.TRANSCRIPTS_ROOT
+
+        try:
+            # Scan recursively for agent-*.jsonl files matching real Claude Code layout:
+            # ~/.claude/projects/*/subagents/agent-*.jsonl or {session}/subagents/agent-*.jsonl
+            # Uses same pattern as agents.py to ensure consistency (ui/agents.py:482)
+            if transcripts_root.exists():
+                for transcript_file in transcripts_root.glob("**/agent-*.jsonl"):
+                    # Filter to recent files only (<30 min) to avoid hundreds of stale entries
+                    age_sec = _get_last_activity_age_sec(transcript_file)
+                    if age_sec < 0:  # File missing or error reading
+                        continue
+                    if age_sec > 1800:  # 30 minutes; skip stale transcripts
+                        continue
+
+                    agent_id = transcript_file.stem  # e.g., "agent-12345"
+                    if agent_id.startswith("agent-"):
+                        # Remove "agent-" prefix for display
+                        display_id = agent_id[6:]  # "12345"
+
+                        phase = _infer_agent_phase_from_transcript(transcript_file)
+                        tokens = _estimate_tokens_from_file_size(transcript_file)
+
+                        # Build warnings
+                        warnings = []
+                        if age_sec > 300:  # 5 minutes
+                            warnings.append("inactive >5min")
+                        if age_sec > 600:  # 10 minutes
+                            warnings.append("stalled >10min")
+
+                        agent_entry = {
+                            "id": display_id,
+                            "phase": phase,
+                            "last_activity_age_sec": age_sec,
+                            "token_estimate": tokens,
+                        }
+                        if warnings:
+                            agent_entry["warnings"] = warnings
+
+                        agents.append(agent_entry)
+        except Exception as e:
+            print(f"[wave_dispatch] Error scanning transcripts: {e}", file=sys.stderr)
+
+        # Determine availability: if no agents found, mark as unavailable
+        available = len(agents) > 0
+
+        payload = {
+            "available": available,
+            "wave_phase": wave_phase,
+            "agents": agents,
+            "at": timestamp
+        }
+
+        # Cache this payload for ~5s to avoid re-reading transcripts on rapid polls
+        _cache["payload"] = payload
+        _cache["expires"] = now_epoch + _CACHE_TTL_SECONDS
+        _cache["transcripts_root"] = str(config.TRANSCRIPTS_ROOT)
+
+        return payload
+    except Exception as e:
+        print(f"[wave_dispatch] Uncaught error: {e}", file=sys.stderr)
+        payload = {
+            "available": False,
+            "wave_phase": None,
+            "agents": [],
+            "error": "Internal error",
+            "at": datetime.now(timezone.utc).isoformat(timespec='seconds').replace('+00:00', 'Z')
+        }
+
+        # Cache error response too (so we don't retry immediately)
+        _cache["payload"] = payload
+        _cache["expires"] = now_epoch + _CACHE_TTL_SECONDS
+        _cache["transcripts_root"] = str(config.TRANSCRIPTS_ROOT)
+
+        return payload

package/ui/wave_failure.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""Wave PR failure drill-down collector — CI job logs and failure details.
+
+Provides structured access to GitHub CI job logs and failure details for a given
+PR number. When the Wave PR Board shows a red PR row, the UI can drill down via
+this endpoint to see which checks failed, their logs, and stderr excerpts.
+
+Backend:
+  - Shells `gh run view --json jobs` to list jobs for the latest run on a PR branch
+  - For failing jobs, shells `gh api repos/{owner}/{repo}/actions/jobs/{id}/logs`
+    to fetch the full log, extracts ~100-line tail excerpt
+  - 5-second cache per PR to avoid hammering GitHub API
+  - Degrades to {available:false, error:...} when gh is missing/unauthed (never 500)
+  - Honors AESOP_GH_BIN override; all text uses encoding='utf-8', errors='replace'
+
+Response shape when available:
+  {
+    "available": true,
+    "error": null,
+    "pr_number": <int>,
+    "branch": "<str>",
+    "latest_run": {
+      "id": "<str>",
+      "name": "<str>",
+      "status": "completed" | "in_progress" | "queued",
+      "conclusion": "success" | "failure" | "cancelled" | "timed_out" | null,
+      "url": "<str>"
+    },
+    "jobs": [
+      {
+        "id": <int>,
+        "name": "<str>",
+        "status": "completed" | "in_progress" | "queued",
+        "conclusion": "success" | "failure" | "cancelled" | "timed_out" | null,
+        "url": "<str>",
+        "log_excerpt": "<str>" | null  # ~100 lines, tail-truncated; null if fetch fails
+      },
+      ...
+    ]
+  }
+
+When gh is missing/unauthed:
+  {
+    "available": false,
+    "error": "<human reason>",
+    "pr_number": <int>,
+    "branch": "",
+    "latest_run": null,
+    "jobs": []
+  }
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import config
+
+_CACHE_TTL_SECONDS = 5.0
+_SUBPROCESS_TIMEOUT_SECONDS = 12
+_LOG_EXCERPT_LINES = 100
+
+# Module-level cache: {pr_number: (expires_at_epoch, payload_dict)}
+_cache: Dict[int, Tuple[float, Dict[str, Any]]] = {}
+
+
+def _gh_bin() -> str:
+    """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: List[str]) -> Tuple[bool, str, str]:
+    """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 _get_branch_for_pr(pr_number: int) -> Optional[str]:
+    """Get the branch name for a PR number via gh pr view.
+
+    Returns the headRefName (branch) for the PR, or None if lookup fails.
+    """
+    ok, out, _err = _run([
+        _gh_bin(), "pr", "view", str(pr_number),
+        "--json", "headRefName"
+    ])
+    if not ok or not out.strip():
+        return None
+    try:
+        data = json.loads(out)
+        return data.get("headRefName")
+    except (ValueError, TypeError):
+        return None
+
+
+def _get_latest_run(branch: str) -> Optional[Dict[str, Any]]:
+    """Get the latest workflow run for a branch.
+
+    Shells: gh run list --branch <branch> --limit 1 --json id,name,status,conclusion,url
+    Returns a run object or None if lookup fails.
+    """
+    ok, out, _err = _run([
+        _gh_bin(), "run", "list", "--branch", branch,
+        "--limit", "1",
+        "--json", "id,name,status,conclusion,url"
+    ])
+    if not ok or not out.strip():
+        return None
+    try:
+        data = json.loads(out)
+        return data[0] if data else None
+    except (ValueError, TypeError, IndexError):
+        return None
+
+
+def _get_jobs_for_run(run_id: str) -> List[Dict[str, Any]]:
+    """Get all jobs in a run.
+
+    Shells: gh run view <run_id> --json jobs --json id,name,status,conclusion,url
+    Returns a list of job objects, or empty list if lookup fails.
+    """
+    ok, out, _err = _run([
+        _gh_bin(), "run", "view", run_id,
+        "--json", "jobs"
+    ])
+    if not ok or not out.strip():
+        return []
+    try:
+        data = json.loads(out)
+        # data should be {"jobs": [{...}, ...]}
+        return data.get("jobs", []) if isinstance(data, dict) else data if isinstance(data, list) else []
+    except (ValueError, TypeError):
+        return []
+
+
+def _get_job_log_excerpt(job_id: int) -> Optional[str]:
+    """Fetch the full log for a job and extract ~100-line tail excerpt.
+
+    Shells: gh api repos/{owner}/{repo}/actions/jobs/{job_id}/logs
+    (Note: gh api auto-fills {owner}/{repo} when run inside a repo.)
+    Extracts the last _LOG_EXCERPT_LINES lines as a tail, decompresses if gzipped.
+
+    Returns the tail excerpt (plain text, utf-8 with errors='replace'), or None if fetch fails.
+    """
+    # Determine owner/repo from the current repo (gh api can infer them)
+    ok, repo_info, _err = _run([
+        "git", "remote", "get-url", "origin"
+    ])
+    if not ok:
+        return None
+
+    # Try to extract owner/repo from the remote URL
+    # Supports: https://github.com/owner/repo.git or git@github.com:owner/repo.git
+    match = re.search(r'(?:github\.com[:/]|git@github\.com:)([^/]+)/([^/.]+)', repo_info)
+    if not match:
+        return None
+
+    owner, repo = match.group(1), match.group(2)
+
+    # Fetch log via gh api
+    api_path = f"repos/{owner}/{repo}/actions/jobs/{job_id}/logs"
+    ok, out, _err = _run([
+        _gh_bin(), "api", api_path
+    ])
+    if not ok or not out.strip():
+        return None
+
+    # Split into lines and take the tail
+    lines = out.splitlines()
+    tail_lines = lines[-_LOG_EXCERPT_LINES:] if lines else []
+    return "\n".join(tail_lines) if tail_lines else None
+
+
+def _get_failure_details(pr_number: int) -> Tuple[bool, Optional[str], Optional[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Collect failure details for a PR.
+
+    Returns: (available, error, latest_run, jobs)
+      - available: bool — gh is working and authenticated
+      - error: str | None — human reason if available is False
+      - latest_run: run object or None
+      - jobs: list of job objects with log_excerpt fields
+    """
+    # Get the branch for the PR
+    branch = _get_branch_for_pr(pr_number)
+    if not branch:
+        return False, f"Could not find branch for PR #{pr_number}", None, []
+
+    # Get the latest run for the branch
+    run = _get_latest_run(branch)
+    if not run:
+        # Could mean: no runs at all, or gh failure
+        # Assume success (no failure data to show) rather than error
+        return True, None, None, []
+
+    # Get all jobs in the run
+    jobs = _get_jobs_for_run(run["id"])
+
+    # For each job, fetch log excerpt if it failed
+    for job in jobs:
+        job_id = job.get("id")
+        if job_id and job.get("conclusion") == "failure":
+            excerpt = _get_job_log_excerpt(job_id)
+            job["log_excerpt"] = excerpt
+        else:
+            job["log_excerpt"] = None
+
+    return True, None, run, jobs
+
+
+def get_wave_failure(pr_number: int, force: bool = False) -> Dict[str, Any]:
+    """Get consolidated failure drill-down data for a PR.
+
+    Shape:
+        {
+          "available": bool,
+          "error": str | None,
+          "pr_number": int,
+          "branch": str,
+          "latest_run": {...} | null,
+          "jobs": [{id, name, status, conclusion, url, log_excerpt}, ...]
+        }
+
+    Cached for _CACHE_TTL_SECONDS so rapid polls don't re-run gh. Never raises.
+    """
+    now = time.time()
+    if not force and pr_number in _cache:
+        expires, payload = _cache[pr_number]
+        if now < expires:
+            return payload
+
+    try:
+        available, error, run, jobs = _get_failure_details(pr_number)
+
+        # Get branch name for the response
+        branch = ""
+        if run:
+            # Try to infer branch from run or PR
+            branch_name = _get_branch_for_pr(pr_number)
+            branch = branch_name or ""
+
+        payload = {
+            "available": available,
+            "error": error,
+            "pr_number": pr_number,
+            "branch": branch,
+            "latest_run": run,
+            "jobs": jobs,
+        }
+    except Exception as e:
+        print(f"[wave_failure] Uncaught error: {e}", file=sys.stderr)
+        payload = {
+            "available": False,
+            "error": f"Internal error: {e}",
+            "pr_number": pr_number,
+            "branch": "",
+            "latest_run": None,
+            "jobs": [],
+        }
+
+    _cache[pr_number] = (now + _CACHE_TTL_SECONDS, payload)
+    return payload