sessions_cmd_browse.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. """Interactive picker for ``hermes sessions browse``: curses UI with live search filtering and ``d``
  2. delete-with-confirmation; numbered-list fallback when curses is unavailable (Windows, etc.)."""
  3. from typing import Optional
  4. from hermes_cli.timefmt import relative_time as _relative_time
  5. from hermes_state_errors import SessionActiveWriteGuardError
  6. def _session_status_tag(status: Optional[str]) -> str:
  7. """Short fixed-width tag for a session lifecycle status."""
  8. return {"complete": "done", "interrupted": "intr", "error": "err", "empty": "empty"}.get(status or "", "-")
  9. def _annotate_session_statuses(sessions: list, session_db) -> None:
  10. """Attach ``_status`` per row via one indexed lookup (never a transcript scan); on failure rows render '-'."""
  11. if session_db is None or not sessions:
  12. return
  13. try:
  14. statuses = session_db.session_lifecycle_statuses([s.get("id") for s in sessions])
  15. except Exception:
  16. return
  17. for s in sessions:
  18. s["_status"] = statuses.get(s.get("id"), "")
  19. def _label(s: dict) -> str:
  20. """Title, else preview, else id."""
  21. return (s.get("title") or "").strip() or (s.get("preview") or "").strip() or s["id"]
  22. def _clip(text: str, n: int) -> str:
  23. return text if len(text) <= n else text[: n - 3] + "..."
  24. def _msgs_str(s: dict) -> str:
  25. msgs = s.get("message_count")
  26. return str(msgs) if isinstance(msgs, int) else "-"
  27. def _match(s: dict, query: str) -> bool:
  28. """Case-insensitive substring match over title / preview / id / source."""
  29. q = query.lower()
  30. return (
  31. q in (s.get("title") or "").lower()
  32. or q in (s.get("preview") or "").lower()
  33. or q in s.get("id", "").lower()
  34. or q in (s.get("source") or "").lower()
  35. )
  36. # Layout: [arrow 3] [title/preview flexible] [status 5] [msgs 5] [active 12] [src 6] [id 18]
  37. _FIXED_COLS = 3 + 5 + 2 + 5 + 2 + 12 + 6 + 18 + 6
  38. def _format_row(s: dict, max_x: int) -> str:
  39. name_width = max(20, max_x - _FIXED_COLS)
  40. sid = s["id"][:18]
  41. name = ((s.get("title") or "").strip() or (s.get("preview") or "").strip())[:name_width] or sid
  42. return (
  43. f"{name:<{name_width}} {_session_status_tag(s.get('_status')):<5} "
  44. f"{_msgs_str(s):>5} {_relative_time(s.get('last_active'), session_id=s['id']):<10} "
  45. f"{s.get('source', '')[:6]:<5} {sid}"
  46. )
  47. class _CursesBrowser:
  48. """State + render loop for the curses picker. ``run`` is the wrapper target."""
  49. def __init__(self, curses, sessions, delete_fn):
  50. self.curses, self.sessions, self.delete_fn = curses, sessions, delete_fn # delete_fn None => no delete
  51. self.result = None
  52. self.cursor = self.scroll = 0
  53. self.search = ""
  54. self.confirm_delete = None # session dict pending y/n confirmation
  55. self.flash = "" # one-frame notice (e.g. "Deleted.")
  56. self.filtered = list(sessions)
  57. def _pair(self, n, fallback=0):
  58. return self.curses.color_pair(n) if self.curses.has_colors() else fallback
  59. def _status_attr(self, status):
  60. pair = {"complete": 1, "interrupted": 2, "error": 5, "empty": 4}.get(status or "")
  61. return self._pair(pair, self.curses.A_NORMAL) if pair else self.curses.A_NORMAL
  62. def _put(self, stdscr, y, x, text, n, attr):
  63. try:
  64. stdscr.addnstr(y, x, text, n, attr)
  65. except self.curses.error:
  66. pass
  67. def _refilter(self, reset_cursor=True):
  68. self.filtered = [s for s in self.sessions if _match(s, self.search)] if self.search else list(self.sessions)
  69. if reset_cursor:
  70. self.cursor = self.scroll = 0
  71. def _draw(self, stdscr, max_y, max_x):
  72. c = self.curses
  73. if self.search:
  74. header, header_attr = f" Browse sessions — filter: {self.search}█", c.A_BOLD | self._pair(3)
  75. else:
  76. header = " Browse sessions — ↑↓ navigate Enter select Type to filter Esc quit"
  77. header_attr = c.A_BOLD | self._pair(2)
  78. self._put(stdscr, 0, 0, header, max_x - 1, header_attr)
  79. name_width = max(20, max_x - _FIXED_COLS)
  80. col_header = (
  81. f" {'Title / Preview':<{name_width}} {'Stat':<5} {'Msgs':>5} {'Active':<10} {'Src':<5} {'ID'}"
  82. )
  83. self._put(stdscr, 1, 0, col_header, max_x - 1, self._pair(4, c.A_DIM))
  84. visible_rows = max(max_y - 4, 1) # header + col header + blank + footer
  85. filtered = self.filtered
  86. if not filtered:
  87. self._put(stdscr, 3, 0, " No sessions match the filter.", max_x - 1, c.A_DIM)
  88. else:
  89. self.cursor = max(min(self.cursor, len(filtered) - 1), 0)
  90. if self.cursor < self.scroll:
  91. self.scroll = self.cursor
  92. elif self.cursor >= self.scroll + visible_rows:
  93. self.scroll = self.cursor - visible_rows + 1
  94. tag_x = 3 + max(20, (max_x - 3) - _FIXED_COLS) + 2
  95. for draw_i, i in enumerate(range(self.scroll, min(len(filtered), self.scroll + visible_rows))):
  96. y = draw_i + 3
  97. if y >= max_y - 1:
  98. break
  99. s, selected = filtered[i], i == self.cursor
  100. row = (" → " if selected else " ") + _format_row(s, max_x - 3)
  101. try:
  102. stdscr.addnstr(y, 0, row, max_x - 1, c.A_BOLD | self._pair(1) if selected else c.A_NORMAL)
  103. if not selected and tag_x + 5 < max_x - 1: # recolor the status tag in place
  104. status = s.get("_status")
  105. stdscr.addnstr(y, tag_x, f"{_session_status_tag(status):<5}", 5, self._status_attr(status))
  106. except c.error:
  107. pass
  108. footer_attr = self._pair(4, c.A_DIM)
  109. if self.confirm_delete is not None:
  110. footer = f" Delete session '{_clip(_label(self.confirm_delete), 40)}'? [y/N]"
  111. footer_attr = c.A_BOLD | self._pair(5)
  112. elif self.flash:
  113. footer = f" {self.flash}"
  114. self.flash = ""
  115. else:
  116. footer = f" {self.cursor + 1 if filtered else 0}/{len(filtered) or len(self.sessions)} sessions"
  117. if filtered and len(filtered) < len(self.sessions):
  118. footer += f" (filtered from {len(self.sessions)})"
  119. if self.delete_fn is not None and not self.search:
  120. footer += " d delete"
  121. self._put(stdscr, max_y - 1, 0, footer, max_x - 1, footer_attr)
  122. def _handle_key(self, key) -> bool:
  123. """Apply one keypress; return True when the picker should exit."""
  124. c = self.curses
  125. if self.confirm_delete is not None: # y/n confirmation mode — only an explicit 'y' deletes
  126. target, self.confirm_delete = self.confirm_delete, None
  127. if key not in {ord("y"), ord("Y")}:
  128. return False
  129. try:
  130. ok = self.delete_fn(target["id"])
  131. except SessionActiveWriteGuardError:
  132. self.flash = "Session is active (a live turn owns it); try again when it finishes."
  133. return False
  134. if not ok:
  135. self.flash = "Delete failed."
  136. return False
  137. self.sessions[:] = [s for s in self.sessions if s["id"] != target["id"]]
  138. self._refilter(reset_cursor=False)
  139. self.flash = "Deleted."
  140. return not self.sessions
  141. if key in (c.KEY_UP, c.KEY_DOWN):
  142. if self.filtered:
  143. self.cursor = (self.cursor + (1 if key == c.KEY_DOWN else -1)) % len(self.filtered)
  144. elif key in {c.KEY_ENTER, 10, 13}:
  145. if self.filtered:
  146. self.result = self.filtered[self.cursor]["id"]
  147. return True
  148. elif key == 27 and not self.search: # Esc: first clears the search, second exits
  149. return True
  150. elif key == 27:
  151. self.search = ""
  152. self._refilter()
  153. elif key in {c.KEY_BACKSPACE, 127, 8}:
  154. if self.search:
  155. self.search = self.search[:-1]
  156. self._refilter()
  157. elif key == ord("q") and not self.search:
  158. return True
  159. elif key == ord("d") and not self.search and self.delete_fn is not None and self.filtered:
  160. # 'd' deletes only when the filter is empty; mid-search it types into the query.
  161. self.confirm_delete = self.filtered[self.cursor]
  162. elif 32 <= key <= 126:
  163. self.search += chr(key)
  164. self._refilter()
  165. return False
  166. def run(self, stdscr):
  167. c = self.curses
  168. c.curs_set(0)
  169. if c.has_colors():
  170. c.start_color()
  171. c.use_default_colors()
  172. # 1 selected, 2 header, 3 search, 4 dim, 5 error/delete
  173. palette = (c.COLOR_GREEN, c.COLOR_YELLOW, c.COLOR_CYAN, 8 if c.COLORS > 8 else c.COLOR_WHITE, c.COLOR_RED)
  174. for n, color in enumerate(palette, 1):
  175. c.init_pair(n, color, -1)
  176. while True:
  177. stdscr.clear()
  178. max_y, max_x = stdscr.getmaxyx()
  179. if max_y < 5 or max_x < 40:
  180. try:
  181. stdscr.addstr(0, 0, "Terminal too small")
  182. except c.error:
  183. pass
  184. stdscr.refresh()
  185. stdscr.getch()
  186. return
  187. self._draw(stdscr, max_y, max_x)
  188. stdscr.refresh()
  189. if self._handle_key(stdscr.getch()):
  190. return
  191. def _fallback_picker(sessions: list) -> Optional[str]:
  192. """Numbered list (Windows without curses, etc.). Same columns, no delete."""
  193. print("\n Browse sessions (enter number to resume, q to cancel)\n")
  194. for i, s in enumerate(sessions):
  195. print(
  196. f" {i + 1:>3}. {_clip(_label(s), 50):<50} {_session_status_tag(s.get('_status')):<5} "
  197. f"{_msgs_str(s):>5} {_relative_time(s.get('last_active'), session_id=s['id']):<10} {s.get('source', '')[:6]}"
  198. )
  199. while True:
  200. try:
  201. val = input(f"\n Select [1-{len(sessions)}]: ").strip()
  202. if not val or val.lower() in {"q", "quit", "exit"}:
  203. return None
  204. idx = int(val) - 1
  205. if 0 <= idx < len(sessions):
  206. return sessions[idx]["id"]
  207. print(f" Invalid selection. Enter 1-{len(sessions)} or q to cancel.")
  208. except ValueError:
  209. print(" Invalid input. Enter a number or q to cancel.")
  210. except (KeyboardInterrupt, EOFError):
  211. print()
  212. return None
  213. def _session_browse_picker(sessions: list, session_db=None) -> Optional[str]:
  214. """Curses session browser with live search; returns the selected session ID, or None if cancelled.
  215. With *session_db*: shows lifecycle status / message count per row, and ``d`` (while the filter is
  216. empty) prompts y/n and deletes via ``SessionDB.delete_session``.
  217. """
  218. if not sessions:
  219. print("No sessions found.")
  220. return None
  221. _annotate_session_statuses(sessions, session_db)
  222. def _delete_session(session_id: str) -> bool:
  223. try:
  224. from hermes_cli.sessions_cmd import get_hermes_home
  225. sessions_dir = get_hermes_home() / "sessions"
  226. except Exception:
  227. sessions_dir = None
  228. try:
  229. return bool(session_db.delete_session(session_id, sessions_dir=sessions_dir, exclude_active_write_guards=True))
  230. except SessionActiveWriteGuardError:
  231. raise # the browser tells the user the session is busy instead of a generic failure
  232. except Exception:
  233. return False
  234. try: # curses first; any failure (no curses module, odd terminal) falls back
  235. import curses
  236. browser = _CursesBrowser(curses, sessions, _delete_session if session_db is not None else None)
  237. curses.wrapper(browser.run)
  238. return browser.result
  239. except Exception:
  240. return _fallback_picker(sessions)