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

code_puppy_core_plugins/statusline/statusline_command.py

@@ -0,0 +1,197 @@
+"""`/statusline` command — scaffold, enable, inspect the status line.
+
+Mirrors Claude Code's ``/statusline``. Rather than calling the model, this
+scaffolds a ready-to-edit starter script (Claude Code generates one via the
+agent; we hand you a working template you can tweak immediately).
+
+Subcommands:
+    /statusline                 Show current status + quick help
+    /statusline init            Write a starter ~/.code_puppy/statusline.sh,
+                                point config at it, and enable
+    /statusline on | off        Enable / disable rendering
+    /statusline show            Run the command once and preview its output
+    /statusline json            Print the JSON payload your script receives
+"""
+
+from __future__ import annotations
+
+import stat
+import subprocess as _sp
+import sys
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+
+from code_puppy.messaging import emit_info, emit_success, emit_warning
+
+from . import config, payload, runner
+
+_COMMAND_NAME = "statusline"
+
+# PowerShell equivalent for Windows — no bash, no jq required.
+_STARTER_SCRIPT_PS1 = """\
+# Code Puppy status line — PowerShell version.
+# Receives session JSON on stdin; prints one line to stdout.
+# Edit freely. Requires PowerShell 5+ (ships with Windows 10+).
+$input_text = $input | Out-String
+try {
+    $data = $input_text | ConvertFrom-Json
+} catch {
+    $data = [PSCustomObject]@{}
+}
+$puppy  = if ($data.puppy_name)                    { $data.puppy_name }                    else { "code-puppy" }
+$model  = if ($data.model.display_name)            { $data.model.display_name }            else { "model" }
+$dir    = if ($data.workspace.current_dir)         { $data.workspace.current_dir }         elseif ($data.cwd) { $data.cwd } else { "" }
+$branch = if ($data.workspace.git_branch)          { " ($($data.workspace.git_branch))" }  else { "" }
+$pct    = if ($null -ne $data.context_window.used_percentage) { $data.context_window.used_percentage } else { 0 }
+$base   = if ($dir) { Split-Path $dir -Leaf } else { "" }
+Write-Output "🐶 $puppy [$model] $base$branch ${pct}%ctx" # stdout, captured by parent process
+"""
+
+_STARTER_SCRIPT = """\
+#!/usr/bin/env bash
+# Code Puppy status line. Receives session JSON on stdin; prints one line.
+# In the default "replace" mode this line REPLACES the default prompt content
+# (so include a name/emoji if you want one). Edit freely.
+# Requires `jq` for the parsing below (or parse however you like).
+input=$(cat)
+
+puppy=$(printf '%s' "$input" | jq -r '.puppy_name // "code-puppy"')
+model=$(printf '%s' "$input" | jq -r '.model.display_name // "model"')
+dir=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // ""')
+branch=$(printf '%s' "$input" | jq -r '.workspace.git_branch // empty')
+ind=$(printf '%s' "$input" | jq -r '.context_window.indicator // ""')
+pct=$(printf '%s' "$input" | jq -r '.context_window.used_percentage // 0')
+tps=$(printf '%s' "$input" | jq -r '.tokens_per_second // 0')
+
+line="\\033[1m🐶 $puppy\\033[0m"
+[ -n "$ind" ] && line="$line $ind"
+line="$line \\033[36m[$model]\\033[0m \\033[2m$(basename "$dir")\\033[0m"
+[ -n "$branch" ] && line="$line \\033[35m($branch)\\033[0m"
+line="$line \\033[33m${pct}%ctx\\033[0m"
+# Show t/s only while generating.
+awk "BEGIN{exit !($tps>0)}" && line="$line \\033[32m${tps} t/s\\033[0m"
+
+printf '%b' "$line"
+"""
+
+
+def statusline_command_help() -> List[Tuple[str, str]]:
+    return [
+        (_COMMAND_NAME, "Customize the bottom status line (init/on/off/show/json)"),
+    ]
+
+
+def _default_script_path() -> Path:
+    if sys.platform == "win32":
+        return Path.home() / ".code_puppy" / "statusline.ps1"
+    return Path.home() / ".code_puppy" / "statusline.sh"
+
+
+def _status_text() -> str:
+    enabled = "ON" if config.is_enabled() else "OFF"
+    cmd = config.get_command() or "(none)"
+    return (
+        f"Status line: {enabled}   mode: {config.get_mode()}\n"
+        f"  command: {cmd}\n"
+        f"  refresh: {config.get_refresh_ms()}ms   timeout: {config.get_timeout_ms()}ms\n"
+        "  Subcommands: init | on | off | mode <replace|above|newline> | show | json"
+    )
+
+
+def _do_init() -> None:
+    path = _default_script_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if sys.platform == "win32":
+        # Windows: write a PowerShell script; invoke via powershell.exe so no
+        # bash/jq dependency and no chmod needed.
+        path.write_text(_STARTER_SCRIPT_PS1, encoding="utf-8")
+        # list2cmdline handles cmd.exe quoting rules for paths with spaces
+        ps1_cmd = _sp.list2cmdline(
+            ["powershell", "-ExecutionPolicy", "Bypass", "-File", str(path)]
+        )
+        config.set_command(ps1_cmd)
+        runner.reset_cache()
+        emit_success(f"Wrote starter status line script: {path}")
+        emit_info(
+            "Enabled. Edit that file to customize. Preview with /statusline show."
+        )
+    else:
+        path.write_text(_STARTER_SCRIPT, encoding="utf-8")
+        path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        config.set_command(str(path))
+        runner.reset_cache()
+        emit_success(f"Wrote starter status line script: {path}")
+        emit_info(
+            "Enabled. Edit that file to customize. Preview with /statusline show."
+        )
+        if not _has_jq():
+            emit_warning(
+                "Note: the starter script uses `jq` (not found on PATH). Install jq "
+                "or rewrite the script to parse JSON another way."
+            )
+    config.set_enabled(True)
+
+
+def _has_jq() -> bool:
+    from shutil import which
+
+    return which("jq") is not None
+
+
+def handle_statusline_command(command: str, name: str) -> Optional[Any]:
+    if name != _COMMAND_NAME:
+        return None
+
+    tokens = command.split()
+    sub = tokens[1].strip().lower() if len(tokens) > 1 else "status"
+
+    if sub in ("status", ""):
+        emit_info(_status_text())
+        return True
+    if sub == "init":
+        _do_init()
+        return True
+    if sub == "on":
+        if not config.get_command():
+            emit_warning(
+                "No command set. Run /statusline init first, or set "
+                "statusline_command via /set."
+            )
+            return True
+        config.set_enabled(True)
+        runner.reset_cache()
+        emit_success("Status line enabled.")
+        return True
+    if sub == "off":
+        config.set_enabled(False)
+        emit_warning("Status line disabled.")
+        return True
+    if sub == "mode":
+        mode = tokens[2].strip().lower() if len(tokens) > 2 else ""
+        if mode not in ("replace", "above", "newline"):
+            emit_warning("Usage: /statusline mode <replace|above|newline>")
+            emit_info(
+                "  replace = your line REPLACES the default prompt (no duplicate)\n"
+                "  above   = your line sits on its own line above the default prompt\n"
+                "  newline = like replace, but >>> drops to its own line below"
+            )
+            return True
+        config.set_mode(mode)
+        emit_success(f"Status line mode set to '{mode}'.")
+        return True
+    if sub == "show":
+        if not config.get_command():
+            emit_warning("No command set. Run /statusline init first.")
+            return True
+        out = runner.run_once_sync()
+        emit_info("Status line preview (raw output):")
+        emit_info(out or "(empty)")
+        return True
+    if sub == "json":
+        emit_info("JSON payload your status command receives on stdin:")
+        emit_info(payload.build_payload_json())
+        return True
+
+    emit_warning(f"Unknown /statusline subcommand: {sub}")
+    emit_info("Use: init | on | off | show | json")
+    return True

