ripperdoc 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

ripperdoc/cli/ui/interrupt_handler.py

@@ -0,0 +1,175 @@
+"""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
+
+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
+        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.
+        """
+        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)

ripperdoc/cli/ui/message_display.py

@@ -0,0 +1,249 @@
+"""Message display and rendering utilities for RichUI.
+
+This module handles rendering conversation messages to the terminal, including:
+- Tool call and result formatting
+- Assistant/user message display
+- Reasoning block rendering
+"""
+
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.markup import escape
+
+from ripperdoc.cli.ui.tool_renderers import ToolResultRendererRegistry
+from ripperdoc.utils.messages import UserMessage, AssistantMessage, ProgressMessage
+from ripperdoc.utils.message_formatting import format_reasoning_preview
+
+ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
+
+
+class MessageDisplay:
+    """Handles message rendering and display operations."""
+
+    def __init__(self, console: Console, verbose: bool = False):
+        """Initialize the message display handler.
+
+        Args:
+            console: Rich console for output
+            verbose: Whether to show verbose output
+        """
+        self.console = console
+        self.verbose = verbose
+
+    def format_tool_args(self, tool_name: str, tool_args: Optional[dict]) -> List[str]:
+        """Render tool arguments into concise display-friendly parts."""
+        if not tool_args:
+            return []
+
+        args_parts: List[str] = []
+
+        def _format_arg(arg_key: str, arg_value: Any) -> str:
+            if arg_key == "todos" and isinstance(arg_value, list):
+                counts = {"pending": 0, "in_progress": 0, "completed": 0}
+                for item in arg_value:
+                    status = ""
+                    if isinstance(item, dict):
+                        status = item.get("status", "")
+                    elif hasattr(item, "get"):
+                        status = item.get("status", "")
+                    elif hasattr(item, "status"):
+                        status = getattr(item, "status")
+                    if status in counts:
+                        counts[status] += 1
+                total = len(arg_value)
+                return f"{arg_key}: {total} items"
+            if isinstance(arg_value, (list, dict)):
+                return f"{arg_key}: {len(arg_value)} items"
+            if isinstance(arg_value, str) and len(arg_value) > 50:
+                return f'{arg_key}: "{arg_value[:50]}..."'
+            return f"{arg_key}: {arg_value}"
+
+        if tool_name == "Bash":
+            command_value = tool_args.get("command")
+            if command_value is not None:
+                args_parts.append(_format_arg("command", command_value))
+
+            background_value = tool_args.get("run_in_background", tool_args.get("runInBackground"))
+            background_value = bool(background_value) if background_value is not None else False
+            args_parts.append(f"background: {background_value}")
+
+            sandbox_value = tool_args.get("sandbox")
+            sandbox_value = bool(sandbox_value) if sandbox_value is not None else False
+            args_parts.append(f"sandbox: {sandbox_value}")
+
+            for key, value in tool_args.items():
+                if key in {"command", "run_in_background", "runInBackground", "sandbox"}:
+                    continue
+                args_parts.append(_format_arg(key, value))
+            return args_parts
+
+        # Special handling for Edit and MultiEdit tools - don't show old_string
+        if tool_name in ["Edit", "MultiEdit"]:
+            for key, value in tool_args.items():
+                if key == "new_string":
+                    continue  # Skip new_string for Edit/MultiEdit tools
+                if key == "old_string":
+                    continue  # Skip old_string for Edit/MultiEdit tools
+                # For MultiEdit, also handle edits array
+                if key == "edits" and isinstance(value, list):
+                    args_parts.append(f"edits: {len(value)} operations")
+                    continue
+                args_parts.append(_format_arg(key, value))
+            return args_parts
+
+        for key, value in tool_args.items():
+            args_parts.append(_format_arg(key, value))
+        return args_parts
+
+    def print_tool_call(self, sender: str, content: str, tool_args: Optional[dict]) -> None:
+        """Render a tool invocation line."""
+        if sender == "Task":
+            subagent = ""
+            if isinstance(tool_args, dict):
+                subagent = tool_args.get("subagent_type") or tool_args.get("subagent") or ""
+            desc = ""
+            if isinstance(tool_args, dict):
+                raw_desc = tool_args.get("description") or tool_args.get("prompt") or ""
+                desc = raw_desc if len(str(raw_desc)) <= 120 else str(raw_desc)[:117] + "..."
+            label = f"-> Launching subagent: {subagent or 'unknown'}"
+            if desc:
+                label += f" — {desc}"
+            self.console.print(f"[cyan]{escape(label)}[/cyan]")
+            return
+
+        tool_name = sender if sender != "Ripperdoc" else content
+        tool_display = f"● {tool_name}("
+
+        args_parts = self.format_tool_args(tool_name, tool_args)
+        if args_parts:
+            tool_display += ", ".join(args_parts)
+        tool_display += ")"
+
+        self.console.print(f"[dim cyan]{escape(tool_display)}[/]")
+
+    def print_tool_result(
+        self,
+        sender: str,
+        content: str,
+        tool_data: Any,
+        tool_error: bool = False,
+        parse_bash_output_fn: Optional[Callable] = None,
+    ) -> None:
+        """Render a tool result summary using the renderer registry."""
+        # Check for failure states
+        failed = tool_error
+        if tool_data is not None:
+            if isinstance(tool_data, dict):
+                failed = failed or (tool_data.get("success") is False)
+            else:
+                success = getattr(tool_data, "success", None)
+                failed = failed or (success is False)
+            failed = failed or bool(self._get_tool_field(tool_data, "is_error"))
+
+        # Extract warning/token info
+        warning_text = None
+        token_estimate = None
+        if tool_data is not None:
+            warning_text = self._get_tool_field(tool_data, "warning")
+            token_estimate = self._get_tool_field(tool_data, "token_estimate")
+
+        # Handle failure case
+        if failed:
+            if content:
+                self.console.print(f"  ⎿  [red]{escape(content)}[/red]")
+            else:
+                self.console.print(f"  ⎿  [red]{escape(sender)} failed[/red]")
+            return
+
+        # Display warnings and token estimates
+        if warning_text:
+            self.console.print(f"  ⎿  [yellow]{escape(str(warning_text))}[/yellow]")
+            if token_estimate:
+                self.console.print(
+                    f"      [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]"
+                )
+        elif token_estimate and self.verbose:
+            self.console.print(f"  ⎿  [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]")
+
+        # Handle empty content
+        if not content:
+            self.console.print("  ⎿  [dim]Tool completed[/]")
+            return
+
+        # Use renderer registry for tool-specific rendering
+        registry = ToolResultRendererRegistry(
+            self.console, self.verbose, parse_bash_output_fn or self._default_parse_bash
+        )
+        if registry.render(sender, content, tool_data):
+            return
+
+        # Fallback for unhandled tools
+        self.console.print("  ⎿  [dim]Tool completed[/]")
+
+    def print_generic_tool(self, sender: str, content: str) -> None:
+        """Fallback rendering for miscellaneous tool messages."""
+        if sender == "Task" and isinstance(content, str) and content.startswith("[subagent:"):
+            agent_label = content.split("]", 1)[0].replace("[subagent:", "").strip()
+            summary = content.split("]", 1)[1].strip() if "]" in content else ""
+            self.console.print(f"[green]↳ Subagent {escape(agent_label)} finished[/green]")
+            if summary:
+                self.console.print(f"    {summary}", markup=False)
+            return
+        self.console.print(f"[dim cyan][Tool] {escape(sender)}: {escape(content)}[/]")
+
+    def print_human_or_assistant(self, sender: str, content: str) -> None:
+        """Render messages from the user or assistant."""
+        if sender.lower() == "you":
+            self.console.print(f"[bold green]{escape(sender)}:[/] {escape(content)}")
+            return
+        self.console.print(Markdown(content))
+
+    def _get_tool_field(self, data: Any, key: str, default: Any = None) -> Any:
+        """Safely fetch a field from either an object or a dict."""
+        if isinstance(data, dict):
+            return data.get(key, default)
+        return getattr(data, key, default)
+
+    def _default_parse_bash(self, content: str) -> Tuple[List[str], List[str]]:
+        """Default bash output parser."""
+        return parse_bash_output_sections(content)
+
+    def print_reasoning(self, reasoning: Any) -> None:
+        """Display a collapsed preview of reasoning/thinking blocks."""
+        preview = format_reasoning_preview(reasoning)
+        if preview:
+            self.console.print(f"[dim italic]Thinking: {escape(preview)}[/]")
+
+
+def parse_bash_output_sections(content: str) -> Tuple[List[str], List[str]]:
+    """Parse stdout/stderr sections from a bash output text block."""
+    stdout_lines: List[str] = []
+    stderr_lines: List[str] = []
+    if not content:
+        return stdout_lines, stderr_lines
+
+    current: Optional[str] = None
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("stdout:"):
+            current = "stdout"
+            remainder = line.split("stdout:", 1)[1].strip()
+            if remainder:
+                stdout_lines.append(remainder)
+            continue
+        if stripped.startswith("stderr:"):
+            current = "stderr"
+            remainder = line.split("stderr:", 1)[1].strip()
+            if remainder:
+                stderr_lines.append(remainder)
+            continue
+        if stripped.startswith("exit code:"):
+            break
+        if current == "stdout":
+            stdout_lines.append(line)
+        elif current == "stderr":
+            stderr_lines.append(line)
+
+    return stdout_lines, stderr_lines

