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

code_puppy_core_plugins/subagent_panel/state.py

@@ -0,0 +1,231 @@
+"""Thread-safe registry of active sub-agents + status derivation.
+
+The puppy spinner repaints from a background thread ~20x/second, so all reads
+here must be cheap and lock-guarded.
+
+Registration is driven by the sub-agent INVOCATION banner (which carries the
+exact name, session_type, model AND session_id), so attribution is exact even
+for parallel sub-agents -- no FIFO guessing, no session-id parsing. Status
+updates (``record_event``) are UPDATE-ONLY: an event for an unregistered
+session is ignored, which cleanly filters out the MAIN agent's own stream
+events (the main agent is never registered).
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+# session_id -> {session_id, parent, name, model, status, start, last_seen}
+_AGENTS: "Dict[str, Dict[str, Any]]" = {}
+_LOCK = threading.RLock()
+
+# --- tunables (env-overridable) -------------------------------------------
+IDLE_PRUNE_S = float(os.environ.get("SUBAGENT_PANEL_IDLE_S", "600"))
+
+# Single-char braille spinner frames (defined via escapes to keep the source
+# emoji-free; braille isn't emoji but escapes dodge any filter ambiguity).
+SPINNER_FRAMES = [
+    "\u280b",
+    "\u2819",
+    "\u2839",
+    "\u2838",
+    "\u283c",
+    "\u2834",
+    "\u2826",
+    "\u2827",
+    "\u2807",
+    "\u280f",
+]
+
+
+# Registration / teardown (invocation + response banners)
+def register(
+    session_id: Optional[str],
+    name: str,
+    model: Optional[str] = None,
+    parent: Optional[str] = None,
+) -> None:
+    if not session_id:
+        return
+    now = time.time()
+    with _LOCK:
+        # Re-invocation of an existing session: keep its original start time.
+        existing = _AGENTS.get(session_id)
+        _AGENTS[session_id] = {
+            "session_id": session_id,
+            "parent": parent,
+            "name": name,
+            "model": model,
+            "status": "starting",
+            "start": existing["start"] if existing else now,
+            "last_seen": now,
+        }
+
+
+def finish(session_id: Optional[str]) -> None:
+    if not session_id:
+        return
+    with _LOCK:
+        _AGENTS.pop(session_id, None)
+
+
+def mark_done(session_id: Optional[str]) -> None:
+    """Mark a sub-agent completed but KEEP it in the live tree (frozen) until its
+    root flushes. This avoids the vanish-then-reappear gap that happens if a
+    nested child is popped the instant it finishes while its parent runs on."""
+    if not session_id:
+        return
+    now = time.time()
+    with _LOCK:
+        entry = _AGENTS.get(session_id)
+        if entry is None:
+            return
+        entry["done"] = True
+        entry["status"] = "completed"
+        entry["end"] = now
+        entry["last_seen"] = now
+
+
+def mark_failed(session_id: Optional[str]) -> None:
+    """Mark a sub-agent FAILED (errored after exhausting retries) but KEEP it in
+    the live tree until its root flushes -- same lifecycle as mark_done, but the
+    renderer paints it red 'failed' with an X instead of green 'completed'."""
+    if not session_id:
+        return
+    now = time.time()
+    with _LOCK:
+        entry = _AGENTS.get(session_id)
+        if entry is None:
+            return
+        entry["done"] = True
+        entry["failed"] = True
+        entry["status"] = "failed"
+        entry["end"] = now
+        entry["last_seen"] = now
+
+
+def clear() -> None:
+    """Drop ALL tracked sub-agents. Called when the top-level turn ends so a
+    root that errored/was cancelled (and thus never flushed) can't leak its
+    'completed' children into the next prompt's live block."""
+    with _LOCK:
+        _AGENTS.clear()
+
+
+# Live status (stream_event updates only)
+def record_event(session_id: Optional[str], event_type: str, event_data: Any) -> None:
+    if not session_id:
+        return
+    status = _derive_status(event_type, event_data)
+    now = time.time()
+    with _LOCK:
+        entry = _AGENTS.get(session_id)
+        if entry is None:
+            return  # not a registered sub-agent (e.g. the main agent) -> ignore
+        entry["last_seen"] = now
+        if status:
+            entry["status"] = status
+
+
+# Reads
+def snapshot() -> List[Dict[str, Any]]:
+    """Return active sub-agents (oldest first), pruning idle/stale ones.
+
+    DONE entries are never pruned by idle -- they stay in the live tree (shown
+    as 'completed') until their root flushes them, so a finished child never
+    vanishes mid-run.
+
+    PARENTS are never idle-pruned either: a parent that has invoked children and
+    is merely AWAITING them emits no stream events of its own, so its last_seen
+    goes stale -- but it is busy, not idle. Pruning it would orphan its whole
+    subtree, making the children re-render as depth-0 roots.
+
+    ROOT rows (parent=None) are never idle-pruned either. A root is the visible
+    anchor of a live user-initiated ``invoke_agent`` call; silently deleting it
+    while its work is still in flight (e.g. a slow tool call that emits no
+    stream events for many minutes) would strand any completed sibling in state
+    with no flush trigger, and hide from the user that a real invocation is
+    still running. Roots exit via one of three legitimate paths only:
+    completion (``_handle_frozen`` -> ``mark_done`` -> ``_maybe_flush_group``),
+    cancel (``state.clear()`` from ``_on_agent_run_cancel``), or end-of-turn
+    (``state.clear()`` from ``_on_agent_run_end``).
+
+    So only childless, not-done, genuinely-stale ORPHAN LEAVES are eligible --
+    a non-root row whose parent is no longer in the tree AND has been silent
+    longer than IDLE_PRUNE_S. End-of-turn ``state.clear()`` remains the real
+    cleanup for anything that errors/cancels without flushing.
+    """
+    now = time.time()
+    with _LOCK:
+        ids = set(_AGENTS)
+        # session_ids still referenced as someone's parent == busy (awaiting kids).
+        busy_parents = {e.get("parent") for e in _AGENTS.values() if e.get("parent")}
+        # Prune only non-done, childless, non-root orphan leaves whose parent is
+        # gone and whose silence exceeds IDLE_PRUNE_S; roots need explicit cleanup.
+        stale = [
+            s
+            for s, e in _AGENTS.items()
+            if not e.get("done")
+            and s not in busy_parents
+            and e.get("parent") is not None
+            and e.get("parent") not in ids
+            and now - e["last_seen"] > IDLE_PRUNE_S
+        ]
+        for s in stale:
+            _AGENTS.pop(s, None)
+        return sorted(_AGENTS.values(), key=lambda e: e["start"])
+
+
+def has_active() -> bool:
+    with _LOCK:
+        return bool(_AGENTS)
+
+
+# Helpers
+def _derive_status(event_type: str, event_data: Any) -> Optional[str]:
+    """Map a sub-agent stream event to a short status. None = no change."""
+    if not isinstance(event_data, dict):
+        return None
+    if event_type == "part_start":
+        tool = event_data.get("tool_name")
+        if tool:
+            return f"calling {tool}"
+        part_type = event_data.get("part_type", "") or ""
+        if "Thinking" in part_type:
+            return "thinking..."
+        if "Text" in part_type:
+            return "writing response"
+    return None
+
+
+def fmt_elapsed(start: float) -> str:
+    """mm:ss elapsed (2-digit minutes), e.g. 00:19."""
+    elapsed = int(max(0.0, time.time() - start))
+    return f"{elapsed // 60:02d}:{elapsed % 60:02d}"
+
+
+def fmt_elapsed_entry(entry: Dict[str, Any]) -> str:
+    """mm:ss for an entry, frozen at its 'end' time once done."""
+    end = entry.get("end")
+    start = entry["start"]
+    elapsed = int(max(0.0, (end if end else time.time()) - start))
+    return f"{elapsed // 60:02d}:{elapsed % 60:02d}"
+
+
+def spinner_frame() -> str:
+    """Wall-clock-derived spinner char (~10fps), independent of caller."""
+    return SPINNER_FRAMES[int(time.time() * 10) % len(SPINNER_FRAMES)]
+
+
+def status_style(status: str) -> str:
+    """Color-code the status text by activity type."""
+    if status.startswith("calling"):
+        return "yellow"
+    if status.startswith("thinking"):
+        return "magenta"
+    if status.startswith("writing"):
+        return "green"
+    return "dim"

