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

ripperdoc/cli/ui/rich_ui.py

@@ -4,8 +4,10 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 """
 
 import asyncio
+import difflib
 import json
 import sys
+import time
 import uuid
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
@@ -15,16 +17,20 @@ 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
 from ripperdoc.core.hooks.manager import hook_manager
+from ripperdoc.core.hooks.llm_callback import build_hook_llm_callback
 from ripperdoc.cli.commands import (
     get_slash_command,
     get_custom_command,
@@ -46,8 +52,6 @@ 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,
@@ -64,6 +68,8 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.lsp import shutdown_lsp_manager
+from ripperdoc.tools.background_shell import shutdown_background_shell
 from ripperdoc.tools.mcp_tools import load_dynamic_mcp_tools_async, merge_tools_with_dynamic
 from ripperdoc.utils.session_history import SessionHistory
 from ripperdoc.utils.memory import build_memory_instructions
@@ -77,6 +83,7 @@ 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
@@ -86,9 +93,199 @@ console = Console()
 logger = get_logger()
 
 
-# Legacy aliases for backward compatibility with tests
-_extract_tool_ids_from_message = extract_tool_ids_from_message
-_get_complete_tool_pairs_tail = get_complete_tool_pairs_tail
+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:
@@ -101,17 +298,29 @@ class RichUI:
         show_full_thinking: Optional[bool] = None,
         session_id: Optional[str] = None,
         log_file_path: Optional[Path] = None,
+        allowed_tools: Optional[List[str]] = None,
+        custom_system_prompt: Optional[str] = None,
+        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)
         self.console = console
         self.yolo_mode = yolo_mode
         self.verbose = verbose
+        self.allowed_tools = allowed_tools
+        self.custom_system_prompt = custom_system_prompt
+        self.append_system_prompt = append_system_prompt
+        self.model = model or "main"
         self.conversation_messages: List[ConversationMessage] = []
         self._saved_conversation: Optional[List[ConversationMessage]] = None
         self.query_context: Optional[QueryContext] = None
         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
@@ -134,9 +343,35 @@ class RichUI:
             },
         )
         self._session_history = SessionHistory(self.project_path, self.session_id)
-        self._permission_checker = (
-            None if yolo_mode else make_permission_checker(self.project_path, yolo_mode=False)
-        )
+        self._session_hook_contexts: List[str] = []
+        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
+        hook_manager.set_transcript_path(str(self._session_history.path))
+
+        # 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
 
@@ -155,10 +390,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._message_display = MessageDisplay(self.console, self.verbose, self.show_full_thinking)
         self._interrupt_handler = InterruptHandler()
         self._interrupt_handler.set_abort_callback(self._trigger_abort)
 
@@ -176,6 +415,7 @@ class RichUI:
         # Initialize hook manager with project context
         hook_manager.set_project_dir(self.project_path)
         hook_manager.set_session_id(self.session_id)
+        hook_manager.set_llm_callback(build_hook_llm_callback())
         logger.debug(
             "[ui] Initialized hook manager",
             extra={
@@ -183,6 +423,18 @@ class RichUI:
                 "project_path": str(self.project_path),
             },
         )
+        self._run_session_start("startup")
+
+        # Handle resume_messages if provided (for --continue)
+        if resume_messages:
+            self.conversation_messages = list(resume_messages)
+            logger.info(
+                "[ui] Resumed conversation with messages",
+                extra={
+                    "session_id": self.session_id,
+                    "message_count": len(resume_messages),
+                },
+            )
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Properties for backward compatibility with interrupt handler
@@ -200,6 +452,58 @@ class RichUI:
     def _esc_listener_paused(self, value: bool) -> None:
         self._interrupt_handler._esc_listener_paused = value
 
+    # ─────────────────────────────────────────────────────────────────────────────
+    # 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
+
+    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
+
+    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
     ) -> List[str]:
@@ -218,6 +522,69 @@ class RichUI:
             },
         )
         self._session_history = SessionHistory(self.project_path, session_id)
+        hook_manager.set_session_id(self.session_id)
+        hook_manager.set_transcript_path(str(self._session_history.path))
+
+    def _collect_hook_contexts(self, hook_result: Any) -> List[str]:
+        contexts: List[str] = []
+        system_message = getattr(hook_result, "system_message", None)
+        additional_context = getattr(hook_result, "additional_context", None)
+        if system_message:
+            contexts.append(str(system_message))
+        if additional_context:
+            contexts.append(str(additional_context))
+        return contexts
+
+    def _set_session_hook_contexts(self, hook_result: Any) -> None:
+        self._session_hook_contexts = self._collect_hook_contexts(hook_result)
+        self._session_start_time = time.time()
+        self._session_end_sent = False
+
+    def _run_session_start(self, source: str) -> None:
+        try:
+            result = self._run_async(hook_manager.run_session_start_async(source))
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    async def _run_session_start_async(self, source: str) -> None:
+        try:
+            result = await hook_manager.run_session_start_async(source)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionStart hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "source": source},
+            )
+            return
+        self._set_session_hook_contexts(result)
+
+    def _run_session_end(self, reason: str) -> None:
+        if self._session_end_sent:
+            return
+        duration = max(time.time() - self._session_start_time, 0.0)
+        message_count = len(self.conversation_messages)
+        try:
+            self._run_async(
+                hook_manager.run_session_end_async(
+                    reason, duration_seconds=duration, message_count=message_count
+                )
+            )
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] SessionEnd hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id, "reason": reason},
+            )
+        self._session_end_sent = True
 
     def _log_message(self, message: Any) -> None:
         """Best-effort persistence of a message to the session log."""
@@ -278,8 +645,8 @@ class RichUI:
                 self.display_message("Ripperdoc", text)
 
     def get_default_tools(self) -> list:
-        """Get the default set of tools."""
-        return get_default_tools()
+        """Get the default set of tools, filtered by allowed_tools if specified."""
+        return get_default_tools(allowed_tools=self.allowed_tools)
 
     def display_message(
         self,
@@ -334,7 +701,9 @@ class RichUI:
     def _print_reasoning(self, reasoning: Any) -> None:
         self._message_display.print_reasoning(reasoning)
 
-    async def _prepare_query_context(self, user_input: str) -> tuple[str, Dict[str, str]]:
+    async def _prepare_query_context(
+        self, user_input: str, hook_instructions: Optional[List[str]] = None
+    ) -> tuple[str, Dict[str, str]]:
         """Load MCP servers, skills, and build system prompt.
 
         Returns:
