| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184 |
- """Ctrl+S prompt stash — pure state machine for the classic CLI composer.
- No prompt_toolkit imports so it can be unit tested directly; ``cli.py`` owns only the keybinding
- and the rendering. Newest-first: index 0 is always the most recently stashed draft, so "undo my
- last Ctrl+S" is a single keystroke.
- """
- from __future__ import annotations
- import time
- from dataclasses import dataclass, field
- from typing import Any, List, Optional, Sequence, Tuple
- # Single-line preview length for the browse panel.
- PREVIEW_WIDTH = 60
- # Cap the stack so a user leaning on Ctrl+S can't grow it without bound.
- MAX_STASH_ITEMS = 20
- def build_preview(text: str, width: int = PREVIEW_WIDTH) -> str:
- """Collapse a possibly multi-line draft into one preview line."""
- if not text:
- return ""
- flat = text.replace("\r\n", "\n").replace("\r", "\n")
- flat = flat.replace("\n", " ⏎ ").replace("\t", " ")
- flat = " ".join(flat.split())
- if width > 1 and len(flat) > width:
- return flat[: width - 1] + "…"
- return flat
- @dataclass
- class StashEntry:
- """One parked draft: exact text plus any images that were attached."""
- text: str
- images: list[Any] = field(default_factory=list)
- stashed_at: float = 0.0
- preview: str = ""
- def as_dict(self) -> dict:
- """Shape ``HermesCLI._render_stash_panel`` consumes."""
- return {"text": self.text, "images": list(self.images), "stashed_at": self.stashed_at, "preview": self.preview}
- class PromptStash:
- """Session-scoped stack of parked composer drafts."""
- def __init__(self, *, max_items: int = MAX_STASH_ITEMS, clock=None):
- self._items: list[StashEntry] = []
- self._max_items = max(1, int(max_items))
- self._clock = clock or time.monotonic
- self.panel_open = False
- self.panel_cursor = 0
- def __len__(self) -> int:
- return len(self._items)
- @property
- def items(self) -> list[StashEntry]:
- """Newest-first list of entries (a copy — mutate via the API)."""
- return list(self._items)
- def panel_rows(self) -> list[dict]:
- return [e.as_dict() for e in self._items]
- def indicator(self) -> str:
- """Status-bar indicator: ``📌 2`` idle, ``📌 2 ▲`` while browsing, ``""`` when empty."""
- n = len(self._items)
- return "" if not n else f"📌 {n} ▲" if self.panel_open else f"📌 {n}"
- def placeholder_hint(self) -> str:
- """Composer placeholder text advertising the stashed draft."""
- n = len(self._items)
- if n == 1:
- return f"Ctrl+S to restore: {self._items[0].preview}"
- return f"Ctrl+S to browse {n} stashed drafts" if n else ""
- def stash(self, text: str, images: Optional[Sequence[Any]] = None) -> bool:
- """Push a draft. A blank buffer with no images is a no-op (returns False) so Ctrl+S on an
- empty composer triggers the restore half of the gesture instead of pushing junk.
- """
- if not (text or "").strip() and not images:
- return False
- entry = StashEntry(text=text or "", images=list(images or []), stashed_at=self._clock(),
- preview=build_preview(text or "") or "(images only)")
- self._items.insert(0, entry)
- del self._items[self._max_items:] # drop the oldest past the cap
- self.close_panel() # a push invalidates any open browse session
- return True
- def pop(self, index: int = 0) -> Optional[tuple[str, list[Any]]]:
- """Remove and return ``(text, images)`` at ``index``, or None."""
- if not 0 <= index < len(self._items):
- return None
- entry = self._items.pop(index)
- if not self._items:
- self.panel_open = False
- self.panel_cursor = self._clamp_cursor(self.panel_cursor)
- return entry.text, list(entry.images)
- def peek(self, index: int = 0) -> Optional[StashEntry]:
- return self._items[index] if 0 <= index < len(self._items) else None
- def clear(self) -> None:
- self._items.clear()
- self.close_panel()
- # ------------------------------------------------------------ panel state
- def _clamp_cursor(self, value: int) -> int:
- return max(0, min(int(value), len(self._items) - 1)) if self._items else 0
- def open_panel(self) -> bool:
- """Open the browse panel. False when there is nothing to browse."""
- if not self._items:
- return False
- self.panel_open = True
- self.panel_cursor = 0
- return True
- def close_panel(self) -> None:
- self.panel_open = False
- self.panel_cursor = 0
- def move_cursor(self, delta: int) -> int:
- """Move the panel cursor, clamped to the list bounds."""
- self.panel_cursor = self._clamp_cursor(self.panel_cursor + int(delta))
- return self.panel_cursor
- def delete_at_cursor(self) -> bool:
- """Delete the highlighted entry. False when there was nothing to drop."""
- if not self._items:
- return False
- idx = self._clamp_cursor(self.panel_cursor)
- self._items.pop(idx)
- if not self._items:
- self.close_panel()
- else:
- self.panel_cursor = self._clamp_cursor(idx)
- return True
- def restore_at_cursor(self) -> Optional[tuple[str, list[Any]]]:
- """Pop the highlighted entry and close the panel."""
- if not self._items:
- return None
- result = self.pop(self._clamp_cursor(self.panel_cursor))
- self.close_panel()
- return result
- # Outcomes of a single Ctrl+S press.
- ACTION_NOOP = "noop"
- ACTION_STASHED = "stashed"
- ACTION_RESTORED = "restored"
- ACTION_OPEN_PANEL = "open_panel"
- ACTION_CLOSE_PANEL = "close_panel"
- def resolve_ctrl_s(
- stash: PromptStash, buffer_text: str, images: Optional[Sequence[Any]] = None
- ) -> tuple[str, Optional[tuple[str, list[Any]]]]:
- """Decide what one Ctrl+S press does. Returns ``(action, payload)`` where ``payload`` is
- ``(text, images)`` for :data:`ACTION_RESTORED`, else None.
- """
- # Panel open → Ctrl+S is the "close it" escape hatch.
- if stash.panel_open:
- stash.close_panel()
- return ACTION_CLOSE_PANEL, None
- # Something to park → park it (onto a stack, so an earlier draft is still reachable).
- if (buffer_text or "").strip() or images:
- return (ACTION_STASHED if stash.stash(buffer_text, images) else ACTION_NOOP), None
- # Empty buffer → restore half of the gesture.
- count = len(stash)
- if count == 0:
- return ACTION_NOOP, None
- if count == 1:
- return ACTION_RESTORED, stash.pop(0)
- stash.open_panel()
- return ACTION_OPEN_PANEL, None
|