ripperdoc/cli/ui/panels.py

@@ -0,0 +1,63 @@
+"""UI panels and visual components for RichUI.
+
+This module contains welcome panels, status bars, and other
+visual UI elements.
+"""
+
+from typing import List, Tuple
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+
+from ripperdoc import __version__
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+
+
+def create_welcome_panel() -> Panel:
+    """Create a welcome panel for the CLI startup."""
+    welcome_content = """
+[bold cyan]Welcome to Ripperdoc![/bold cyan]
+
+Ripperdoc is an AI-powered coding assistant that helps with software development tasks.
+You can read files, edit code, run commands, and help with various programming tasks.
+
+[dim]Type your questions below. Press Ctrl+C to exit.[/dim]
+"""
+
+    return Panel(
+        welcome_content,
+        title=f"Ripperdoc v{__version__}",
+        border_style="cyan",
+        box=box.ROUNDED,
+        padding=(1, 2),
+    )
+
+
+def create_status_bar() -> Text:
+    """Create a status bar with current model information."""
+    profile = get_profile_for_pointer("main")
+    model_name = profile.model if profile else "Not configured"
+
+    status_text = Text()
+    status_text.append("Ripperdoc", style="bold cyan")
+    status_text.append(" • ")
+    status_text.append(model_name, style="dim")
+    status_text.append(" • ")
+    status_text.append("Ready", style="green")
+
+    return status_text
+
+
+def print_shortcuts(console: Console) -> None:
+    """Show common keyboard shortcuts and prefixes."""
+    pairs: List[Tuple[str, str]] = [
+        ("? for shortcuts", "! for bash mode"),
+        ("/ for commands", "@ for file mention"),
+    ]
+    console.print("[dim]Shortcuts[/dim]")
+    for left, right in pairs:
+        left_text = f"  {left}".ljust(32)
+        right_text = f"{right}" if right else ""
+        console.print(f"{left_text}{right_text}")