@@ -380,14 +749,32 @@ class RichUI:
         memory_instructions = build_memory_instructions()
         if memory_instructions:
             additional_instructions.append(memory_instructions)
-
-        system_prompt = build_system_prompt(
-            self.query_context.tools if self.query_context else [],
-            user_input,
-            context,
-            additional_instructions=additional_instructions or None,
-            mcp_instructions=mcp_instructions,
-        )
+        if self._session_hook_contexts:
+            additional_instructions.extend(self._session_hook_contexts)
+        if hook_instructions:
+            additional_instructions.extend([text for text in hook_instructions if text])
+
+        # Build system prompt based on options:
+        # - custom_system_prompt: replaces the default entirely
+        # - append_system_prompt: appends to the default system prompt
+        if self.custom_system_prompt:
+            # Complete replacement
+            system_prompt = self.custom_system_prompt
+            # Still append if both are provided
+            if self.append_system_prompt:
+                system_prompt = f"{system_prompt}\n\n{self.append_system_prompt}"
+        else:
+            # Build default with optional append
+            all_instructions = list(additional_instructions) if additional_instructions else []
+            if self.append_system_prompt:
+                all_instructions.append(self.append_system_prompt)
+            system_prompt = build_system_prompt(
+                self.query_context.tools if self.query_context else [],
+                user_input,
+                context,
+                additional_instructions=all_instructions or None,
+                mcp_instructions=mcp_instructions,
+            )
 
         return system_prompt, context
 
@@ -452,10 +839,33 @@ class RichUI:
         if usage_status.should_auto_compact:
             original_messages = list(messages)
             spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
+            hook_instructions = ""
+            try:
+                hook_result = await hook_manager.run_pre_compact_async(
+                    trigger="auto", custom_instructions=""
+                )
+                if hook_result.should_block or not hook_result.should_continue:
+                    reason = (
+                        hook_result.block_reason
+                        or hook_result.stop_reason
+                        or "Compaction blocked by hook."
+                    )
+                    console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                    return messages
+                hook_contexts = self._collect_hook_contexts(hook_result)
+                if hook_contexts:
+                    hook_instructions = "\n\n".join(hook_contexts)
+            except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+                logger.warning(
+                    "[ui] PreCompact hook failed: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"session_id": self.session_id},
+                )
             try:
                 spinner.start()
                 result = await compact_conversation(
-                    messages, custom_instructions="", protocol=protocol
+                    messages, custom_instructions=hook_instructions, protocol=protocol
                 )
             finally:
                 spinner.stop()
