ripperdoc 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.3.0"
+__version__ = "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/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/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
 

ripperdoc/core/permissions.py

@@ -3,11 +3,18 @@
 from __future__ import annotations
 
 import asyncio
+import html
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Optional, Set, TYPE_CHECKING, TYPE_CHECKING as TYPE_CHECKING
 
+from prompt_toolkit.filters import is_done
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.shortcuts import choice
+from prompt_toolkit.styles import Style
+
 from ripperdoc.core.config import config_manager
 from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.tool import Tool
@@ -36,35 +43,37 @@ def _format_input_preview(parsed_input: Any, tool_name: Optional[str] = None) ->
 
     For Bash commands, shows full details for security review.
     For other tools, shows a concise preview.
+    Returns HTML-formatted text with color tags.
     """
     # For Bash tool, show full command details for security review
     if tool_name == "Bash" and hasattr(parsed_input, "command"):
-        lines = [f"Command: {getattr(parsed_input, 'command')}"]
+        command = html.escape(getattr(parsed_input, "command"))
+        lines = [f"<label>Command:</label> <value>{command}</value>"]
 
         # Add other relevant parameters
         if hasattr(parsed_input, "timeout") and parsed_input.timeout:
-            lines.append(f"Timeout: {parsed_input.timeout}ms")
+            lines.append(f"<label>Timeout:</label> <value>{parsed_input.timeout}ms</value>")
         if hasattr(parsed_input, "sandbox"):
-            lines.append(f"Sandbox: {parsed_input.sandbox}")
+            lines.append(f"<label>Sandbox:</label> <value>{parsed_input.sandbox}</value>")
         if hasattr(parsed_input, "run_in_background"):
-            lines.append(f"Background: {parsed_input.run_in_background}")
+            lines.append(f"<label>Background:</label> <value>{parsed_input.run_in_background}</value>")
         if hasattr(parsed_input, "shell_executable") and parsed_input.shell_executable:
-            lines.append(f"Shell: {parsed_input.shell_executable}")
+            lines.append(f"<label>Shell:</label> <value>{html.escape(parsed_input.shell_executable)}</value>")
 
         return "\n  ".join(lines)
 
     # For other tools with commands, show concise preview
     if hasattr(parsed_input, "command"):
-        return f"command='{getattr(parsed_input, 'command')}'"
+        return f"<label>command:</label> <value>'{html.escape(getattr(parsed_input, 'command'))}'</value>"
     if hasattr(parsed_input, "file_path"):
-        return f"file='{getattr(parsed_input, 'file_path')}'"
+        return f"<label>file:</label> <value>'{html.escape(getattr(parsed_input, 'file_path'))}'</value>"
     if hasattr(parsed_input, "path"):
-        return f"path='{getattr(parsed_input, 'path')}'"
+        return f"<label>path:</label> <value>'{html.escape(getattr(parsed_input, 'path'))}'</value>"
 
     preview = str(parsed_input)
     if len(preview) > 140:
-        return preview[:137] + "..."
-    return preview
+        preview = preview[:137] + "..."
+    return f"<value>{html.escape(preview)}</value>"
 
 
 def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
@@ -92,53 +101,23 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
     return tool.name
 
 
-def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
-    """Render a simple numbered prompt (fallback for non-Rich environments)."""
-    border = "─" * 120
-    lines = [border, prompt, ""]
-    for idx, (_, label) in enumerate(options, start=1):
-        prefix = "❯" if idx == 1 else " "
-        lines.append(f"{prefix} {idx}. {label}")
-    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-    shortcut_choices = "/".join(opt[0] for opt in options)
-    lines.append(f"Choice ({numeric_choices} or {shortcut_choices}): ")
-    return "\n".join(lines)
-
-
-def _render_options_prompt_rich(
-    console: "Console",
-    prompt: str,
-    options: list[tuple[str, str]]
-) -> None:
-    """Render permission dialog using Rich Panel for better visual consistency."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    # Build option lines with markup
-    option_lines = []
-    for idx, (_, label) in enumerate(options, start=1):
-        prefix = "[cyan]❯[/cyan]" if idx == 1 else " "
-        option_lines.append(f"{prefix} {idx}. {label}")
-
-    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-    shortcut_choices = "/".join(opt[0] for opt in options)
-
-    # Build the prompt content as a markup string
-    markup_content = f"{prompt}\n\n" + "\n".join(option_lines) + "\n"
-    markup_content += f"Choice ([cyan]{numeric_choices}[/cyan] or [cyan]{shortcut_choices}[/cyan]): "
-
-    # Parse markup to create a Text object
-    content = Text.from_markup(markup_content)
-
-    # Render the panel
-    panel = Panel(
-        content,
-        title=Text.from_markup("[yellow]Permission Required[/yellow]"),
-        title_align="left",
-        border_style="yellow",
-        padding=(0, 1),
+def _permission_style() -> Style:
+    """Create the style for permission choice prompts."""
+    return Style.from_dict(
+        {
+            "frame.border": "#d4a017",  # Golden/amber border
+            "selected-option": "bold",
+            "option": "#5fd7ff",  # Cyan for unselected options
+            "title": "#ffaf00",  # Orange/amber for tool name
+            "description": "#ffffff",  # White for descriptions
+            "question": "#ffd700",  # Gold for the question
+            "label": "#87afff",  # Light blue for field labels (Command:, Sandbox:, etc.)
+            "warning": "#ff5555",  # Red for warnings
+            "yes-option": "#ffffff",  # Neutral for Yes options
+            "no-option": "#ffffff",  # Neutral for No option
+            "value": "#f8f8f2",  # Off-white for values
+        }
     )
-    console.print(panel)
 
 
 def _rule_strings(rule_suggestions: Optional[Any]) -> list[str]:
@@ -179,41 +158,68 @@ def make_permission_checker(
     session_allowed_tools: Set[str] = set()
     session_tool_rules: dict[str, Set[str]] = defaultdict(set)
 
-    async def _prompt_user(prompt: str, options: list[tuple[str, str]]) -> str:
-        """Prompt the user with proper interrupt handling."""
-        # Build the prompt message
-        if console is not None:
-            # Use Rich Panel for the dialog
-            _render_options_prompt_rich(console, prompt, options)
-            # Build simple prompt for the input line
-            numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-            shortcut_choices = "/".join(opt[0] for opt in options)
-            input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
-        else:
-            # Use plain text rendering
-            rendered = _render_options_prompt(prompt, options)
-            input_prompt = rendered
-
-        # Try to use PromptSession if available (better interrupt handling)
-        if prompt_session is not None:
-            try:
-                # PromptSession.prompt() can handle Ctrl+C gracefully
-                return await prompt_session.prompt_async(input_prompt)
-            except KeyboardInterrupt:
-                logger.debug("[permissions] KeyboardInterrupt in prompt_session")
-                return "n"
-            except EOFError:
-                logger.debug("[permissions] EOFError in prompt_session")
-                return "n"
+    async def _prompt_user(prompt: str, options: list[tuple[str, str]], is_html: bool = False) -> str:
+        """Prompt the user with proper interrupt handling using choice().
 
-        # Fallback to simple input() via executor
+        Args:
+            prompt: The prompt text to display.
+            options: List of (value, label) tuples for choices.
+            is_html: If True, prompt is already formatted HTML and should not be escaped.
+        """
         loop = asyncio.get_running_loop()
-        responder = prompt_fn or input
 
         def _ask() -> str:
             try:
-                return responder(input_prompt)
-            except (KeyboardInterrupt, EOFError):
+                # If a custom prompt_fn is provided (e.g., for tests), use it directly
+                responder = prompt_fn or None
+                if responder is not None:
+                    # Build a simple text prompt for the prompt_fn
+                    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
+                    shortcut_choices = "/".join(opt[0] for opt in options)
+                    input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
+                    return responder(input_prompt)
+
+                # Convert options to choice() format (value, label)
+                # Labels can be HTML-formatted strings
+                choice_options = [(value, HTML(label) if "<" in label else label) for value, label in options]
+
+                # Build formatted message with prompt text
+                # Add visual separation with lines
+                if is_html:
+                    # Prompt is already HTML formatted
+                    formatted_prompt = HTML(f"\n{prompt}\n")
+                else:
+                    # Escape HTML special characters in plain text prompt
+                    formatted_prompt = HTML(f"\n{html.escape(prompt)}\n")
+
+                esc_bindings = KeyBindings()
+
+                @esc_bindings.add("escape", eager=True)
+                def _esc_to_deny(event: Any) -> None:
+                    event.app.exit(result="n", style="class:aborting")
+
+                result = choice(
+                    message=formatted_prompt,
+                    options=choice_options,
+                    style=_permission_style(),
+                    show_frame=~is_done,  # Frame disappears after selection
+                    key_bindings=esc_bindings,
+                )
+
+                # Clear the entire prompt after selection
+                # ANSI codes: ESC[F = move cursor to beginning of previous line
+                #              ESC[2K = clear entire line
+                # We need to clear: blank + prompt + blank + options (each option takes 1 line)
+                # plus frame borders (top and bottom) = approximately 6-8 lines
+                for _ in range(12):  # Clear enough lines to cover the prompt
+                    print("\033[F\033[2K", end="", flush=True)
+
+                return result
+            except KeyboardInterrupt:
+                logger.debug("[permissions] KeyboardInterrupt in choice")
+                return "n"
+            except EOFError:
+                logger.debug("[permissions] EOFError in choice")
                 return "n"
 
         return await loop.run_in_executor(None, _ask)
@@ -387,23 +393,24 @@ def make_permission_checker(
             )
 
         input_preview = _format_input_preview(parsed_input, tool_name=tool.name)
-        prompt_lines = [
-            f"{tool.name}",
-            "",
-            f"  {input_preview}",
-        ]
+        # Use inline styles for prompt_toolkit HTML formatting
+        # The style names must match keys in the _permission_style() dict
+        prompt_html = f"""<title>{html.escape(tool.name)}</title>
+
+  <description>{input_preview}</description>"""
         if decision.message:
-            prompt_lines.append(f"  {decision.message}")
-        prompt_lines.append("  Do you want to proceed?")
-        prompt = "\n".join(prompt_lines)
+            # Use warning style for warning messages
+            prompt_html += f"\n  <warning>{html.escape(decision.message)}</warning>"
+        prompt_html += "\n  <question>Do you want to proceed?</question>"
+        prompt = prompt_html
 
         options = [
-            ("y", "Yes"),
-            ("s", "Yes, for this session"),
-            ("n", "No"),
+            ("y", "<yes-option>Yes</yes-option>"),
+            ("s", "<yes-option>Yes, for this session</yes-option>"),
+            ("n", "<no-option>No</no-option>"),
         ]
 
-        answer = (await _prompt_user(prompt, options=options)).strip().lower()
+        answer = (await _prompt_user(prompt, options=options, is_html=True)).strip().lower()
         logger.debug(
             "[permissions] User answer for permission prompt",
             extra={"answer": answer, "tool": getattr(tool, "name", None)},

{ripperdoc-0.3.0.dist-info → ripperdoc-0.3.1.dist-info}/METADATA

@@ -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.dist-info → ripperdoc-0.3.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ripperdoc/__init__.py,sha256=r9wkvo_s7lhTfuQG7WVFeE3Eg4HgMGHovnyZR1OVnPA,66
+ripperdoc/__init__.py,sha256=WpPS91f5Gza7_d_r4nyqaZ8bJMFXt486w-h3D1Ha9qk,66
 ripperdoc/__main__.py,sha256=1Avq2MceBfwUlNsfasC8n4dqVL_V56Bl3DRsnY4_Nxk,370
 ripperdoc/cli/__init__.py,sha256=03wf6gXBcEgXJrDJS-W_5BEG_DdJ_ep7CxQFPML-73g,35
 ripperdoc/cli/cli.py,sha256=OZgN803jYmzdKxynHWG7VNwd7dQhM1KdYakXDyMlZT8,21826
@@ -30,11 +30,11 @@ ripperdoc/cli/ui/__init__.py,sha256=TxSzTYdITlrYmYVfins_w_jzPqqWRpqky5u1ikwvmtM,
 ripperdoc/cli/ui/context_display.py,sha256=3ezdtHVwltkPQ5etYwfqUh-fjnpPu8B3P81UzrdHxZs,10020
 ripperdoc/cli/ui/file_mention_completer.py,sha256=ysNqZieQVlUb7DC4CP_FMKNeTG8AIqKLmJgl6HJBURo,13649
 ripperdoc/cli/ui/helpers.py,sha256=iM7kMb-fMTO6n4_MDVrESE1P-Y7w8PXiIhCCLp5yyA4,2618
-ripperdoc/cli/ui/interrupt_handler.py,sha256=6MwZ2wo1ZCdd4JGV5dWOzHkNDDce51z9Rhf0LdFjWTM,7107
-ripperdoc/cli/ui/message_display.py,sha256=W9VlRCpMykkamxphej5LHgmU-P4YaBfm9HPdIKlFKpg,10573
+ripperdoc/cli/ui/interrupt_listener.py,sha256=m9NeyOSJ3f-zuLE4YzUUEoKuuxo7oBKuvY5Z1WabjoE,7223
+ripperdoc/cli/ui/message_display.py,sha256=eaS80PBo9QfgWT-MX4jfQOjbt0vwQ4w1MDGKBWPrQOs,10856
 ripperdoc/cli/ui/panels.py,sha256=kaf3sDG2AIcrdrqbASnqGYHySfSeMNozGFhqvZ4bTJs,2207
 ripperdoc/cli/ui/provider_options.py,sha256=Ic30K1ev8w2oEcha4IjDYSoxw1tyCVB4hLoQpS_Y_5E,8369
-ripperdoc/cli/ui/rich_ui.py,sha256=LZjmaCSfXf8Le5zq03e4PH2S0nlsSXW566q7mW-xWaA,76968
+ripperdoc/cli/ui/rich_ui.py,sha256=LkE22XdNE4sooX-SyVUec7qX_XDTHjExFTwhqj1MPY4,76870
 ripperdoc/cli/ui/spinner.py,sha256=IlmMgyk-eA6Bk4fXDjbWs3AFL2iFPeWmnS0q28tWOgU,5175
 ripperdoc/cli/ui/thinking_spinner.py,sha256=3zmxj3vd-1njdiHF2Afsm7RGiRl7645AEc7fTLKgAbU,2805
 ripperdoc/cli/ui/tool_renderers.py,sha256=7ACcZoKU91kvFsk3YdP2TzibfI-W_F1dv-Ksr68rrYE,11280
@@ -45,7 +45,7 @@ ripperdoc/core/commands.py,sha256=NXCkljYbAP4dDoRy-_3semFNWxG4YAk9q82u8FTKH60,83
 ripperdoc/core/config.py,sha256=4KvaGKG4bf9wX6haPvxJllokdpPbJVvfTIMfsC0maag,29936
 ripperdoc/core/custom_commands.py,sha256=2BMYiBq15FDjl3aOa3styN6nARyfU7xFAb4ly2Vsp-w,14254
 ripperdoc/core/default_tools.py,sha256=mpb9mqmrAjMqgcmpRU_uQF1G6vpYbp8nkiwrh71KQyM,5250
-ripperdoc/core/permissions.py,sha256=yp7OK36_I_UceDnLbGmxPh6nSbIDfns4IgTVGH5Tkqs,16986
+ripperdoc/core/permissions.py,sha256=7Fj44HB4yJj5bm54T_c85sdzjMFWWg_5kXm3CZqklI4,18424
 ripperdoc/core/query.py,sha256=dC_sW2D2bPLI6nPM3VxFpTBA4fYYHHRNmE6zvy93pus,62057
 ripperdoc/core/query_utils.py,sha256=2OQYeobFD-24NG0CZnnm3D5HCJ7r8AOB08I-wpQhH1A,24888
 ripperdoc/core/skills.py,sha256=NGP_QFzL2SBkz8wZBGxNA_6Gt8qkRIZtJDnPs_DayxE,10511
@@ -128,9 +128,9 @@ ripperdoc/utils/permissions/__init__.py,sha256=33FfOaDLepxJSkp0RLvTdVu7qBXuEcnOo
 ripperdoc/utils/permissions/path_validation_utils.py,sha256=KOegjWaph8tXU7aqwQXRAxFEzrmRuPvdLb36J1QIPDQ,5772
 ripperdoc/utils/permissions/shell_command_validation.py,sha256=BRi-1OGzr-Wiuxa00Ye6oqPctoJUZBOoRoi6dUiAsfM,33256
 ripperdoc/utils/permissions/tool_permission_utils.py,sha256=YqbYSXyR0RBbLibBtigYb9O9143mDRulsQCh_WwArvY,14653
-ripperdoc-0.3.0.dist-info/licenses/LICENSE,sha256=bRv9UhBor6GhnQDj12RciDcRfu0R7sB-lqCy1sWF75c,9242
-ripperdoc-0.3.0.dist-info/METADATA,sha256=fZifh_w_rlHCJHbkadgF5_g3oDi7bH_7M_qekoC4g1Y,8651
-ripperdoc-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ripperdoc-0.3.0.dist-info/entry_points.txt,sha256=79aohFxFPJmrQ3-Mhain04vb3EWpuc0EyzvDDUnwAu4,81
-ripperdoc-0.3.0.dist-info/top_level.txt,sha256=u8LbdTr1a-laHgCO0Utl_R3QGFUhLxWelCDnP2ZgpCU,10
-ripperdoc-0.3.0.dist-info/RECORD,,
+ripperdoc-0.3.1.dist-info/licenses/LICENSE,sha256=bRv9UhBor6GhnQDj12RciDcRfu0R7sB-lqCy1sWF75c,9242
+ripperdoc-0.3.1.dist-info/METADATA,sha256=QawsGroIo9Rs4CodXPVMBNbiFmPZrnJE8nMgqNNDEyQ,8651
+ripperdoc-0.3.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ripperdoc-0.3.1.dist-info/entry_points.txt,sha256=79aohFxFPJmrQ3-Mhain04vb3EWpuc0EyzvDDUnwAu4,81
+ripperdoc-0.3.1.dist-info/top_level.txt,sha256=u8LbdTr1a-laHgCO0Utl_R3QGFUhLxWelCDnP2ZgpCU,10
+ripperdoc-0.3.1.dist-info/RECORD,,

ripperdoc/cli/ui/interrupt_handler.py

@@ -1,208 +0,0 @@
-"""Interrupt handling for RichUI.
-
-This module handles ESC/Ctrl+C key detection during query execution,
-including terminal raw mode management.
-"""
-
-import asyncio
-import contextlib
-import sys
-from typing import Any, Optional, Set
-
-from ripperdoc.utils.log import get_logger
-from ripperdoc.utils.platform import is_windows
-
-logger = get_logger()
-
-# Keys that trigger interrupt
-INTERRUPT_KEYS: Set[str] = {"\x1b", "\x03"}  # ESC, Ctrl+C
-
-
-class InterruptHandler:
-    """Handles keyboard interrupt detection during async operations."""
-
-    def __init__(self) -> None:
-        """Initialize the interrupt handler."""
-        self._query_interrupted: bool = False
-        self._esc_listener_active: bool = False
-        self._esc_listener_paused: bool = False
-        self._stdin_fd: Optional[int] = None
-        self._stdin_old_settings: Optional[list] = None
-        self._stdin_in_raw_mode: bool = False
-        self._abort_callback: Optional[Any] = None
-
-    def set_abort_callback(self, callback: Any) -> None:
-        """Set the callback to trigger when interrupt is detected."""
-        self._abort_callback = callback
-
-    @property
-    def was_interrupted(self) -> bool:
-        """Check if the last query was interrupted."""
-        return self._query_interrupted
-
-    def pause_listener(self) -> bool:
-        """Pause ESC listener and restore cooked terminal mode if we own raw mode.
-
-        Returns:
-            Previous paused state for later restoration.
-        """
-        prev = self._esc_listener_paused
-        self._esc_listener_paused = True
-
-        # Windows doesn't support termios
-        if is_windows():
-            return prev
-
-        try:
-            import termios
-        except ImportError:
-            return prev
-
-        if (
-            self._stdin_fd is not None
-            and self._stdin_old_settings is not None
-            and self._stdin_in_raw_mode
-        ):
-            with contextlib.suppress(OSError, termios.error, ValueError):
-                termios.tcsetattr(self._stdin_fd, termios.TCSADRAIN, self._stdin_old_settings)
-            self._stdin_in_raw_mode = False
-        return prev
-
-    def resume_listener(self, previous_state: bool) -> None:
-        """Restore paused state to what it was before a blocking prompt."""
-        self._esc_listener_paused = previous_state
-
-    async def _listen_for_interrupt_key(self) -> bool:
-        """Listen for interrupt keys (ESC/Ctrl+C) during query execution.
-
-        Uses raw terminal mode for immediate key detection without waiting
-        for escape sequences to complete.
-
-        Returns:
-            True if an interrupt key was pressed.
-        """
-        if is_windows():
-            # Windows: use msvcrt for non-blocking key detection
-            try:
-                import msvcrt
-            except ImportError:
-                # Fallback: just wait - Ctrl+C is handled by OS
-                while self._esc_listener_active:
-                    await asyncio.sleep(0.1)
-                return False
-
-            while self._esc_listener_active:
-                if self._esc_listener_paused:
-                    await asyncio.sleep(0.05)
-                    continue
-
-                # Check for key press in a thread to avoid blocking
-                def check_key() -> Optional[str]:
-                    if msvcrt.kbhit():  # type: ignore[attr-defined]
-                        return msvcrt.getch().decode("latin-1")  # type: ignore[attr-defined,no-any-return]
-                    return None
-
-                key = await asyncio.to_thread(check_key)
-                if key in INTERRUPT_KEYS:
-                    return True
-
-                await asyncio.sleep(0.02)
-            return False
-
-        import select
-        import termios
-        import tty
-
-        try:
-            fd = sys.stdin.fileno()
-            old_settings = termios.tcgetattr(fd)
-        except (OSError, termios.error, ValueError):
-            return False
-
-        self._stdin_fd = fd
-        self._stdin_old_settings = old_settings
-        raw_enabled = False
-        try:
-            while self._esc_listener_active:
-                if self._esc_listener_paused:
-                    if raw_enabled:
-                        with contextlib.suppress(OSError, termios.error, ValueError):
-                            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                        raw_enabled = False
-                        self._stdin_in_raw_mode = False
-                    await asyncio.sleep(0.05)
-                    continue
-
-                if not raw_enabled:
-                    tty.setraw(fd)
-                    raw_enabled = True
-                    self._stdin_in_raw_mode = True
-
-                await asyncio.sleep(0.02)
-                if select.select([sys.stdin], [], [], 0)[0]:
-                    if sys.stdin.read(1) in INTERRUPT_KEYS:
-                        return True
-        except (OSError, ValueError):
-            pass
-        finally:
-            self._stdin_in_raw_mode = False
-            with contextlib.suppress(OSError, termios.error, ValueError):
-                if raw_enabled:
-                    termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-            self._stdin_fd = None
-            self._stdin_old_settings = None
-
-        return False
-
-    async def _cancel_task(self, task: asyncio.Task) -> None:
-        """Cancel a task and wait for it to finish."""
-        if not task.done():
-            task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await task
-
-    def _trigger_abort(self) -> None:
-        """Signal the query to abort via callback."""
-        if self._abort_callback is not None:
-            self._abort_callback()
-
-    async def run_with_interrupt(self, query_coro: Any) -> bool:
-        """Run a coroutine with ESC key interrupt support.
-
-        Args:
-            query_coro: The coroutine to run with interrupt support.
-
-        Returns:
-            True if interrupted, False if completed normally.
-        """
-        self._query_interrupted = False
-        self._esc_listener_active = True
-
-        query_task = asyncio.create_task(query_coro)
-        interrupt_task = asyncio.create_task(self._listen_for_interrupt_key())
-
-        try:
-            done, _ = await asyncio.wait(
-                {query_task, interrupt_task}, return_when=asyncio.FIRST_COMPLETED
-            )
-
-            # Check if interrupted
-            if interrupt_task in done and interrupt_task.result():
-                self._query_interrupted = True
-                self._trigger_abort()
-                await self._cancel_task(query_task)
-                return True
-
-            # Query completed normally
-            if query_task in done:
-                await self._cancel_task(interrupt_task)
-                with contextlib.suppress(Exception):
-                    query_task.result()
-                return False
-
-            return False
-
-        finally:
-            self._esc_listener_active = False
-            await self._cancel_task(query_task)
-            await self._cancel_task(interrupt_task)