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

ripperdoc/cli/ui/rich_ui.py

@@ -96,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
@@ -128,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,
@@ -146,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)
 
@@ -157,7 +168,8 @@ 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},
             )
 
@@ -215,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},
             )
 
@@ -229,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},
             )
 
@@ -476,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", {})
@@ -512,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
 
@@ -527,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
@@ -545,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,
@@ -577,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)
@@ -600,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)
@@ -684,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
@@ -702,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(
@@ -723,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)
@@ -733,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},
                     )
 
@@ -753,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)
@@ -823,14 +862,10 @@ class RichUI:
         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
-            )
+            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]"
-            )
+            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]")
 
@@ -921,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(
@@ -972,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},
@@ -991,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:
@@ -1029,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:
@@ -1082,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
@@ -1110,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:
@@ -1130,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

ripperdoc/cli/ui/wizard.py

@@ -0,0 +1,215 @@
+"""
+Interactive onboarding wizard for Ripperdoc.
+"""
+
+from typing import List, Optional, Tuple
+
+import click
+from rich.console import Console
+
+from ripperdoc.cli.ui.provider_options import (
+    KNOWN_PROVIDERS,
+    ProviderOption,
+    default_model_for_protocol,
+)
+from ripperdoc.core.config import (
+    GlobalConfig,
+    ModelProfile,
+    ProviderType,
+    get_global_config,
+    save_global_config,
+)
+from ripperdoc.utils.prompt import prompt_secret
+
+
+console = Console()
+
+
+def resolve_provider_choice(raw_choice: str, provider_keys: List[str]) -> Optional[str]:
+    """Normalize user input into a provider key."""
+    normalized = raw_choice.strip().lower()
+    if normalized in provider_keys:
+        return normalized
+    try:
+        idx = int(normalized)
+        if 1 <= idx <= len(provider_keys):
+            return provider_keys[idx - 1]
+    except ValueError:
+        return None
+    return None
+
+
+def check_onboarding() -> bool:
+    """Check if onboarding is complete and run if needed."""
+    config = get_global_config()
+
+    if config.has_completed_onboarding:
+        return True
+
+    console.print("[bold cyan]Welcome to Ripperdoc![/bold cyan]\n")
+    console.print("Let's set up your AI model configuration.\n")
+
+    return run_onboarding_wizard(config)
+
+
+def run_onboarding_wizard(config: GlobalConfig) -> bool:
+    """Run interactive onboarding wizard."""
+    provider_keys = KNOWN_PROVIDERS.keys() + ["custom"]
+    default_choice_key = KNOWN_PROVIDERS.default_choice.key
+
+    # Display provider options vertically
+    console.print("[bold]Available providers:[/bold]")
+    for i, provider_key in enumerate(provider_keys, 1):
+        marker = "[cyan]→[/cyan]" if provider_key == default_choice_key else " "
+        console.print(f"  {marker} {i}. {provider_key}")
+    console.print("")
+
+    # Prompt for provider choice with validation
+    provider_choice: Optional[str] = None
+    while provider_choice is None:
+        raw_choice = click.prompt(
+            "Choose your model provider",
+            default=default_choice_key,
+        )
+        provider_choice = resolve_provider_choice(raw_choice, provider_keys)
+        if provider_choice is None:
+            console.print(
+                f"[red]Invalid choice. Please enter a provider name or number (1-{len(provider_keys)}).[/red]"
+            )
+
+    api_base_override: Optional[str] = None
+    if provider_choice == "custom":
+        protocol_input = click.prompt(
+            "Protocol family (for API compatibility)",
+            type=click.Choice([p.value for p in ProviderType]),
+            default=ProviderType.OPENAI_COMPATIBLE.value,
+        )
+        protocol = ProviderType(protocol_input)
+        api_base_override = click.prompt("API Base URL")
+        provider_option = ProviderOption(
+            key="custom",
+            protocol=protocol,
+            default_model=default_model_for_protocol(protocol),
+            model_suggestions=(),
+        )
+    else:
+        provider_option = KNOWN_PROVIDERS.get(provider_choice)
+        if provider_option is None:
+            provider_option = ProviderOption(
+                key=provider_choice,
+                protocol=ProviderType.OPENAI_COMPATIBLE,
+                default_model=default_model_for_protocol(ProviderType.OPENAI_COMPATIBLE),
+                model_suggestions=(),
+            )
+
+    api_key = ""
+    while not api_key:
+        api_key = prompt_secret("Enter your API key").strip()
+        if not api_key:
+            console.print("[red]API key is required.[/red]")
+
+    # Get model name with provider-specific suggestions
+    model, api_base = get_model_name_with_suggestions(provider_option, api_base_override)
+
+    # Get context window
+    context_window = get_context_window()
+
+    # Create model profile
+    config.model_profiles["default"] = ModelProfile(
+        provider=provider_option.protocol,
+        model=model,
+        api_key=api_key,
+        api_base=api_base,
+        context_window=context_window,
+    )
+
+    config.has_completed_onboarding = True
+    config.last_onboarding_version = get_version()
+
+    save_global_config(config)
+
+    console.print("\n[green]✓ Configuration saved![/green]\n")
+    return True
+
+
+def get_model_name_with_suggestions(
+    provider: ProviderOption,
+    api_base_override: Optional[str],
+) -> Tuple[str, Optional[str]]:
+    """Get model name with provider-specific suggestions and default API base.
+    
+    Returns:
+        Tuple of (model_name, api_base)
+    """
+    # Set default API base based on provider choice
+    api_base = api_base_override
+    if api_base is None and provider.default_api_base:
+        api_base = provider.default_api_base
+        console.print(f"[dim]Using default API base: {api_base}[/dim]")
+
+    default_model = provider.default_model or default_model_for_protocol(provider.protocol)
+    suggestions = list(provider.model_suggestions)
+
+    # Show suggestions if available
+    if suggestions:
+        console.print("\n[dim]Available models for this provider:[/dim]")
+        for i, model_name in enumerate(suggestions[:5]):  # Show top 5
+            console.print(f"  [dim]{i+1}. {model_name}[/dim]")
+        console.print("")
+
+    # Prompt for model name
+    if provider.protocol == ProviderType.ANTHROPIC:
+        model = click.prompt("Model name", default=default_model)
+    elif provider.protocol == ProviderType.OPENAI_COMPATIBLE:
+        model = click.prompt("Model name", default=default_model)
+        # Prompt for API base if still not set
+        if api_base is None:
+            api_base_input = click.prompt(
+                "API base URL (optional)", default="", show_default=False
+            )
+            api_base = api_base_input or None
+    elif provider.protocol == ProviderType.GEMINI:
+        model = click.prompt("Model name", default=default_model)
+        if api_base is None:
+            api_base_input = click.prompt(
+                "API base URL (optional)", default="", show_default=False
+            )
+            api_base = api_base_input or None
+    else:
+        model = click.prompt("Model name", default=default_model)
+
+    return model, api_base
+
+
+def get_context_window() -> Optional[int]:
+    """Get context window size from user."""
+    context_window_input = click.prompt(
+        "Context window in tokens (optional, press Enter to skip)",
+        default="",
+        show_default=False,
+    )
+    context_window = None
+    if context_window_input.strip():
+        try:
+            context_window = int(context_window_input.strip())
+        except ValueError:
+            console.print(
+                "[yellow]Invalid context window, using auto-detected defaults.[/yellow]"
+            )
+    return context_window
+
+
+def get_version() -> str:
+    """Get current version of Ripperdoc."""
+    try:
+        from ripperdoc import __version__
+        return __version__
+    except ImportError:
+        return "unknown"
+
+
+if __name__ == "__main__":
+    # For testing
+    config = get_global_config()
+    config.has_completed_onboarding = False
+    run_onboarding_wizard(config)