@@ -476,6 +886,7 @@ class RichUI:
                         "tokens_saved": result.tokens_saved,
                     },
                 )
+                await self._run_session_start_async("compact")
                 return result.messages
             elif isinstance(result, CompactionError):
                 logger.warning(
@@ -624,21 +1035,59 @@ 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(), yolo_mode=self.yolo_mode, verbose=self.verbose
+                tools=self.get_default_tools(),
+                max_thinking_tokens=self._get_thinking_tokens(),
+                yolo_mode=self.yolo_mode,
+                verbose=self.verbose,
+                model=self.model,
             )
         else:
             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(
             "[ui] Starting query processing",
@@ -650,14 +1099,43 @@ class RichUI:
         )
 
         try:
+            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."
+                )
+                self.console.print(f"[red]{escape(str(reason))}[/red]")
+                return
+            hook_instructions = self._collect_hook_contexts(hook_result)
+
             # Prepare context and system prompt
-            system_prompt, context = await self._prepare_query_context(user_input)
+            system_prompt, context = await self._prepare_query_context(
+                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()
@@ -872,7 +1350,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:
@@ -886,7 +1371,7 @@ class RichUI:
             def __init__(self, project_path: Path):
                 self.project_path = project_path
 
-            def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
+            def get_completions(self, document: Any, _complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
@@ -930,19 +1415,113 @@ 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:
                 buf.start_completion(select_first=True)
 
+        @key_bindings.add("escape", "enter")
+        def _(event: Any) -> None:
+            """Insert newline on Alt+Enter."""
+            event.current_buffer.insert_text("\n")
+
+        # Capture self for use in Ctrl+C handler closure
+        ui_instance = self
+
+        @key_bindings.add("c-c")
+        def _(event: Any) -> None:
+            """Handle Ctrl+C: first press clears input, second press exits."""
+            import time as time_module
+
+            buf = event.current_buffer
+            current_text = buf.text
+            current_time = time_module.time()
+
+            # Check if this is a double Ctrl+C (within 1.5 seconds)
+            if current_time - ui_instance._last_ctrl_c_time < 1.5:
+                # Double Ctrl+C - exit
+                buf.reset()
+                raise KeyboardInterrupt()
+
+            # First Ctrl+C - save to history and clear
+            ui_instance._last_ctrl_c_time = current_time
+
+            if current_text.strip():
+                # Save current input to history before clearing
+                try:
+                    event.app.current_buffer.history.append_string(current_text)
+                except (AttributeError, TypeError, ValueError):
+                    pass
+
+            # Print hint message in clean terminal context, then clear buffer
+            from prompt_toolkit.application import run_in_terminal
+
+            def _print_hint() -> None:
+                print("\n\033[2mPress Ctrl+C again to exit, or continue typing.\033[0m")
+
+            run_in_terminal(_print_hint)
+
+            # 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,
             complete_while_typing=True,
             history=InMemoryHistory(),
             key_bindings=key_bindings,
+            multiline=True,
+            input=input_obj,
+            style=prompt_style,
+            rprompt=self._get_rprompt,
         )
         return self._prompt_session
 
@@ -957,7 +1536,9 @@ class RichUI:
         console.print(create_status_bar())
         console.print()
         console.print(
-            "[dim]Tip: type '/' then press Tab to see available commands. Type '@' to mention files. Press ESC to interrupt a running query.[/dim]\n"
+            "[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"
         )
 
         session = self.get_prompt_session()
@@ -966,11 +1547,36 @@ class RichUI:
             extra={"session_id": self.session_id, "log_file": str(self.log_file_path)},
         )
 
+        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
+
+                # Use _run_async instead of _run_async_with_esc_interrupt for piped stdin
+                # since there's no TTY for ESC key detection
+                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
@@ -988,6 +1594,7 @@ class RichUI:
                         )
                         handled = self.handle_slash_command(user_input)
                         if self._should_exit:
+                            exit_reason = self._exit_reason or "other"
                             break
                         # If handled is a string, it's expanded custom command content
                         if isinstance(handled, str):
@@ -1006,29 +1613,49 @@ 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},
+                    # 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},
+                            )
 
                     console.print()  # Add spacing between interactions
 
                 except KeyboardInterrupt:
+                    # Handle Ctrl+C: first press during query aborts it,
+                    # double press exits the CLI
+                    current_time = time.time()
+
                     # Signal abort to cancel running queries
                     if self.query_context:
                         abort_controller = getattr(self.query_context, "abort_controller", None)
                         if abort_controller is not None:
                             abort_controller.set()
-                    console.print("\n[yellow]Goodbye![/yellow]")
-                    break
+
+                    # Check if this is a double Ctrl+C (within 1.5 seconds)
+                    if current_time - self._last_ctrl_c_time < 1.5:
+                        console.print("\n[yellow]Goodbye![/yellow]")
+                        exit_reason = "prompt_input_exit"
+                        break
+
+                    # 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]")
+                    continue
                 except EOFError:
                     console.print("\n[yellow]Goodbye![/yellow]")
+                    exit_reason = "prompt_input_exit"
                     break
                 except (
                     OSError,
@@ -1056,6 +1683,8 @@ class RichUI:
                 if abort_controller is not None:
                     abort_controller.set()
 
+            self._run_session_end(exit_reason)
+
             # Suppress async generator cleanup errors during shutdown
             original_hook = sys.unraisablehook
 
@@ -1072,6 +1701,7 @@ class RichUI:
             try:
                 try:
                     self._run_async(shutdown_mcp_runtime())
+                    self._run_async(shutdown_lsp_manager())
                 except (OSError, RuntimeError, ConnectionError, asyncio.CancelledError) as exc:
                     # pragma: no cover - defensive shutdown
                     logger.warning(
@@ -1080,6 +1710,17 @@ class RichUI:
                         exc,
                         extra={"session_id": self.session_id},
                     )
+
+                # Shutdown background shell manager to clean up any background tasks
+                try:
+                    shutdown_background_shell(force=True)
+                except (OSError, RuntimeError) as exc:
+                    logger.debug(
+                        "[ui] Failed to shut down background shell cleanly: %s: %s",
+                        type(exc).__name__,
+                        exc,
+                        extra={"session_id": self.session_id},
+                    )
             finally:
                 if not self._loop.is_closed():
                     # Cancel all pending tasks
@@ -1121,11 +1762,42 @@ class RichUI:
         original_messages = list(self.conversation_messages)
         spinner = Spinner(self.console, "Summarizing conversation...", spinner="dots")
 
+        hook_instructions = ""
+        try:
+            hook_result = await hook_manager.run_pre_compact_async(
+                trigger="manual", custom_instructions=custom_instructions
+            )
+            if hook_result.should_block or not hook_result.should_continue:
+                reason = (
+                    hook_result.block_reason
+                    or hook_result.stop_reason
+                    or "Compaction blocked by hook."
+                )
+                self.console.print(f"[yellow]{escape(str(reason))}[/yellow]")
+                return
+            hook_contexts = self._collect_hook_contexts(hook_result)
+            if hook_contexts:
+                hook_instructions = "\n\n".join(hook_contexts)
+        except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+            logger.warning(
+                "[ui] PreCompact hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"session_id": self.session_id},
+            )
+
+        merged_instructions = custom_instructions.strip()
+        if hook_instructions:
+            merged_instructions = (
+                f"{merged_instructions}\n\n{hook_instructions}".strip()
+                if merged_instructions
+                else hook_instructions
+            )
         try:
             spinner.start()
             result = await compact_conversation(
                 self.conversation_messages,
-                custom_instructions,
+                merged_instructions,
                 protocol=protocol,
             )
         except Exception as exc:
@@ -1144,6 +1816,7 @@ class RichUI:
                 f"[green]✓ Conversation compacted[/green] "
                 f"(saved ~{result.tokens_saved} tokens). Use /resume to restore full history."
             )
+            await self._run_session_start_async("compact")
         elif isinstance(result, CompactionError):
             self.console.print(f"[red]{escape(result.message)}[/red]")
 
@@ -1171,8 +1844,19 @@ def main_rich(
     show_full_thinking: Optional[bool] = None,
     session_id: Optional[str] = None,
     log_file_path: Optional[Path] = None,
+    allowed_tools: Optional[List[str]] = None,
+    custom_system_prompt: Optional[str] = None,
+    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():
@@ -1185,6 +1869,12 @@ def main_rich(
         show_full_thinking=show_full_thinking,
         session_id=session_id,
         log_file_path=log_file_path,
+        allowed_tools=allowed_tools,
+        custom_system_prompt=custom_system_prompt,
+        append_system_prompt=append_system_prompt,
+        model=model,
+        resume_messages=resume_messages,
+        initial_query=initial_query,
     )
     ui.run()