ripperdoc 0.3.0__tar.gz → 0.3.1__tar.gz

{ripperdoc-0.3.0 → ripperdoc-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripperdoc
-Version: 0.3.0
+Version: 0.3.1
 Summary: AI-powered terminal assistant for coding tasks
 Author: Ripperdoc Team
 License: Apache-2.0

{ripperdoc-0.3.0 → ripperdoc-0.3.1}/ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

ripperdoc-0.3.1/ripperdoc/cli/ui/interrupt_listener.py

@@ -0,0 +1,233 @@
+"""ESC key interrupt listener for the Rich UI."""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from typing import Any, Callable, Optional
+
+from ripperdoc.utils.log import get_logger
+
+if os.name != "nt":
+    import select
+    import termios
+    import tty
+
+
+class EscInterruptListener:
+    """Listen for ESC keypresses in a background thread and invoke a callback."""
+
+    def __init__(self, on_interrupt: Callable[[], None], *, logger: Optional[Any] = None) -> None:
+        self._on_interrupt = on_interrupt
+        self._logger = logger or get_logger()
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+        self._pause_depth = 0
+        self._interrupt_sent = False
+        self._fd: Optional[int] = None
+        self._owns_fd = False
+        self._orig_termios = None
+        self._cbreak_active = False
+        self._availability_checked = False
+        self._available = True
+
+    @property
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def start(self) -> None:
+        if self.is_running or not self._available:
+            return
+        if os.name != "nt" and not self._setup_posix_input():
+            return
+        self._stop_event.clear()
+        with self._lock:
+            self._pause_depth = 0
+            self._interrupt_sent = False
+        self._thread = threading.Thread(
+            target=self._run,
+            name="ripperdoc-esc-listener",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=0.25)
+        self._thread = None
+        if os.name != "nt":
+            self._restore_posix_input()
+
+    def pause(self) -> None:
+        if os.name == "nt":
+            return
+        with self._lock:
+            self._pause_depth += 1
+            if self._pause_depth == 1:
+                self._restore_termios_locked()
+
+    def resume(self) -> None:
+        if os.name == "nt":
+            return
+        with self._lock:
+            if self._pause_depth == 0:
+                return
+            self._pause_depth -= 1
+            if self._pause_depth == 0:
+                self._apply_cbreak_locked()
+
+    def _run(self) -> None:
+        if os.name == "nt":
+            self._run_windows()
+        else:
+            self._run_posix()
+
+    def _run_windows(self) -> None:
+        import msvcrt
+
+        while not self._stop_event.is_set():
+            with self._lock:
+                paused = self._pause_depth > 0
+            if paused:
+                time.sleep(0.05)
+                continue
+            if msvcrt.kbhit():
+                ch = msvcrt.getwch()
+                if ch == "\x1b":
+                    self._signal_interrupt()
+            time.sleep(0.02)
+
+    def _run_posix(self) -> None:
+        while not self._stop_event.is_set():
+            with self._lock:
+                paused = self._pause_depth > 0
+                fd = self._fd
+            if paused or fd is None:
+                time.sleep(0.05)
+                continue
+            try:
+                readable, _, _ = select.select([fd], [], [], 0.1)
+            except (OSError, ValueError):
+                time.sleep(0.05)
+                continue
+            if not readable:
+                continue
+            try:
+                ch = os.read(fd, 1)
+            except OSError:
+                continue
+            if ch == b"\x1b":
+                if self._is_escape_sequence(fd):
+                    continue
+                self._signal_interrupt()
+
+    def _is_escape_sequence(self, fd: int) -> bool:
+        try:
+            readable, _, _ = select.select([fd], [], [], 0.02)
+        except (OSError, ValueError):
+            return False
+        if not readable:
+            return False
+        self._drain_pending_bytes(fd)
+        return True
+
+    def _drain_pending_bytes(self, fd: int) -> None:
+        while True:
+            try:
+                readable, _, _ = select.select([fd], [], [], 0)
+            except (OSError, ValueError):
+                return
+            if not readable:
+                return
+            try:
+                os.read(fd, 32)
+            except OSError:
+                return
+
+    def _signal_interrupt(self) -> None:
+        with self._lock:
+            if self._interrupt_sent:
+                return
+            self._interrupt_sent = True
+        try:
+            self._on_interrupt()
+        except (RuntimeError, ValueError, OSError) as exc:
+            self._logger.debug(
+                "[ui] ESC interrupt callback failed: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
+
+    def _setup_posix_input(self) -> bool:
+        if self._fd is not None:
+            return True
+        fd: Optional[int] = None
+        owns = False
+        try:
+            if sys.stdin.isatty():
+                fd = sys.stdin.fileno()
+            elif os.path.exists("/dev/tty"):
+                fd = os.open("/dev/tty", os.O_RDONLY)
+                owns = True
+        except OSError as exc:
+            self._disable_listener(f"input error: {exc}")
+            return False
+        if fd is None:
+            self._disable_listener("no TTY available")
+            return False
+        try:
+            self._orig_termios = termios.tcgetattr(fd)
+        except (termios.error, OSError) as exc:
+            if owns:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+            self._disable_listener(f"termios unavailable: {exc}")
+            return False
+        self._fd = fd
+        self._owns_fd = owns
+        self._apply_cbreak_locked()
+        return True
+
+    def _restore_posix_input(self) -> None:
+        with self._lock:
+            self._restore_termios_locked()
+            if self._fd is not None and self._owns_fd:
+                try:
+                    os.close(self._fd)
+                except OSError:
+                    pass
+            self._fd = None
+            self._owns_fd = False
+            self._orig_termios = None
+            self._cbreak_active = False
+
+    def _apply_cbreak_locked(self) -> None:
+        if self._fd is None or self._orig_termios is None or self._cbreak_active:
+            return
+        try:
+            tty.setcbreak(self._fd)
+            self._cbreak_active = True
+        except (termios.error, OSError):
+            self._disable_listener("failed to enter cbreak mode")
+
+    def _restore_termios_locked(self) -> None:
+        if self._fd is None or self._orig_termios is None or not self._cbreak_active:
+            return
+        try:
+            termios.tcsetattr(self._fd, termios.TCSADRAIN, self._orig_termios)
+        except (termios.error, OSError):
+            pass
+        self._cbreak_active = False
+
+    def _disable_listener(self, reason: str) -> None:
+        if self._availability_checked:
+            return
+        self._availability_checked = True
+        self._available = False
+        self._logger.debug("[ui] ESC interrupt listener disabled: %s", reason)

{ripperdoc-0.3.0 → ripperdoc-0.3.1}/ripperdoc/cli/ui/message_display.py

@@ -218,6 +218,13 @@ class MessageDisplay:
         if preview:
             self.console.print(f"[dim italic]Thinking: {escape(preview)}[/]")
 
+    def print_interrupt_notice(self) -> None:
+        """Display an interrupt notice when the user cancels with ESC."""
+        self.console.print(
+            "\n[red]■ Conversation interrupted[/red] · "
+            "[dim]Tell the model what to do differently.[/dim]"
+        )
+
 
 def parse_bash_output_sections(content: str) -> Tuple[List[str], List[str]]:
     """Parse stdout/stderr sections from a bash output text block."""

{ripperdoc-0.3.0 → ripperdoc-0.3.1}/ripperdoc/cli/ui/rich_ui.py

@@ -47,7 +47,7 @@ from ripperdoc.cli.ui.thinking_spinner import ThinkingSpinner
 from ripperdoc.cli.ui.context_display import context_usage_lines
 from ripperdoc.cli.ui.panels import create_welcome_panel, create_status_bar, print_shortcuts
 from ripperdoc.cli.ui.message_display import MessageDisplay, parse_bash_output_sections
-from ripperdoc.cli.ui.interrupt_handler import InterruptHandler
+from ripperdoc.cli.ui.interrupt_listener import EscInterruptListener
 from ripperdoc.utils.conversation_compaction import (
     compact_conversation,
     CompactionResult,
@@ -77,6 +77,8 @@ from ripperdoc.utils.messages import (
     UserMessage,
     AssistantMessage,
     ProgressMessage,
+    INTERRUPT_MESSAGE,
+    INTERRUPT_MESSAGE_FOR_TOOL_USE,
     create_user_message,
 )
 from ripperdoc.utils.log import enable_session_file_logging, get_logger
@@ -349,6 +351,10 @@ class RichUI:
         self._exit_reason: Optional[str] = None
         self._using_tty_input = False  # Track if we're using /dev/tty for input
         self._thinking_mode_enabled = False  # Toggle for extended thinking mode
+        self._interrupt_listener = EscInterruptListener(self._schedule_esc_interrupt, logger=logger)
+        self._esc_interrupt_seen = False
+        self._query_in_progress = False
+        self._active_spinner: Optional[ThinkingSpinner] = None
         hook_manager.set_transcript_path(str(self._session_history.path))
 
         # Create permission checker with Rich console and PromptSession support
@@ -398,8 +404,6 @@ class RichUI:
 
         # Initialize component handlers
         self._message_display = MessageDisplay(self.console, self.verbose, self.show_full_thinking)
-        self._interrupt_handler = InterruptHandler()
-        self._interrupt_handler.set_abort_callback(self._trigger_abort)
 
         # Keep MCP runtime alive for the whole UI session. Create it on the UI loop up front.
         try:
@@ -440,18 +444,6 @@ class RichUI:
     # Properties for backward compatibility with interrupt handler
     # ─────────────────────────────────────────────────────────────────────────────
 
-    @property
-    def _query_interrupted(self) -> bool:
-        return self._interrupt_handler.was_interrupted
-
-    @property
-    def _esc_listener_paused(self) -> bool:
-        return self._interrupt_handler._esc_listener_paused
-
-    @_esc_listener_paused.setter
-    def _esc_listener_paused(self, value: bool) -> None:
-        self._interrupt_handler._esc_listener_paused = value
-
     # ─────────────────────────────────────────────────────────────────────────────
     # Thinking mode toggle
     # ─────────────────────────────────────────────────────────────────────────────
@@ -924,6 +916,11 @@ class RichUI:
         last_tool_name: Optional[str] = None
 
         if isinstance(message.message.content, str):
+            if self._esc_interrupt_seen and message.message.content.strip() in (
+                INTERRUPT_MESSAGE,
+                INTERRUPT_MESSAGE_FOR_TOOL_USE,
+            ):
+                return last_tool_name
             with pause():
                 self.display_message("Ripperdoc", message.message.content)
         elif isinstance(message.message.content, list):
@@ -1156,11 +1153,26 @@ class RichUI:
             spinner = ThinkingSpinner(console, prompt_tokens_est)
 
             def pause_ui() -> None:
-                spinner.stop()
+                self._pause_interrupt_listener()
+                try:
+                    spinner.stop()
+                except (RuntimeError, ValueError, OSError):
+                    logger.debug("[ui] Failed to pause spinner")
 
             def resume_ui() -> None:
-                spinner.start()
-                spinner.update("Thinking...")
+                if self._esc_interrupt_seen:
+                    return
+                try:
+                    spinner.start()
+                    spinner.update("Thinking...")
+                except (RuntimeError, ValueError, OSError) as exc:
+                    logger.debug(
+                        "[ui] Failed to restart spinner after pause: %s: %s",
+                        type(exc).__name__,
+                        exc,
+                    )
+                finally:
+                    self._resume_interrupt_listener()
 
             self.query_context.pause_ui = pause_ui
             self.query_context.resume_ui = resume_ui
@@ -1169,8 +1181,7 @@ class RichUI:
             base_permission_checker = self._permission_checker
 
             async def permission_checker(tool: Any, parsed_input: Any) -> bool:
-                spinner.stop()
-                was_paused = self._pause_interrupt_listener()
+                pause_ui()
                 try:
                     if base_permission_checker is not None:
                         result = await base_permission_checker(tool, parsed_input)
@@ -1186,18 +1197,7 @@ class RichUI:
                         return allowed
                     return True
                 finally:
-                    self._resume_interrupt_listener(was_paused)
-                    # Wrap spinner restart in try-except to prevent exceptions
-                    # from discarding the permission result
-                    try:
-                        spinner.start()
-                        spinner.update("Thinking...")
-                    except (RuntimeError, ValueError, OSError) as exc:
-                        logger.debug(
-                            "[ui] Failed to restart spinner after permission check: %s: %s",
-                            type(exc).__name__,
-                            exc,
-                        )
+                    resume_ui()
 
             # Process query stream
             tool_registry: Dict[str, Dict[str, Any]] = {}
@@ -1205,6 +1205,10 @@ class RichUI:
             output_token_est = 0
 
             try:
+                self._active_spinner = spinner
+                self._esc_interrupt_seen = False
+                self._query_in_progress = True
+                self._start_interrupt_listener()
                 spinner.start()
                 async for message in query(
                     messages,
@@ -1253,6 +1257,9 @@ class RichUI:
                         extra={"session_id": self.session_id},
                     )
 
+                self._stop_interrupt_listener()
+                self._query_in_progress = False
+                self._active_spinner = None
                 self.conversation_messages = messages
                 logger.info(
                     "[ui] Query processing completed",
@@ -1279,21 +1286,49 @@ class RichUI:
     # ESC Key Interrupt Support
     # ─────────────────────────────────────────────────────────────────────────────
 
-    # Delegate to InterruptHandler
-    def _pause_interrupt_listener(self) -> bool:
-        return self._interrupt_handler.pause_listener()
+    def _schedule_esc_interrupt(self) -> None:
+        """Schedule ESC interrupt handling on the UI event loop."""
+        if self._loop.is_closed():
+            return
+        try:
+            self._loop.call_soon_threadsafe(self._handle_esc_interrupt)
+        except RuntimeError:
+            pass
+
+    def _handle_esc_interrupt(self) -> None:
+        """Abort the current query and display the interrupt notice."""
+        if not self._query_in_progress:
+            return
+        if self._esc_interrupt_seen:
+            return
+        abort_controller = getattr(self.query_context, "abort_controller", None)
+        if abort_controller is None or abort_controller.is_set():
+            return
+
+        self._esc_interrupt_seen = True
+
+        try:
+            if self.query_context and self.query_context.pause_ui:
+                self.query_context.pause_ui()
+            elif self._active_spinner:
+                self._active_spinner.stop()
+        except (RuntimeError, ValueError, OSError):
+            logger.debug("[ui] Failed to pause spinner for ESC interrupt")
+
+        self._message_display.print_interrupt_notice()
+        abort_controller.set()
 
-    def _resume_interrupt_listener(self, previous_state: bool) -> None:
-        self._interrupt_handler.resume_listener(previous_state)
+    def _start_interrupt_listener(self) -> None:
+        self._interrupt_listener.start()
 
-    def _trigger_abort(self) -> None:
-        """Signal the query to abort."""
-        if self.query_context and hasattr(self.query_context, "abort_controller"):
-            self.query_context.abort_controller.set()
+    def _stop_interrupt_listener(self) -> None:
+        self._interrupt_listener.stop()
 
-    async def _run_query_with_esc_interrupt(self, query_coro: Any) -> bool:
-        """Run a query with ESC key interrupt support."""
-        return await self._interrupt_handler.run_with_interrupt(query_coro)
+    def _pause_interrupt_listener(self) -> None:
+        self._interrupt_listener.pause()
+
+    def _resume_interrupt_listener(self) -> None:
+        self._interrupt_listener.resume()
 
     def _run_async(self, coro: Any) -> Any:
         """Run a coroutine on the persistent event loop."""
@@ -1302,16 +1337,6 @@ class RichUI:
             asyncio.set_event_loop(self._loop)
         return self._loop.run_until_complete(coro)
 
-    def _run_async_with_esc_interrupt(self, coro: Any) -> bool:
-        """Run a coroutine with ESC key interrupt support.
-
-        Returns True if interrupted by ESC, False if completed normally.
-        """
-        if self._loop.is_closed():
-            self._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self._loop)
-        return self._loop.run_until_complete(self._run_query_with_esc_interrupt(coro))
-
     def run_async(self, coro: Any) -> Any:
         """Public wrapper for running coroutines on the UI event loop."""
         return self._run_async(coro)
@@ -1537,8 +1562,7 @@ class RichUI:
         console.print()
         console.print(
             "[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. "
-            "Press Alt+Enter for newline. Press Tab to toggle thinking mode. "
-            "Press ESC to interrupt.[/dim]\n"
+            "Press Alt+Enter for newline. Press Tab to toggle thinking mode.[/dim]\n"
         )
 
         session = self.get_prompt_session()
@@ -1562,8 +1586,7 @@ class RichUI:
                 )
                 console.print()  # Add spacing before response
 
-                # Use _run_async instead of _run_async_with_esc_interrupt for piped stdin
-                # since there's no TTY for ESC key detection
+                # Process initial query (ESC interrupt handling removed)
                 self._run_async(self.process_query(self._initial_query))
 
                 logger.info(
@@ -1614,21 +1637,8 @@ class RichUI:
                         },
                     )
 
-                    # When using /dev/tty input, disable ESC interrupt to avoid conflicts
-                    if self._using_tty_input:
-                        self._run_async(self.process_query(user_input))
-                    else:
-                        interrupted = self._run_async_with_esc_interrupt(
-                            self.process_query(user_input)
-                        )
-                        if interrupted:
-                            console.print(
-                                "\n[red]■ Conversation interrupted[/red] · [dim]Tell the model what to do differently.[/dim]"
-                            )
-                            logger.info(
-                                "[ui] Query interrupted by ESC key",
-                                extra={"session_id": self.session_id},
-                            )
+                    # Run query (ESC interrupt handling removed)
+                    self._run_async(self.process_query(user_input))
 
                     console.print()  # Add spacing between interactions