code_puppy_core_plugins/switch_agent_resume/__init__.py

@@ -0,0 +1,5 @@
+"""Plugin: /switch-agent and /sa commands.
+
+Switches the active agent and automatically resumes the last autosave
+session that was active in this terminal window.
+"""

code_puppy_core_plugins/switch_agent_resume/register_callbacks.py

@@ -0,0 +1,314 @@
+"""Register /switch-agent and /sa custom commands.
+
+/switch-agent <agent>  — switch agent + auto-resume last terminal session
+/switch-agent          — show interactive agent picker, then switch + resume
+/sa                    — alias for /switch-agent
+"""
+
+import datetime
+import os
+from pathlib import Path
+
+from code_puppy.callbacks import register_callback
+
+
+def _do_switch_and_resume(agent_name: str) -> bool:
+    """Switch to agent_name and auto-resume this terminal's last session."""
+    import uuid
+
+    from rich.text import Text
+
+    from code_puppy.agents import get_current_agent, set_current_agent
+    from code_puppy.config import (
+        AUTOSAVE_DIR,
+        finalize_autosave_session,
+        get_current_session_name,
+        get_last_terminal_session,
+        pin_current_session_name,
+        record_terminal_session,
+    )
+    from code_puppy.messaging import emit_info, emit_success, emit_warning
+    from code_puppy.session_storage import (
+        build_session_paths,
+        load_session,
+        save_session,
+    )
+
+    group_id = str(uuid.uuid4())
+
+    current_agent = get_current_agent()
+    if current_agent.name == agent_name:
+        emit_info(
+            f"Already using agent: {current_agent.display_name}",
+            message_group=group_id,
+        )
+        return True
+
+    # Capture the last saved session before finalize rotates to a fresh empty ID.
+    last_session_to_resume = get_last_terminal_session()
+
+    # Force-save before switching so users without auto-save keep context; resume the
+    # conversation just saved.
+    try:
+        history = current_agent.get_message_history()
+        if history:  # Only save if there's something to save
+            session_name = get_current_session_name()
+            # Record the terminal session mapping before saving
+            record_terminal_session(session_name)
+            # Force-save the session to disk
+            save_session(
+                history=history,
+                session_name=session_name,
+                base_dir=Path(AUTOSAVE_DIR),
+                timestamp=datetime.datetime.now().isoformat(),
+                token_estimator=current_agent.estimate_tokens_for_message,
+                auto_saved=True,
+            )
+            last_session_to_resume = session_name
+    except Exception as e:
+        emit_warning(
+            f"Failed to save session before switching: {e}. "
+            "Your context may not be recoverable.",
+            message_group=group_id,
+        )
+
+    # Finalize current session, switch agent
+    new_session_id = finalize_autosave_session()
+    if not set_current_agent(agent_name):
+        emit_warning(
+            "Agent switch failed after autosave rotation. Your context was preserved.",
+            message_group=group_id,
+        )
+        return True
+
+    new_agent = get_current_agent()
+    new_agent.reload_code_generation_agent()
+
+    # Auto-resume the session captured before finalize rotated/recorded a new id.
+    if last_session_to_resume:
+        try:
+            autosave_dir = Path(AUTOSAVE_DIR).resolve()
+            session_pickle = build_session_paths(
+                autosave_dir, last_session_to_resume
+            ).pickle_path.resolve()
+            if autosave_dir not in session_pickle.parents:
+                raise FileNotFoundError(session_pickle)
+            history = load_session(last_session_to_resume, autosave_dir)
+            new_agent.set_message_history(history)
+            pin_current_session_name(last_session_to_resume)
+            record_terminal_session(last_session_to_resume)
+            total_tokens = sum(
+                new_agent.estimate_tokens_for_message(m) for m in history
+            )
+            emit_success(
+                Text.from_markup(
+                    f"Switched to [bold]{new_agent.display_name}[/bold] "
+                    f"and resumed last session "
+                    f"([dim]{len(history)} messages, {total_tokens} tokens[/dim])"
+                ),
+                message_group=group_id,
+            )
+            emit_info(f"{new_agent.description}", message_group=group_id)
+            emit_info(
+                Text.from_markup(
+                    f"[dim]Auto-save session: {last_session_to_resume}[/dim]"
+                ),
+                message_group=group_id,
+            )
+            # Show resumed history summary
+            try:
+                from code_puppy.command_line.autosave_menu import (
+                    display_resumed_history,
+                )
+
+                display_resumed_history(history)
+            except Exception:
+                pass
+        except Exception:
+            # Session file gone or any other load error — clean switch, don't crash
+            emit_success(
+                f"Switched to agent: {new_agent.display_name}",
+                message_group=group_id,
+            )
+            emit_info(f"{new_agent.description}", message_group=group_id)
+    else:
+        # No previous session for this terminal — fresh start
+        emit_success(
+            f"Switched to agent: {new_agent.display_name}",
+            message_group=group_id,
+        )
+        emit_info(f"{new_agent.description}", message_group=group_id)
+        emit_info(
+            Text.from_markup(
+                f"[dim]Auto-save session rotated to: {new_session_id}[/dim]"
+            ),
+            message_group=group_id,
+        )
+
+    return True
+
+
+def _handle_switch_agent(command: str, name: str) -> object:
+    """Handle /switch-agent and /sa commands."""
+    if name not in ("switch-agent", "sa"):
+        return None  # Not our command
+
+    from code_puppy.agents import get_available_agents
+    from code_puppy.command_line.agent_menu import interactive_agent_picker
+
+    tokens = command.split()
+
+    # No arg OR unrecognized agent name → interactive picker (same as /agent)
+    if len(tokens) == 1:
+        agent_name = None
+    else:
+        candidate = tokens[1].lower()
+        available = get_available_agents()
+        agent_name = candidate if candidate in available else None
+
+    if agent_name is None:
+        # Show interactive picker
+        import asyncio
+        import concurrent.futures
+
+        try:
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(
+                    lambda: asyncio.run(interactive_agent_picker())
+                )
+                agent_name = future.result(timeout=300)
+        except Exception:
+            agent_name = None
+
+        # Apply picker-deferred pin reloads on the main loop; worker-thread reloads
+        # can deadlock MCP autostart during loop shutdown.
+        try:
+            from code_puppy.command_line.agent_menu import (
+                apply_pending_pin_reload,
+                consume_pending_pin_reloads,
+            )
+
+            for pin_agent, pin_model in consume_pending_pin_reloads():
+                apply_pending_pin_reload(pin_agent, pin_model)
+        except Exception:
+            pass
+
+        if not agent_name:
+            from code_puppy.messaging import emit_warning
+
+            emit_warning("Agent selection cancelled")
+            return True
+
+    return _do_switch_and_resume(agent_name)
+
+
+def _handle_help() -> list:
+    return [
+        (
+            "switch-agent",
+            "Switch agent + auto-resume last terminal session (alias: /sa)",
+        ),
+    ]
+
+
+def _cleanup_orphaned_tty_sessions() -> None:
+    """Clean up orphaned TTY session files on startup.
+
+    Removes session files for:
+    1. TTY devices that no longer exist (terminal closed)
+    2. Files older than 7 days (stale sessions)
+
+    Never crashes — all errors are silently caught.
+    """
+    from code_puppy.config import CACHE_DIR, get_terminal_tty
+
+    try:
+        # Skip cleanup if no TTY available
+        current_tty = get_terminal_tty()
+        if not current_tty:
+            return
+
+        # Get the tty_sessions directory
+        tty_sessions_dir = Path(CACHE_DIR) / "tty_sessions"
+        if not tty_sessions_dir.exists():
+            return
+
+        # Build current terminal's filename to skip it
+        current_tty_key = current_tty.replace("/", "_").lstrip("_")
+        current_filename = f"{current_tty_key}.txt"
+
+        # Calculate cutoff time (7 days ago)
+        cutoff_time = datetime.datetime.now() - datetime.timedelta(days=7)
+
+        # Iterate through all .txt files in tty_sessions directory
+        for session_file in tty_sessions_dir.glob("*.txt"):
+            try:
+                # Skip current terminal's file
+                if session_file.name == current_filename:
+                    continue
+
+                # Rebuild the TTY path from the session filename (e.g. dev_ttys057 ->
+                # /dev/ttys057).
+                tty_key = session_file.stem  # Remove .txt extension
+                tty_path = "/" + tty_key.replace("_", "/")
+
+                # Delete if TTY device no longer exists
+                if not os.path.exists(tty_path):
+                    session_file.unlink()
+                    continue
+
+                # Delete if file is older than 7 days
+                file_mtime = datetime.datetime.fromtimestamp(
+                    session_file.stat().st_mtime
+                )
+                if file_mtime < cutoff_time:
+                    session_file.unlink()
+
+            except Exception:
+                # Skip this file on any error, never crash
+                continue
+
+    except Exception:
+        # Never crash the app over cleanup
+        pass
+
+
+async def _cleanup_orphaned_tty_sessions_async() -> None:
+    """Non-blocking wrapper for TTY session cleanup on startup.
+
+    Fires off the cleanup task in a background thread and immediately returns,
+    ensuring zero impact on Code Puppy launch time.
+    """
+    import asyncio
+
+    # Fire-and-forget: run cleanup in background thread without blocking startup
+    asyncio.create_task(asyncio.to_thread(_cleanup_orphaned_tty_sessions))
+
+
+def _has_user_override() -> bool:
+    """Return True if a user-level switch_agent_resume plugin exists.
+
+    Built-in plugins load before user plugins. The callback wrapper below
+    returns ``None`` when a user plugin exists so user code can take ownership
+    of /switch-agent and /sa without racing the built-in handler.
+    """
+    user_plugin_file = (
+        Path.home()
+        / ".code_puppy"
+        / "plugins"
+        / "switch_agent_resume"
+        / "register_callbacks.py"
+    )
+    return user_plugin_file.exists()
+
+
+def _handle_switch_agent_callback(command: str, name: str) -> object:
+    """Callback wrapper that yields ownership to a user override plugin."""
+    if _has_user_override():
+        return None
+    return _handle_switch_agent(command, name)
+
+
+register_callback("startup", _cleanup_orphaned_tty_sessions_async)
+register_callback("custom_command", _handle_switch_agent_callback)
+register_callback("custom_command_help", _handle_help)

