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

ripperdoc/cli/ui/rich_ui.py

@@ -4,6 +4,7 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 """
 
 import asyncio
+import difflib
 import json
 import sys
 import time
@@ -16,12 +17,15 @@ from rich.markup import escape
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion, merge_completers
+from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.shortcuts.prompt import CompleteStyle
+from prompt_toolkit.styles import Style
 
-from ripperdoc.core.config import get_global_config, provider_protocol
+from ripperdoc.core.config import get_global_config, provider_protocol, model_supports_vision
 from ripperdoc.core.default_tools import get_default_tools
+from ripperdoc.core.theme import get_theme_manager
 from ripperdoc.core.query import query, QueryContext
 from ripperdoc.core.system_prompt import build_system_prompt
 from ripperdoc.core.skills import build_skill_summary, load_all_skills
@@ -43,13 +47,11 @@ 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,
     CompactionError,
-    extract_tool_ids_from_message,
-    get_complete_tool_pairs_tail,
 )
 from ripperdoc.utils.message_compaction import (
     estimate_conversation_tokens,
@@ -75,12 +77,15 @@ 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
 from ripperdoc.utils.path_ignore import build_ignore_filter
 from ripperdoc.cli.ui.file_mention_completer import FileMentionCompleter
 from ripperdoc.utils.message_formatting import stringify_message_content
+from ripperdoc.utils.image_utils import read_image_as_base64, is_image_file
 
 
 # Type alias for conversation messages
@@ -90,6 +95,201 @@ console = Console()
 logger = get_logger()
 
 
+def _suggest_slash_commands(name: str, project_path: Optional[Path]) -> List[str]:
+    """Return close matching slash commands for a mistyped name."""
+    if not name:
+        return []
+    seen = set()
+    candidates: List[str] = []
+    for command_name, _cmd in slash_command_completions(project_path):
+        if command_name not in seen:
+            candidates.append(command_name)
+            seen.add(command_name)
+    return difflib.get_close_matches(name, candidates, n=3, cutoff=0.6)
+
+
+def _extract_image_paths(text: str) -> List[str]:
+    """Extract @-referenced image paths from text.
+
+    Handles cases like:
+    - "@image.png describe this" (space after)
+    - "@image.png描述这个" (no space after, Chinese text)
+    - "@image.png.whatIsThis" (no space, ASCII text)
+
+    Args:
+        text: User input text
+
+    Returns:
+        List of file paths (without the @ prefix)
+    """
+    import re
+    from pathlib import Path
+
+    result = []
+
+    # Find all @ followed by content until space or end
+    for match in re.finditer(r"@(\S+)", text):
+        candidate = match.group(1)
+        if not candidate:
+            continue
+
+        # Try to find the actual file path by progressively trimming
+        # First, check if the full candidate is a file
+        if Path(candidate).exists():
+            result.append(candidate)
+            continue
+
+        # Not a file, try to find where the file path ends
+        # Common file extensions
+        extensions = [
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".webp",
+            ".bmp",
+            ".svg",
+            ".py",
+            ".js",
+            ".ts",
+            ".tsx",
+            ".jsx",
+            ".vue",
+            ".go",
+            ".rs",
+            ".java",
+            ".c",
+            ".cpp",
+            ".h",
+            ".hpp",
+            ".cs",
+            ".php",
+            ".rb",
+            ".sh",
+            ".md",
+            ".txt",
+            ".json",
+            ".yaml",
+            ".yml",
+            ".xml",
+            ".html",
+            ".css",
+            ".scss",
+            ".sql",
+            ".db",
+        ]
+
+        found_path = None
+        for ext in extensions:
+            # Look for this extension in the candidate
+            if ext.lower() in candidate.lower():
+                # Found extension, extract path up to and including it
+                ext_pos = candidate.lower().find(ext.lower())
+                potential_path = candidate[: ext_pos + len(ext)]
+                if Path(potential_path).exists():
+                    found_path = potential_path
+                    break
+
+                # Also try to find the LAST occurrence of this extension
+                # For cases like "file.txt.extraText"
+                last_ext_pos = candidate.lower().rfind(ext.lower())
+                if last_ext_pos > ext_pos:
+                    potential_path = candidate[: last_ext_pos + len(ext)]
+                    if Path(potential_path).exists():
+                        found_path = potential_path
+                        break
+
+        if found_path:
+            result.append(found_path)
+        else:
+            # No file found, keep the original candidate
+            # The processing function will handle non-existent files
+            result.append(candidate)
+
+    return result
+
+
+def _process_images_in_input(
+    user_input: str,
+    project_path: Path,
+    model_pointer: str,
+) -> tuple[str, List[Dict[str, Any]]]:
+    """Process @ references for images in user input.
+
+    Only image files are processed and converted to image blocks.
+    Text files and non-existent files are left as-is in the text.
+
+    Args:
+        user_input: Raw user input text
+        project_path: Project root path
+        model_pointer: Model pointer to check vision support
+
+    Returns:
+        (processed_text, image_blocks) tuple
+    """
+    import re
+    from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+
+    image_blocks: List[Dict[str, Any]] = []
+    processed_text = user_input
+
+    # Check if current model supports vision
+    profile = get_profile_for_pointer(model_pointer)
+    supports_vision = profile and model_supports_vision(profile)
+
+    if not supports_vision:
+        # Model doesn't support vision, leave all @ references as-is
+        return processed_text, image_blocks
+
+    referenced_paths = _extract_image_paths(user_input)
+
+    for ref_path in referenced_paths:
+        # Try relative path first, then absolute path
+        path_candidate = project_path / ref_path
+        if not path_candidate.exists():
+            path_candidate = Path(ref_path)
+
+        if not path_candidate.exists():
+            logger.debug(
+                "[ui] @ referenced file not found",
+                extra={"path": ref_path},
+            )
+            # Keep the reference in text (LLM should know file doesn't exist)
+            continue
+
+        # Only process image files
+        if not is_image_file(path_candidate):
+            # Not an image file, keep @ reference in text
+            # The LLM can decide to read it with the Read tool if needed
+            continue
+
+        # Process image file
+        result = read_image_as_base64(path_candidate)
+        if result:
+            base64_data, mime_type = result
+            image_blocks.append(
+                {
+                    "type": "image",
+                    "source_type": "base64",
+                    "media_type": mime_type,
+                    "image_data": base64_data,
+                }
+            )
+            # Remove image reference from text (content included separately as image block)
+            processed_text = processed_text.replace(f"@{ref_path}", "")
+        else:
+            # Failed to read image, keep reference in text
+            logger.warning(
+                "[ui] Failed to read @ referenced image",
+                extra={"path": ref_path},
+            )
+
+    # Clean up extra whitespace
+    processed_text = re.sub(r"\s+", " ", processed_text).strip()
+
+    return processed_text, image_blocks
+
+
 class RichUI:
     """Rich-based UI for Ripperdoc."""
 
@@ -105,6 +305,7 @@ class RichUI:
         append_system_prompt: Optional[str] = None,
         model: Optional[str] = None,
         resume_messages: Optional[List[Any]] = None,
+        initial_query: Optional[str] = None,
     ):
         self._loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self._loop)
@@ -121,6 +322,7 @@ class RichUI:
         self._current_tool: Optional[str] = None
         self._should_exit: bool = False
         self._last_ctrl_c_time: float = 0.0  # Track Ctrl+C timing for double-press exit
+        self._initial_query = initial_query  # Query from piped stdin to auto-send on startup
         self.command_list = list_slash_commands()
         self._custom_command_list = list_custom_commands()
         self._prompt_session: Optional[PromptSession] = None
@@ -147,10 +349,35 @@ class RichUI:
         self._session_start_time = time.time()
         self._session_end_sent = False
         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))
-        self._permission_checker = (
-            None if yolo_mode else make_permission_checker(self.project_path, yolo_mode=False)
-        )
+
+        # Create permission checker with Rich console and PromptSession support
+        if not yolo_mode:
+            # Create a dedicated PromptSession for permission dialogs
+            # This provides better interrupt handling than console.input()
+            from prompt_toolkit import PromptSession
+
+            # Disable CPR (Cursor Position Request) to avoid warnings in terminals
+            # that don't support it (like some remote/CI terminals)
+            import os
+            os.environ['PROMPT_TOOLKIT_NO_CPR'] = '1'
+
+            permission_session = PromptSession()
+
+            self._permission_checker = make_permission_checker(
+                self.project_path,
+                yolo_mode=False,
+                console=console,  # Pass console for Rich Panel rendering
+                prompt_session=permission_session,  # Use PromptSession for input
+            )
+        else:
+            self._permission_checker = None
         # Build ignore filter for file completion
         from ripperdoc.utils.path_ignore import get_project_ignore_patterns
 
@@ -169,12 +396,14 @@ class RichUI:
         else:
             self.show_full_thinking = show_full_thinking
 
+        # Initialize theme from config
+        theme_manager = get_theme_manager()
+        theme_name = getattr(config, "theme", None) or "dark"
+        if not theme_manager.set_theme(theme_name):
+            theme_manager.set_theme("dark")  # Fallback to default
+
         # 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)
+        self._message_display = MessageDisplay(self.console, self.verbose, self.show_full_thinking)
 
         # Keep MCP runtime alive for the whole UI session. Create it on the UI loop up front.
         try:
@@ -215,17 +444,57 @@ class RichUI:
     # Properties for backward compatibility with interrupt handler
     # ─────────────────────────────────────────────────────────────────────────────
 
-    @property
-    def _query_interrupted(self) -> bool:
-        return self._interrupt_handler.was_interrupted
+    # ─────────────────────────────────────────────────────────────────────────────
+    # Thinking mode toggle
+    # ─────────────────────────────────────────────────────────────────────────────
+
+    def _supports_thinking_mode(self) -> bool:
+        """Check if the current model supports extended thinking mode."""
+        from ripperdoc.core.query import infer_thinking_mode
+        from ripperdoc.core.config import ProviderType
+
+        model_profile = get_profile_for_pointer("main")
+        if not model_profile:
+            return False
+        # Anthropic natively supports thinking mode
+        if model_profile.provider == ProviderType.ANTHROPIC:
+            return True
+        # For other providers, check if we can infer a thinking mode
+        return infer_thinking_mode(model_profile) is not None
 
-    @property
-    def _esc_listener_paused(self) -> bool:
-        return self._interrupt_handler._esc_listener_paused
+    def _toggle_thinking_mode(self) -> None:
+        """Toggle thinking mode on/off. Status is shown in rprompt."""
+        if not self._supports_thinking_mode():
+            self.console.print("[yellow]Current model does not support thinking mode.[/yellow]")
+            return
+        self._thinking_mode_enabled = not self._thinking_mode_enabled
 
-    @_esc_listener_paused.setter
-    def _esc_listener_paused(self, value: bool) -> None:
-        self._interrupt_handler._esc_listener_paused = value
+    def _get_thinking_tokens(self) -> int:
+        """Get the thinking tokens budget based on current mode."""
+        if not self._thinking_mode_enabled:
+            return 0
+        config = get_global_config()
+        return config.default_thinking_tokens
+
+    def _get_prompt(self) -> str:
+        """Generate the input prompt."""
+        return "> "
+
+    def _get_rprompt(self) -> Union[str, FormattedText]:
+        """Generate the right prompt with thinking mode status."""
+        if not self._supports_thinking_mode():
+            return ""
+        if self._thinking_mode_enabled:
+            return FormattedText(
+                [
+                    ("class:rprompt-on", "⚡ Thinking"),
+                ]
+            )
+        return FormattedText(
+            [
+                ("class:rprompt-off", "Thinking: off"),
+            ]
+        )
 
     def _context_usage_lines(
         self, breakdown: Any, model_label: str, auto_compact_enabled: bool
@@ -647,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):
@@ -758,16 +1032,48 @@ class RichUI:
             output_token_est += delta_tokens
             spinner.update_tokens(output_token_est)
         else:
-            spinner.update_tokens(output_token_est, suffix=f"Working... {message.content}")
+            # Simplify spinner suffix for bash command progress to avoid clutter
+            suffix = self._simplify_progress_suffix(message.content)
+            spinner.update_tokens(output_token_est, suffix=suffix)
 
         return output_token_est
 
+    def _simplify_progress_suffix(self, content: Any) -> str:
+        """Simplify progress message content for cleaner spinner display.
+
+        For bash command progress (format: "Running... (elapsed)\nstdout_preview"),
+        extract only the timing information to avoid cluttering the spinner with
+        multi-line stdout content that causes terminal wrapping issues.
+
+        Args:
+            content: Progress message content (can be str or other types)
+
+        Returns:
+            Simplified suffix string for spinner display
+        """
+        if not isinstance(content, str):
+            return f"Working... {content}"
+
+        # Handle bash command progress: "Running... (10s)\nstdout..."
+        if content.startswith("Running..."):
+            # Extract just the "Running... (time)" part before any newline
+            first_line = content.split("\n", 1)[0]
+            return first_line
+
+        # For other progress messages, limit length to avoid terminal wrapping
+        max_length = 60
+        if len(content) > max_length:
+            return f"Working... {content[:max_length]}..."
+
+        return f"Working... {content}"
+
     async def process_query(self, user_input: str) -> None:
         """Process a user query and display the response."""
         # Initialize or reset query context
         if not self.query_context:
             self.query_context = QueryContext(
                 tools=self.get_default_tools(),
+                max_thinking_tokens=self._get_thinking_tokens(),
                 yolo_mode=self.yolo_mode,
                 verbose=self.verbose,
                 model=self.model,
@@ -776,6 +1082,8 @@ class RichUI:
             abort_controller = getattr(self.query_context, "abort_controller", None)
             if abort_controller is not None:
                 abort_controller.clear()
+            # Update thinking tokens in case user toggled thinking mode
+            self.query_context.max_thinking_tokens = self._get_thinking_tokens()
         self.query_context.stop_hook_active = False
 
         logger.info(
@@ -791,9 +1099,7 @@ class RichUI:
             hook_result = await hook_manager.run_user_prompt_submit_async(user_input)
             if hook_result.should_block or not hook_result.should_continue:
                 reason = (
-                    hook_result.block_reason
-                    or hook_result.stop_reason
-                    or "Prompt blocked by hook."
+                    hook_result.block_reason or hook_result.stop_reason or "Prompt blocked by hook."
                 )
                 self.console.print(f"[red]{escape(str(reason))}[/red]")
                 return
@@ -804,11 +1110,29 @@ class RichUI:
                 user_input, hook_instructions
             )
 
+            # Process images in user input
+            processed_input, image_blocks = _process_images_in_input(
+                user_input, self.project_path, self.model
+            )
+
             # Create and log user message
-            user_message = create_user_message(user_input)
+            if image_blocks:
+                # Has images: use structured content
+                content_blocks = []
+                # Add images first
+                for block in image_blocks:
+                    content_blocks.append({"type": "image", **block})
+                # Add user's text input
+                if processed_input:
+                    content_blocks.append({"type": "text", "text": processed_input})
+                user_message = create_user_message(content=content_blocks)
+            else:
+                # No images: use plain text
+                user_message = create_user_message(content=processed_input)
+
             messages: List[ConversationMessage] = self.conversation_messages + [user_message]
             self._log_message(user_message)
-            self._append_prompt_history(user_input)
+            self._append_prompt_history(processed_input)
 
             # Get model configuration
             config = get_global_config()
@@ -829,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
@@ -842,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)
@@ -859,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]] = {}
@@ -878,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,
@@ -926,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",
@@ -952,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 _resume_interrupt_listener(self, previous_state: bool) -> None:
-        self._interrupt_handler.resume_listener(previous_state)
+    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")
 
-    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()
+        self._message_display.print_interrupt_notice()
+        abort_controller.set()
 
-    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 _start_interrupt_listener(self) -> None:
+        self._interrupt_listener.start()
+
+    def _stop_interrupt_listener(self) -> None:
+        self._interrupt_listener.stop()
+
+    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."""
@@ -975,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)
@@ -1023,7 +1375,14 @@ class RichUI:
             # Return the expanded content to be processed as a query
             return expanded_content
 
