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

ripperdoc/cli/ui/rich_ui.py

@@ -4,37 +4,37 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 """
 
 import asyncio
-import contextlib
 import json
-import os
 import sys
 import uuid
-import re
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
 
 from rich.console import Console
-from rich.markdown import Markdown
 from rich.markup import escape
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion, merge_completers
-from prompt_toolkit.shortcuts.prompt import CompleteStyle
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.document import Document
+from prompt_toolkit.shortcuts.prompt import CompleteStyle
 
 from ripperdoc.core.config import get_global_config, provider_protocol
 from ripperdoc.core.default_tools import get_default_tools
 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.cli.commands import (
     get_slash_command,
+    get_custom_command,
     list_slash_commands,
+    list_custom_commands,
     slash_command_completions,
+    expand_command_content,
+    CustomCommandDefinition,
 )
-from ripperdoc.cli.ui.helpers import get_profile_for_pointer, THINKING_WORDS
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
 from ripperdoc.core.permissions import make_permission_checker
 from ripperdoc.cli.ui.spinner import Spinner
 from ripperdoc.cli.ui.thinking_spinner import ThinkingSpinner
@@ -72,7 +72,6 @@ from ripperdoc.utils.messages import (
     AssistantMessage,
     ProgressMessage,
     create_user_message,
-    create_assistant_message,
 )
 from ripperdoc.utils.log import enable_session_file_logging, get_logger
 from ripperdoc.utils.path_ignore import build_ignore_filter
@@ -97,15 +96,16 @@ class RichUI:
 
     def __init__(
         self,
-        safe_mode: bool = False,
+        yolo_mode: bool = False,
         verbose: bool = False,
+        show_full_thinking: Optional[bool] = None,
         session_id: Optional[str] = None,
         log_file_path: Optional[Path] = None,
     ):
         self._loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self._loop)
         self.console = console
-        self.safe_mode = safe_mode
+        self.yolo_mode = yolo_mode
         self.verbose = verbose
         self.conversation_messages: List[ConversationMessage] = []
         self._saved_conversation: Optional[List[ConversationMessage]] = None
@@ -113,7 +113,7 @@ class RichUI:
         self._current_tool: Optional[str] = None
         self._should_exit: bool = False
         self.command_list = list_slash_commands()
-        self._command_completions = slash_command_completions()
+        self._custom_command_list = list_custom_commands()
         self._prompt_session: Optional[PromptSession] = None
         self.project_path = Path.cwd()
         # Track a stable session identifier for the current UI run.
@@ -129,16 +129,17 @@ class RichUI:
                 "session_id": self.session_id,
                 "project_path": str(self.project_path),
                 "log_file": str(self.log_file_path),
-                "safe_mode": self.safe_mode,
+                "yolo_mode": self.yolo_mode,
                 "verbose": self.verbose,
             },
         )
         self._session_history = SessionHistory(self.project_path, self.session_id)
         self._permission_checker = (
-            make_permission_checker(self.project_path, safe_mode) if safe_mode else None
+            None if yolo_mode else make_permission_checker(self.project_path, yolo_mode=False)
         )
         # Build ignore filter for file completion
         from ripperdoc.utils.path_ignore import get_project_ignore_patterns
+
         project_patterns = get_project_ignore_patterns()
         self._ignore_filter = build_ignore_filter(
             self.project_path,
@@ -147,8 +148,17 @@ class RichUI:
             include_gitignore=True,
         )
 
+        # Get global config for display preferences
+        config = get_global_config()
+        if show_full_thinking is None:
+            self.show_full_thinking = config.show_full_thinking
+        else:
+            self.show_full_thinking = show_full_thinking
+
         # Initialize component handlers
-        self._message_display = MessageDisplay(self.console, self.verbose)
+        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)
 
@@ -158,10 +168,22 @@ class RichUI:
         except (OSError, RuntimeError, ConnectionError) as exc:
             logger.warning(
                 "[ui] Failed to initialize MCP runtime at startup: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
+        # Initialize hook manager with project context
+        hook_manager.set_project_dir(self.project_path)
+        hook_manager.set_session_id(self.session_id)
+        logger.debug(
+            "[ui] Initialized hook manager",
+            extra={
+                "session_id": self.session_id,
+                "project_path": str(self.project_path),
+            },
+        )
+
     # ─────────────────────────────────────────────────────────────────────────────
     # Properties for backward compatibility with interrupt handler
     # ─────────────────────────────────────────────────────────────────────────────
@@ -205,7 +227,8 @@ class RichUI:
             # Logging failures should never interrupt the UI flow
             logger.warning(
                 "[ui] Failed to append message to session history: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -219,7 +242,8 @@ class RichUI:
         except (AttributeError, TypeError, ValueError) as exc:
             logger.warning(
                 "[ui] Failed to append prompt history: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
 
@@ -452,7 +476,7 @@ class RichUI:
                         "tokens_saved": result.tokens_saved,
                     },
                 )
-                return result.messages  # type: ignore[return-value]
+                return result.messages
             elif isinstance(result, CompactionError):
                 logger.warning(
                     "[ui] Auto-compaction failed: %s",
@@ -466,29 +490,36 @@ class RichUI:
         self,
         message: AssistantMessage,
         tool_registry: Dict[str, Dict[str, Any]],
+        spinner: Optional[ThinkingSpinner] = None,
     ) -> Optional[str]:
         """Handle an assistant message from the query stream.
 
         Returns:
             The last tool name if a tool_use block was processed, None otherwise.
         """
+        # Factory to create pause context - spinner.paused() if spinner exists, else no-op
+        from contextlib import nullcontext
+
+        pause = lambda: spinner.paused() if spinner else nullcontext()  # noqa: E731
+
         meta = getattr(getattr(message, "message", None), "metadata", {}) or {}
         reasoning_payload = (
-            meta.get("reasoning_content")
-            or meta.get("reasoning")
-            or meta.get("reasoning_details")
+            meta.get("reasoning_content") or meta.get("reasoning") or meta.get("reasoning_details")
         )
         if reasoning_payload:
-            self._print_reasoning(reasoning_payload)
+            with pause():
+                self._print_reasoning(reasoning_payload)
 
         last_tool_name: Optional[str] = None
 
         if isinstance(message.message.content, str):
-            self.display_message("Ripperdoc", message.message.content)
+            with pause():
+                self.display_message("Ripperdoc", message.message.content)
         elif isinstance(message.message.content, list):
             for block in message.message.content:
                 if hasattr(block, "type") and block.type == "text" and block.text:
-                    self.display_message("Ripperdoc", block.text)
+                    with pause():
+                        self.display_message("Ripperdoc", block.text)
                 elif hasattr(block, "type") and block.type == "tool_use":
                     tool_name = getattr(block, "name", "unknown tool")
                     tool_args = getattr(block, "input", {})
@@ -502,9 +533,10 @@ class RichUI:
                         }
 
                     if tool_name == "Task":
-                        self.display_message(
-                            tool_name, "", is_tool=True, tool_type="call", tool_args=tool_args
-                        )
+                        with pause():
+                            self.display_message(
+                                tool_name, "", is_tool=True, tool_type="call", tool_args=tool_args
+                            )
                         if tool_use_id:
                             tool_registry[tool_use_id]["printed"] = True
 
@@ -517,11 +549,17 @@ class RichUI:
         message: UserMessage,
         tool_registry: Dict[str, Dict[str, Any]],
         last_tool_name: Optional[str],
+        spinner: Optional[ThinkingSpinner] = None,
     ) -> None:
         """Handle a user message containing tool results."""
         if not isinstance(message.message.content, list):
             return
 
+        # Factory to create pause context - spinner.paused() if spinner exists, else no-op
+        from contextlib import nullcontext
+
+        pause = lambda: spinner.paused() if spinner else nullcontext()  # noqa: E731
+
         for block in message.message.content:
             if not (hasattr(block, "type") and block.type == "tool_result" and block.text):
                 continue
@@ -535,25 +573,27 @@ class RichUI:
             if entry:
                 tool_name = entry.get("name", tool_name)
                 if not entry.get("printed"):
-                    self.display_message(
-                        tool_name,
-                        "",
-                        is_tool=True,
-                        tool_type="call",
-                        tool_args=entry.get("args", {}),
-                    )
+                    with pause():
+                        self.display_message(
+                            tool_name,
+                            "",
+                            is_tool=True,
+                            tool_type="call",
+                            tool_args=entry.get("args", {}),
+                        )
                     entry["printed"] = True
             elif last_tool_name:
                 tool_name = last_tool_name
 
-            self.display_message(
-                tool_name,
-                block.text,
-                is_tool=True,
-                tool_type="result",
-                tool_data=tool_data,
-                tool_error=is_error,
-            )
+            with pause():
+                self.display_message(
+                    tool_name,
+                    block.text,
+                    is_tool=True,
+                    tool_type="result",
+                    tool_data=tool_data,
+                    tool_error=is_error,
+                )
 
     def _handle_progress_message(
         self,
@@ -567,14 +607,17 @@ class RichUI:
             Updated output token estimate.
         """
         if self.verbose:
