chore: import upstream snapshot with attribution

surfaces/interactive_shell/runtime/input/__init__.py

@@ -0,0 +1,37 @@
+"""Prompt input event reader for the interactive shell runtime."""
+
+from surfaces.interactive_shell.runtime.input.actions import (
+    QUEUE_DURING_CONFIRMATION_WARNING,
+    CancelTurn,
+    CloseShell,
+    DeliverConfirmation,
+    IgnoreInput,
+    InputAction,
+    ShellInputSnapshot,
+    SubmitTurn,
+    decide_input_action,
+)
+from surfaces.interactive_shell.runtime.input.events import (
+    InputCancelled,
+    InputClosed,
+    InputEvent,
+    InputSubmitted,
+)
+from surfaces.interactive_shell.runtime.input.prompt_input_reader import PromptInputReader
+
+__all__ = [
+    "CancelTurn",
+    "CloseShell",
+    "DeliverConfirmation",
+    "IgnoreInput",
+    "InputAction",
+    "InputCancelled",
+    "InputClosed",
+    "InputEvent",
+    "InputSubmitted",
+    "PromptInputReader",
+    "QUEUE_DURING_CONFIRMATION_WARNING",
+    "ShellInputSnapshot",
+    "SubmitTurn",
+    "decide_input_action",
+]

surfaces/interactive_shell/runtime/input/actions.py

@@ -0,0 +1,109 @@
+"""Pure input-action decisions for the interactive shell controller."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from surfaces.interactive_shell.runtime.core.turn_detection import (
+    looks_like_cancel_request,
+    looks_like_confirmation_answer,
+)
+from surfaces.interactive_shell.runtime.input.events import (
+    InputCancelled,
+    InputClosed,
+    InputEvent,
+    InputSubmitted,
+)
+
+QUEUE_DURING_CONFIRMATION_WARNING = (
+    "[dim](type y/N to confirm the pending action; your input has been queued for after)[/]"
+)
+
+
+@dataclass(frozen=True)
+class ShellInputSnapshot:
+    exit_requested: bool
+    dispatch_running: bool
+    awaiting_confirmation: bool
+
+
+@dataclass(frozen=True)
+class IgnoreInput:
+    pass
+
+
+@dataclass(frozen=True)
+class CloseShell:
+    pass
+
+
+@dataclass(frozen=True)
+class CancelTurn:
+    submitted_text: str | None = None
+
+
+@dataclass(frozen=True)
+class DeliverConfirmation:
+    text: str
+
+
+@dataclass(frozen=True)
+class SubmitTurn:
+    text: str
+    wait_until_idle: bool = False
+    warning: str | None = None
+
+
+InputAction = IgnoreInput | CloseShell | CancelTurn | DeliverConfirmation | SubmitTurn
+
+
+def decide_input_action(
+    event: InputEvent,
+    snapshot: ShellInputSnapshot,
+    *,
+    needs_exclusive_stdin: Callable[[str], bool],
+) -> InputAction:
+    """Interpret one prompt event without mutating runtime state."""
+    match event:
+        case InputClosed():
+            return CloseShell()
+        case InputCancelled():
+            return CancelTurn()
+        case InputSubmitted(text):
+            if snapshot.exit_requested or not text:
+                return IgnoreInput()
+
+            stripped = text.strip()
+            if not stripped:
+                return IgnoreInput()
+
+            if snapshot.dispatch_running and looks_like_cancel_request(stripped):
+                return CancelTurn(submitted_text=stripped)
+
+            if snapshot.awaiting_confirmation:
+                if looks_like_confirmation_answer(stripped):
+                    return DeliverConfirmation(text=stripped)
+                return SubmitTurn(
+                    text=stripped,
+                    warning=QUEUE_DURING_CONFIRMATION_WARNING,
+                )
+
+            return SubmitTurn(
+                text=stripped,
+                wait_until_idle=needs_exclusive_stdin(stripped),
+            )
+    raise AssertionError(f"Unhandled input event: {event!r}")
+
+
+__all__ = [
+    "CancelTurn",
+    "CloseShell",
+    "DeliverConfirmation",
+    "IgnoreInput",
+    "InputAction",
+    "QUEUE_DURING_CONFIRMATION_WARNING",
+    "ShellInputSnapshot",
+    "SubmitTurn",
+    "decide_input_action",
+]

surfaces/interactive_shell/runtime/input/events.py

@@ -0,0 +1,26 @@
+"""Explicit input events consumed by the interactive shell loop."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class InputSubmitted:
+    text: str
+
+
+@dataclass(frozen=True)
+class InputCancelled:
+    pass
+
+
+@dataclass(frozen=True)
+class InputClosed:
+    pass
+
+
+InputEvent = InputSubmitted | InputCancelled | InputClosed
+
+
+__all__ = ["InputCancelled", "InputClosed", "InputEvent", "InputSubmitted"]

surfaces/interactive_shell/runtime/input/prompt_input_reader.py

@@ -0,0 +1,74 @@
+"""Convert prompt-toolkit terminal behavior into shell input events."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+from platform.terminal.prompt_support import (
+    print_session_resume_hint,
+    repl_prompt_note_ctrl_c,
+    repl_reset_ctrl_c_gate,
+)
+from surfaces.interactive_shell.runtime.core.prompt_manager import PromptManager
+from surfaces.interactive_shell.runtime.core.state import ReplState
+from surfaces.interactive_shell.runtime.input.events import (
+    InputCancelled,
+    InputClosed,
+    InputEvent,
+    InputSubmitted,
+)
+from surfaces.interactive_shell.session import Session
+from surfaces.interactive_shell.ui import DIM
+from surfaces.interactive_shell.ui.components.cpr_stdin import (
+    contains_cpr_sequence,
+    strip_cpr_sequences,
+)
+
+
+class PromptInputReader:
+    """Read prompt text and hide terminal-specific control flow from the loop."""
+
+    def __init__(
+        self,
+        prompt: PromptManager,
+        state: ReplState,
+        session: Session,
+        console: Console,
+    ) -> None:
+        self.prompt = prompt
+        self.state = state
+        self.session = session
+        self.console = console
+
+    async def read(self) -> InputEvent:
+        while True:
+            try:
+                text = await self.prompt.read_prompt_text()
+            except EOFError:
+                if self.state.is_dispatch_running():
+                    return InputCancelled()
+                self._render_session_resume_hint()
+                return InputClosed()
+            except KeyboardInterrupt:
+                if self.state.is_dispatch_running():
+                    return InputCancelled()
+                if repl_prompt_note_ctrl_c(self.console, self.session.session_id):
+                    return InputClosed()
+                return InputCancelled()
+
+            repl_reset_ctrl_c_gate()
+            raw_text = text
+            text = strip_cpr_sequences(text)
+            if not text.strip() and contains_cpr_sequence(raw_text):
+                continue
+            return InputSubmitted(text)
+
+    def _render_session_resume_hint(self) -> None:
+        if not self.session.session_id:
+            return
+        self.console.print()
+        print_session_resume_hint(self.console, self.session.session_id)
+        self.console.print(f"[{DIM}]Goodbye![/]")
+
+
+__all__ = ["PromptInputReader"]