code_puppy_core_plugins/steer_queue/__init__.py

@@ -0,0 +1,10 @@
+"""Steer/queue plugin.
+
+Mid-run submissions now QUEUE by default (run as the next turn); this
+plugin provides the escape hatches and the management UI:
+
+* ``/steer <text>`` -- inject guidance mid-turn (the old default).
+* ``/queue`` -- full-screen TUI to view, add, edit, reorder, and delete prompts,
+  available at idle and mid-run alike.
+* ``(N queued)`` -- live count on the bottom bar's status row.
+"""

code_puppy_core_plugins/steer_queue/queue_menu.py

@@ -0,0 +1,444 @@
+"""Full-screen queue manager for ``/queue``.
+
+The application owns presentation state only. Queue mutations continue to flow
+through :class:`PauseController`, keeping listeners and the bottom status bar in
+sync with edits made here.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import List, Optional
+from code_puppy.callbacks import on_prompt_toolkit_style
+
+logger = logging.getLogger(__name__)
+
+_PREVIEW_CELLS = 58
+
+
+def _preview(text: str, width: int = _PREVIEW_CELLS) -> str:
+    """Return a compact single-line preview for a queued prompt."""
+    flat = " ".join(text.split())
+    if len(flat) <= width:
+        return flat
+    return flat[: max(0, width - 1)] + "…"
+
+
+@dataclass
+class QueueMenuState:
+    """Small, testable state adapter around ``PauseController``."""
+
+    controller: object
+    selected: int = 0
+    editing: bool = False
+    adding: bool = False
+    delete_armed: Optional[int] = None
+    notice: str = ""
+
+    @property
+    def items(self) -> List[str]:
+        return self.controller.peek_pending_steer_queued()
+
+    @property
+    def selected_text(self) -> str:
+        items = self.items
+        if not items:
+            return ""
+        self.selected = min(max(self.selected, 0), len(items) - 1)
+        return items[self.selected]
+
+    def clamp_selection(self) -> None:
+        self.selected = min(max(self.selected, 0), max(0, len(self.items) - 1))
+
+    def move_selection(self, delta: int) -> None:
+        if not self.items:
+            self.selected = 0
+            return
+        self.selected = min(max(self.selected + delta, 0), len(self.items) - 1)
+        self.delete_armed = None
+        self.notice = ""
+
+    def begin_add(self) -> None:
+        self.editing = True
+        self.adding = True
+        self.delete_armed = None
+        self.notice = "Adding prompt — Ctrl+S save · Esc cancel"
+
+    def begin_edit(self) -> bool:
+        if not self.items:
+            self.notice = "Queue is empty — press A to add a prompt"
+            return False
+        self.editing = True
+        self.adding = False
+        self.delete_armed = None
+        self.notice = "Editing prompt — Ctrl+S save · Esc cancel"
+        return True
+
+    def cancel_edit(self) -> None:
+        self.editing = False
+        self.adding = False
+        self.notice = "Edit cancelled"
+
+    def save(self, text: str) -> bool:
+        normalized = text.strip()
+        if not normalized:
+            self.notice = "Prompt cannot be blank"
+            return False
+
+        items = self.items
+        if self.adding:
+            self.controller.request_steer(normalized, mode="queue")
+            self.selected = len(items)
+            self.notice = "Prompt added"
+        elif self.selected < len(items):
+            items[self.selected] = normalized
+            self.controller.replace_pending_steer_queued(items)
+            self.notice = "Prompt updated"
+        else:
+            self.notice = "That queue item no longer exists"
+            return False
+
+        self.editing = False
+        self.adding = False
+        self.delete_armed = None
+        self.clamp_selection()
+        return True
+
+    def request_delete(self) -> bool:
+        if not self.items:
+            self.notice = "Queue is already empty"
+            return False
+        if self.delete_armed != self.selected:
+            self.delete_armed = self.selected
+            self.notice = "Press D again to delete this prompt"
+            return False
+
+        items = self.items
+        del items[self.selected]
+        self.controller.replace_pending_steer_queued(items)
+        self.delete_armed = None
+        self.clamp_selection()
+        self.notice = "Prompt deleted"
+        return True
+
+    def reorder(self, delta: int) -> bool:
+        items = self.items
+        destination = self.selected + delta
+        if not items or destination < 0 or destination >= len(items):
+            return False
+        items[self.selected], items[destination] = (
+            items[destination],
+            items[self.selected],
+        )
+        self.controller.replace_pending_steer_queued(items)
+        self.selected = destination
+        self.delete_armed = None
+        self.notice = "Prompt moved"
+        return True
+
+
+class QueueMenuApp:
+    """Persistent full-screen prompt queue manager."""
+
+    def __init__(self, controller):
+        from prompt_toolkit import Application
+        from prompt_toolkit.buffer import Buffer
+        from prompt_toolkit.filters import Condition
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
+        from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+        from prompt_toolkit.layout.dimension import Dimension
+        from prompt_toolkit.layout.processors import BeforeInput
+        from prompt_toolkit.widgets import Frame
+
+        self.state = QueueMenuState(controller)
+        self._list_control = FormattedTextControl(
+            self._render_list, focusable=True, show_cursor=False
+        )
+        self._editor_buffer = Buffer(multiline=True)
+        self._editor_control = BufferControl(
+            buffer=self._editor_buffer,
+            input_processors=[BeforeInput(self._editor_prefix)],
+            focusable=Condition(lambda: self.state.editing),
+        )
+        self._detail_frame = Frame(
+            Window(
+                self._editor_control,
+                wrap_lines=True,
+                always_hide_cursor=Condition(lambda: not self.state.editing),
+            ),
+            title=self._detail_title,
+            style="class:tui.body",
+        )
+
+        body = VSplit(
+            [
+                Frame(
+                    Window(
+                        self._list_control,
+                        wrap_lines=False,
+                        width=Dimension(weight=2),
+                    ),
+                    title="Queued prompts",
+                    style="class:tui.body",
+                ),
+                Window(width=1, char=" "),
+                self._detail_frame,
+            ],
+            padding=0,
+        )
+        root = HSplit(
+            [
+                Window(
+                    FormattedTextControl(self._render_header),
+                    height=2,
+                    style="class:tui.header",
+                ),
+                body,
+                Window(
+                    FormattedTextControl(self._render_notice),
+                    height=1,
+                    style="class:tui.warning",
+                ),
+                Window(
+                    FormattedTextControl(self._render_footer),
+                    height=2,
+                    style="class:tui.help",
+                ),
+            ]
+        )
+
+        self._bindings = KeyBindings()
+        self._register_bindings()
+        self.application = Application(
+            layout=Layout(root, focused_element=self._list_control),
+            key_bindings=self._bindings,
+            full_screen=True,
+            mouse_support=True,
+            style=on_prompt_toolkit_style(),
+        )
+        self._sync_editor()
+
+    def _editor_prefix(self):
+        return [("class:tui.label", "EDIT  " if self.state.editing else "")]
+
+    def _detail_title(self) -> str:
+        if self.state.adding:
+            return "New prompt"
+        if self.state.editing:
+            return f"Edit prompt {self.state.selected + 1}"
+        return "Prompt preview"
+
+    def _render_header(self):
+        count = len(self.state.items)
+        return [
+            ("class:tui.title", "  PROMPT QUEUE\n"),
+            ("class:tui.header", f"  {count} item{'s' if count != 1 else ''} waiting"),
+        ]
+
+    def _render_list(self):
+        items = self.state.items
+        if not items:
+            return [
+                (
+                    "class:tui.muted",
+                    "\n  Queue is empty.\n\n  Press A to add a prompt.",
+                )
+            ]
+        fragments = []
+        for index, text in enumerate(items):
+            style = (
+                "class:tui.selected"
+                if index == self.state.selected
+                else "class:tui.body"
+            )
+            marker = "▶" if index == self.state.selected else " "
+            fragments.extend(
+                [
+                    (style, f" {marker} "),
+                    (f"{style} class:tui.muted", f"{index + 1:>2}  "),
+                    (style, _preview(text)),
+                    (style, "\n"),
+                ]
+            )
+        return fragments
+
+    def _render_notice(self):
+        return [("class:tui.warning", f"  {self.state.notice}")]
+
+    def _render_footer(self):
+        if self.state.editing:
+            return [
+                ("class:tui.help", "  "),
+                ("class:tui.help-key", "Ctrl+S"),
+                ("class:tui.help", " save   "),
+                ("class:tui.help-key", "Esc"),
+                ("class:tui.help", " cancel   Multi-line editing enabled"),
+            ]
+        return [
+            ("class:tui.help", "  "),
+            ("class:tui.help-key", "↑↓/JK"),
+            ("class:tui.help", " select   "),
+            ("class:tui.help-key", "Enter/E"),
+            ("class:tui.help", " edit   "),
+            ("class:tui.help-key", "A"),
+            ("class:tui.help", " add   "),
+            ("class:tui.help-key", "D D"),
+            ("class:tui.help", " delete\n  "),
+            ("class:tui.help-key", "[ ]"),
+            ("class:tui.help", " reorder   "),
+            ("class:tui.help-key", "Q/Esc"),
+            ("class:tui.help", " done"),
+        ]
+
+    def _sync_editor(self, text: Optional[str] = None) -> None:
+        value = self.state.selected_text if text is None else text
+        self._editor_buffer.set_document(
+            self._editor_buffer.document.__class__(value, cursor_position=len(value)),
+            bypass_readonly=True,
+        )
+
+    def _refresh(self) -> None:
+        self.application.invalidate()
+
+    def _focus_list(self) -> None:
+        self.application.layout.focus(self._list_control)
+
+    def _begin_add(self) -> None:
+        self.state.begin_add()
+        self._sync_editor("")
+        self.application.layout.focus(self._editor_control)
+
+    def _begin_edit(self) -> None:
+        if self.state.begin_edit():
+            self._sync_editor()
+            self.application.layout.focus(self._editor_control)
+
+    def _cancel_edit(self) -> None:
+        self.state.cancel_edit()
+        self._sync_editor()
+        self._focus_list()
+
+    def _save_edit(self) -> None:
+        if self.state.save(self._editor_buffer.text):
+            self._sync_editor()
+            self._focus_list()
+
+    def _move_selection(self, delta: int) -> None:
+        self.state.move_selection(delta)
+        self._sync_editor()
+
+    def _register_bindings(self) -> None:
+        kb = self._bindings
+
+        @kb.add("up")
+        @kb.add("k")
+        def _up(event):
+            if not self.state.editing:
+                self._move_selection(-1)
+
+        @kb.add("down")
+        @kb.add("j")
+        def _down(event):
+            if not self.state.editing:
+                self._move_selection(1)
+
+        @kb.add("home")
+        def _home(event):
+            if not self.state.editing:
+                self.state.selected = 0
+                self._sync_editor()
+
+        @kb.add("end")
+        def _end(event):
+            if not self.state.editing and self.state.items:
+                self.state.selected = len(self.state.items) - 1
+                self._sync_editor()
+
+        @kb.add("a")
+        def _add(event):
+            if not self.state.editing:
+                self._begin_add()
+
+        @kb.add("e")
+        @kb.add("enter")
+        def _edit(event):
+            if not self.state.editing:
+                self._begin_edit()
+            else:
+                self._editor_buffer.insert_text("\n")
+
+        @kb.add("d")
+        def _delete(event):
+            if not self.state.editing:
+                deleted = self.state.request_delete()
+                if deleted:
+                    self._sync_editor()
+                self._refresh()
+
+        @kb.add("[")
+        def _move_up(event):
+            if not self.state.editing and self.state.reorder(-1):
+                self._sync_editor()
+
+        @kb.add("]")
+        def _move_down(event):
+            if not self.state.editing and self.state.reorder(1):
+                self._sync_editor()
+
+        @kb.add("c-s")
+        def _save(event):
+            if self.state.editing:
+                self._save_edit()
+
+        @kb.add("escape")
+        def _escape(event):
+            if self.state.editing:
+                self._cancel_edit()
+            else:
+                event.app.exit()
+
+        @kb.add("q")
+        def _quit(event):
+            if not self.state.editing:
+                event.app.exit()
+
+        @kb.add("c-c")
+        def _ctrl_c(event):
+            if self.state.editing:
+                self._cancel_edit()
+            else:
+                event.app.exit()
+
+    async def run(self) -> None:
+        await self.application.run_async()
+
+
+async def run_queue_menu() -> None:
+    """Run the full-screen queue manager."""
+    from code_puppy.messaging.pause_controller import get_pause_controller
+
+    await QueueMenuApp(get_pause_controller()).run()
+
+
+def open_queue_menu_blocking(timeout_s: float = 600.0) -> None:
+    """Run the menu on a worker thread with an isolated event loop."""
+    import asyncio
+    import concurrent.futures
+
+    try:
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            executor.submit(lambda: asyncio.run(run_queue_menu())).result(
+                timeout=timeout_s
+            )
+    except Exception:
+        logger.debug("queue menu failed", exc_info=True)
+
+
+__all__ = [
+    "QueueMenuApp",
+    "QueueMenuState",
+    "open_queue_menu_blocking",
+    "run_queue_menu",
+]