-            self.display_message("System", f"Progress: {message.content}", is_tool=True)
+            with spinner.paused():
+                self.display_message("System", f"Progress: {message.content}", is_tool=True)
         elif message.content and isinstance(message.content, str):
             if message.content.startswith("Subagent: "):
-                self.display_message(
-                    "Subagent", message.content[len("Subagent: ") :], is_tool=True
-                )
+                with spinner.paused():
+                    self.display_message(
+                        "Subagent", message.content[len("Subagent: ") :], is_tool=True
+                    )
             elif message.content.startswith("Subagent"):
-                self.display_message("Subagent", message.content, is_tool=True)
+                with spinner.paused():
+                    self.display_message("Subagent", message.content, is_tool=True)
 
         if message.tool_use_id == "stream":
             delta_tokens = estimate_tokens(message.content)
@@ -590,7 +633,7 @@ class RichUI:
         # Initialize or reset query context
         if not self.query_context:
             self.query_context = QueryContext(
-                tools=self.get_default_tools(), safe_mode=self.safe_mode, verbose=self.verbose
+                tools=self.get_default_tools(), yolo_mode=self.yolo_mode, verbose=self.verbose
             )
         else:
             abort_controller = getattr(self.query_context, "abort_controller", None)
@@ -674,7 +717,8 @@ class RichUI:
                     except (RuntimeError, ValueError, OSError) as exc:
                         logger.debug(
                             "[ui] Failed to restart spinner after permission check: %s: %s",
-                            type(exc).__name__, exc,
+                            type(exc).__name__,
+                            exc,
                         )
 
             # Process query stream
