The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Enter arriving inside a fast input burst: pasted newline or scripted submit.
Paste without bracketed paste (tmux ``paste-buffer`` without ``-p``) and IME/voice dictation
deliver every newline as its own Enter key right behind the text, so an Enter within
``RAPID_INPUT_ENTER_WINDOW_S`` of the last buffer change is a line break, not a submit (#10994).
A script typing ``text`` + Enter in ONE write (``tmux send-keys 'text' Enter``, a PTY write of
``text\\r``) looks identical up to that Enter, except nothing follows it and no other Enter came
before it. So an Enter with more keys of the same read still queued stays a newline, and so does
the last Enter of a burst that already held one (the tail of a multi-line paste: input never went
quiet for ``BURST_END_QUIET_S`` since that earlier Enter, however long the paste ran). The lone Enter
that ends a burst inserts a provisional newline and submits once input has stayed quiet for
``BURST_END_QUIET_S``; any input in that window (the next chunk of a paste split across reads)
keeps the newline.
"""
from __future__ import annotations
from time import monotonic
RAPID_INPUT_ENTER_WINDOW_S = 0.05
# Long enough for the next read of a paste split across reads (slow SSH links), short enough
# that a scripted submit still feels immediate. Humans never reach this path: their Enter comes
# more than RAPID_INPUT_ENTER_WINDOW_S after the last keystroke.
BURST_END_QUIET_S = 0.25
def note_text_change(cli) -> float:
"""Record a buffer change; input arriving inside the quiet window keeps a paste burst alive.
So does input arriving while an Enter is held, however late a stalled loop reads it: it makes
that Enter a pasted newline, so the paste's own trailing Enter stays one too.
"""
now = monotonic()
held = getattr(cli, "_tui_held_enter", None) is not None
if held or now - getattr(cli, "_tui_paste_burst_at", float("-inf")) < BURST_END_QUIET_S:
cli._tui_paste_burst_at = now
cli._tui_held_enter = None
return now
def handle_burst_enter(cli, event, buf) -> bool:
"""Handle an Enter that arrived mid-burst; False when it is an ordinary (human) Enter.
``cli._tui_submit_buffer(event, buf)`` is called later when this Enter turns out to end the
burst.
"""
now = monotonic()
if now - getattr(cli, "_tui_last_text_change", 0.0) >= RAPID_INPUT_ENTER_WINDOW_S:
return False
pasted_newline_before = now - getattr(cli, "_tui_paste_burst_at", float("-inf")) < BURST_END_QUIET_S
cli._tui_paste_burst_at = now
before = buf.document # the newline lands at the cursor, not necessarily at the end
buf.insert_text("\n")
app = event.app
key_processor = getattr(app, "key_processor", None)
loop = getattr(app, "loop", None)
if key_processor is None or loop is None or key_processor.input_queue or pasted_newline_before:
return True # inside (or the tail of) a multi-line paste
with_newline = buf.document
changed_at = getattr(cli, "_tui_last_text_change", 0.0)
held = cli._tui_held_enter = object()
def _settle() -> None:
if cli._tui_held_enter is held:
cli._tui_held_enter = None
if not app.is_running or buf.document != with_newline or cli._tui_last_text_change != changed_at:
return # more input arrived (or the buffer was edited): the newline stays
buf.document = before
cli._tui_submit_buffer(event, buf)
app.invalidate()
# Decide only after one more selector pass has run its reader callbacks: a loop stalled past
# the window can reach this timer with the next chunk still unread (a signal handler that
# interrupts the selector past its deadline returns no events). asyncio runs a call_soon
# queued now ahead of the next pass's readers; the second hop runs after them.
loop.call_later(BURST_END_QUIET_S, loop.call_soon, loop.call_soon, _settle)
return True