sjmaZdZddlmZdZddZdd Zdd Zdd Zdd ZddZ ddZ ddZ dS)uAugmentations to prompt_toolkit's input-parsing tables. Imported once at CLI startup. Each helper installs a small mapping into prompt_toolkit's `ANSI_SEQUENCES` so byte sequences emitted by modern keyboard protocols (Kitty / xterm `modifyOtherKeys`) decode to existing key tuples Hermes already binds. Kept in a standalone module — separate from `cli.py` — so the registrations can be unit-tested without importing the whole CLI runtime. ) annotations)r@modifierintreturntuple[int, ...]cDtfdtDS)z9Return ``modifier`` plus its CapsLock/NumLock/both twins.c3"K|] }|zV dSN.0offrs >/home/agent/.hermes/hermes-agent/hermes_cli/pt_input_extras.py z!_lock_variants..s'==CC======tuple_LOCK_BIT_OFFSETSrs`r_lock_variantsrs' ====+<=== = ==rcTtfdtddDS)zBReturn only the lock twins of ``modifier`` (never the base value).c3"K|] }|zV dSr rrs rrz_lock_twins..s'AACCAAAAAArNrrs`r _lock_twinsrs0 AAAA+z-install_shift_enter_alias..T 7 7 7OqOOO 7 7 7rz [27;2;13~z r *prompt_toolkit.input.ansi_escape_sequencesr(prompt_toolkit.keysr*r$EscapeControlMrgetr%r(r* alt_enterchangedseqsseqs rinstall_shift_enter_aliasr>3s2MMMMMM,,,,,,, qqdm,IG 7 7^A%6%6 7 7 7D_o ..D   c " "i / /"+N3  qLG$!### N  c ddlm}ddlm}n#t$rYdSwxYw|j|jf}d}dtdD}|ddgz }|D]%}|||kr |||<|dz }&|rt|S) uMap Ctrl+Enter byte sequences to the (Escape, ControlM) key tuple that Alt+Enter produces, so the existing Alt+Enter newline handler fires for terminals that emit a distinct Ctrl+Enter. Sequences mapped: - "\x1b[13;5u" — Kitty keyboard protocol / CSI-u, modifier=5 (Ctrl) (plus its CapsLock/NumLock lock twins via ``_lock_variants``) - "\x1b[27;5;13~" — xterm modifyOtherKeys=2, modifier=5 (Ctrl) - "\x1b[27;5;13u" — alternate ordering some emitters use Stock prompt_toolkit maps only the tilde form ``\x1b[27;5;13~`` (to plain ``Keys.ControlM``, which this deliberately overwrites — same bug-fix rationale as install_shift_enter_alias). Without this alias, Kitty/mintty/xterm-with-modifyOtherKeys users over SSH never get a Ctrl+Enter newline — the keystroke arrives as a raw CSI sequence that falls through to the default character-insert handler. See #22379. Returns the number of sequences whose mapping was changed. rr'r)cg|]}d|d Sr,rr.s rr0z,install_ctrl_enter_alias..{r1rz [27;5;13~z rr3r9s rinstall_ctrl_enter_aliasrC_s(MMMMMM,,,,,,, qqdm,IG 7 7^A%6%6 7 7 7D_o ..D   c " "i / /"+N3  qLG$!### Nr?c` ddlm}ddlm}n#t$rYdSwxYwi}dD]0}t |D]}|j|d|d<|j|d|d<1|j|d <d}|D](\}}| ||kr |||<|d z })|rt|S) uPMap Cmd+Backspace / Cmd+ForwardDelete to the readline kill bindings prompt_toolkit already ships (``unix-line-discard`` / ``kill-line``). Terminals that rewrite Cmd+Backspace to Ctrl+U (``\x15``) already work. Kitty keyboard protocol and xterm modifyOtherKeys terminals instead report Cmd as the *super* modifier bit (8), producing sequences prompt_toolkit does not map — the raw bytes then fall through to literal insertion. Cmd+Backspace → ``Keys.ControlU`` (kill backward to start of line). Codepoint 127 with modifier 9 (super) / 10 (super+shift), each with its CapsLock/NumLock lock twins via ``_lock_variants``: - ``\x1b[127;9u`` / ``\x1b[127;10u`` — Kitty CSI-u - ``\x1b[27;9;127~`` — xterm modifyOtherKeys Cmd+ForwardDelete → ``Keys.ControlK`` (kill to end of line). The forward-delete key is a CSI *tilde* key, not a CSI-u codepoint, so the modifier rides in the standard ``CSI 3 ; mod ~`` form: - ``\x1b[3;9~`` / ``\x1b[3;10~`` Returns the number of sequences whose mapping was changed. rr'r)) z-z[3;~z [27;9;127~r) r4r(r5r*r$rControlUControlKitemsr8r%)r(r*aliasesbasemodr;r=keys rinstall_cmd_backspace_aliasrOs*.MMMMMM,,,,,,, qq"$G66!$'' 6 6C*.-G&&&& '(, G$c$$$ % % 6!% G GMMOOS   c " "c ) )"%N3  qLG$!### Nr?c   ddlmddlm}n#t$rYdSwxYwi}t t dt ddzD]0}t|dz}|}||||<1t d D](}t|d ||t d |z<)d D]0}t|dz}|}||||<1dd@fd }|d|i}t t dt ddzD]>}t|} t|dz } |j | f||<|j | f||dz <?|d|i} t t dt ddzD]!}t|dz } | | |<| | |dz <"|d| i} i}i}t t dt ddzD]R}t|dz } ||}||dz fD]!}|j | f| |<||||<|j |f||<"S|d| |d||d||d|dgdt ddDzD]}|vr|j |<dz |d|j |j dd |d|j |j f|j |j f|j dfd!|d|j|j |j fd"|d|j|j d|j d#t ddD]}d$D]s}|dkrd%||nd&|}|}||dkrd'|}|Lt|D]}d%||}|vr ||<dz td(D]X}|dkr d&|d)|d*nd&|d*}|}|/t|D]}d&|d)|d*}|vr ||<dz Yi}t d D]}t!||d+|z<|d,d-d.d/d0|j d1d2d3||j|j|j|j|j|j|j|j|j|jd4 t d5d6D]}t|d7||d8|d5z z<t9t d9d:t9t d;d+zdzD]}|||j|D]B\}}d&|d?}|vr ||<dz tdD]}d&|d)|d?}|vr ||<dz CrtAS)Au Map Ctrl+key and Alt+key sequences emitted under ``modifyOtherKeys`` level 2 and Kitty CSI-u to the same ``Keys``.* values that the raw control bytes already map to. When the terminal is in ``modifyOtherKeys=2`` mode (pushed by ``_enable_extended_enter_keys`` so Shift+Enter is distinguishable from Enter), the terminal re-encodes *every* Ctrl+key combo as ``ESC[27;5;~`` instead of the raw control byte (``\x01`` etc.). Kitty keyboard protocol emits ``ESC[;5u``. Stock prompt_toolkit 3.x only maps ``ESC[27;5;13~`` (Ctrl+Enter = Ctrl+M); all other Ctrl+letter combos are unmapped and leak as literal text or get swallowed — breaking Ctrl+A, Ctrl+C, Ctrl+D, Ctrl+E, Ctrl+K, Ctrl+R, Ctrl+U, Ctrl+W, Ctrl+Z, etc. (#56684, #86866, #87390). This function populates ``ANSI_SEQUENCES`` for the full set: * **Ctrl+letter** (a–z): ``ESC[27;5;~`` and ``ESC[;5u`` → ``Keys.ControlA`` .. ``Keys.ControlZ`` * **Ctrl+digit** (0–9): same formats → ``Keys.Control0`` .. ``Keys.Control9`` * **Ctrl+symbol** (``[`` ``\`` ``]`` ``^`` ``_`` `` `` ``@``): same formats → the same ``Keys`` value the raw control byte maps to. * **Alt+letter** (a–z, A–Z): ``ESC[27;3;~`` and ``ESC[;3u`` → ``(Keys.Escape, )`` — matching how prompt_toolkit handles a bare ``ESC`` followed by a character. * **Shift+letter** (a–z): → the uppercase character. * **Multi-modifier letters** (Shift+Alt=4, Ctrl+Shift=6, Ctrl+Alt=7, Ctrl+Alt+Shift=8): normalized onto the same targets — Ctrl-bearing combos behave as the Ctrl key (Alt adds an ``Escape`` prefix), matching how dte/kakoune normalize these protocols. * **Lock-bit variants**: every CSI-u mapping above is also installed with the CapsLock (64) and NumLock (128) bits ORed into the modifier parameter — kitty/ghostty include them while a lock is on, and without the variants every key combo dies with the lock enabled (``ESC[99;133u`` instead of ``ESC[99;5u``, #89651). * **Esc key**: ``ESC[27u`` / ``ESC[27;u`` (Kitty disambiguate mode reports Esc this way, #56684) → ``Keys.Escape``. * **Modified Enter/Tab/Backspace/Space**: Alt+Enter → the Alt+Enter newline tuple; Shift+Tab → ``BackTab``; Ctrl+Tab → plain Tab; Ctrl/Alt+Backspace → ``(Escape, ControlH)`` (backward-kill-word, matching the Ink TUI and Desktop, #78285); Shift+Backspace → plain backspace; Shift+Space → a plain space (#86866); Alt+Space → ``(Escape, " ")``. * **Kitty functional keys** (Private Use Area codepoints): keypad keys → their non-keypad equivalents (KP_ENTER → Enter, KP_4 → '4', KP_LEFT → Left, …); F13–F24 → ``Keys.F13``..``F24``; lock/media/ modifier-event keys → ``Keys.Ignore`` so they are consumed instead of leaking as literal text. kitty emits these CSI-u forms even in legacy mode for keys that have no legacy encoding. Existing mappings (including those installed by ``install_shift_enter_alias`` / ``install_ctrl_enter_alias``) are never overwritten — ``setdefault`` semantics. Returns the number of sequences whose mapping was newly installed. rr'r)azrNrFControl0)r[\]^_ rrmappingdictr rc |D]X\}}|dkrgn d|d|dg}t|D]}|d|d|d|D]}|vr ||<dz YdS)u Install both modifyOtherKeys (ESC[27;N;CP~) and CSI-u (ESC[CP;Nu) mappings for the given modifier and codepoint→key mapping. The tilde form is skipped for modifier 1 ("no modifier") — xterm never emits modifier-1 tilde sequences. r[27;;rG-N)rJrappend) rr\ codepointkey_valr<rMr=r(r;s r_install_pairedz:install_modify_other_keys_aliases.._install_paireds#*--// ! ! Iw!Q22-O-O-O9-O-O-O,PD%h// 8 8 6I666667777 ! !n,,*1N3'qLG !  ! !rrBr[r2zc>g|]}t|D]}d|d S)r_r-)r)rr/rMs rr0z5install_modify_other_keys_aliases..qsR !!$$  3r )rEr[) rnr[)rErn)rEror[rn ABCDFHPQRSzazO)rr2rfrgrBrhrirjr`rGi7./*-+=,)iAiBiCiDiEiFiGiH) iIiJiKiLiMiNiOiPiQiRroFi iii,iSiTior-)rrr\r]r r)!r4r(r5r*r$rangeordchrr8getattrr6BackTabControlHr7ControlIrstrupdateLeftRightUpDownPageUpPageDownHomeEndInsertDeletelist setdefaultIgnorerJr%)r* ctrl_key_mapchrawexistingdrcrealt_mapletterupper shift_map upper_char shift_alt_mapctrl_shift_map ctrl_alt_mapctrl_keycpr=r/trailerbase_seqrNrMnumfunctional_mapncoderdr(r;s @@r!install_modify_other_keys_aliasesrsXrMMMMMM,,,,,,, qq')LCHHc#hhl++(("t)nn!%%c**  'L  2YYBB%,T=Q==%A%A SXX\""2// )d"##!%%c**  &.L #G!!!!!!!$OA|$$$ !#GCHHc#hhl++00RBG {F+  K/ROAw!#ICHHc#hhl++((b\\ " " ' "r'OAy!!!')M(*N%'LCHHc#hhl++;;b\\ ##B''rBw- ; ;B!%j 9M" #%-r"$(K#: R  ; OA}%%%OA~&&&OA|$$$OA|$$$|q" n $ $"&+N3  qLG OA < ]  OA [$- (k4= ) [#  OA =k4= )OA = M  ] "1b\\!!# ! !G12Q--G--->  C'$'''''C.((&-s#1   $!### Ns  c ddlm}ddlm}n#t$rYdSwxYwd}dD]}||vr|j||<|dz }|rt |S)uMap terminal-emitted noise sequences to ``Keys.Ignore`` so they are consumed by the VT100 parser before they reach key bindings or the input buffer. Currently covers focus reports: - ``\x1b[I`` — terminal regained focus (focus in) - ``\x1b[O`` — terminal lost focus (focus out) Ghostty, iTerm2, and some xterm builds can emit these sequences when the user switches tabs / windows or when a multiplexer toggles focus tracking upstream. prompt_toolkit does not map these by default, so its parser falls back to literal key presses (ESC, ``[``, ``I``/``O``) and inserts ``[I``/``[O`` into the prompt buffer after the ESC byte is handled. Registering them as ``Keys.Ignore`` is parser-level — strictly cleaner than post-hoc regex stripping in the input sanitizer because the bytes never reach the buffer. ``setdefault`` is used so any user or downstream registration wins. Returns the number of sequences whose mapping was changed. rr'r))zzr)r4r(r5r*r$rr%)r(r*r;r=s r"install_ignored_terminal_sequencesrs.MMMMMM,,,,,,, qqG# n $ $"&+N3  qLG$!### Nr?N)rrr r )r r)r r) __doc__ __future__rrrrr%r>rCrOrrrrrrs  #"""""&>>>> BBBB     $))))X$$$$N****Z||||~ $$$$$$r