code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/steer_queue/register_callbacks.py

@@ -0,0 +1,138 @@
+"""Register callbacks for the ``steer_queue`` plugin.
+
+Mid-run Enter now QUEUES by default (see ``line_editor``); this plugin
+supplies the rest of the feature:
+
+* ``/steer <text>`` -- inject guidance mid-turn, interrupting the
+  agent's current train of thought ASAP (the old Enter default). At
+  idle it's a no-op with a hint: just type at the prompt.
+* ``/queue`` -- full-screen queue manager with prompt preview, multiline
+  add/edit, guarded delete, and reordering. Works at idle and mid-run: both
+  paths already release the terminal around command execution.
+* Status suffix -- a ``(N queued)`` tag rides the bottom bar's status
+  row, updated live via the PauseController's steer-queue listeners
+  (submit, drain, TUI edits -- every mutation fires them).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+_STEER = "steer"
+_QUEUE = "queue"
+
+
+def _emit_info(message: str) -> None:
+    from code_puppy.messaging import emit_info
+
+    emit_info(message)
+
+
+def _emit_warning(message: str) -> None:
+    from code_puppy.messaging import emit_warning
+
+    emit_warning(message)
+
+
+# /steer
+def _handle_steer(command: str) -> bool:
+    text = command.split(" ", 1)[1].strip() if " " in command else ""
+    if not text:
+        _emit_info("Usage: /steer <message> \u2014 inject guidance mid-turn")
+        return True
+
+    from code_puppy.messaging.run_ui import is_run_active
+
+    if not is_run_active():
+        _emit_warning(
+            "No agent run in flight \u2014 just type your prompt; "
+            "/steer only makes sense while the agent is working."
+        )
+        return True
+
+    from code_puppy.messaging.pause_controller import get_pause_controller
+
+    # ``mode='now'`` is announced by the history processor; no duplicate ack.
+    get_pause_controller().request_steer(text, mode="now")
+    return True
+
+
+# /queue
+def _handle_queue(command: str) -> bool:
+    from .queue_menu import open_queue_menu_blocking
+
+    open_queue_menu_blocking()
+    _emit_queue_summary()
+    return True
+
+
+def _emit_queue_summary() -> None:
+    from code_puppy.messaging.pause_controller import get_pause_controller
+
+    count = len(get_pause_controller().peek_pending_steer_queued())
+    if count:
+        _emit_info(f"\u23ed {count} prompt(s) queued")
+    else:
+        _emit_info("Queue is empty")
+
+
+# Status suffix: '(N queued)'
+def _update_status_suffix(count: int) -> None:
+    """Steer-queue listener: paint/clear the pending-count tag.
+
+    ``count`` is the TOTAL across both queues (now + queued), so the
+    suffix is on whenever EITHER queue holds something. ``/steer`` uses
+    ``mode="now"``; that steer sits in the now-queue until the history
+    processor drains it, so the suffix tags the whole window between
+    submit and injection.
+    """
+    try:
+        from code_puppy.messaging.bottom_bar import get_bottom_bar
+
+        get_bottom_bar().set_status_suffix(f" ({count} pending)" if count else "")
+    except Exception:
+        logger.debug("pending-count paint failed", exc_info=True)
+
+
+def _on_startup() -> None:
+    try:
+        from code_puppy.messaging.pause_controller import get_pause_controller
+
+        get_pause_controller().add_steer_queue_listener(_update_status_suffix)
+    except Exception:
+        logger.debug("steer_queue startup failed", exc_info=True)
+
+
+# Registration
+def _handle_custom_command(command: str, name: str) -> Optional[bool]:
+    if name == _STEER:
+        return _handle_steer(command)
+    if name == _QUEUE:
+        return _handle_queue(command)
+    return None
+
+
+def _custom_help() -> List[Tuple[str, str]]:
+    return [
+        (_STEER, "Inject guidance mid-turn while the agent is running"),
+        (_QUEUE, "Manage queued prompts in a full-screen TUI"),
+    ]
+
+
+register_callback("startup", _on_startup)
+register_callback("custom_command", _handle_custom_command)
+register_callback("custom_command_help", _custom_help)
+
+
+__all__ = [
+    "_handle_custom_command",
+    "_handle_queue",
+    "_handle_steer",
+    "_on_startup",
+    "_update_status_suffix",
+]

code_puppy_core_plugins/subagent_panel/README.md

@@ -0,0 +1,102 @@
+# subagent_panel
+
+A live, two-line status block for each running sub-agent, painted just above the
+bouncing puppy:
+
+```
+  INVOKE AGENT  pup-ticket-investigator  claude-4-8-opus
+  (spin) 00:19  calling read_file
+  INVOKE AGENT  pup-analysis-adjudicator
+  (spin) 00:25  calling grep
+
+Milo is thinking... (  o  )
+```
+
+- Line 1 is the `INVOKE AGENT` banner (same color/styling as core).
+- Line 2 is a single-char animated spinner + `mm:ss` elapsed + the current
+  activity, color-coded: **yellow** = calling a tool, **magenta** = thinking,
+  **green** = writing the response.
+- Parallel sub-agents stack, each with its own live row. There is no arbitrary
+  cap: every tracked agent renders as long as it fits. The row count is only
+  clamped to the terminal height (the prompt + status always keep their rows) --
+  if a swarm is taller than the viewport, the rows that don't fit collapse into a
+  single `… +N more` summary rather than blanking the whole bar.
+- **Nested sub-agents render as a true tree.** A sub-agent that itself calls
+  `invoke_agent` is shown indented under its parent. Only top-level (depth-0)
+  agents get the full two-line `INVOKE AGENT` banner; deeper agents collapse to
+  a compact one-liner -- `<elbow> name  mm:ss  purpose  model` -- so the banner
+  text + model label aren't repeated at every level:
+
+  ```
+    INVOKE AGENT  regression-runner  gpt-5.5
+    (spin) 00:12  calling invoke_agent
+    \u2514\u2500 pup-ticket-investigator  00:12  calling read_file  claude-4-8-opus
+       \u2514\u2500 deep-helper  00:12  thinking...  gpt-5.5-mini
+  ```
+
+  The parent link is captured at emit time from an async-safe `ContextVar`
+  (`_PARENT_SID`), NOT the bus's single global `_current_session_id`. The
+  global is shared across all asyncio tasks, so two `invoke_agent` calls running
+  concurrently would clobber it and mis-parent one root under the other (a bogus
+  deep chain). A `ContextVar` is copied into each task at `create_task` time, so
+  concurrent siblings each see their own correct parent -- see
+  `_install_parent_tracking` (mirrors `set_session_context`) + `_install_emit_hook`.
+- **On completion** the block doesn't just vanish: a persistent frozen record
+  is printed to the transcript mirroring the live look, with line 2 finalized
+  as a green check + `mm:ss completed`:
+
+  ```
+    INVOKE AGENT  pup-ticket-investigator  claude-4-8-opus
+    (check) 00:45  completed
+  ```
+
+  (The redundant core "<check> <name> completed successfully" line is suppressed.)
+  Nested agents get a compact one-liner frozen record instead of the full block:
+  `<elbow> name  (check) mm:ss  completed  model`.
+
+## How it works (3 monkeypatches, 1 callback -- no core edits)
+
+The puppy spinner already runs a Rich `Live` that repaints ~20x/second. Rather
+than spin up a second `Live` (which fights the puppy's -- the reason the
+built-in `SubAgentConsoleManager` is dead code), this plugin reuses it:
+
+1. **`ConsoleSpinner._generate_spinner_panel`** -> returns
+   `Group(status block..., "", puppy)` so the existing loop renders everything.
+2. **`RichConsoleRenderer._render_subagent_invocation`** -> *captures* the exact
+   metadata (name / session_type / model / **session_id**) and *suppresses* the
+   permanent banner. The live block now owns the banner, so there's no
+   duplicate, and registration is exact even for parallel sub-agents (no
+   session-id guessing).
+3. **`RichConsoleRenderer._do_render`** -> when the `SubAgentResponseMessage`
+   arrives (core skips it), print the persistent frozen two-line record + pop
+   the live row, and suppress the redundant completion-text line.
+
+Status text is fed by the **`stream_event`** callback, keyed by `session_id`.
+`record_event` is *update-only*: an event for an unregistered session is ignored,
+which cleanly filters out the main agent's own stream events. `coalesce_patch.py`
+batches sub-agent stream-event callbacks (~50ms) so parallel token streams do
+not starve the steer overlay's event-loop continuations.
+
+## Config
+
+Runtime toggle:
+
+```text
+/set subagent_panel off
+/set subagent_panel on
+```
+
+Environment startup hard-disable:
+
+| Var | Default | Meaning |
+|-----|---------|---------|
+| DISABLE_SUBAGENT_PANEL | unset | Set 1 to skip registration entirely |
+| SUBAGENT_PANEL | 1 | Set 0 to skip registration entirely |
+| SUBAGENT_PANEL_IDLE_S | 600 | Prune after this many idle seconds (safety net) |
+
+## Notes
+
+- Installs wrappers at **startup**, but `/set subagent_panel off` makes them pass through live.
+- The permanent invocation banner (with Prompt/Session) is intentionally
+  replaced by the transient live block; on completion a compact frozen
+  two-line record (banner + green check) is left in the transcript.

code_puppy_core_plugins/subagent_panel/__init__.py

@@ -0,0 +1,24 @@
+"""subagent_panel -- live two-line status per sub-agent above the puppy.
+
+Renders, inside the puppy spinner's own Rich Live region, a block per active
+sub-agent::
+
+      INVOKE AGENT <name>  <model>
+       <spin> 00:19  calling read_file
+
+    <bouncing puppy>
+
+Line 1 is the INVOKE AGENT banner (core styling); line 2 is a single-char
+animated spinner + mm:ss elapsed + a color-coded status (yellow=calling,
+magenta=thinking, green=writing). Parallel sub-agents stack.
+
+It reuses the puppy spinner's existing Rich ``Live`` (a monkeypatch of
+``_generate_spinner_panel``) rather than a second ``Live`` -- two Live displays
+on one console fight each other (which is why the built-in, fully-built but
+never-wired ``SubAgentConsoleManager`` was dead code). Exact per-agent metadata
+is captured by monkeypatching ``_render_subagent_invocation`` (which also
+suppresses the now-redundant permanent banner). On completion, ``_do_render``
+is wrapped to print a persistent frozen two-line record (banner + green check +
+mm:ss completed) and suppress the redundant core completion line. Status text is
+fed by the ``stream_event`` callback. See register_callbacks.py + state.py.
+"""

code_puppy_core_plugins/subagent_panel/coalesce_patch.py

@@ -0,0 +1,242 @@
+"""Coalesce sub-agent stream_event callbacks from a user plugin.
+
+PUP-301 briefly patched ``code_puppy.agents.subagent_stream_handler`` in core so
+parallel sub-agents don't create one asyncio task per streamed token. That fixed
+Ctrl+T steer-overlay lag under a sub-agent swarm, but the feature belongs in the
+user plugin while this experiment stays out of the repo.
+
+This module installs the same behavior as a small monkeypatch:
+
+* replace ``subagent_stream_handler._fire_callback`` with a batched version;
+* wrap ``subagent_stream_handler.subagent_stream_handler`` so stream-end flushes
+  any trailing events (especially ``part_end``);
+* pass through to the original callback whenever ``subagent_panel`` is
+  runtime-disabled via ``/set subagent_panel off``.
+
+All state is event-loop local in practice: core calls this from the stream
+handler running on the main loop. No locks, no cute cleverness. Cute cleverness
+is how puppies end up inside washing machines.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import importlib
+import logging
+import time
+from collections.abc import Awaitable, Callable
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+COALESCE_INTERVAL_S: float = 0.050
+_MARKER = "_subagent_panel_coalesced"
+
+Event = tuple[str, Any, Optional[str]]
+EnabledChecker = Callable[[], bool]
+FireCallback = Callable[[str, Any, Optional[str]], None]
+
+_pending_events: list[Event] = []
+_drain_scheduled = False
+_last_drain_time = 0.0
+_original_fire_callback: FireCallback | None = None
+_original_stream_handler: Callable[..., Awaitable[None]] | None = None
+_enabled_checker: EnabledChecker | None = None
+
+
+def _enabled() -> bool:
+    if _enabled_checker is None:
+        return True
+    try:
+        return bool(_enabled_checker())
+    except Exception:
+        return True
+
+
+def _fire_original(event_type: str, event_data: Any, session_id: Optional[str]) -> None:
+    original = _original_fire_callback
+    if original is None:
+        return
+    try:
+        original(event_type, event_data, session_id)
+    except Exception as exc:  # noqa: BLE001 - callback plumbing must not explode
+        logger.debug("Original stream_event callback failed: %s", exc)
+
+
+def _coalesced_fire_callback(
+    event_type: str,
+    event_data: Any,
+    session_id: Optional[str],
+) -> None:
+    """Queue a stream-event callback for batched delivery.
+
+    When runtime-disabled, this delegates to the exact original core callback so
+    ``/set subagent_panel off`` really behaves like vanilla Code Puppy.
+    """
+    global _drain_scheduled, _last_drain_time
+
+    if not _enabled():
+        _fire_original(event_type, event_data, session_id)
+        return
+
+    _pending_events.append((event_type, event_data, session_id))
+    if _drain_scheduled:
+        return
+
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        clear_pending()
+        return
+
+    now = time.monotonic()
+    elapsed = now - _last_drain_time
+    _drain_scheduled = True
+    if elapsed >= COALESCE_INTERVAL_S:
+        loop.call_soon(_drain_pending_task, loop)
+    else:
+        loop.call_later(COALESCE_INTERVAL_S - elapsed, _drain_pending_task, loop)
+
+
+def _drain_pending_task(loop: asyncio.AbstractEventLoop) -> None:
+    """Drain pending events as one scheduled asyncio task."""
+    global _drain_scheduled, _last_drain_time
+
+    _drain_scheduled = False
+    _last_drain_time = time.monotonic()
+    if not _pending_events:
+        return
+
+    batch = list(_pending_events)
+    _pending_events.clear()
+    loop.create_task(_fire_batch(batch))
+
+
+async def _fire_batch(batch: list[Event]) -> None:
+    try:
+        from code_puppy import callbacks
+    except ImportError:
+        logger.debug("Callbacks module not available for stream event")
+        return
+
+    for event_type, event_data, session_id in batch:
+        try:
+            await callbacks.on_stream_event(event_type, event_data, session_id)
+        except Exception as exc:  # noqa: BLE001 - match core's fail-safe behavior
+            logger.debug("Error in stream_event callback: %s", exc)
+
+
+async def flush_pending_callbacks() -> None:
+    """Synchronously drain any queued events.
+
+    The stream-handler wrapper calls this in ``finally`` so terminal events do
+    not sit behind the coalesce timer after a sub-agent stream completes.
+    """
+    global _drain_scheduled, _last_drain_time
+
+    _drain_scheduled = False
+    _last_drain_time = time.monotonic()
+    if not _pending_events:
+        return
+
+    batch = list(_pending_events)
+    _pending_events.clear()
+    await _fire_batch(batch)
+
+
+def clear_pending() -> None:
+    """Drop pending events without firing them; used only for abnormal no-loop paths."""
+    global _drain_scheduled
+
+    _pending_events.clear()
+    _drain_scheduled = False
+
+
+def _make_stream_handler_wrapper(original: Callable[..., Awaitable[None]]):
+    async def _wrapped(*args: Any, **kwargs: Any) -> None:
+        try:
+            await original(*args, **kwargs)
+        finally:
+            await flush_pending_callbacks()
+
+    setattr(_wrapped, _MARKER, True)
+    setattr(_wrapped, "_subagent_panel_original_stream_handler", original)
+    return _wrapped
+
+
+def install(enabled_checker: EnabledChecker | None = None) -> bool:
+    """Install the coalescing monkeypatch idempotently.
+
+    Returns ``True`` when installed/already installed, ``False`` if the core
+    module is not importable. Import failure is okay during lightweight tests.
+    """
+    global _enabled_checker, _original_fire_callback, _original_stream_handler
+
+    _enabled_checker = enabled_checker
+    try:
+        module = importlib.import_module("code_puppy.agents.subagent_stream_handler")
+    except Exception as exc:  # noqa: BLE001 - plugin startup must be best-effort
+        logger.debug("Could not import subagent_stream_handler: %s", exc)
+        return False
+
+    current_fire = getattr(module, "_fire_callback", None)
+    if current_fire is None:
+        return False
+    if not getattr(current_fire, _MARKER, False):
+        _original_fire_callback = current_fire
+        setattr(_coalesced_fire_callback, _MARKER, True)
+        setattr(
+            _coalesced_fire_callback,
+            "_subagent_panel_original_fire_callback",
+            current_fire,
+        )
+        module._fire_callback = _coalesced_fire_callback
+    elif _original_fire_callback is None:
+        _original_fire_callback = getattr(
+            current_fire, "_subagent_panel_original_fire_callback", None
+        )
+
+    current_handler = getattr(module, "subagent_stream_handler", None)
+    if current_handler is None:
+        return True
+    if not getattr(current_handler, _MARKER, False):
+        _original_stream_handler = current_handler
+        module.subagent_stream_handler = _make_stream_handler_wrapper(current_handler)
+    elif _original_stream_handler is None:
+        _original_stream_handler = getattr(
+            current_handler, "_subagent_panel_original_stream_handler", None
+        )
+
+    return True
+
+
+def uninstall() -> None:
+    """Restore original core callables when this plugin owns the patch."""
+    global _original_fire_callback, _original_stream_handler, _enabled_checker
+
+    try:
+        module = importlib.import_module("code_puppy.agents.subagent_stream_handler")
+    except Exception:
+        clear_pending()
+        return
+
+    if getattr(getattr(module, "_fire_callback", None), _MARKER, False):
+        if _original_fire_callback is not None:
+            module._fire_callback = _original_fire_callback
+    if getattr(getattr(module, "subagent_stream_handler", None), _MARKER, False):
+        if _original_stream_handler is not None:
+            module.subagent_stream_handler = _original_stream_handler
+
+    clear_pending()
+    _original_fire_callback = None
+    _original_stream_handler = None
+    _enabled_checker = None
+
+
+__all__ = [
+    "COALESCE_INTERVAL_S",
+    "clear_pending",
+    "flush_pending_callbacks",
+    "install",
+    "uninstall",
+]