@@ -692,12 +736,14 @@ class RichUI:
                     permission_checker,  # type: ignore[arg-type]
                 ):
                     if message.type == "assistant" and isinstance(message, AssistantMessage):
-                        result = self._handle_assistant_message(message, tool_registry)
+                        result = self._handle_assistant_message(message, tool_registry, spinner)
                         if result:
                             last_tool_name = result
 
                     elif message.type == "user" and isinstance(message, UserMessage):
-                        self._handle_tool_result_message(message, tool_registry, last_tool_name)
+                        self._handle_tool_result_message(
+                            message, tool_registry, last_tool_name, spinner
+                        )
 
                     elif message.type == "progress" and isinstance(message, ProgressMessage):
                         output_token_est = self._handle_progress_message(
@@ -713,7 +759,8 @@ class RichUI:
             except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
                 logger.warning(
                     "[ui] Error while processing streamed query response: %s: %s",
-                    type(e).__name__, e,
+                    type(e).__name__,
+                    e,
                     extra={"session_id": self.session_id},
                 )
                 self.display_message("System", f"Error: {str(e)}", is_tool=True)
@@ -723,7 +770,8 @@ class RichUI:
                 except (RuntimeError, ValueError, OSError) as exc:
                     logger.warning(
                         "[ui] Failed to stop spinner: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                         extra={"session_id": self.session_id},
                     )
 
@@ -743,7 +791,8 @@ class RichUI:
         except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as exc:
             logger.warning(
                 "[ui] Error during query processing: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"session_id": self.session_id},
             )
             self.display_message("System", f"Error: {str(exc)}", is_tool=True)
@@ -789,8 +838,9 @@ class RichUI:
         """Public wrapper for running coroutines on the UI event loop."""
         return self._run_async(coro)
 
-    def handle_slash_command(self, user_input: str) -> bool:
-        """Handle slash commands. Returns True if the input was handled."""
+    def handle_slash_command(self, user_input: str) -> bool | str:
+        """Handle slash commands. Returns True if handled as built-in, False if not a command,
+        or a string if it's a custom command that should be sent to the AI."""
 
         if not user_input.startswith("/"):
             return False
@@ -802,12 +852,28 @@ class RichUI:
 
         command_name = parts[0].lower()
         trimmed_arg = " ".join(parts[1:]).strip()
+
+        # First, try built-in commands
         command = get_slash_command(command_name)
-        if command is None:
-            self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]")
-            return True
+        if command is not None:
+            return command.handler(self, trimmed_arg)
+
+        # Then, try custom commands
+        custom_cmd = get_custom_command(command_name, self.project_path)
+        if custom_cmd is not None:
+            # Expand the custom command content
+            expanded_content = expand_command_content(custom_cmd, trimmed_arg, self.project_path)
+
+            # Show a hint that this is from a custom command
+            self.console.print(f"[dim]Running custom command: /{command_name}[/dim]")
+            if custom_cmd.argument_hint and trimmed_arg:
+                self.console.print(f"[dim]Arguments: {trimmed_arg}[/dim]")
+
+            # Return the expanded content to be processed as a query
+            return expanded_content
 