-        self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]")
+        suggestions = _suggest_slash_commands(command_name, self.project_path)
+        hint = ""
+        if suggestions:
+            hint = " [dim]Did you mean "
+            hint += ", ".join(f"/{escape(s)}" for s in suggestions)
+            hint += "?[/dim]"
+
+        self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]{hint}")
         return True
 
     def get_prompt_session(self) -> PromptSession:
@@ -1081,8 +1440,18 @@ class RichUI:
 
         @key_bindings.add("tab")
         def _(event: Any) -> None:
-            """Use Tab to accept the highlighted completion when visible."""
+            """Toggle thinking mode when input is empty; otherwise handle completion."""
             buf = event.current_buffer
+            # If input is empty, toggle thinking mode
+            if not buf.text.strip():
+                from prompt_toolkit.application import run_in_terminal
+
+                def _toggle() -> None:
+                    ui_instance._toggle_thinking_mode()
+
+                run_in_terminal(_toggle)
+                return
+            # Otherwise, handle completion as usual
             if buf.complete_state and buf.complete_state.current_completion:
                 buf.apply_completion(buf.complete_state.current_completion)
             else:
@@ -1132,6 +1501,42 @@ class RichUI:
             # Clear the buffer after printing
             buf.reset()
 
+        # If stdin is not a TTY (e.g., piped input), try to use /dev/tty for interactive input
+        # This allows the user to continue interacting after processing piped content
+        input_obj = None
+        if not sys.stdin.isatty():
+            # First check if /dev/tty exists and is accessible
+            try:
+                import os
+
+                if os.path.exists("/dev/tty"):
+                    from prompt_toolkit.input import create_input
+
+                    input_obj = create_input(always_prefer_tty=True)
+                    self._using_tty_input = True  # Mark that we're using /dev/tty
+                    logger.info(
+                        "[ui] Stdin is not a TTY, using /dev/tty for prompt input",
+                        extra={"session_id": self.session_id},
+                    )
+                else:
+                    logger.info(
+                        "[ui] Stdin is not a TTY and /dev/tty not available",
+                        extra={"session_id": self.session_id},
+                    )
+            except (OSError, RuntimeError, ValueError, ImportError) as exc:
+                logger.warning(
+                    "[ui] Failed to create TTY input: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"session_id": self.session_id},
+                )
+
+        prompt_style = Style.from_dict(
+            {
+                "rprompt-on": "fg:ansicyan bold",
+                "rprompt-off": "fg:ansibrightblack",
+            }
+        )
         self._prompt_session = PromptSession(
             completer=combined_completer,
             complete_style=CompleteStyle.COLUMN,
@@ -1139,6 +1544,9 @@ class RichUI:
             history=InMemoryHistory(),
             key_bindings=key_bindings,
             multiline=True,
+            input=input_obj,
+            style=prompt_style,
+            rprompt=self._get_rprompt,
         )
         return self._prompt_session
 