code_puppy_core_plugins/theme/README.md

@@ -0,0 +1,86 @@
+# theme — `/theme` for Code Puppy
+
+A friendlier `/theme` command with an **interactive picker**, **live preview**,
+and **four layers of theming** — banner headers, body text, inline markup,
+AND the whole terminal window background/foreground/ANSI palette via OSC
+escape sequences (mure-style).
+
+## What you get
+
+```
+/theme
+```
+Launches a paginated split-panel TUI with 16 themes (7 neon/dark themes, 7 palette-first/light themes, surprise, reset). Five themes are shown per page; use Up/Down for item navigation and PgUp/PgDn to change pages.
+
+
+## What gets themed
+
+| Level | Surface | Themed? |
+|-------|---------|---------|
+| 0 | Banner headers (`[ THINKING ]`, etc.) | ✅ |
+| 1 | Body text (`emit_info`/`warning`/`success`/`error`/`debug` + diffs) | ✅ |
+| 2 | Inline Rich markup (`[bold cyan]`, `[dim cyan]`, `[magenta]`...) | ✅ |
+| 3 | **Entire terminal window** (bg/fg/16-color ANSI palette via OSC 10/11/4) | ✅ |
+
+**Semantic colors are preserved** at Level 2 (red errors stay angry, yellow warnings warn). Level 3 OSC remap is broader — it changes how *your terminal itself* interprets every ANSI color, so e.g. an `ls` ran after `/theme tokyo-night` will also look Tokyo Night. Pure terminal-level magic.
+
+Tokyo Night is applied by default on first run. Themes persist to your Code Puppy config and survive restarts; existing or explicitly restored choices are never overwritten by the default. The OSC palette auto-resets on Code Puppy exit (via `atexit`) so you never get a stuck-pink terminal.
+
+## Bundled themes
+
+| # | Theme | Vibe |
+|---|-------|------|
+| 1 | 🌊 Ocean | cool blues, cyans & teals |
+| 2 | 🌲 Forest | earthy greens & olives |
+| 3 | 🌅 Sunset | warm reds, oranges & gold |
+| 4 | 🪩 Vaporwave | neon pinks & purples |
+| 5 | 🫧 Bubblegum Pink | sweet pinks, candy neon & glow |
+| 6 | 🐶 Purple Puppy | vivid violet fur, white muzzle & pink tongue |
+| 7 | 🐱 Catppuccin Mocha | soothing pastel dark (mure default) |
+| 8 | ☕ Catppuccin Latte | soothing pastel light |
+| 9 | 🌃 Tokyo Night | neon-on-navy night |
+| 10 | [CRT] Green Screen | llxprt's radioactive green phosphor CRT |
+| 11 |  Deep Black | inky noir with subtle neon edge |
+| 12 |  Solarized Light | classic warm beige with calm accents |
+| 13 |  GitHub Light | crisp white, familiar code colors |
+| 14 |  Rose Pine Dawn | soft pastel rose light |
+| 15 |  Surprise Me | a fresh random remix every time |
+| 16 |  Restore Defaults | back to Code Puppy + terminal factory |
+
+Green Screen ports the canonical phosphor colors from [vybestack/llxprt-code](https://github.com/vybestack/llxprt-code), whose theme is licensed under Apache-2.0.
+
+## Power-user shortcuts
+
+```
+/theme 5            apply theme #5 (Bubblegum Pink)
+/theme bubblegum    apply by alias (also: pink, puppy, purple, mocha,
+                    latte, tokyo, green, crt, solarized, github, rose-pine)
+/theme tokyo-night  apply by canonical name
+/theme surprise     re-roll a random palette
+/theme default      restore Code Puppy + terminal factory colors
+/theme reset        alias of /theme default
+/theme show         dump current banner + content style mappings
+```
+
+## Architecture (Zen-compliant, one job per file)
+
+| File | Responsibility |
+|------|----------------|
+| `themes.py` | Theme catalog + banner/content/remap/palette construction |
+| `bundled_palettes.py` | Hex palette data (Catppuccin, Tokyo Night, Deep Black, +5 originals) |
+| `content_styles.py` | Mutates `RichConsoleRenderer` style maps (Level 1) |
+| `rich_themes.py` | Monkey-patches `Console.get_style()` for inline remap (Level 2) |
+| `osc_palette.py` | OSC escape sequences for terminal-wide bg/fg/ANSI palette (Level 3) |
+| `picker.py` | prompt_toolkit split-panel TUI with live preview |
+| `register_callbacks.py` | `/theme` command handler, glue only |
+| `__init__.py` | Re-applies persisted (L1 + L2 + L3) on plugin load |
+
+## How each level works (the spicy bits)
+
+**Level 1** — mutates `code_puppy.messaging.rich_renderer.DEFAULT_STYLES` and walks live `RichConsoleRenderer._styles` via `gc.get_objects()`.
+
+**Level 2** — Rich's stock `Theme` only intercepts named styles, not base colors inside `[bold cyan]`. So we monkey-patch `Console.get_style()` on every live `Console`: every resolved `Style` flows throughd if `.color`/`.bgcolor` matches our remap, we swap. Tracked in a `WeakKeyDictionary` for clean swap-without-leak.
+
+**Level 3** — fires xterm OSC sequences (`\\033]10;#fg\\007`, `\\033]11;#bg\\007`, `\\033]4;N;#hex\\007`) which modern terminals honor terminal-wide. Auto-resets on exit via `atexit`. Persists across restarts via JSON in `puppy.cfg`. Supported in iTerm2, Terminal.app, Alacritty, kitty, ode, GNOME Terminal, Windows Terminal. Unsupported terminals silently ignore.
+
+Plays nice with `/colors` — same color pool, same config keys for banners.

code_puppy_core_plugins/theme/__init__.py

@@ -0,0 +1,14 @@
+"""Theme picker plugin for Code Puppy - banner + content + inline + terminal theming."""
+
+# Reapply persisted overrides at load: banner colors persist in puppy.cfg, while
+# content styles, Rich remaps, and OSC palettes reset each process.
+from . import content_styles as _cs
+from . import osc_palette as _osc
+from . import rich_themes as _rt
+
+for _mod in (_cs, _rt, _osc):
+    try:
+        _mod.reapply_from_config()
+    except Exception:
+        # Never let theme persistence break Code Puppy startup.
+        pass