-        return command.handler(self, trimmed_arg)
+        self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]")
+        return True
 
     def get_prompt_session(self) -> PromptSession:
         """Create (or return) the prompt session with command completion."""
@@ -815,35 +881,68 @@ class RichUI:
             return self._prompt_session
 
         class SlashCommandCompleter(Completer):
-            """Autocomplete for slash commands."""
+            """Autocomplete for slash commands including custom commands."""
 
-            def __init__(self, completions: List):
-                self.completions = completions
+            def __init__(self, project_path: Path):
+                self.project_path = project_path
 
             def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
                 query = text[1:]
-                for name, cmd in self.completions:
+                # Get completions including custom commands
+                completions = slash_command_completions(self.project_path)
+                for name, cmd in completions:
                     if name.startswith(query):
+                        # Handle both SlashCommand and CustomCommandDefinition
+                        description = cmd.description
+                        # Add hint for custom commands
+                        if isinstance(cmd, CustomCommandDefinition):
+                            hint = cmd.argument_hint or ""
+                            display = f"{name} {hint}".strip() if hint else name
+                            display_meta = f"[custom] {description}"
+                        else:
+                            display = name
+                            display_meta = description
                         yield Completion(
                             name,
                             start_position=-len(query),
-                            display=name,
-                            display_meta=cmd.description,
+                            display=display,
+                            display_meta=display_meta,
                         )
 
         # Merge both completers
-        slash_completer = SlashCommandCompleter(self._command_completions)
+        slash_completer = SlashCommandCompleter(self.project_path)
         file_completer = FileMentionCompleter(self.project_path, self._ignore_filter)
         combined_completer = merge_completers([slash_completer, file_completer])
 
+        key_bindings = KeyBindings()
+
+        @key_bindings.add("enter")
+        def _(event: Any) -> None:
+            """Accept completion if menu is open; otherwise submit line."""
+            buf = event.current_buffer
+            if buf.complete_state and buf.complete_state.current_completion:
+                buf.apply_completion(buf.complete_state.current_completion)
+                return
+            buf.validate_and_handle()
+
+        @key_bindings.add("tab")
+        def _(event: Any) -> None:
+            """Use Tab to accept the highlighted completion when visible."""
+            buf = event.current_buffer
+            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)
+
         self._prompt_session = PromptSession(
             completer=combined_completer,
             complete_style=CompleteStyle.COLUMN,
             complete_while_typing=True,
             history=InMemoryHistory(),
+            key_bindings=key_bindings,
         )
         return self._prompt_session
 
@@ -857,7 +956,9 @@ class RichUI:
         # Display status
         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")
+        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"
+        )
 
         session = self.get_prompt_session()
         logger.info(
@@ -888,7 +989,11 @@ class RichUI:
                         handled = self.handle_slash_command(user_input)
                         if self._should_exit:
                             break
-                        if handled:
+                        # If handled is a string, it's expanded custom command content
+                        if isinstance(handled, str):
+                            # Process the expanded custom command as a query
+                            user_input = handled
+                        elif handled:
                             console.print()  # spacing
                             continue
 
@@ -904,7 +1009,9 @@ class RichUI:
                     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]")
