@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/terminal.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import shutil
-import subprocess
-from typing import Callable
-
-
-RunCommand = Callable[[list[str], int], subprocess.CompletedProcess[str]]
-SessionExists = Callable[[str | None], bool]
-
-
-def run_cmd(args: list[str], timeout: int = 20) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(args, text=True, capture_output=True, timeout=timeout, check=False)
-
-
-def shutil_which(command: str) -> str | None:
-    return shutil.which(command)
-
-
-def tmux_session_exists(session_name: str | None, *, run: RunCommand = run_cmd) -> bool:
-    if not session_name:
-        return False
-    proc = run(["tmux", "has-session", "-t", session_name], timeout=5)
-    return proc.returncode == 0
-
-
-def tmux_window_exists(session_name: str | None, window: str | None, *, run: RunCommand = run_cmd) -> bool:
-    if not session_name or not window:
-        return False
-    proc = run(["tmux", "list-windows", "-t", session_name, "-F", "#{window_name}"], timeout=5)
-    if proc.returncode != 0:
-        return False
-    return window in proc.stdout.splitlines()
-
-
-def tmux_start_command_for_agent_window(
-    session_name: str,
-    window_name: str,
-    command: str,
-    *,
-    session_exists: SessionExists = tmux_session_exists,
-) -> tuple[list[str], str]:
-    if session_exists(session_name):
-        return ["tmux", "new-window", "-t", session_name, "-n", window_name, "sh", "-lc", command], "new-window"
-    return ["tmux", "new-session", "-d", "-s", session_name, "-n", window_name, "sh", "-lc", command], "new-session"
-
-
-def tmux_stdout_last_line(stdout: str) -> str | None:
-    lines = [line.strip() for line in stdout.splitlines() if line.strip()]
-    return lines[-1] if lines else None
-
-
-def tmux_truthy(value: str) -> int:
-    try:
-        return 1 if int(value) > 0 else 0
-    except (TypeError, ValueError):
-        return 1 if value and value != "0" else 0

package/src/team_agent/wake.py

