Skip to content

The agent that grows with you

3.8 KB
Raw Blame
"""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