| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311 |
- # health: allow FILE_LINES -- usage-window plans: /model picker hooks only (a multi-row hint, Large/Free row labels); the logic lives in hermes_cli/model_picker_usage.py
- """prompt_toolkit TUI construction, key-binding handlers, and overlay display fragments for the
- interactive CLI. Mixin bound onto ``HermesCLI`` via the MRO; cli.py-internal symbols are imported
- LAZILY inside each method (``from cli import ...``) — never at module load (import cycle)."""
- from __future__ import annotations
- import errno
- import json
- import os
- import queue
- import shutil
- import string
- import sys
- import threading
- import time
- from agent.i18n import t
- from agent.interrupt_compat import request_hard_interrupt
- from hermes_cli.commands_completion import SlashCommandAutoSuggest, cli_slash_completer
- from pathlib import Path
- from prompt_toolkit.filters import Condition
- from prompt_toolkit.history import FileHistory
- from prompt_toolkit.key_binding import KeyBindings
- from prompt_toolkit.layout import (
- ConditionalContainer,
- FormattedTextControl,
- Layout,
- Window,
- WindowAlign)
- from prompt_toolkit.layout.dimension import Dimension
- from prompt_toolkit.layout.menus import CompletionsMenu
- from prompt_toolkit.layout.processors import (
- ConditionalProcessor,
- PasswordProcessor,
- Processor,
- Transformation)
- from prompt_toolkit.styles import Style as PTStyle
- from prompt_toolkit.widgets import TextArea
- from typing import Optional
- from hermes_cli import cli_enter_burst as _enter_burst
- from hermes_cli.cli_enter_burst import RAPID_INPUT_ENTER_WINDOW_S as _RAPID_INPUT_ENTER_WINDOW_S
- from hermes_cli.cli_footer_split import FooterSplit
- from hermes_cli.cli_panel import _Panel
- from hermes_cli.cli_tui_wrap import _prefix_wrapped_rows, _wrap_rows
- # Rows below an overlay panel taken by spinner/tool-progress, status bar, input, separators and
- # prompt symbol (measured ~6 during live PTY approval prompts) — shared by every panel budget.
- _PANEL_RESERVED_BELOW = 6
- _TYPING_CHARS = string.digits + string.ascii_letters + "-_.:/ "
- # Approval-choice identifiers (protocol tokens, never translated) → catalog keys for their labels.
- _APPROVAL_CHOICE_KEYS = {
- "once": "cli.tui.approval_once",
- "session": "cli.tui.approval_session",
- "always": "cli.tui.approval_always",
- "deny": "cli.tui.approval_deny",
- "view": "cli.tui.approval_view"}
- def _approval_choice_label(choice: str) -> str:
- """Localized label for an approval choice id; unknown ids render verbatim."""
- key = _APPROVAL_CHOICE_KEYS.get(choice)
- return t(key) if key else choice
- def _agent_name() -> str:
- try:
- from hermes_cli.skin_engine import get_active_skin
- return get_active_skin().get_branding("agent_name", "Hermes")
- except Exception:
- return "Hermes"
- def _tn(key: str, count: int, **kwargs) -> str:
- """Plural-aware lookup: ``<key>_one`` for exactly one, ``<key>_other`` otherwise."""
- return t(f"{key}_one" if count == 1 else f"{key}_other", count=count, **kwargs)
- def _num_prefix(i: int) -> str:
- """Quick-select key label: 1-9 for items 1-9, 0 for the 10th, blank beyond."""
- return str(i + 1) if i < 9 else ("0" if i == 9 else " ")
- def _term_rows() -> int:
- return shutil.get_terminal_size((100, 24)).lines
- class CLITuiMixin:
- """prompt_toolkit TUI construction, key-binding handlers, and overlay display fragments."""
- def _tui_input_rule_height(self, position: str, width: Optional[int] = None) -> int:
- """Visible height for the top/bottom input separator rules."""
- if position not in {"top", "bottom"}:
- raise ValueError(f"Unknown input rule position: {position}")
- if getattr(self, "_status_bar_suppressed_after_resize", False):
- return 0
- if position == "top":
- return 1
- return 0 if self._use_minimal_tui_chrome(width=width) else 1
- def _get_slash_confirm_display_fragments(self):
- """Render the /new-/clear-style confirmation panel."""
- from cli import _panel_box_width, _wrap_panel_text_keep_ws
- state = self._slash_confirm_state
- if not state:
- return []
- wrap = _wrap_panel_text_keep_ws
- title = state.get("title") or t("cli.tui.confirm_title")
- detail = state.get("detail") or ""
- choices = state.get("choices") or []
- selected = state.get("selected", 0)
- footer = t("cli.tui.confirm_footer")
- choice_labels = [
- f"{'❯' if idx == selected else ' '} [{idx + 1}] {label} — {desc}"
- for idx, (_value, label, desc) in enumerate(choices)]
- preview_lines = [w for line in detail.splitlines() for w in wrap(line, 72)]
- preview_lines.extend(w for _i, w in _wrap_rows(wrap, choice_labels, 72, " "))
- preview_lines.append(footer)
- box_width = _panel_box_width(title, preview_lines, min_width=56, max_width=86)
- inner_text_width = max(8, box_width - 2)
- detail_wrapped = [w for line in detail.splitlines() for w in wrap(line, inner_text_width)]
- choice_wrapped = _wrap_rows(wrap, choice_labels, inner_text_width, " ")
- chrome_full = 6
- available = max(0, _term_rows() - _PANEL_RESERVED_BELOW)
- max_detail_rows = min(8, max(1, available - chrome_full - len(choice_wrapped)))
- if len(detail_wrapped) > max_detail_rows:
- detail_wrapped = detail_wrapped[:max(1, max_detail_rows - 1)] + [t("cli.tui.detail_truncated")]
- panel = _Panel('class:approval-border', box_width)
- panel.row('class:approval-title', title)
- panel.blank()
- for wrapped in detail_wrapped:
- panel.row('class:approval-desc', wrapped)
- panel.blank()
- for idx, wrapped in choice_wrapped:
- style = 'class:approval-selected' if idx == selected else 'class:approval-choice'
- panel.row(style, wrapped)
- panel.blank()
- panel.row('class:approval-cmd', footer)
- return panel.close()
- def _get_approval_display_fragments(self):
- """Render the dangerous-command approval panel.
- Layout priority: title + command + choices must always render, even in a short terminal
- or with a long multi-paragraph description. The description sits at the bottom
- and is truncated to the remaining row budget, so HSplit never clips approve/deny off-screen.
- """
- from cli import _panel_box_width, _wrap_panel_text_keep_ws
- state = self._approval_state
- if not state:
- return []
- wrap = _wrap_panel_text_keep_ws
- command = state["command"]
- description = state["description"]
- choices = state["choices"]
- selected = state.get("selected", 0)
- show_full = state.get("show_full", False)
- title = t("cli.tui.approval_title")
- preview_lines = wrap(description, 60)
- preview_lines.extend(wrap(command, 60))
- for i, choice in enumerate(choices):
- prefix = '❯ ' if i == selected else ' '
- label = _approval_choice_label(choice)
- preview_lines.extend(wrap(f"{prefix}{label}", 60, subsequent_indent=" "))
- box_width = _panel_box_width(title, preview_lines)
- inner_text_width = max(8, box_width - 2)
- # Pre-wrap the mandatory content — command + choices must always render.
- cmd_wrapped = wrap(command, inner_text_width)
- if not show_full and "view" in choices and len(cmd_wrapped) > 4:
- cmd_wrapped = cmd_wrapped[:3] + wrap(
- t("cli.tui.approval_choose_full", label=t("cli.tui.approval_view")), inner_text_width)
- choice_labels = [
- f"{'❯' if i == selected else ' '} {_num_prefix(i)}. {_approval_choice_label(choice)}"
- for i, choice in enumerate(choices)]
- choice_wrapped = _wrap_rows(wrap, choice_labels, inner_text_width, " ")
- # Row budget so HSplit never clips the command or choices. Full chrome = top border +
- # title + blank + blank-between-cmd/choices + bottom border (5); when that doesn't fit,
- # drop the separator blanks (3) so every choice stays on-screen in compact terminals.
- available = max(0, _term_rows() - _PANEL_RESERVED_BELOW)
- use_compact_chrome = 5 + len(cmd_wrapped) + len(choice_wrapped) > available
- chrome_rows = 3 if use_compact_chrome else 5
- # A command too long to leave room for the choices (e.g. "view" on a multi-hundred-char
- # command) is truncated so approve/deny still render; keep at least 1 command row.
- max_cmd_rows = max(1, available - chrome_rows - len(choice_wrapped))
- if len(cmd_wrapped) > max_cmd_rows:
- keep = max(1, max_cmd_rows - 1) if max_cmd_rows > 1 else 1
- cmd_wrapped = cmd_wrapped[:keep] + wrap(
- t("cli.tui.approval_command_truncated"), inner_text_width)
- # Remaining rows go to the description (minus the blank separator in full mode), capped
- # at 10 so the panel stays compact even on huge terminals.
- mandatory_no_desc = chrome_rows + len(cmd_wrapped) + len(choice_wrapped)
- available_for_desc = available - mandatory_no_desc - (0 if use_compact_chrome else 1)
- available_for_desc = max(0, min(available_for_desc, 10))
- desc_wrapped = wrap(description, inner_text_width) if description else []
- if available_for_desc < 1 or not desc_wrapped:
- desc_wrapped = []
- elif len(desc_wrapped) > available_for_desc:
- desc_wrapped = desc_wrapped[:max(1, available_for_desc - 1)] + [t("cli.tui.approval_description_truncated")]
- # Render title → command → choices → description; description last so any overflow
- # clips the least-critical content, never the command or choices.
- panel = _Panel('class:approval-border', box_width)
- panel.row('class:approval-title', title)
- if not use_compact_chrome:
- panel.blank()
- for wrapped in cmd_wrapped:
- panel.row('class:approval-cmd', wrapped)
- if not use_compact_chrome:
- panel.blank()
- for i, wrapped in choice_wrapped:
- style = 'class:approval-selected' if i == selected else 'class:approval-choice'
- panel.row(style, wrapped)
- if desc_wrapped:
- if not use_compact_chrome:
- panel.blank()
- for wrapped in desc_wrapped:
- panel.row('class:approval-desc', wrapped)
- return panel.close()
- def _get_tui_prompt_symbols(self) -> tuple[str, str]:
- """Return ``(normal_prompt, state_suffix)`` for the active skin.
- ``state_suffix`` is what special states (sudo/secret/approval/agent) render after their
- leading icon. A non-default profile name is prepended (``coder ❯``).
- """
- try:
- from hermes_cli.skin_engine import get_active_prompt_symbol
- symbol = get_active_prompt_symbol("❯ ")
- except Exception:
- symbol = "❯ "
- symbol = (symbol or "❯ ").rstrip() + " "
- try:
- from hermes_cli.profiles import get_active_profile_name
- profile = get_active_profile_name()
- if profile not in {"default", "custom"}:
- symbol = f"{profile} {symbol}"
- except Exception:
- pass
- stripped = symbol.rstrip()
- if not stripped:
- return "❯ ", "❯ "
- parts = stripped.split()
- candidate = parts[-1] if parts else ""
- if any(ch in candidate for ch in ("❯", ">", "$", "#", "›", "»", "→")):
- return symbol, candidate.rstrip() + " "
- # Icon-only custom prompts should still remain visible in special states.
- return symbol, symbol
- def _audio_level_bar(self) -> str:
- """One-char audio level indicator from the recorder's current RMS."""
- rec = getattr(self, "_voice_recorder", None)
- if rec is None:
- return ""
- # RMS 0-32767 → index 0-7; typical speech is 500-5000, display caps at ~8000.
- return " ▁▂▃▄▅▆▇"[min(rec.current_rms, 8000) * 7 // 8000]
- def _get_tui_prompt_fragments(self):
- """prompt_toolkit fragments for the current interactive state."""
- symbol, state_suffix = self._get_tui_prompt_symbols()
- compact = self._use_minimal_tui_chrome(width=self._get_tui_terminal_width())
- def _state_fragment(style: str, icon: str, extra: str = ""):
- if compact:
- text = icon
- if extra:
- text = f"{text} {extra.strip()}".rstrip()
- return [(style, text + " ")]
- if extra:
- return [(style, f"{icon} {extra} {state_suffix}")]
- return [(style, f"{icon} {state_suffix}")]
- if self._voice_recording:
- return _state_fragment("class:voice-recording", "●", self._audio_level_bar())
- if self._voice_processing:
- return _state_fragment("class:voice-processing", "◉")
- if self._sudo_state:
- return _state_fragment("class:sudo-prompt", "🔐")
- if self._secret_state:
- return _state_fragment("class:sudo-prompt", "🔑")
- if self._connection_state:
- return _state_fragment("class:prompt-working", "⚙")
- if self._approval_state or getattr(self, "_slash_confirm_state", None):
- return _state_fragment("class:prompt-working", "⚠")
- if self._clarify_freetext:
- return _state_fragment("class:clarify-selected", "✎")
- if self._clarify_state:
- return _state_fragment("class:prompt-working", "?")
- if self._command_running:
- return _state_fragment("class:prompt-working", self._command_spinner_frame())
- if self._agent_running:
- return _state_fragment("class:prompt-working", "☤")
- if self._voice_mode:
- return _state_fragment("class:voice-prompt", "🎤")
- return [("class:prompt", symbol)]
- def _get_tui_prompt_text(self) -> str:
- """Visible prompt text for width calculations."""
- return "".join(text for _, text in self._get_tui_prompt_fragments())
- def _build_tui_style_dict(self) -> dict[str, str]:
- """Layer the active skin's prompt_toolkit colors over the base TUI style.
- On a light terminal, hex tokens in each style string are rewritten through the light-mode
- remap so the chrome stays readable on cream Terminal.app backgrounds. CRITICAL: a style
- that paints its own ``bg:`` (status bar, completion menu) is left alone — its fg was tuned
- for that dark bg and remapping would give dark-on-dark; the terminal's mode is irrelevant.
- """
- from cli import _detect_light_mode, _maybe_remap_for_light_mode
- style_dict = dict(getattr(self, "_tui_style_base", {}) or {})
- try:
- from hermes_cli.skin_engine import get_prompt_toolkit_style_overrides
- style_dict.update(get_prompt_toolkit_style_overrides())
- except Exception:
- pass
- try:
- if _detect_light_mode():
- def _remap_value(v: str) -> str:
- if not v:
- return v
- tokens = v.split()
- if any(t.startswith("bg:") for t in tokens):
- return v
- return " ".join(_maybe_remap_for_light_mode(t) if t.startswith("#") else t for t in tokens)
- style_dict = {k: _remap_value(v or "") for k, v in style_dict.items()}
- except Exception:
- pass
- return style_dict
- def _apply_tui_skin_style(self) -> bool:
- """Refresh prompt_toolkit styling for a running interactive TUI."""
- if not getattr(self, "_app", None) or not getattr(self, "_tui_style_base", None):
- return False
- self._app.style = PTStyle.from_dict(self._build_tui_style_dict())
- self._invalidate(min_interval=0.0)
- return True
- def _get_extra_tui_widgets(self) -> list:
- """Extension hook: wrapper CLIs return widgets inserted between the spacer and status bar."""
- return []
- def _register_extra_tui_keybindings(self, kb, *, input_area) -> None:
- """Extension hook: wrapper CLIs add bindings to ``kb`` (``input_area`` is the main TextArea)."""
- def _build_tui_layout_children(
- self,
- *,
- sudo_widget,
- secret_widget,
- connection_widget=None,
- approval_widget,
- slash_confirm_widget=None,
- clarify_widget,
- model_picker_widget=None,
- command_palette_widget=None,
- spinner_widget=None,
- spacer,
- status_bar,
- input_rule_top,
- image_bar,
- input_area,
- input_rule_bot,
- voice_status_bar,
- completions_menu) -> list:
- """Ordered children of the root ``HSplit``; override only for full control over ordering
- (wrappers normally override ``_get_extra_tui_widgets`` instead)."""
- ordered = [
- Window(height=0),
- sudo_widget,
- secret_widget,
- connection_widget,
- approval_widget,
- slash_confirm_widget,
- clarify_widget,
- model_picker_widget,
- command_palette_widget,
- spinner_widget,
- spacer,
- *self._get_extra_tui_widgets(),
- getattr(self, "_pet_widget", None),
- getattr(self, "_stash_panel_widget", None),
- getattr(self, "_subagent_dock_widget", None),
- status_bar,
- input_rule_top,
- image_bar,
- input_area,
- input_rule_bot,
- voice_status_bar,
- completions_menu]
- if getattr(self, "_modern_layout", False): # footer under the composer and its completions
- ordered.append(ordered.pop(ordered.index(status_bar)))
- return [item for item in ordered if item is not None]
- def _tui_spinner_loop(self):
- while not self._should_exit:
- if not self._app:
- time.sleep(0.1)
- continue
- monitor = getattr(self, "_subagent_monitor", None)
- if monitor is not None:
- monitor.tick()
- if self._command_running:
- self._invalidate(min_interval=0.1)
- time.sleep(0.1)
- else:
- # Never repaint the idle prompt on a timer: in non-full-screen mode background
- # redraws fight tmux/Ghostty/cmux viewport restoration after focus changes and
- # visually move the input area. Input/agent events invalidate explicitly.
- time.sleep(0.2)
- def _get_clarify_display_fragments(self):
- """Batch (multi-question) clarify panel: "N questions" header, one status line per question
- (✓ answered → answer / ▸ active / · pending), and the active question's numbered choices
- (+ Other) expanded beneath its status line."""
- from cli import _panel_box_width, _wrap_panel_text
- state = self._clarify_state
- if not state:
- return []
- questions_list = state.get("questions") or []
- answers = state.get("answers") or {}
- answer_meta = state.get("answer_meta") or {}
- active = state.get("active", 0)
- choices = state.get("choices") or []
- selected = state.get("selected", 0)
- multi_select = state.get("multi_select", False)
- selected_indices = state.get("selected_indices", set()) if multi_select else set()
- freetext = self._clarify_freetext
- title = t("cli.tui.clarify_title", agent_name=_agent_name())
- header = _tn("cli.tui.clarify_question_count", len(questions_list))
- def _status_rows(width):
- rows = []
- # End of the active question block and the row span of its selected choice.
- focus = {}
- for idx, entry in enumerate(questions_list):
- answered = entry["qid"] in answers
- marker = "✓" if answered else ("▸" if idx == active else "·")
- row_style = 'class:clarify-selected' if idx == active else 'class:clarify-choice'
- for wrapped in _wrap_panel_text(f"{marker} {entry['question']}", width, subsequent_indent=" "):
- rows.append((row_style, wrapped))
- if answered:
- # Locked answer on its own line/color so it stays readable while Tab-walking.
- locked = answers[entry['qid']]
- answer = f" {'—' if locked is None else locked}"
- for wrapped in _wrap_panel_text(answer, width, subsequent_indent=" "):
- rows.append(('class:clarify-answer', wrapped))
- if idx != active:
- continue
- for i, choice in enumerate(choices):
- cursor = "❯" if i == selected and not freetext else " "
- cb = ("[x] " if i in selected_indices else "[ ] ") if multi_select else ""
- style = 'class:clarify-selected' if i == selected and not freetext else 'class:clarify-choice'
- label = f" {cursor} {cb}{_num_prefix(i)}. {choice}"
- first = len(rows)
- for wrapped in _wrap_panel_text(label, width, subsequent_indent=" "):
- rows.append((style, wrapped))
- if i == selected and not freetext:
- focus["selected"] = (first, len(rows))
- if choices:
- other_idx = len(choices)
- mid = _num_prefix(other_idx)
- if multi_select:
- mid = f"{'[x]' if other_idx in selected_indices else '[ ]'} {mid}"
- # An earlier typed answer stays visible next to Other; Enter on it edits
- # (the composer is prefilled).
- other_text = (answer_meta.get(entry["qid"]) or {}).get("other_text") or ""
- other_suffix = t("cli.tui.clarify_other_answer", text=other_text) if other_text else None
- if freetext:
- other_label = f" ❯ {mid}. " + (other_suffix or t("cli.tui.clarify_other_type_below"))
- other_style = 'class:clarify-active-other'
- elif selected == other_idx:
- other_label = f" ❯ {mid}. " + (other_suffix or t("cli.tui.clarify_other_type_answer"))
- other_style = 'class:clarify-selected'
- else:
- other_label = f" {mid}. " + (other_suffix or t("cli.tui.clarify_other_type_answer"))
- other_style = 'class:clarify-choice'
- first = len(rows)
- for wrapped in _wrap_panel_text(other_label, width, subsequent_indent=" "):
- rows.append((other_style, wrapped))
- if freetext or selected == other_idx:
- focus["selected"] = (first, len(rows))
- elif freetext:
- guidance = " " + t("cli.tui.clarify_guidance")
- for wrapped in _wrap_panel_text(guidance, width):
- rows.append(('class:clarify-active-other', wrapped))
- focus["end"] = len(rows)
- return rows, focus
- preview_rows, _ = _status_rows(60)
- box_width = _panel_box_width(title, [header] + [text for _, text in preview_rows])
- rows, focus = _status_rows(max(8, box_width - 2))
- # The panel is an unsized Window, so rows past the viewport are clipped from the
- # bottom, which is where the active question's choices sit. When the body does not
- # fit, show the slice that ends with those choices and always holds the selected one.
- # Top rule, header and bottom rule take three rows.
- budget = max(1, _term_rows() - _PANEL_RESERVED_BELOW - 3)
- if len(rows) > budget and "end" in focus:
- sel_start, _sel_end = focus.get("selected", (focus["end"] - 1, focus["end"]))
- first = min(sel_start, focus["end"] - budget)
- first = max(0, min(first, len(rows) - budget))
- rows = rows[first:first + budget]
- panel = _Panel('class:clarify-border', box_width, title, 'class:clarify-title')
- panel.row('class:clarify-question', header)
- for style, text in rows:
- panel.row(style, text)
- return panel.close()
- def _render_scroll_list_panel(self, state, title, hint, labels, *, min_width, max_width, indent):
- """Titled panel with a hint row and a scrolling selectable list (model picker, palette).
- The panel renders into a Window with no max height, so the visible slice is limited to
- the terminal rows or the bottom border and trailing items get clipped on long lists
- (e.g. Ollama Cloud's 36+ models). ``state["_scroll_offset"]`` is updated in place.
- """
- from cli import HermesCLI, _panel_box_width, _wrap_panel_text
- # ``hint`` may be several rows (a window plan's limit line above the usual hint).
- hints = list(hint) if isinstance(hint, (list, tuple)) else [hint]
- box_width = _panel_box_width(title, hints + labels, min_width=min_width, max_width=max_width)
- # ``_Panel.row`` pads every row to ``box_width - 2``, so that is the real
- # body width. Keep the wrap budget in sync with it and reserve the
- # leading cell for the cursor/indent applied below, rather than the old
- # blanket ``- 6`` which wrapped long labels two columns early.
- inner_text_width = max(8, box_width - 2)
- label_width = max(8, inner_text_width - max(2, len(indent)))
- selected = state.get("selected", 0)
- try:
- from prompt_toolkit.application import get_app
- term_rows = get_app().output.get_size().rows
- except Exception:
- term_rows = _term_rows()
- scroll_offset, visible = HermesCLI._compute_model_picker_viewport(
- selected, state.get("_scroll_offset", 0), len(labels), term_rows,
- panel_chrome=5 + len(hints))
- state["_scroll_offset"] = scroll_offset
- panel = _Panel('class:clarify-border', box_width, title, 'class:clarify-title')
- panel.blank()
- for line in hints:
- panel.row('class:clarify-hint', line)
- panel.blank()
- for idx in range(scroll_offset, min(scroll_offset + visible, len(labels))):
- style = 'class:clarify-selected' if idx == selected else 'class:clarify-choice'
- # The cursor cell is always two columns wide, so unselected rows get two spaces
- # regardless of ``indent`` (the palette's continuation indent is four) — otherwise
- # the selected label starts two columns left of its neighbours.
- lead = '❯ ' if idx == selected else ' '
- for wrapped in _prefix_wrapped_rows(
- _wrap_panel_text, labels[idx], label_width, lead, indent
- ):
- panel.row(style, wrapped)
- panel.blank()
- return panel.close()
- def _get_model_picker_display_fragments(self):
- state = self._model_picker_state
- if not state:
- return []
- if state.get("stage", "provider") == "provider":
- title = t("cli.tui.picker_title_provider")
- choices = []
- _providers = state.get("providers")
- for p in _providers if isinstance(_providers, list) else []:
- count = p.get("total_models", len(p.get("models", [])))
- label = _tn("cli.tui.picker_provider_row", count, name=p['name'])
- if p.get("is_current"):
- label += t("cli.tui.picker_current_marker")
- choices.append(label)
- choices.append(t("cli.shared.cancel"))
- _unknown = t("cli.shared.unknown")
- hint = t("cli.tui.picker_current_hint",
- model=state.get('current_model', _unknown),
- provider=state.get('current_provider', _unknown))
- elif state.get("stage") == "reasoning":
- from hermes_cli.cli_model_switch_mixin import _picker_reasoning_rows
- result = state.get("switch_result")
- picked = getattr(result, "new_model", "") or t("cli.shared.noun_model")
- title = t("cli.tui.picker_title_effort", model=picked)
- rc = self.reasoning_config
- current = ("none" if isinstance(rc, dict) and rc.get("enabled") is False
- else (rc or {}).get("effort", "medium") if isinstance(rc, dict) else "medium")
- choices = [t("cli.tui.picker_current_labeled", label=label) if value == current else label
- for value, label in _picker_reasoning_rows()]
- choices += [t("cli.shared.back"), t("cli.shared.cancel")]
- hint = t("cli.tui.picker_effort_hint")
- else:
- provider_data = state.get("provider_data") or {}
- model_list = state.get("model_list") or []
- title = t("cli.tui.picker_title_models", provider=provider_data.get(
- 'name', provider_data.get('slug', t("cli.tui.picker_provider_fallback"))))
- # Fuzzy filter narrows the concrete list; selection still resolves to a real entry via
- # the filtered_pairs index mapping, so this never makes model resolution ambiguous.
- _query = state.get("filter", "") or ""
- filtered_pairs = self._filter_model_picker_entries(model_list, _query)
- state["_filtered_pairs"] = filtered_pairs
- model_labels = [e for (_i, e) in filtered_pairs]
- from hermes_cli.model_picker_usage import annotate_window_plan_rows
- row_labels, limit_line = annotate_window_plan_rows(provider_data, model_labels)
- choices = row_labels + [t("cli.shared.back"), t("cli.shared.cancel")]
- if _query:
- hint = t("cli.tui.picker_filter_hint", query=_query, shown=len(model_labels), total=len(model_list))
- elif model_list:
- hint = t("cli.tui.picker_select_hint", count=len(model_list))
- else:
- hint = t("cli.tui.picker_empty")
- # Window plan past an allowance: say once what happens next (pay as you go or wait), above the hint.
- if limit_line:
- hint = [limit_line, hint]
- return self._render_scroll_list_panel(
- state, title, hint, choices, min_width=46, max_width=84, indent=' ')
- def _get_command_palette_display_fragments(self):
- state = self._command_palette_state
- if not state:
- return []
- rows = self._command_palette_visible_entries()
- state["_visible_count"] = len(rows)
- _query = state.get("filter", "") or ""
- total = len(state.get("entries") or [])
- if _query:
- hint = t("cli.tui.palette_filter_hint", query=_query, shown=len(rows), total=total)
- else:
- hint = t("cli.tui.palette_hint", total=total)
- labels = [f"{c} — {d}" if d else c for (c, _cat, d) in rows] or [t("cli.tui.palette_empty")]
- return self._render_scroll_list_panel(
- state, t("cli.tui.palette_title"), hint, labels, min_width=50, max_width=90, indent=' ')
- def _render_sudo_style_panel(
- self, title: str, body_lines: list[str], row_styles: list[str] | None = None
- ):
- """Bordered ``sudo-*`` panel: blank, each body line, blank, body-final line, blank."""
- from cli import _panel_box_width
- box_width = _panel_box_width(title, body_lines)
- panel = _Panel('class:sudo-border', box_width, title, 'class:sudo-title')
- panel.blank()
- for i, text in enumerate(body_lines):
- if i == len(body_lines) - 1 and i > 0:
- panel.blank()
- style = row_styles[i] if row_styles and i < len(row_styles) else 'class:sudo-text'
- panel.row(style, text)
- panel.blank()
- return panel.close()
- def _get_sudo_display_fragments(self):
- if not self._sudo_state:
- return []
- # Panel bodies are one catalog value per panel (multi-line prose), split into rows here.
- if code := self._sudo_state.get("vault_code"):
- return self._render_sudo_style_panel(
- t("cli.tui.vault_code_title", site=code["site"]),
- t("cli.tui.vault_code_body", site=code["site"], agent_name=_agent_name()).split("\n"))
- if save := self._sudo_state.get("vault_save"):
- if save["step"] == "identifier":
- return self._render_sudo_style_panel(
- t("cli.tui.vault_save_title", site=save["site"]),
- t("cli.tui.vault_save_body").split("\n"))
- return self._render_sudo_style_panel(
- t("cli.tui.vault_save_title", site=save["site"]),
- t("cli.tui.vault_save_pw_body", origin=save["origin"]).split("\n"))
- if backend := self._sudo_state.get("vault_backend"):
- return self._render_sudo_style_panel(
- t("cli.tui.vault_unlock_title", backend=backend),
- t("cli.tui.vault_unlock_body", backend=backend).split("\n"))
- return self._render_sudo_style_panel(t("cli.tui.sudo_title"), [t("cli.tui.sudo_body")])
- def _get_secret_display_fragments(self):
- state = self._secret_state
- if not state:
- return []
- prompt = state.get("prompt") or t(
- "cli.tui.secret_prompt", var_name=state.get('var_name', t("cli.tui.secret_fallback_name")))
- help_text = (state.get("metadata") or {}).get("help")
- content_lines = [prompt, t("cli.tui.secret_body")]
- if help_text:
- content_lines.insert(1, str(help_text))
- return self._render_sudo_style_panel(t("cli.tui.secret_title"), content_lines)
- def _get_connection_display_fragments(self):
- state = self._connection_state
- lines = self._connection_render_lines()
- if not state or not lines:
- return []
- body_lines = lines[1:]
- styles = ['class:sudo-text'] * len(body_lines)
- phase = state.get("phase")
- fields = state.get("fields") or []
- instructions_offset = 1 if state.get("target", {}).get("instructions") else 0
- if phase in {"form", "failed"}:
- field_offset = instructions_offset + (1 if phase == "failed" else 0)
- field_index = state.get("field_index", 0)
- if 0 <= field_index < len(fields):
- styles[field_offset + field_index] = 'class:clarify-selected'
- elif body_lines:
- action_index = len(body_lines) - 1
- styles[action_index] = 'class:clarify-selected'
- choices = [t("cli.tui.connection_connect"), t("cli.shared.cancel")]
- selected = min(1, max(0, state.get("selected", 0)))
- body_lines[action_index] = " ".join(
- f"▸ {choice}" if i == selected else choice for i, choice in enumerate(choices)
- )
- elif phase == "authorized" and body_lines:
- styles[-1] = 'class:clarify-selected'
- body_lines[-1] = "▸ " + t("cli.tui.connection_continue")
- return self._render_sudo_style_panel(lines[0], body_lines, styles)
- # (state attr, deadline attr, hint catalog key) for the modal prompts with a countdown hint
- # row. Keys, not text: the label is looked up at render time so a language switch applies.
- _TUI_MODAL_HINTS = (
- ("_sudo_state", "_sudo_deadline", "cli.tui.hint_sudo"),
- ("_secret_state", "_secret_deadline", "cli.tui.hint_secret"),
- ("_approval_state", "_approval_deadline", "cli.tui.hint_approval"),
- ("_slash_confirm_state", "_slash_confirm_deadline", "cli.tui.hint_slash_confirm"),
- )
- # Connection-setup phase (protocol id) → hint catalog key.
- _TUI_CONNECTION_HINT_KEYS = {
- "form": "cli.tui.hint_connection_form",
- "failed": "cli.tui.hint_connection_form",
- "url": "cli.tui.hint_connection_url",
- "authorized": "cli.tui.hint_connection_authorized",
- "waiting": "cli.tui.hint_connection_waiting",
- }
- def _tui_hint_text(self):
- if self._connection_state:
- phase = self._connection_state.get("phase")
- hint = " " + t(self._TUI_CONNECTION_HINT_KEYS.get(phase, "cli.tui.hint_connection_default"))
- deadline = float(self._connection_state.get("payload", {}).get("deadline_at") or 0)
- countdown = f" ({max(0, int(deadline - time.time()))}s)" if deadline else ""
- return [('class:hint', hint), ('class:clarify-countdown', countdown)]
- for state_attr, deadline_attr, hint_key in self._TUI_MODAL_HINTS:
- if getattr(self, state_attr):
- if state_attr == "_sudo_state" and ((self._sudo_state.get("vault_save") or {}).get("step") == "identifier"
- or self._sudo_state.get("vault_code")):
- hint_key = "cli.tui.hint_vault_username"
- hint = " " + t(hint_key)
- remaining = max(0, int(getattr(self, deadline_attr) - time.monotonic()))
- return [('class:hint', hint), ('class:clarify-countdown', f' ({remaining}s)')]
- if self._clarify_state:
- # None deadline = unlimited wait → hide the countdown entirely.
- if self._clarify_deadline is None:
- countdown = ''
- else:
- countdown = f' ({max(0, int(self._clarify_deadline - time.monotonic()))}s)'
- if self._clarify_freetext:
- hint = " " + t("cli.tui.hint_clarify_freetext")
- else:
- hint = " " + t("cli.tui.hint_clarify_batch")
- return [('class:hint', hint), ('class:clarify-countdown', countdown)]
- if self._command_running:
- frame = self._command_spinner_frame()
- if self._command_blocks_input:
- detail = t("cli.tui.hint_input_disabled")
- else:
- detail = t("cli.tui.hint_input_queues")
- return [('class:hint', " " + t("cli.tui.hint_command_running", frame=frame, detail=detail))]
- return []
- def _tui_placeholder_text(self):
- if self._voice_recording: # live STT partial text (stt.streaming) replaces the hint
- return self._voice_live_text or t("cli.tui.placeholder_recording", shortcut=self._voice_record_key_label())
- if self._voice_processing:
- return self._voice_live_text or t("cli.tui.placeholder_transcribing")
- if self._sudo_state:
- if (self._sudo_state.get("vault_save") or {}).get("step") == "identifier":
- return t("cli.tui.placeholder_vault_username")
- if self._sudo_state.get("vault_code"):
- return t("cli.tui.placeholder_vault_code")
- return t("cli.tui.placeholder_password")
- if self._secret_state:
- return t("cli.tui.placeholder_secret")
- if self._approval_state:
- return ""
- if self._slash_confirm_state:
- return t("cli.tui.placeholder_choice")
- if self._clarify_freetext:
- return t("cli.tui.placeholder_answer")
- if self._clarify_state:
- return ""
- if self._command_running:
- return f"{self._command_spinner_frame()} {self._command_status or t('cli.tui.placeholder_processing_command')}"
- if self._agent_running:
- if getattr(self, "_modern_layout", False):
- return t(f"cli.modern.placeholder_busy_{self.busy_input_mode}")
- return t("cli.tui.placeholder_busy")
- if self._voice_mode:
- return t("cli.tui.placeholder_voice_idle", shortcut=self._voice_record_key_label())
- # Advertise a parked draft so the stash can never be silently forgotten.
- try:
- _stash_hint = self._prompt_stash.placeholder_hint()
- except Exception:
- _stash_hint = ""
- if _stash_hint:
- return _stash_hint
- # Idle + empty composer: a task-oriented example chosen once per session
- # (self._composer_placeholder) so it stays stable while being read, not flickering.
- return getattr(self, "_composer_placeholder", "") or ""
- def _get_stash_panel_display_fragments(self):
- try:
- _stash = self._prompt_stash
- return self._render_stash_panel(
- _stash.panel_rows(), _stash.panel_cursor, self._get_tui_terminal_width())
- except Exception:
- return []
- def _tui_handle_voice_record(self, event):
- """Toggle voice recording when voice mode is active.
- Runs on prompt_toolkit's event-loop thread: any blocking call here (locks, sd.wait,
- disk I/O) freezes the whole UI, so all heavy work goes to daemon threads.
- """
- from cli import _DIM, _RST, _cprint, logger
- if not self._voice_mode:
- return
- if self._voice_recording:
- # Always allow STOPPING (even while the agent runs); manual stop ends continuous
- # mode. Flag clearing happens atomically inside _voice_stop_and_transcribe.
- with self._voice_lock:
- self._voice_continuous = False
- event.app.invalidate()
- threading.Thread(target=self._voice_stop_and_transcribe, daemon=True).start()
- return
- # Allow disarming continuous mode while the agent runs or transcribes — otherwise the
- # user is stuck in an auto-restart loop until /voice off.
- if self._agent_running or self._voice_processing:
- with self._voice_lock:
- self._voice_continuous = False
- event.app.invalidate()
- return
- # Don't START recording during interactive prompts.
- if (self._clarify_state or self._sudo_state or self._approval_state
- or self._slash_confirm_state or self._connection_state):
- return
- # Cut TTS so the user can start talking: stop_playback() just terminates a subprocess;
- # the stop event drains the streaming pipeline if one is live.
- if not self._voice_tts_done.is_set():
- try:
- logger.info("TTS CUT: record key handler cutting TTS")
- from tools.tts_streaming import mark_speech_interrupted
- mark_speech_interrupted()
- if self._voice_tts_stop is not None:
- self._voice_tts_stop.set()
- from tools.voice_mode import stop_playback
- stop_playback()
- self._voice_tts_done.set()
- except Exception:
- pass
- with self._voice_lock:
- self._voice_continuous = True
- # play_beep(sd.wait), AudioRecorder.start(lock) and config I/O must never block the loop.
- def _start_recording():
- try:
- self._voice_start_recording()
- if hasattr(self, '_app') and self._app:
- self._app.invalidate()
- except Exception as e:
- _cprint(f"\n{_DIM}{t('cli.tui.voice_recording_failed', error=e)}{_RST}")
- threading.Thread(target=_start_recording, daemon=True).start()
- event.app.invalidate()
- def _tui_cancel_voice_recording(self, event) -> bool:
- """Cancel an active recording; True when one was cancelled (caller stops there)."""
- from cli import _DIM, _RST, _cprint
- _recorder_ref = None
- with self._voice_lock:
- if self._voice_recording and self._voice_recorder:
- _recorder_ref = self._voice_recorder
- self._voice_recording = False
- self._voice_continuous = False
- if _recorder_ref is None:
- return False
- _cprint(f"\n{_DIM}{t('cli.tui.recording_cancelled')}{_RST}")
- # cancel() may block on AudioRecorder._lock / CoreAudio — keep it off the event loop.
- threading.Thread(target=_recorder_ref.cancel, daemon=True).start()
- event.app.invalidate()
- return True
- def _tui_cancel_foreground_ui(self, event, *, closers) -> bool:
- """Close the first active foreground UI (slash-confirm / picker / palette); True if any."""
- for state_attr, close in closers:
- if getattr(self, state_attr, None):
- close()
- event.app.current_buffer.reset()
- event.app.invalidate()
- return True
- return False
- def _tui_clear_blocking_overlays(self, event) -> bool:
- """Clear every agent-blocking overlay (approval/clarify/sudo/secret) in one shot.
- Callers must NOT return on True alone: they fall through so a stale/orphaned overlay
- (left by an earlier interrupt) can't swallow the press before the agent-interrupt
- branch, leaving the chat frozen (#14026).
- """
- if not (self._sudo_state or self._secret_state or self._approval_state
- or self._clarify_state or self._connection_state):
- return False
- self._clear_active_overlays_for_interrupt()
- event.app.current_buffer.reset()
- event.app.invalidate()
- return True
- def _tui_clear_or_exit(self, event) -> None:
- """Clear text/images like bash; exit when everything is already empty."""
- if event.app.current_buffer.text or self._attached_images:
- event.app.current_buffer.reset()
- self._attached_images.clear()
- event.app.invalidate()
- else:
- self._should_exit = True
- event.app.exit()
- def _tui_handle_ctrl_c(self, event):
- """Ctrl+C priority: cancel voice recording → cancel foreground UI/overlay prompt or the wait for a
- command on its own gateway socket (a plugin command, /cron) → clear a typed draft, even mid-run (a correction must never kill the turn)
- → interrupt the running agent → force exit (second press within 2s) → when idle and empty, exit."""
- now = time.time()
- if self._tui_cancel_voice_recording(event):
- return
- if self._tui_cancel_foreground_ui(event, closers=(
- ("_slash_confirm_state", lambda: self._submit_slash_confirm_response("cancel")),
- ("_model_picker_state", self._close_model_picker), ("_command_palette_state", self._close_command_palette),
- ("_gateway_command_wait", lambda: self._gateway_command_wait.set()))):
- return
- overlay_cleared = self._tui_clear_blocking_overlays(event)
- if overlay_cleared and not (self._agent_running and self.agent):
- return
- if self._agent_running and self.agent and not (event.app.current_buffer.text or self._attached_images):
- if now - self._last_ctrl_c_time < 2.0:
- print("\n" + t("cli.tui.force_exiting"))
- self._should_exit = True
- event.app.exit()
- return
- self._last_ctrl_c_time = now
- print("\n" + t("cli.tui.interrupting_again_hint"))
- request_hard_interrupt(self.agent)
- else:
- self._tui_clear_or_exit(event)
- def _tui_handle_ctrl_q(self, event):
- """Ctrl+Q: like Ctrl+C minus the double-press force exit (and it leaves the palette)."""
- if self._tui_cancel_voice_recording(event):
- return
- if self._tui_cancel_foreground_ui(event, closers=(
- ("_slash_confirm_state", lambda: self._submit_slash_confirm_response("cancel")),
- ("_model_picker_state", self._close_model_picker))):
- return
- overlay_cleared = self._tui_clear_blocking_overlays(event)
- if overlay_cleared and not (self._agent_running and self.agent):
- return
- if self._agent_running and self.agent and not (event.app.current_buffer.text or self._attached_images):
- print("\n" + t("cli.tui.interrupting"))
- request_hard_interrupt(self.agent)
- else:
- self._tui_clear_or_exit(event)
- def _tui_make_clarify_number_handler(self, idx):
- def handler(event):
- state = self._clarify_state
- if not state or self._clarify_freetext:
- return
- choices = state.get("choices") or []
- if idx > len(choices):
- return
- # Multi-select: number keys toggle checkboxes (incl. "Other") instead of submitting.
- if state.get("multi_select"):
- indices = state.get("selected_indices", set())
- indices.symmetric_difference_update({idx})
- event.app.invalidate()
- return
- if idx == len(choices):
- # "Other" → freetext
- self._clarify_freetext = True
- else:
- # Lock the numbered choice for the active question only.
- self._clarify_batch_lock(state, choices[idx])
- event.app.invalidate()
- return handler
- def _tui_restore_stash_payload(self, event, payload) -> None:
- """Put a popped (text, images) payload back into the composer."""
- if not payload:
- return
- text, images = payload
- buf = event.app.current_buffer
- buf.text = text
- buf.cursor_position = len(text)
- # Extend rather than replace attachments: the user may have attached something new since
- # the stash was taken and dropping it silently would be data loss.
- for img in images or ():
- if img not in self._attached_images:
- self._attached_images.append(img)
- def _tui_handle_stash_panel_up(self, event):
- self._prompt_stash.move_cursor(-1)
- event.app.invalidate()
- def _tui_handle_stash_panel_down(self, event):
- self._prompt_stash.move_cursor(1)
- event.app.invalidate()
- def _tui_handle_stash_panel_delete(self, event):
- """D in the browse panel discards the highlighted draft."""
- self._prompt_stash.delete_at_cursor()
- event.app.invalidate()
- def _tui_handle_stash_panel_close(self, event):
- self._prompt_stash.close_panel()
- event.app.invalidate()
- def _tui_handle_tab(self, event):
- """Tab: accept the open completion, else the ghost auto-suggestion, else start completions.
- After accepting a provider like 'anthropic:' the menu closes and complete_while_typing
- doesn't fire (no keystroke); re-triggering here makes stage-2 models appear immediately.
- """
- buf = event.current_buffer
- if buf.complete_state:
- completion = buf.complete_state.current_completion
- if completion is None:
- # Menu open but nothing selected — select first then grab it
- buf.go_to_completion(0)
- completion = buf.complete_state and buf.complete_state.current_completion
- if completion is None:
- return
- buf.apply_completion(completion)
- elif buf.suggestion and buf.suggestion.text:
- buf.insert_text(buf.suggestion.text)
- else:
- buf.start_completion()
- def _tui_handle_double_escape(self, event):
- """Double ESC discards the draft and attached images (Claude Code / Gemini CLI gesture).
- Works while the agent streams — the gap Ctrl+C leaves (it interrupts the turn and only
- clears the draft when idle). The draft is appended to history first so Up recalls it,
- which is what makes a reflex key safe. Single ESC is the Alt-sequence prefix
- (escape+enter/g/v) so the escape-timeout keeps those distinct; modal prompts bind ESC
- eagerly and are excluded so cancel still wins.
- """
- buf = event.app.current_buffer
- if not (buf.text or self._attached_images):
- return
- buf.reset(append_to_history=bool(buf.text))
- self._attached_images.clear()
- event.app.invalidate()
- def _tui_handle_ignored_terminal_sequence(self, event):
- """Consume parser-level ignored terminal sequences before self-insert.
- hermes_cli.pt_input_extras registers focus reports (CSI I / CSI O) as Keys.Ignore at the
- VT100 parser; without this no-op binding the default self-insert would still land the
- bytes in the buffer. Focus-in additionally schedules a rate-limited full repaint: while
- hidden, the emulator may have coalesced output or repainted, so prompt_toolkit's
- incremental diff would stack a fresh prompt chrome on the stale one (#60920, #25337).
- """
- try:
- for press in getattr(event, "key_sequence", None) or ():
- if getattr(press, "data", None) == "\x1b[I":
- self._schedule_focus_regain_redraw()
- break
- except Exception:
- pass
- def _tui_handle_escape_modal(self, event):
- """ESC cancels active secret/sudo/connection/slash-confirm prompts."""
- if self._connection_state:
- self._connection_cancel()
- event.app.current_buffer.reset()
- event.app.invalidate()
- elif self._secret_state:
- self._cancel_secret_capture()
- event.app.current_buffer.reset()
- event.app.invalidate()
- elif self._sudo_state:
- self._sudo_state["response_queue"].put("")
- self._sudo_state = None
- event.app.invalidate()
- elif self._slash_confirm_state:
- self._submit_slash_confirm_response("cancel")
- event.app.current_buffer.reset()
- event.app.invalidate()
- def _tui_handle_ctrl_z(self, event):
- """Ctrl+Z suspends the process (Unix only)."""
- from cli import _DIM, _RST, _cprint
- if sys.platform == 'win32':
- _cprint(f"\n{_DIM}{t('cli.tui.suspend_unsupported')}{_RST}")
- event.app.invalidate()
- return
- import signal as _sig
- from prompt_toolkit.application import run_in_terminal
- from hermes_cli.skin_engine import get_active_skin
- agent_name = get_active_skin().get_branding("agent_name", "Hermes Agent")
- msg = "\n" + t("cli.tui.suspended", agent_name=agent_name)
- def _suspend():
- os.write(1, msg.encode())
- os.kill(0, _sig.SIGTSTP)
- run_in_terminal(_suspend)
- def _tui_handle_ctrl_d(self, event):
- """Ctrl+D deletes under the cursor (readline); exits only on empty input (pending images count),
- like bash/zsh. Mid-turn it detaches: the gateway finishes the turn, Ctrl+C stops it (LC-6b)."""
- buf = event.app.current_buffer
- if buf.text:
- buf.delete()
- elif not self._attached_images:
- self._should_exit, self._detach_on_exit = True, bool(self._agent_running)
- event.app.exit()
- def _tui_recall_without_recollapse(self, buf, move):
- """Run a history move with paste-collapse suppressed.
- Recalled history can hold the full text of a paste collapsed at submit time; loading it
- back looks like a fresh large paste to ``_on_text_changed``. If the move didn't change the
- text (plain cursor movement) the flag is cleared so a later real paste still collapses.
- """
- before = buf.text
- self._skip_paste_collapse = True
- move()
- if buf.text == before:
- self._skip_paste_collapse = False
- def _tui_handle_alt_v(self, event):
- """Alt+V pastes an image from the clipboard. Alt combos pass through every terminal
- (ESC + key), unlike Ctrl+V which terminals intercept — reliable on WSL2/VSCode/SSH.
- Silent when no image (avoid noise on accidental press)."""
- if self._try_attach_clipboard_image():
- event.app.invalidate()
- def _tui_handle_ctrl_v(self, event):
- """Image paste for terminals without bracketed paste: GNOME Terminal/Konsole send raw
- 0x16. Terminals that intercept Ctrl+V (macOS Terminal, iTerm2, VSCode, Windows Terminal)
- fire the bracketed-paste handler instead and never reach this."""
- if self._try_attach_clipboard_image():
- event.app.invalidate()
- def _tui_handle_ctrl_l(self, event):
- """Ctrl+L forces a clean repaint after terminal buffer drift (tmux/cmux tab switches,
- ``clear`` from a subshell, SSH restores) that prompt_toolkit can't detect."""
- self._force_full_redraw()
- def _tui_insert_newline(self, event):
- """Newline for multi-line input (Alt+Enter; Ctrl+J/Ctrl+Enter with multiline shortcuts).
- Windows Terminal intercepts Alt+Enter (fullscreen) and delivers Ctrl+Enter as c-j."""
- event.current_buffer.insert_text('\n')
- def _tui_handle_open_in_editor(self, event):
- """Ctrl+G (or Alt+G in VSCode/Cursor) opens the draft in an external editor."""
- self._open_external_editor(event.current_buffer)
- def _tui_connection_move(self, event, delta: int) -> None:
- state = self._connection_state
- if not state:
- return
- phase = state.get("phase")
- if phase in {"form", "failed"}:
- fields = state.get("fields") or []
- current = state.get("field_index", 0)
- if current < len(fields):
- field = fields[current]
- target_name = state.get("target", {}).get("name", "")
- state["drafts"][target_name][field.get("name")] = event.app.current_buffer.text
- state["field_index"] = min(len(fields), max(0, current + delta))
- elif delta < 0 and fields:
- state["field_index"] = len(fields) - 1
- else:
- state["selected"] = (state.get("selected", 0) + delta) % 2
- self._connection_sync_input_buffer()
- elif phase == "authorized":
- state["selected"] = (state.get("selected", 0) + delta) % 2
- self._paint_now()
- event.app.invalidate()
- def _tui_connection_up(self, event):
- self._tui_connection_move(event, -1)
- def _tui_connection_down(self, event):
- self._tui_connection_move(event, 1)
- def _tui_connection_side(self, event):
- state = self._connection_state
- if not state:
- return
- fields = state.get("fields") or []
- if state.get("phase") == "authorized" or (
- state.get("phase") in {"form", "failed"}
- and state.get("field_index", 0) >= len(fields)
- ):
- state["selected"] = 1 - min(1, max(0, state.get("selected", 0)))
- self._paint_now()
- event.app.invalidate()
- def _tui_model_picker_down(self, event):
- state = self._model_picker_state
- if not state:
- return
- if state.get("stage") == "provider":
- max_idx = len(state.get("providers") or [])
- elif state.get("stage") == "reasoning":
- from hermes_cli.cli_model_switch_mixin import _picker_reasoning_rows
- max_idx = len(_picker_reasoning_rows()) + 1 # + Back + Cancel
- else:
- # +1 for "← Back" and Cancel over the filtered visible rows.
- _fp = state.get("_filtered_pairs")
- max_idx = (len(_fp) if _fp is not None else len(state.get("model_list") or [])) + 1
- state["selected"] = min(max_idx, state.get("selected", 0) + 1)
- event.app.invalidate()
- def _tui_model_picker_up(self, event):
- if self._model_picker_state:
- self._model_picker_state["selected"] = max(0, self._model_picker_state.get("selected", 0) - 1)
- event.app.invalidate()
- @staticmethod
- def _tui_set_filter(st, value: str) -> None:
- """Replace a picker/palette filter and rewind the selection + viewport."""
- st["filter"] = value
- st["selected"] = 0
- st["_scroll_offset"] = 0
- def _tui_model_picker_escape(self, event):
- """ESC clears an active filter first, else steps back from the effort stage, else closes."""
- st = self._model_picker_state
- if st and st.get("stage") == "model" and (st.get("filter") or ""):
- self._tui_set_filter(st, "")
- event.app.invalidate()
- return
- if st and st.get("stage") == "reasoning":
- st.update(stage="model", selected=0, _scroll_offset=0, switch_result=None)
- event.app.invalidate()
- return
- self._close_model_picker()
- event.app.current_buffer.reset()
- event.app.invalidate()
- def _tui_model_picker_filter_backspace(self, event):
- st = self._model_picker_state
- if st:
- self._tui_set_filter(st, (st.get("filter", "") or "")[:-1])
- event.app.invalidate()
- def _tui_make_model_filter_char_handler(self, ch: str):
- def handler(event):
- st = self._model_picker_state
- if not st or st.get("stage") != "model":
- return
- self._tui_set_filter(st, (st.get("filter", "") or "") + ch)
- event.app.invalidate()
- return handler
- def _tui_make_palette_char_handler(self, ch: str):
- def handler(event):
- st = self._command_palette_state
- if st:
- self._tui_set_filter(st, (st.get("filter", "") or "") + ch)
- event.app.invalidate()
- return handler
- def _tui_make_approval_number_handler(self, idx):
- def handler(event):
- if self._approval_state and idx < len(self._approval_state["choices"]):
- self._approval_state["selected"] = idx
- self._handle_approval_selection()
- event.app.invalidate()
- return handler
- def _tui_make_slash_confirm_number_handler(self, idx):
- def handler(event):
- if self._slash_confirm_state and idx < len(self._slash_confirm_state.get("choices") or []):
- self._submit_slash_confirm_response(self._slash_confirm_state["choices"][idx][0])
- event.app.current_buffer.reset()
- event.app.invalidate()
- return handler
- def _tui_clarify_toggle(self, event):
- if self._clarify_state:
- indices = self._clarify_state.get("selected_indices", set())
- indices.symmetric_difference_update({self._clarify_state["selected"]})
- event.app.invalidate()
- def _tui_clarify_down(self, event):
- if self._clarify_state:
- max_idx = len(self._clarify_state.get("choices") or []) # last index is "Other"
- self._clarify_state["selected"] = min(max_idx, self._clarify_state["selected"] + 1)
- event.app.invalidate()
- def _tui_clarify_up(self, event):
- if self._clarify_state:
- self._clarify_state["selected"] = max(0, self._clarify_state["selected"] - 1)
- event.app.invalidate()
- def _tui_clarify_batch_step(self, event, delta: int):
- state = self._clarify_state
- if state:
- self._clarify_batch_set_active(state, (state["active"] + delta) % len(state["questions"]))
- event.app.invalidate()
- def _tui_clarify_batch_tab(self, event):
- self._tui_clarify_batch_step(event, 1)
- def _tui_clarify_batch_backtab(self, event):
- self._tui_clarify_batch_step(event, -1)
- def _tui_command_palette_backspace(self, event):
- st = self._command_palette_state
- if st:
- self._tui_set_filter(st, (st.get("filter", "") or "")[:-1])
- event.app.invalidate()
- def _tui_command_palette_down(self, event):
- st = self._command_palette_state
- if st:
- n = st.get("_visible_count", len(self._command_palette_visible_entries()))
- st["selected"] = min(max(0, n - 1), st.get("selected", 0) + 1)
- event.app.invalidate()
- def _tui_command_palette_up(self, event):
- st = self._command_palette_state
- if st:
- st["selected"] = max(0, st.get("selected", 0) - 1)
- event.app.invalidate()
- def _tui_command_palette_enter(self, event):
- self._handle_command_palette_selection()
- event.app.invalidate()
- def _tui_command_palette_escape(self, event):
- self._close_command_palette()
- event.app.invalidate()
- def _tui_open_command_palette(self, event):
- self._open_command_palette()
- event.app.invalidate()
- def _tui_slash_confirm_down(self, event):
- st = self._slash_confirm_state
- if st:
- st["selected"] = min(len(st.get("choices") or []) - 1, st.get("selected", 0) + 1)
- event.app.invalidate()
- def _tui_slash_confirm_up(self, event):
- st = self._slash_confirm_state
- if st:
- st["selected"] = max(0, st.get("selected", 0) - 1)
- event.app.invalidate()
- def _tui_approval_down(self, event):
- st = self._approval_state
- if st:
- st["selected"] = min(len(st["choices"]) - 1, st["selected"] + 1)
- event.app.invalidate()
- def _tui_approval_up(self, event):
- st = self._approval_state
- if st:
- st["selected"] = max(0, st["selected"] - 1)
- event.app.invalidate()
- def _tui_wake_startup(self):
- from cli import logger
- try:
- self._maybe_start_wake_word()
- except Exception as e:
- logger.debug("wake-word startup skipped: %s", e)
- def _tui_suppress_closed_loop_errors(self, loop, context):
- exc = context.get("exception")
- if isinstance(exc, RuntimeError) and "Event loop is closed" in str(exc):
- return
- if isinstance(exc, KeyError) and "is not registered" in str(exc):
- return # selector registration failures (#6393)
- if isinstance(exc, OSError) and getattr(exc, "errno", None) == errno.EIO:
- return # broken stdout on interrupt (#13710)
- loop.default_exception_handler(context)
- def _tui_handle_enter(self, event):
- """Enter: submit input.
- Modal overlays (sudo/secret/approval/slash-confirm/picker/clarify) are answered first via
- ``_tui_enter_overlay``. Otherwise: agent running → busy_input_mode routing (steer /
- redirect / interrupt queue / next-turn queue); idle → ``_pending_input``. Slash and bang
- commands always take the local-dispatch path (never steer/interrupt text to the model).
- """
- from cli import _apply_backslash_line_continuation, _is_backslash_line_continuation
- if self._tui_enter_overlay(event):
- return
- buf = event.app.current_buffer
- raw_text = buf.text
- # Explicit `\` + Enter continuation runs first so its backslash is consumed identically
- # whether the Enter was typed or arrived inside a paste.
- if (
- self._tui_multiline_shortcuts
- and buf.cursor_position == len(raw_text)
- and _is_backslash_line_continuation(raw_text)):
- continued = _apply_backslash_line_continuation(raw_text)
- buf.text = continued
- buf.cursor_position = len(continued)
- event.app.invalidate()
- return
- # Enter mid-burst: a pasted newline (#10994), or the end of a scripted `text`+Enter write.
- from hermes_cli.cli_enter_burst import handle_burst_enter
- if not handle_burst_enter(self, event, buf):
- self._tui_submit_buffer(event, buf)
- def _tui_submit_buffer(self, event, buf):
- """Submit the composer: inline commands, busy routing or ``_pending_input``."""
- from cli import _looks_like_slash_command
- text = buf.text.strip()
- has_images = bool(self._attached_images)
- if not (text or has_images):
- return
- if self._tui_enter_inline_command(event, text, has_images):
- return
- # Snapshot and clear attached images; bundle text + images as a tuple when present.
- images = list(self._attached_images)
- self._attached_images.clear()
- event.app.invalidate()
- payload = (text, images) if images else text
- # A bang command is treated like a slash command while the agent is busy: it must never
- # be routed into steer/redirect (injecting `!git status` into the model's context as a
- # prompt). It queues and runs locally once the loop drains.
- _is_local_dispatch = bool(text) and (_looks_like_slash_command(text) or text.strip().startswith("!"))
- if self._agent_running and not _is_local_dispatch:
- self._tui_enter_while_busy(text, images, payload)
- else:
- self._pending_input.put(payload)
- # History stores real pasted content, not the placeholder, so up-arrow recall restores it.
- self._inline_pastes(buf)
- buf.reset(append_to_history=True)
- def _tui_enter_inline_command(self, event, text: str, has_images: bool) -> bool:
- """Run /model, /steer, /bg, /btw directly on the UI thread; True when handled.
- /model needs the prompt_toolkit terminal-handoff helpers of the interactive pickers.
- /steer, /bg and /btw while the agent runs must not queue through _pending_input: the
- process loop is blocked inside self.chat(), so they would only run after the foreground
- turn — turning /steer into a next-turn message (defeating mid-run injection, #34569) and
- starting the /bg side task after the turn it should run alongside (#75221). The
- foreground turn is left alone: no interrupt, no steer. agent.steer() is thread-safe.
- Every branch invalidates after reset: process_command() prints through patch_stdout
- and never invalidates the app, so the just-cleared input area would keep showing the
- submitted text (looking unsent, inviting a re-submit) until some unrelated redraw.
- """
- if self._should_handle_model_command_inline(text, has_images=has_images):
- if not self.process_command(text):
- self._should_exit = True
- if event.app.is_running:
- event.app.exit()
- elif (self._should_handle_steer_command_inline(text, has_images=has_images)
- or self._should_handle_background_command_inline(text, has_images=has_images)
- or self._should_handle_stop_command_inline(text, has_images=has_images)):
- self.process_command(text)
- else:
- return False
- event.app.current_buffer.reset(append_to_history=True)
- event.app.invalidate()
- return True
- def _tui_enter_while_busy(self, text: str, images: list, payload, mode: str | None = None) -> None:
- """Route a submission typed while the agent runs, per ``busy_input_mode``.
- steer → agent.steer(text) mid-run (images can't ride along; a missing/rejecting steer() falls back
- to queue). interrupt → agent.redirect() when supported, else the legacy interrupt queue. queue →
- next turn: text-only on the gateway's session is a ``/queue`` FIFO admission (#134889 N5)."""
- from cli import CLI_CONFIG, _ACCENT, _DIM, _RST, _cprint, _hermes_home
- _effective_mode = mode or self.busy_input_mode
- redirected = False
- if _effective_mode == "steer":
- if images or not text:
- _effective_mode = "queue"
- else:
- accepted = False
- try:
- if self.agent is not None and hasattr(self.agent, "steer"):
- accepted = self.agent.steer(text)
- except Exception as exc:
- _cprint(f" {_DIM}{t('cli.tui.steer_failed_queued', error=exc)}{_RST}")
- accepted = False
- if accepted == "voice_stopped": # TUI-26: consumed as a voice stop; nothing to queue
- return
- if accepted:
- preview = text[:80] + ("..." if len(text) > 80 else "")
- _cprint(f" {_ACCENT}{t('cli.tui.steered', preview=preview)}{_RST}")
- else:
- _effective_mode = "queue"
- if _effective_mode == "queue" and text and not images and self._gateway_queue_store() is not None:
- self._queue_enqueue(text)
- elif _effective_mode == "queue":
- self._pending_input.put(payload)
- preview = text if text else _tn("cli.tui.images_attached_preview", len(images))
- preview = preview[:80] + ('...' if len(preview) > 80 else '')
- _cprint(" " + t("cli.tui.queued_next_turn", preview=preview))
- elif _effective_mode == "interrupt":
- if not images and text:
- try:
- if (
- self.agent is not None
- and getattr(self.agent, "_supports_active_turn_redirect", False) is True
- and hasattr(self.agent, "redirect")):
- redirected = self.agent.redirect(text)
- except Exception:
- redirected = False
- if redirected == "voice_stopped": # TUI-26: consumed as a voice stop; nothing to queue
- return
- if redirected:
- preview = text[:80] + ("..." if len(text) > 80 else "")
- _cprint(f" {_ACCENT}{t('cli.tui.redirected_turn', preview=preview)}{_RST}")
- else:
- self._interrupt_queue.put(payload)
- try:
- with open(_hermes_home / "interrupt_debug.log", "a", encoding="utf-8") as _f:
- _f.write(
- f"{time.strftime('%H:%M:%S')} ENTER: queued interrupt msg={str(payload)[:60]!r}, "
- f"agent_running={self._agent_running}\n")
- except Exception:
- pass
- # First-touch onboarding: one-line tip about the /busy knob on the first busy-while-
- # running event for this install; the flag persists to config.yaml. Guarded so
- # onboarding can never break the input loop.
- try:
- from agent.onboarding import BUSY_INPUT_FLAG, busy_input_hint_cli, is_seen, mark_seen
- if not is_seen(CLI_CONFIG, BUSY_INPUT_FLAG):
- _hint_mode = "redirect" if redirected else _effective_mode
- _cprint(f" {_DIM}{busy_input_hint_cli(_hint_mode)}{_RST}")
- mark_seen(_hermes_home / "config.yaml", BUSY_INPUT_FLAG)
- CLI_CONFIG.setdefault("onboarding", {}).setdefault("seen", {})[BUSY_INPUT_FLAG] = True
- except Exception:
- pass
- def _tui_enter_overlay(self, event) -> bool:
- """Enter while a modal overlay is up: submit it. True when handled."""
- from cli import _cprint
- buf = event.app.current_buffer
- if self._connection_state:
- state = self._connection_state
- fields = state.get("fields") or []
- if state.get("phase") in {"form", "failed"} and state.get("field_index", 0) < len(fields):
- value = buf.text
- buf.reset()
- self._connection_set_field(value)
- else:
- self._connection_submit()
- event.app.invalidate()
- return True
- if self._sudo_state:
- self._sudo_state["response_queue"].put(buf.text)
- self._sudo_state = None
- event.app.invalidate()
- return True
- if self._secret_state:
- value = buf.text
- buf.reset()
- self._submit_secret_response(value)
- event.app.invalidate()
- return True
- if self._approval_state:
- self._handle_approval_selection()
- event.app.invalidate()
- return True
- if self._slash_confirm_state:
- # Typed choice wins over the highlighted one.
- text = buf.text.strip()
- choices = self._slash_confirm_state.get("choices") or []
- choice = self._normalize_slash_confirm_choice(text, choices) if text else None
- if choice is None:
- selected = self._slash_confirm_state.get("selected", 0)
- if 0 <= selected < len(choices):
- choice = choices[selected][0]
- self._submit_slash_confirm_response(choice or "cancel")
- buf.reset()
- event.app.invalidate()
- return True
- if self._model_picker_state:
- try:
- # Picker selections follow the same session-scoped default as /model <name>
- # (model.persist_switch_by_default).
- from hermes_cli.model_switch import resolve_persist_behavior
- self._handle_model_picker_selection(persist_global=resolve_persist_behavior(False, False))
- except Exception as _exc:
- _cprint(" " + t("cli.tui.model_selection_failed", error=_exc))
- self._close_model_picker()
- buf.reset()
- event.app.invalidate()
- return True
- if self._clarify_state and self._clarify_freetext:
- self._tui_enter_clarify_freetext(event)
- return True
- if self._clarify_state:
- self._tui_enter_clarify_choice(event)
- return True
- return False
- def _tui_enter_clarify_freetext(self, event) -> None:
- """Clarify "Other": lock the typed answer; empty input skips the question."""
- buf = event.app.current_buffer
- text = buf.text.strip()
- state = self._clarify_state
- base = getattr(self, '_clarify_multi_base', None)
- if not text:
- self._clarify_freetext = False
- self._clarify_prefill = ""
- self._clarify_multi_base = None
- if base:
- self._clarify_batch_lock(state, json.dumps(base, ensure_ascii=False),
- meta={"kind": "multi", "choices": list(base), "other_text": ""})
- else:
- self._clarify_batch_lock(state, None, meta={"kind": "skipped"})
- buf.reset()
- event.app.invalidate()
- return
- # Multi-select "Other" appends the typed answer to the checked labels as a JSON array string.
- if base is not None:
- answer = json.dumps(base + [text], ensure_ascii=False)
- meta = {"kind": "multi", "choices": list(base), "other_text": text}
- self._clarify_multi_base = None
- else:
- answer = text
- meta = {"kind": "other", "other_text": text}
- self._clarify_freetext = False
- self._clarify_prefill = ""
- self._clarify_batch_lock(state, answer, meta=meta)
- buf.reset()
- event.app.invalidate()
- def _tui_enter_clarify_choice(self, event) -> None:
- """Clarify choice mode: lock the active question's answer and advance to the next
- unanswered."""
- self._clarify_batch_enter(self._clarify_state)
- # Editing an earlier "Other" answer: prefill the composer with the previous text.
- if self._clarify_freetext and self._clarify_prefill:
- event.app.current_buffer.text = self._clarify_prefill
- event.app.current_buffer.cursor_position = len(self._clarify_prefill)
- self._clarify_prefill = ""
- event.app.invalidate()
- def _tui_collapse_paste(self, text: str, line_count: int, *, fallback: bool) -> str:
- """Save a large paste under ~/.hermes/pastes and return the placeholder for the buffer."""
- from cli import _hermes_home, datetime, logger
- self._tui_paste_counter += 1
- paste_dir = _hermes_home / "pastes"
- paste_dir.mkdir(parents=True, exist_ok=True)
- paste_file = paste_dir / f"paste_{self._tui_paste_counter}_{datetime.now().strftime('%H%M%S')}.txt"
- paste_file.write_text(text, encoding="utf-8")
- logger.info(
- "Collapsed paste #%d: %d lines, %d chars -> %s" + (" (fallback)" if fallback else ""),
- self._tui_paste_counter, line_count + 1, len(text), paste_file)
- self._tui_paste_just_collapsed = True
- return f"[Pasted text #{self._tui_paste_counter}: {line_count + 1} lines \u2192 {paste_file}]"
- def _tui_paste_over_threshold(self, text: str, line_count: int, threshold_key: str) -> bool:
- threshold = self.config.get(threshold_key, 5)
- char_threshold = self.config.get("paste_collapse_char_threshold", 2000)
- lines_hit = threshold > 0 and line_count >= threshold
- chars_hit = char_threshold > 0 and len(text) >= char_threshold
- return lines_hit or chars_hit
- def _tui_handle_paste(self, event):
- """Bracketed paste: strip leaked terminal responses, auto-attach a clipboard image only
- for image-only/empty gestures (so text pastes and dictation never attach stale images),
- and collapse large pastes to a file-reference placeholder, preserving existing text."""
- from cli import (
- _should_auto_attach_clipboard_image_on_paste,
- _strip_leaked_bracketed_paste_wrappers,
- _strip_leaked_terminal_responses_with_meta,
- logger)
- # Diagnostic canary: log when the handler blocks the event loop >500ms so recurring
- # "CLI freezes on paste" reports (#16263, macOS Tahoe + iTerm2/Ghostty) arrive with data.
- _paste_handler_start = time.perf_counter()
- _paste_raw_size = len(event.data or "")
- # Normalise line endings so the collapse threshold and display are consistent.
- pasted_text = (event.data or "").replace('\r\n', '\n').replace('\r', '\n')
- pasted_text = _strip_leaked_bracketed_paste_wrappers(pasted_text)
- pasted_text, _had_mouse_reports = _strip_leaked_terminal_responses_with_meta(pasted_text)
- if _had_mouse_reports:
- self._recover_terminal_input_modes(reason="mouse reports leaked into bracketed paste payload")
- if _should_auto_attach_clipboard_image_on_paste(pasted_text) and self._try_attach_clipboard_image():
- event.app.invalidate()
- if pasted_text:
- # Sanitize surrogates (Word/Google Docs paste) before writing.
- from agent.message_sanitization import _sanitize_surrogates
- pasted_text = _sanitize_surrogates(pasted_text)
- line_count = pasted_text.count('\n')
- buf = event.current_buffer
- if (
- self._tui_paste_over_threshold(pasted_text, line_count, "paste_collapse_threshold")
- and not buf.text.strip().startswith('/')):
- placeholder = self._tui_collapse_paste(pasted_text, line_count, fallback=False)
- prefix = "\n" if buf.cursor_position > 0 and buf.text[buf.cursor_position - 1] != '\n' else ""
- buf.insert_text(prefix + placeholder)
- else:
- buf.insert_text(pasted_text)
- _paste_handler_elapsed_ms = (time.perf_counter() - _paste_handler_start) * 1000.0
- if _paste_handler_elapsed_ms > 500.0:
- logger.warning(
- "Slow bracketed-paste handler: %.1fms to process %d bytes "
- "(%d lines) on %s. If the input becomes unresponsive after "
- "this, attach this log line to the bug report.",
- _paste_handler_elapsed_ms,
- _paste_raw_size,
- pasted_text.count('\n') + 1 if pasted_text else 0,
- sys.platform)
- def _tui_on_text_changed(self, buf):
- """Fallback paste collapse for terminals without bracketed paste.
- Either heuristic triggers: many characters added in one event (paste delivered in one
- tick), or the newline count jumped by 4+ (terminals that feed characters individually
- but batch newlines; Alt+Enter adds 1 newline per event so never trips it).
- """
- self._tui_last_text_change = _enter_burst.note_text_change(self)
- from cli import _strip_leaked_bracketed_paste_wrappers, _strip_leaked_terminal_responses_with_meta
- text = _strip_leaked_bracketed_paste_wrappers(buf.text)
- text, _had_mouse_reports = _strip_leaked_terminal_responses_with_meta(text)
- if _had_mouse_reports:
- self._recover_terminal_input_modes(reason="mouse reports leaked into prompt buffer")
- if text != buf.text:
- cursor = min(buf.cursor_position, len(text))
- self._tui_paste_just_collapsed = True
- buf.text = text
- buf.cursor_position = cursor
- self._tui_prev_text_len = len(text)
- self._tui_prev_newline_count = text.count('\n')
- return
- chars_added = len(text) - self._tui_prev_text_len
- self._tui_prev_text_len = len(text)
- if self._tui_paste_just_collapsed or self._skip_paste_collapse:
- self._tui_paste_just_collapsed = False
- self._skip_paste_collapse = False
- self._tui_prev_newline_count = text.count('\n')
- return
- line_count = text.count('\n')
- newlines_added = line_count - self._tui_prev_newline_count
- self._tui_prev_newline_count = line_count
- is_paste = chars_added > 1 or newlines_added >= 4
- if (
- self._tui_paste_over_threshold(text, line_count, "paste_collapse_threshold_fallback")
- and is_paste
- and not text.startswith('/')):
- buf.text = self._tui_collapse_paste(text, line_count, fallback=True)
- buf.cursor_position = len(buf.text)
- def _tui_handle_prompt_stash(self, event):
- """Ctrl+S: composer has content → push onto the stash and clear; empty + one stashed →
- pop it back; empty + several → open the browse panel; panel open → close it.
- A stack (not a single slot) is what makes repeated Ctrl+S safe: a second stash never
- silently overwrites the first, both stay reachable in the panel.
- """
- from hermes_cli.prompt_stash import ACTION_RESTORED, ACTION_STASHED, resolve_ctrl_s
- buf = event.app.current_buffer
- action, payload = resolve_ctrl_s(self._prompt_stash, buf.text, self._attached_images)
- if action == ACTION_STASHED:
- # reset() (not `text = ""`) also clears completion state, selection and the undo stack.
- buf.reset()
- self._attached_images.clear()
- elif action == ACTION_RESTORED:
- self._tui_restore_stash_payload(event, payload)
- # ACTION_OPEN_PANEL: resolve_ctrl_s already flipped panel_open.
- event.app.invalidate()
- def _tui_handle_stash_panel_restore(self, event):
- """Enter in the browse panel restores the highlighted draft."""
- self._tui_restore_stash_payload(event, self._prompt_stash.restore_at_cursor())
- event.app.invalidate()
- def _tui_history_up(self, event):
- """Up: browse history when on the first line, else move the cursor up."""
- buf = event.app.current_buffer
- self._tui_recall_without_recollapse(buf, lambda: buf.auto_up(count=event.arg))
- def _tui_history_down(self, event):
- buf = event.app.current_buffer
- self._tui_recall_without_recollapse(buf, lambda: buf.auto_down(count=event.arg))
- def _tui_image_bar_fragments(self):
- from cli import _format_image_attachment_badges
- if not self._attached_images:
- return []
- badges = _format_image_attachment_badges(self._attached_images, self._image_counter)
- return [("class:image-badge", f" {badges} ")]
- def _tui_voice_status_fragments(self):
- return self._get_voice_status_fragments()
- def _tui_spinner_text(self):
- spinner_line = self._render_spinner_text()
- return [('class:hint', spinner_line)] if spinner_line else []
- def _tui_spinner_height(self):
- return self._spinner_widget_height()
- def _tui_hint_height(self):
- if (
- self._sudo_state or self._secret_state or self._approval_state or self._connection_state
- or self._slash_confirm_state or self._clarify_state or self._command_running):
- return 1
- # Keep a spacer while the agent runs on roomy terminals; reclaim the row on narrow screens.
- return self._agent_spacer_height()
- def _tui_init_run_state(self):
- """Reset the per-run REPL state (queues, modal states, voice state, config watcher)."""
- from hermes_cli.config_backend import config_version_or_none
- self._agent_running = False
- self._pending_input = queue.Queue() # normal input (commands + new queries)
- self._interrupt_queue = queue.Queue() # messages typed while the agent is running
- # Seeded -q handoff: main() can't put directly into _pending_input (this reinit would
- # discard it), so the seeded first message rides in on an attribute and is enqueued here.
- _seed_msg = getattr(self, "_seeded_first_message", None)
- if _seed_msg is not None:
- self._seeded_first_message = None
- self._pending_input.put(_seed_msg)
- # See constructor note; mirrored for the run() path that skips the earlier __init__ branch.
- self._last_turn_interrupted = False
- self._should_exit = False
- self._last_ctrl_c_time = 0 # double Ctrl+C force-exit tracking
- # No PluginManager._cli_ref: plugins load in the gateway, not here (PLG-7).
- # Config file watcher — detect mcp_servers changes and auto-reload.
- from hermes_cli.config import get_config_path as _get_config_path
- _cfg_path = _get_config_path()
- self._config_sig: tuple | None = config_version_or_none(_cfg_path)
- self._config_mcp_servers: dict = self.config.get("mcp_servers") or {}
- self._last_config_check: float = 0.0 # monotonic time of last check
- # Modal overlay states: each is a dict (with a response_queue) while active, else None.
- # The prompt_toolkit UI switches to the matching selection/input mode.
- self._clarify_state = None
- self._clarify_freetext = False # True when the user chose "Other" and is typing
- self._clarify_deadline = 0 # monotonic timeout
- self._sudo_state = None
- self._sudo_deadline = 0
- self._modal_input_snapshot = None
- self._approval_state = None
- self._approval_deadline = 0
- self._approval_lock = threading.Lock() # serialize concurrent approval prompts (delegation race)
- # Destructive slash-command confirmations (/new, /clear, /undo) are answered through the
- # composer, not raw input(), so the labels stay visible and Enter can't EOF the app.
- self._slash_confirm_state = None
- self._slash_confirm_deadline = 0
- self._command_running = False
- self._command_blocks_input = False
- self._command_status = ""
- self._secret_state = None # skill-setup secret capture
- self._secret_deadline = 0
- self._connection_state = None
- self._attached_images: list[Path] = [] # clipboard image attachments
- self._image_counter = 0
- # Voice mode state (protected by _voice_lock for cross-thread access).
- self._voice_lock = threading.Lock()
- self._voice_mode = False
- self._voice_tts = False
- self._voice_recorder = None # AudioRecorder (lazy init)
- self._voice_recording = False
- self._voice_processing, self._voice_live_text = False, "" # STT in progress; live partial text
- self._voice_continuous = False # auto-restart after the agent responds
- self._voice_tts_done = threading.Event() # TTS playback finished
- self._voice_tts_done.set() # initially "done" (no TTS pending)
- self._voice_tts_stop = None # active streaming pipeline's stop event
- self._voice_barge_capture = threading.Event() # barge monitor is capturing the interruption
- self._voice_last_tts_text = "" # most recently spoken TTS text (echo guard, #75780)
- self._voice_barge_phase = None # "generation" or "playback" phase of the last barge trip
- if os.environ.get("HERMES_DEFER_AGENT_STARTUP") != "1":
- self._install_tool_callbacks()
- def _tui_build_key_bindings(self):
- """Build the prompt_toolkit KeyBindings for the REPL input area.
- Registration ORDER matters: for the same key, prompt_toolkit picks the last matching
- binding, so the generic handlers (Tab, history Up/Down) are registered before or after
- their filtered modal overrides deliberately.
- """
- from cli import (
- CLI_CONFIG,
- _bind_prompt_submit_keys,
- _cli_multiline_shortcuts_enabled,
- _preserve_ctrl_enter_newline)
- from prompt_toolkit.keys import Keys
- kb = KeyBindings()
- _multiline_shortcuts_enabled = _cli_multiline_shortcuts_enabled(self.config or CLI_CONFIG)
- self._tui_multiline_shortcuts = _multiline_shortcuts_enabled
- kb.add(Keys.Ignore, eager=True)(self._tui_handle_ignored_terminal_sequence)
- _bind_prompt_submit_keys(
- kb, self._tui_handle_enter, multiline_shortcuts_enabled=_multiline_shortcuts_enabled)
- kb.add('escape', 'enter')(self._tui_insert_newline)
- # Ctrl+J inserts a newline (Claude Code / Codex / OpenCode). Windows Terminal delivers
- # Ctrl+Enter as the same c-j code. display.cli_multiline_shortcuts: false restores legacy
- # c-j submit on unusual POSIX PTYs where Enter is LF.
- if _multiline_shortcuts_enabled or _preserve_ctrl_enter_newline():
- kb.add('c-j')(self._tui_insert_newline)
- self._tui_bind_editor_and_stash(kb)
- self._tui_bind_overlay_navigation(kb)
- # History: the TextArea is multiline so Up/Down alone only move the cursor;
- # Buffer.auto_up/auto_down browse history when on the first/last line.
- _normal_input = Condition(
- lambda: not self._clarify_state and not self._approval_state and not self._slash_confirm_state
- and not self._sudo_state and not self._secret_state and not self._connection_state
- and not self._model_picker_state and not self._command_palette_state)
- kb.add('up', filter=_normal_input)(self._tui_history_up)
- kb.add('down', filter=_normal_input)(self._tui_history_down)
- kb.add('c-l')(self._tui_handle_ctrl_l)
- kb.add('c-c')(self._tui_handle_ctrl_c)
- # No Ctrl+Shift+C binding: terminal emulators intercept it before stdin, and
- # prompt_toolkit's key parser doesn't recognise 'c-S-c' anyway (#19884/#19895).
- kb.add('c-q')(self._tui_handle_ctrl_q)
- kb.add('c-d')(self._tui_handle_ctrl_d)
- _modal_prompt_active = Condition(
- lambda: bool(self._secret_state or self._sudo_state or self._slash_confirm_state
- or self._connection_state))
- kb.add('escape', filter=_modal_prompt_active, eager=True)(self._tui_handle_escape_modal)
- kb.add('escape', 'escape', filter=~_modal_prompt_active)(self._tui_handle_double_escape)
- kb.add('c-z')(self._tui_handle_ctrl_z)
- kb.add(*self._tui_voice_record_key_sequence())(self._tui_handle_voice_record)
- kb.add(Keys.BracketedPaste, eager=True)(self._tui_handle_paste)
- kb.add('c-v')(self._tui_handle_ctrl_v)
- kb.add('escape', 'v')(self._tui_handle_alt_v)
- from hermes_cli.cli_subagent_monitor import modal_prompt_active, open_monitor, toggle_dock
- for key in ('c-t', 'f6'):
- kb.add(key, filter=Condition(lambda: not modal_prompt_active(self)))(
- lambda event: open_monitor(self))
- # F7 is retained for terminals that forward the function-key sequence;
- # Ctrl+R is the portable fallback because macOS often reserves F7 for
- # a hardware control unless Fn/globe is held.
- kb.add('c-r', filter=Condition(lambda: not modal_prompt_active(self)))(
- lambda event: toggle_dock(self))
- kb.add('f7', filter=Condition(lambda: not modal_prompt_active(self)))(
- lambda event: toggle_dock(self))
- return kb
- def _tui_bind_editor_and_stash(self, kb) -> None:
- # VSCode/Cursor bind Ctrl+G to "Find Next" so it never reaches the terminal; Alt+G is
- # unbound there and arrives as ('escape', 'g') — register it as a fallback.
- _editor_filter = Condition(
- lambda: not self._clarify_state and not self._approval_state
- and not self._sudo_state and not self._secret_state and not self._connection_state)
- kb.add('c-g', filter=_editor_filter)(
- kb.add('escape', 'g', filter=_editor_filter)(self._tui_handle_open_in_editor))
- # Ctrl+S prompt stash: park a draft, send something else, bring it back. Suppressed while
- # a modal prompt owns the composer so Ctrl+S can't stash a password.
- _stash_filter = Condition(
- lambda: not self._clarify_state and not self._approval_state and not self._sudo_state
- and not self._secret_state and not self._connection_state and not self._slash_confirm_state
- and not self._model_picker_state
- )
- _stash_panel_filter = Condition(lambda: self._prompt_stash.panel_open and bool(len(self._prompt_stash)))
- kb.add('c-s', filter=_stash_filter)(self._tui_handle_prompt_stash)
- kb.add('up', filter=_stash_panel_filter, eager=True)(self._tui_handle_stash_panel_up)
- kb.add('down', filter=_stash_panel_filter, eager=True)(self._tui_handle_stash_panel_down)
- kb.add('enter', filter=_stash_panel_filter, eager=True)(self._tui_handle_stash_panel_restore)
- kb.add('d', filter=_stash_panel_filter, eager=True)(
- kb.add('D', filter=_stash_panel_filter, eager=True)(self._tui_handle_stash_panel_delete)
- )
- kb.add('escape', filter=_stash_panel_filter, eager=True)(self._tui_handle_stash_panel_close)
- kb.add('tab', eager=True)(self._tui_handle_tab)
- def _tui_bind_overlay_navigation(self, kb) -> None:
- """Clarify / approval / slash-confirm / model picker / command palette navigation keys."""
- _clarify_nav = Condition(lambda: bool(self._clarify_state) and not self._clarify_freetext)
- kb.add('up', filter=_clarify_nav)(self._tui_clarify_up)
- kb.add('down', filter=_clarify_nav)(self._tui_clarify_down)
- _connection_nav = Condition(lambda: bool(self._connection_state))
- kb.add('up', filter=_connection_nav)(self._tui_connection_up)
- kb.add('down', filter=_connection_nav)(self._tui_connection_down)
- kb.add('left', filter=_connection_nav)(self._tui_connection_side)
- kb.add('right', filter=_connection_nav)(self._tui_connection_side)
- # Multi-select: Space toggles the checkbox under the cursor.
- kb.add('space', filter=Condition(
- lambda: bool(self._clarify_state) and not self._clarify_freetext
- and self._clarify_state.get("multi_select")
- ))(self._tui_clarify_toggle)
- # Batch clarify: Tab / Shift-Tab cycle the active question (any-order answering; moving
- # onto an answered question lets the user re-answer it). Registered after the generic
- # tab handler so this filtered binding wins while the batch panel is open.
- kb.add('tab', filter=_clarify_nav, eager=True)(self._tui_clarify_batch_tab)
- kb.add('s-tab', filter=_clarify_nav, eager=True)(self._tui_clarify_batch_backtab)
- # Number keys: 1-9 select items 0-8, 0 selects item 9 (10th).
- for _num in range(10):
- _idx = 9 if _num == 0 else _num - 1
- kb.add(str(_num), filter=_clarify_nav)(self._tui_make_clarify_number_handler(_idx))
- _approval = Condition(lambda: bool(self._approval_state))
- _slash_confirm = Condition(lambda: bool(self._slash_confirm_state))
- _picker = Condition(lambda: bool(self._model_picker_state))
- kb.add('up', filter=_approval)(self._tui_approval_up)
- kb.add('down', filter=_approval)(self._tui_approval_down)
- kb.add('up', filter=_slash_confirm)(self._tui_slash_confirm_up)
- kb.add('down', filter=_slash_confirm)(self._tui_slash_confirm_down)
- kb.add('up', filter=_picker)(self._tui_model_picker_up)
- kb.add('down', filter=_picker)(self._tui_model_picker_down)
- def _model_picker_typing_active() -> bool:
- # Type-to-filter is only live on the model stage (concrete list).
- st = self._model_picker_state
- return bool(st) and st.get("stage") == "model"
- _picker_typing = Condition(_model_picker_typing_active)
- for _ch in _TYPING_CHARS:
- kb.add(_ch, filter=_picker_typing)(self._tui_make_model_filter_char_handler(_ch))
- kb.add('backspace', filter=_picker_typing)(self._tui_model_picker_filter_backspace)
- kb.add('escape', filter=_picker, eager=True)(self._tui_model_picker_escape)
- _palette = Condition(lambda: bool(self._command_palette_state))
- kb.add('c-p', filter=Condition(
- lambda: not self._command_palette_state and not self._model_picker_state and not self._clarify_state
- and not self._approval_state and not self._slash_confirm_state and not self._sudo_state
- and not self._secret_state and not self._connection_state
- ))(self._tui_open_command_palette)
- kb.add('up', filter=_palette)(self._tui_command_palette_up)
- kb.add('down', filter=_palette)(self._tui_command_palette_down)
- kb.add('enter', filter=_palette)(self._tui_command_palette_enter)
- kb.add('backspace', filter=_palette)(self._tui_command_palette_backspace)
- kb.add('escape', filter=_palette, eager=True)(self._tui_command_palette_escape)
- for _pch in _TYPING_CHARS:
- kb.add(_pch, filter=_palette)(self._tui_make_palette_char_handler(_pch))
- for _num in range(10):
- _idx = 9 if _num == 0 else _num - 1
- kb.add(str(_num), filter=_approval)(self._tui_make_approval_number_handler(_idx))
- for _num in range(10):
- _idx = 9 if _num == 0 else _num - 1
- kb.add(str(_num), filter=_slash_confirm)(self._tui_make_slash_confirm_number_handler(_idx))
- def _tui_voice_record_key_sequence(self) -> tuple:
- """Resolve the push-to-talk key (voice.record_key, default Ctrl+B) to a prompt_toolkit
- key sequence and cache the UI label.
- Config spellings (ctrl/control/alt/option/opt) are normalized to c-x / a-x so the same
- value binds identically in TUI and CLI. super/win/windows silently fall back to the
- default (prompt_toolkit has no super modifier) — warn so users notice the split. The
- label cache uses the same ``_raw_key`` that drives the binding, so status/placeholder/
- recording-hint renders can never drift from the live key even if the config is edited
- mid-session.
- """
- from cli import logger
- # Voice push-to-talk key: configurable via config.yaml (voice.record_key) Default: Ctrl+B (avoids
- # conflict with Ctrl+R readline reverse-search). Config spellings (ctrl/control/alt/option/opt) are
- # normalized to prompt_toolkit's c-x / a-x format via
- # ``normalize_voice_record_key_for_prompt_toolkit`` so the same config value binds identically in
- # the TUI and CLI (review round-9 on #19835). ``super``/``win``/``windows`` configs silently
- # fall back to the default here since prompt_toolkit has no super modifier — log a warning so users
- # notice the TUI/CLI split instead of a silent mismatch (round-11).
- _raw_key: object = "ctrl+b"
- try:
- from hermes_cli.config import load_config
- from hermes_cli.voice import (
- normalize_voice_record_key_for_prompt_toolkit,
- pt_key_to_sequence,
- voice_record_key_from_config)
- _raw_key = voice_record_key_from_config(load_config())
- _voice_key = normalize_voice_record_key_for_prompt_toolkit(_raw_key)
- if (
- isinstance(_raw_key, str)
- and _raw_key.strip().lower().split("+", 1)[0].strip() in {"super", "win", "windows"}
- and _voice_key == "c-b"):
- logger.warning(
- "voice.record_key %r uses a TUI-only modifier (super/win); "
- "CLI fell back to Ctrl+B. Use ctrl+<key> or alt+<key> for "
- "cross-runtime parity.",
- _raw_key)
- except Exception:
- _voice_key = "c-b"
- # Cache the UI label here — same ``_raw_key`` that drives the prompt_toolkit binding below. Every
- # status / placeholder / recording-hint render reads this cached value so display can never drift
- # from the live keybinding even if the user edits voice.record_key mid-session (review round-13 on
- # #19835).
- self.set_voice_record_key_cache(_raw_key)
- return pt_key_to_sequence(_voice_key)
- def _tui_overlay_widget(self, fragments_fn, state_attr: str):
- """Wrapped, auto-sized panel shown while ``self.<state_attr>`` is not None."""
- return ConditionalContainer(
- Window(FormattedTextControl(fragments_fn), wrap_lines=True),
- filter=Condition(lambda: getattr(self, state_attr) is not None))
- def _tui_build_layout(self, kb):
- """Build the TUI widgets, Layout and Style; registers wrapper keybindings on ``kb``."""
- cli_ref = self
- from hermes_cli.cli_subagent_monitor import install_dock
- install_dock(self)
- input_area = self._tui_build_input_area()
- spinner_widget = Window(
- content=FormattedTextControl(self._tui_spinner_text),
- height=self._tui_spinner_height,
- wrap_lines=True)
- # Petdex mascot — right-aligned Kitty placeholder or half-block sprite above the prompt;
- # height 0 when no pet is enabled. The animation thread queues virtual Kitty frames;
- # after_render writes them out-of-band while prompt_toolkit owns the placeholder grid.
- self._pet_widget = Window(
- content=FormattedTextControl(self._pet_fragments),
- height=self._pet_widget_height,
- align=WindowAlign.RIGHT)
- # Hint line above the input: only for interactive prompts that need extra instructions
- # (sudo countdown, approval navigation, clarify); the agent-running hint is the placeholder.
- spacer = Window(content=FormattedTextControl(self._tui_hint_text), height=self._tui_hint_height)
- clarify_widget = self._tui_overlay_widget(self._get_clarify_display_fragments, "_clarify_state")
- sudo_widget = self._tui_overlay_widget(self._get_sudo_display_fragments, "_sudo_state")
- secret_widget = self._tui_overlay_widget(self._get_secret_display_fragments, "_secret_state")
- connection_widget = self._tui_overlay_widget(
- self._get_connection_display_fragments, "_connection_state")
- approval_widget = self._tui_overlay_widget(self._get_approval_display_fragments, "_approval_state")
- slash_confirm_widget = self._tui_overlay_widget(
- self._get_slash_confirm_display_fragments, "_slash_confirm_state")
- model_picker_widget = self._tui_overlay_widget(
- self._get_model_picker_display_fragments, "_model_picker_state")
- command_palette_widget = self._tui_overlay_widget(
- self._get_command_palette_display_fragments, "_command_palette_state")
- # Rules above/below the input; narrow terminals hide the bottom one to recover a row.
- input_rule_top = Window(
- char='─', height=lambda: cli_ref._tui_input_rule_height("top"), style='class:input-rule',
- )
- input_rule_bot = Window(
- char='─', height=lambda: cli_ref._tui_input_rule_height("bottom"), style='class:input-rule',
- )
- if getattr(self, "_modern_layout", False):
- from hermes_cli.cli_modern_layout import modern_input_rules
- input_rule_top, input_rule_bot = modern_input_rules(self, kb)
- image_bar = Window(
- content=FormattedTextControl(self._tui_image_bar_fragments),
- height=Condition(lambda: bool(cli_ref._attached_images)))
- voice_status_bar = ConditionalContainer(
- Window(FormattedTextControl(self._tui_voice_status_fragments), height=1),
- filter=Condition(lambda: cli_ref._voice_mode))
- status_bar = ConditionalContainer(
- Window(
- content=FormattedTextControl(lambda: cli_ref._get_status_bar_fragments()),
- height=1,
- # wrap_lines=False: fragments overflowing the width must never wrap onto a second
- # row (looked like a duplicated status bar on long SSH sessions with stale
- # shutil sizes). _get_status_bar_fragments reads prompt_toolkit's own width, so
- # this is the belt-and-suspenders guard.
- wrap_lines=False),
- filter=Condition(
- lambda: cli_ref._status_bar_visible
- and not getattr(cli_ref, "_status_bar_suppressed_after_resize", False)))
- # Stash browse panel — just above the status bar, Ctrl+S on an empty composer with 2+ drafts.
- self._stash_panel_widget = ConditionalContainer(
- Window(FormattedTextControl(self._get_stash_panel_display_fragments), wrap_lines=False),
- filter=Condition(lambda: cli_ref._prompt_stash.panel_open and bool(len(cli_ref._prompt_stash))),
- )
- self._register_extra_tui_keybindings(kb, input_area=input_area)
- layout = Layout(FooterSplit(self._build_tui_layout_children(
- sudo_widget=sudo_widget,
- secret_widget=secret_widget,
- connection_widget=connection_widget,
- approval_widget=approval_widget,
- slash_confirm_widget=slash_confirm_widget,
- clarify_widget=clarify_widget,
- model_picker_widget=model_picker_widget,
- command_palette_widget=command_palette_widget,
- spinner_widget=spinner_widget,
- spacer=spacer,
- status_bar=status_bar,
- input_rule_top=input_rule_top,
- image_bar=image_bar,
- input_area=input_area,
- input_rule_bot=input_rule_bot,
- voice_status_bar=voice_status_bar,
- completions_menu=CompletionsMenu(max_height=12, scroll_offset=1))))
- self._tui_set_base_style()
- return layout, PTStyle.from_dict(self._build_tui_style_dict())
- def _tui_build_input_area(self):
- """Multi-line prompt TextArea with slash completion, paste-collapse tracking and
- placeholder/password processors."""
- from cli import _estimate_tui_input_height
- from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
- from prompt_toolkit.completion import ThreadedCompleter
- cli_ref = self
- def get_prompt():
- return cli_ref._get_tui_prompt_fragments()
- _completer = cli_slash_completer(self)
- input_area = TextArea(
- height=Dimension(min=1, max=8, preferred=1),
- prompt=get_prompt,
- style='class:input-area',
- multiline=True,
- wrap_lines=True,
- read_only=Condition(lambda: bool(cli_ref._command_blocks_input)),
- history=FileHistory(str(self._history_file)),
- # The completer does blocking work (fuzzy @-file indexing shells out to rg/fd with a 2s timeout;
- # path completion hits os.listdir/stat), so complete_while_typing inline would stall the render
- # loop per keystroke (WSL2/slow FS). ThreadedCompleter moves it off the UI event loop.
- completer=ThreadedCompleter(_completer),
- complete_while_typing=True,
- auto_suggest=SlashCommandAutoSuggest(history_suggest=AutoSuggestFromHistory(), completer=_completer),
- )
- # Keep prompt_toolkit on its simple tempfile path: buffer.tempfile = "prompt.md" takes
- # the complex-tempfile branch that re-mkdir()s the mkdtemp() dir and raises EEXIST.
- input_area.buffer.tempfile_suffix = '.md'
- def _input_height():
- # Accounts for explicit newlines AND visual wrapping so the area fits its content.
- try:
- from prompt_toolkit.application import get_app
- doc = input_area.buffer.document
- try:
- terminal_columns = get_app().output.get_size().columns
- except Exception:
- terminal_columns = shutil.get_terminal_size((80, 24)).columns
- return _estimate_tui_input_height(doc.lines, self._get_tui_prompt_text(), terminal_columns)
- except Exception:
- return 1
- input_area.window.height = _input_height
- # Paste collapsing state (large pastes are saved to a file and replaced by a placeholder).
- self._tui_paste_counter = 0
- self._tui_prev_text_len = 0
- self._tui_prev_newline_count = 0
- self._tui_paste_just_collapsed = False
- self._skip_paste_collapse = False
- input_area.buffer.on_text_changed += self._tui_on_text_changed
- # Mask input with '*' while a sudo/secret prompt is active.
- input_area.control.input_processors.append(ConditionalProcessor(
- PasswordProcessor(),
- filter=Condition(lambda: (bool(cli_ref._sudo_state)
- and (cli_ref._sudo_state.get("vault_save") or {}).get("step") != "identifier"
- and not cli_ref._sudo_state.get("vault_code"))
- or bool(cli_ref._secret_state)
- or (bool(cli_ref._connection_state)
- and cli_ref._connection_active_field_is_secret()))))
- class _PlaceholderProcessor(Processor):
- """Render grayed-out placeholder text inside the input when empty."""
- def __init__(self, get_text):
- self._get_text = get_text
- def apply_transformation(self, ti):
- if not ti.document.text and ti.lineno == 0:
- text = self._get_text()
- if text:
- # Append after existing fragments (preserves the ❯ prompt).
- return Transformation(fragments=ti.fragments + [('class:placeholder', text)])
- return Transformation(fragments=ti.fragments)
- input_area.control.input_processors.append(_PlaceholderProcessor(self._tui_placeholder_text))
- return input_area
- def _tui_set_base_style(self):
- """Populate ``self._tui_style_base`` (skin-aware defaults the style dict is built from)."""
- self._tui_style_base = {
- # Empty input/prompt styles inherit the terminal's own fg/bg so typed text is readable
- # in both light and dark schemes (a hardcoded near-white was invisible on light).
- 'input-area': '',
- 'placeholder': '#888888 italic',
- 'prompt': '',
- 'prompt-working': '#888888 italic',
- 'hint': '#888888 italic',
- 'status-bar': 'bg:#1a1a2e #C0C0C0',
- 'status-bar-strong': 'bg:#1a1a2e #FFD700 bold',
- 'status-bar-dim': 'bg:#1a1a2e #8B8682',
- 'status-bar-good': 'bg:#1a1a2e #8FBC8F bold',
- 'status-bar-warn': 'bg:#1a1a2e #FFD700 bold',
- 'status-bar-bad': 'bg:#1a1a2e #FF8C00 bold',
- 'status-bar-critical': 'bg:#1a1a2e #FF6B6B bold',
- 'status-bar-yolo': 'bg:#1a1a2e #FF4444 bold',
- 'status-bar-session-title': 'bg:#FFD700 #1a1a2e bold',
- 'input-rule': '#CD7F32',
- 'image-badge': '#87CEEB bold',
- 'completion-menu': 'bg:#1a1a2e #FFF8DC',
- 'completion-menu.completion': 'bg:#1a1a2e #FFF8DC',
- 'completion-menu.completion.current': 'bg:#333355 #FFD700',
- 'completion-menu.meta.completion': 'bg:#1a1a2e #888888',
- 'completion-menu.meta.completion.current': 'bg:#333355 #FFBF00',
- 'clarify-border': '#CD7F32',
- 'clarify-title': '#FFD700 bold',
- 'clarify-question': '#FFF8DC bold',
- 'clarify-choice': '#AAAAAA',
- 'clarify-selected': '#FFD700 bold',
- 'clarify-active-other': '#FFD700 italic',
- 'clarify-answer': '#98FB98',
- 'clarify-countdown': '#CD7F32',
- 'sudo-prompt': '#FF6B6B bold',
- 'sudo-border': '#CD7F32',
- 'sudo-title': '#FF6B6B bold',
- 'sudo-text': '#FFF8DC',
- 'approval-border': '#CD7F32',
- 'approval-title': '#FF8C00 bold',
- 'approval-desc': '#FFF8DC bold',
- 'approval-cmd': '#AAAAAA italic',
- 'approval-choice': '#AAAAAA',
- 'approval-selected': '#FFD700 bold',
- 'voice-prompt': '#87CEEB',
- 'voice-recording': '#FF4444 bold',
- 'voice-processing': '#FFA500 italic',
- 'voice-status': 'bg:#1a1a2e #87CEEB',
- 'voice-status-recording': 'bg:#1a1a2e #FF4444 bold'}
|