@@ -1,58 +0,0 @@
-"""Provider-neutral wake layer (Gap 32 §2): decide WHEN to re-read a session
-file, never HOW to parse it. No polling loop, no screen, no provider names.
-
-Two cheap, passive sources:
-  - a file-change watch (the caller wires FSEvents/inotify/kqueue and calls
-    ``on_file_changed``) — naturally per-session (one file per node);
-  - an mtime gate — only re-read the tail when the file changed since the last
-    classification, or when it has been quiet past the debounce window.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def should_reread(
-    *,
-    last_mtime: float | None,
-    current_mtime: float | None,
-    last_classified_mtime: float | None,
-    now: float,
-    debounce_seconds: float,
-) -> dict[str, Any]:
-    """Return whether a fresh tail-read is warranted and why.
-
-    A read is warranted when the file changed since we last classified it, or
-    when it has been silent longer than the debounce window and we have not yet
-    classified at this mtime (so an idle-close that we already saw is not
-    re-read forever).
-    """
-    if current_mtime is None:
-        return {"reread": False, "reason": "no_file"}
-    if last_classified_mtime is None:
-        return {"reread": True, "reason": "never_classified"}
-    if current_mtime != last_classified_mtime:
-        return {"reread": True, "reason": "file_changed"}
-    silent_for = max(0.0, now - current_mtime)
-    if silent_for >= debounce_seconds:
-        return {"reread": False, "reason": "quiescent_already_classified"}
-    return {"reread": False, "reason": "unchanged"}
-
-
-def on_file_changed(watch_state: dict[str, Any] | None, *, node_id: str, mtime: float) -> dict[str, Any]:
-    """Record a file-change wake for a node (the push path)."""
-    state = dict(watch_state or {})
-    pending = set(state.get("pending") or [])
-    pending.add(node_id)
-    state["pending"] = sorted(pending)
-    state.setdefault("mtimes", {})[node_id] = mtime
-    return state
-
-
-def take_pending(watch_state: dict[str, Any] | None) -> tuple[list[str], dict[str, Any]]:
-    """Drain the set of nodes whose files changed since the last drain."""
-    state = dict(watch_state or {})
-    pending = sorted(state.get("pending") or [])
-    state["pending"] = []
-    return pending, state

package/src/team_agent/watch/__init__.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-import json
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Callable
-
-from team_agent.message_store import MessageStore
-from team_agent.paths import logs_dir, runtime_dir
-from team_agent.status.queries import result_summary_from_row
-
-
-@dataclass
-class WatchCursor:
-    event_offset: int = 0
-    seen_result_ids: set[str] = field(default_factory=set)
-    initialized: bool = False
-    archive_signature: tuple[int, int] | None = None
-
-
-ROTATION_MARKER = "[watch] log rotated; archived segment events.jsonl.1 not replayed — historical replay deferred to a future --replay flag"
-
-
-def run_watch(
-    workspace: Path,
-    *,
-    team: str | None = None,
-    interval: float = 0.5,
-    output: Callable[[str], None] = print,
-    sleep: Callable[[float], None] = time.sleep,
-) -> None:
-    cursor = WatchCursor()
-    while True:
-        for line in collect_watch_lines(workspace, cursor, team=team):
-            output(line)
-        sleep(interval)
-
-
-def collect_watch_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
-    lines = _collect_event_lines(workspace, cursor, team=team)
-    lines.extend(_collect_result_lines(workspace, cursor, team=team))
-    return lines
-
-
-def render_event_line(event: dict[str, Any]) -> str | None:
-    kind = event.get("event")
-    if kind == "result_received":
-        return _result_line(event.get("agent_id"), event.get("summary"))
-    if kind in {"leader_receiver.injected", "leader_receiver.submitted"}:
-        return f"leader_receiver.injected: {_message_snippet(event)} -> {_recipient(event)}"
-    if kind == "send.failed":
-        return f"send.failed: {_recipient(event)} reason={_clean(event.get('reason') or event.get('error') or '-')}"
-    if kind == "leader_receiver.rebind_required":
-        pane = event.get("old_pane_id") or event.get("pane_id") or event.get("target") or "-"
-        reason = event.get("reason") or event.get("rediscovery_status") or "-"
-        return f"leader_receiver.rebind_required: pane={pane} reason={_clean(reason)}"
-    if kind == "leader.api_error":
-        error_class = event.get("error_class") or "Unknown"
-        provider = event.get("provider") or "-"
-        snippet = _clean(event.get("matched_pattern_snippet") or event.get("snippet") or "-")
-        return f"leader.api_error: {error_class} provider={provider} snippet={snippet}"
-    return None
-
-
-def _collect_event_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
-    path = logs_dir(workspace) / "events.jsonl"
-    archive_signature = _archive_signature(path.with_name("events.jsonl.1"))
-    lines: list[str] = []
-    if not cursor.initialized:
-        cursor.archive_signature = archive_signature
-        cursor.initialized = True
-    elif archive_signature and archive_signature != cursor.archive_signature:
-        lines.append(ROTATION_MARKER)
-        cursor.archive_signature = archive_signature
-        cursor.event_offset = 0
-    if not path.exists():
-        return lines
-    size = path.stat().st_size
-    if cursor.event_offset > size:
-        if ROTATION_MARKER not in lines:
-            lines.append(ROTATION_MARKER)
-        cursor.event_offset = 0
-    with path.open("r", encoding="utf-8") as handle:
-        handle.seek(cursor.event_offset)
-        for raw in handle:
-            try:
-                event = json.loads(raw)
-            except json.JSONDecodeError:
-                continue
-            if team and _event_team_id(event) != team:
-                continue
-            rendered = render_event_line(event)
-            if rendered:
-                lines.append(rendered)
-        cursor.event_offset = handle.tell()
-    return lines
-
-
-def _collect_result_lines(workspace: Path, cursor: WatchCursor, *, team: str | None = None) -> list[str]:
-    if not (runtime_dir(workspace) / "team.db").exists():
-        return []
-    store = MessageStore(workspace)
-    lines: list[str] = []
-    for row in store.latest_results(limit=20, owner_team_id=team):
-        result_id = str(row.get("result_id") or "")
-        if not result_id or result_id in cursor.seen_result_ids:
-            continue
-        cursor.seen_result_ids.add(result_id)
-        summary = result_summary_from_row(row) or {}
-        lines.append(_result_line(summary.get("agent_id"), summary.get("summary")))
-    return lines
-
-
-def _result_line(agent_id: Any, summary: Any) -> str:
-    return f"result_received: {agent_id or '-'} -> {_clean(summary or '-')[:80]}"
-
-
-def _message_snippet(event: dict[str, Any]) -> str:
-    message_id = str(event.get("message_id") or event.get("msg_id") or "-")
-    return message_id[:12] if message_id != "-" else "-"
-
-
-def _recipient(event: dict[str, Any]) -> str:
-    return str(event.get("recipient") or event.get("to") or event.get("target") or "-")
-
-
-def _clean(value: Any) -> str:
-    return " ".join(str(value).split())
-
-
-def _event_team_id(event: dict[str, Any]) -> str | None:
-    value = event.get("team_id") or event.get("owner_team_id") or event.get("team")
-    return str(value) if value else None
-
-
-def _archive_signature(path: Path) -> tuple[int, int] | None:
-    try:
-        stat = path.stat()
-    except FileNotFoundError:
-        return None
-    return (stat.st_size, stat.st_mtime_ns)
-
-
-__all__ = ["ROTATION_MARKER", "WatchCursor", "collect_watch_lines", "render_event_line", "run_watch"]