@@ -1154,7 +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 ESC to interrupt. Press Ctrl+C twice to exit.[/dim]\n"
+            "Press Alt+Enter for newline. Press Tab to toggle thinking mode.[/dim]\n"
         )
 
         session = self.get_prompt_session()
@@ -1165,10 +1573,33 @@ class RichUI:
 
         exit_reason = "other"
         try:
+            # Process initial query from piped stdin if provided
+            if self._initial_query:
+                console.print(f"> {self._initial_query}")
+                logger.info(
+                    "[ui] Processing initial query from stdin",
+                    extra={
+                        "session_id": self.session_id,
+                        "prompt_length": len(self._initial_query),
+                        "prompt_preview": self._initial_query[:200],
+                    },
+                )
+                console.print()  # Add spacing before response
+
+                # Process initial query (ESC interrupt handling removed)
+                self._run_async(self.process_query(self._initial_query))
+
+                logger.info(
+                    "[ui] Initial query completed successfully",
+                    extra={"session_id": self.session_id},
+                )
+                console.print()  # Add spacing after response
+                self._initial_query = None  # Clear after processing
+
             while not self._should_exit:
                 try:
-                    # Get user input
-                    user_input = session.prompt("> ")
+                    # Get user input with dynamic prompt
+                    user_input = session.prompt(self._get_prompt())
 
                     if not user_input.strip():
                         continue