code_puppy_core_plugins/subagent_panel/panel_render.py

@@ -0,0 +1,145 @@
+"""Rendering helpers for the sub-agent panel (live rows + transcript).
+
+Pure presentation: tree ordering, model-name shorthand, and the aligned
+one-line-per-agent row renderer shared by the live bottom-bar panel and
+the frozen transcript records. No I/O, no state mutation — that lives in
+``register_callbacks`` / ``state``.
+"""
+
+from __future__ import annotations
+
+
+from . import state
+
+
+def _banner_color():
+    try:
+        from code_puppy.config import get_banner_color
+
+        return get_banner_color("invoke_agent")
+    except Exception:
+        return "blue"
+
+
+# Hierarchy helpers (true parent -> child tree)
+def _ordered_tree(rows):
+    """Return [(entry, depth), ...] in DFS order. A row whose parent is not in
+    the set (e.g. the main agent, or None) is a root (depth 0); descendants are
+    indented one-liners. Cycle-safe; stable by start time."""
+    by_id = {e["session_id"]: e for e in rows if e.get("session_id")}
+    children = {}
+    roots = []
+    for e in rows:
+        p = e.get("parent")
+        if p and p in by_id:
+            children.setdefault(p, []).append(e)
+        else:
+            roots.append(e)
+    out = []
+    seen = set()
+
+    def walk(node, depth):
+        sid = node.get("session_id")
+        if sid in seen:
+            return
+        seen.add(sid)
+        out.append((node, depth))
+        for kid in sorted(children.get(sid, []), key=lambda c: c["start"]):
+            walk(kid, depth + 1)
+
+    for r in sorted(roots, key=lambda e: e["start"]):
+        walk(r, 0)
+    return out
+
+
+def _model_short(model):
+    """Return the model identifier verbatim for the panel display.
+
+    Deliberately a passthrough: whatever the user picked with ``/model <key>``
+    is what shows up in the subagent panel. No parsing, no title-casing, no
+    tier/env extraction -- previous versions built a curated shorthand from
+    a hard-coded allowlist of tier tokens (nano/mini/flash/...) plus an env
+    allowlist ('stage'), which silently dropped any suffix outside the lists
+    (e.g. -stage). Users would rather see the raw config key and trust their
+    own eyes; that also removes an allowlist maintenance chore forever.
+    Empty / None inputs collapse to an empty string so the panel column
+    doesn't render the literal 'None'.
+    """
+    return str(model) if model else ""
+
+
+def _row_lines(ordered, frame):
+    """Render a list of (entry, depth) as aligned single-line rows:
+        <prefix><name>   <model>   <spin|check> <mm:ss>
+    The model + indicator + time columns share a per-tree tab-stop computed
+    from the widest (prefix+name) AND the widest model label, so longer model
+    names (e.g. 'GPT 5.4-Nano') and deeper-indented names both push the whole
+    right block over together -- columns stay aligned no matter what gets added.
+    Alignment is done purely with U+0020 spaces (never literal tabs), and widths
+    use Rich cell_len, so the layout renders identically on Windows and macOS.
+    Root rows carry the INVOKE AGENT badge; nested rows carry the tree elbow.
+    Used for BOTH the live block and the transcript.
+    """
+    from rich.cells import cell_len
+    from rich.text import Text
+
+    color = _banner_color()
+    lefts = []
+    models = []
+    name_w = 0
+    model_w = 0
+    for e, depth in ordered:
+        left = Text(no_wrap=True, overflow="ellipsis")
+        if depth == 0:
+            left.append(" \U0001f916 INVOKE AGENT ", style=f"bold white on {color}")
+            left.append(" ")
+            left.append(e["name"], style="bold cyan")
+        else:
+            left.append("  " + "   " * (depth - 1))
+            left.append("\u2514\u2500 ", style="grey50")  # tree elbow
+            left.append(e["name"], style="bold cyan")
+        lefts.append(left)
+        ms = _model_short(e.get("model"))
+        models.append(ms)
+        name_w = max(name_w, left.cell_len)
+        model_w = max(model_w, cell_len(ms))
+
+    lines = []
+    for (e, depth), left, ms in zip(ordered, lefts, models):
+        done = bool(e.get("done"))
+        failed = bool(e.get("failed"))
+        line = left.copy()
+        # Keep status rows single-line; crop visually for the terminal but retain
+        # full status in state.
+        line.no_wrap = True
+        line.overflow = "ellipsis"
+        line.append(" " * (name_w - left.cell_len + 2))
+        line.append(ms, style="magenta")
+        line.append(" " * (model_w - cell_len(ms) + 2))
+        if failed:
+            line.append("\u2717 ", style="bold red")  # X mark
+        elif done:
+            line.append("\u2713 ", style="bold green")  # check
+        else:
+            line.append((frame or " ") + " ", style="bold cyan")
+        line.append(state.fmt_elapsed_entry(e), style="dim")
+        # Current action / status, color-coded (yellow=calling, magenta=thinking,
+        # green=writing). Done rows show 'completed' green; failed rows 'failed' red.
+        status = e.get("status", "starting")
+        line.append("  ")
+        if failed:
+            line.append("failed", style="bold red")
+        elif done:
+            line.append("completed", style="green")
+        else:
+            line.append(status, style=state.status_style(status))
+        lines.append(line)
+    return lines
+
+
+__all__ = [
+    "_banner_color",
+    "_model_short",
+    "_ordered_tree",
+    "_row_lines",
+]