+                        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},
@@ -923,11 +1030,19 @@ class RichUI:
                 except EOFError:
                     console.print("\n[yellow]Goodbye![/yellow]")
                     break
-                except (OSError, ConnectionError, RuntimeError, ValueError, KeyError, TypeError) as e:
+                except (
+                    OSError,
+                    ConnectionError,
+                    RuntimeError,
+                    ValueError,
+                    KeyError,
+                    TypeError,
+                ) as e:
                     console.print(f"[red]Error: {escape(str(e))}[/]")
                     logger.warning(
                         "[ui] Error in interactive loop: %s: %s",
-                        type(e).__name__, e,
+                        type(e).__name__,
+                        e,
                         extra={"session_id": self.session_id},
                     )
                     if self.verbose:
@@ -961,7 +1076,8 @@ class RichUI:
                     # pragma: no cover - defensive shutdown
                     logger.warning(
                         "[ui] Failed to shut down MCP runtime cleanly: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                         extra={"session_id": self.session_id},
                     )
             finally:
@@ -1014,6 +1130,7 @@ class RichUI:
             )
         except Exception as exc:
             import traceback
+
             self.console.print(f"[red]Error during compaction: {escape(str(exc))}[/red]")
             self.console.print(f"[dim red]{traceback.format_exc()}[/dim red]")
             return
@@ -1042,15 +1159,16 @@ def check_onboarding_rich() -> bool:
     if config.has_completed_onboarding:
         return True
 
-    # Use simple console onboarding
-    from ripperdoc.cli.cli import check_onboarding
+    # Use the wizard onboarding
+    from ripperdoc.cli.ui.wizard import check_onboarding
 
     return check_onboarding()
 
 
 def main_rich(
-    safe_mode: bool = False,
+    yolo_mode: bool = False,
     verbose: bool = False,
+    show_full_thinking: Optional[bool] = None,
     session_id: Optional[str] = None,
     log_file_path: Optional[Path] = None,
 ) -> None:
@@ -1062,8 +1180,9 @@ def main_rich(
 
     # Run the Rich UI
     ui = RichUI(
-        safe_mode=safe_mode,
+        yolo_mode=yolo_mode,
         verbose=verbose,
+        show_full_thinking=show_full_thinking,
         session_id=session_id,
         log_file_path=log_file_path,
     )

ripperdoc/cli/ui/spinner.py

@@ -1,4 +1,6 @@
-from typing import Any, Literal, Optional
+from contextlib import contextmanager
+from typing import Any, Generator, Literal, Optional
+
 from rich.console import Console
 from rich.markup import escape
 from rich.status import Status
@@ -47,3 +49,25 @@ class Spinner:
         self.stop()
         # Do not suppress exceptions
         return False
+
+    @property
+    def is_running(self) -> bool:
+        """Check if spinner is currently running."""
+        return self._status is not None
+
+    @contextmanager
+    def paused(self) -> Generator[None, None, None]:
+        """Context manager to temporarily pause the spinner for clean output.
+
+        Usage:
+            with spinner.paused():
+                console.print("Some output")
+        """
+        was_running = self.is_running
+        if was_running:
+            self.stop()
+        try:
+            yield
+        finally:
+            if was_running:
+                self.start()

ripperdoc/cli/ui/tool_renderers.py

@@ -155,7 +155,10 @@ class BashResultRenderer(ToolResultRenderer):
     """Render Bash tool results."""
 
     def __init__(
-        self, console: Console, verbose: bool = False, parse_fallback: Optional[BashOutputParser] = None
+        self,
+        console: Console,
+        verbose: bool = False,
+        parse_fallback: Optional[BashOutputParser] = None,
     ):
         super().__init__(console, verbose)
         self._parse_fallback = parse_fallback
@@ -254,7 +257,10 @@ class ToolResultRendererRegistry:
     """Registry that selects the appropriate renderer for a tool result."""
 
     def __init__(
-        self, console: Console, verbose: bool = False, parse_bash_fallback: Optional[BashOutputParser] = None
+        self,
+        console: Console,
+        verbose: bool = False,
+        parse_bash_fallback: Optional[BashOutputParser] = None,
     ):
         self.console = console
         self.verbose = verbose