@@ -1205,16 +1636,9 @@ class RichUI:
                             "prompt_preview": user_input[:200],
                         },
                     )
-                    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
 
@@ -1237,9 +1661,7 @@ class RichUI:
 
                     # First Ctrl+C - just abort the query and continue
                     self._last_ctrl_c_time = current_time
-                    console.print(
-                        "\n[dim]Query interrupted. Press Ctrl+C again to exit.[/dim]"
-                    )
+                    console.print("\n[dim]Query interrupted. Press Ctrl+C again to exit.[/dim]")
                     continue
                 except EOFError:
                     console.print("\n[yellow]Goodbye![/yellow]")
@@ -1437,8 +1859,14 @@ def main_rich(
     append_system_prompt: Optional[str] = None,
     model: Optional[str] = None,
     resume_messages: Optional[List[Any]] = None,
+    initial_query: Optional[str] = None,
 ) -> None:
-    """Main entry point for Rich interface."""
+    """Main entry point for Rich interface.
+
+    Args:
+        initial_query: If provided, automatically send this query after starting the session.
+                      Used for piped stdin input (e.g., `echo "query" | ripperdoc`).
+    """
 
     # Ensure onboarding is complete
     if not check_onboarding_rich():
@@ -1456,6 +1884,7 @@ def main_rich(
         append_system_prompt=append_system_prompt,
         model=model,
         resume_messages=resume_messages,
+        initial_query=initial_query,
     )
     ui.run()