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

ripperdoc/cli/ui/spinner.py

@@ -1,43 +1,57 @@
-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
+from rich.live import Live
+from rich.text import Text
+from rich.spinner import Spinner as RichSpinner
 
 
 class Spinner:
-    """Lightweight spinner wrapper for Rich status."""
+    """Lightweight spinner wrapper that plays nicely with other console output."""
 
     def __init__(self, console: Console, text: str = "Thinking...", spinner: str = "dots"):
         self.console = console
         self.text = text
         self.spinner = spinner
-        self._status: Optional[Status] = None
+        self._style = "cyan"
+        self._live: Optional[Live] = None
+        # Blue spinner for clearer visual separation in the terminal (icon + text)
+        self._renderable: RichSpinner = RichSpinner(
+            spinner, text=Text(self.text, style=self._style), style=self._style
+        )
 
     def start(self) -> None:
         """Start the spinner if not already running."""
-
-        if self._status is not None:
+        if self._live is not None:
             return
-        self._status = self.console.status(
-            f"[cyan]{escape(self.text)}[/cyan]", spinner=self.spinner
+        self._renderable.text = Text(self.text, style=self._style)
+        self._live = Live(
+            self._renderable,
+            console=self.console,
+            transient=True,  # Remove spinner line when stopped to avoid layout glitches
+            refresh_per_second=12,
         )
-        self._status.__enter__()
+        self._live.start()
 
     def update(self, text: Optional[str] = None) -> None:
         """Update spinner text."""
-
-        if self._status is None:
+        if self._live is None:
             return
-        new_text = text if text is not None else self.text
-        self._status.update(f"[cyan]{escape(new_text)}[/cyan]")
+        if text is not None:
+            self.text = text
+        self._renderable.text = Text(self.text, style=self._style)
+        # Live.refresh() redraws the current renderable
+        self._live.refresh()
 
     def stop(self) -> None:
         """Stop the spinner if running."""
-
-        if self._status is None:
+        if self._live is None:
             return
-        self._status.__exit__(None, None, None)
-        self._status = None
+        try:
+            self._live.stop()
+        finally:
+            self._live = None
 
     def __enter__(self) -> "Spinner":
         self.start()
@@ -47,3 +61,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._live 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/thinking_spinner.py

@@ -22,7 +22,6 @@ THINKING_WORDS: list[str] = [
     "Cerebrating",
     "Channelling",
     "Churning",
-    "Clauding",
     "Coalescing",
     "Cogitating",
     "Computing",
@@ -114,7 +113,7 @@ class ThinkingSpinner(Spinner):
 
     def _format_text(self, suffix: Optional[str] = None) -> str:
         elapsed = int(time.monotonic() - self.start_time)
-        base = f"✽ {self.thinking_word}… (esc to interrupt · {elapsed}s"
+        base = f" {self.thinking_word}… (esc to interrupt · {elapsed}s"
         if self.out_tokens > 0:
             base += f" · ↓ {self.out_tokens} tokens"
         else:

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,213 @@
+"""
+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) or 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)

ripperdoc/core/agents.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 import yaml
 
+from ripperdoc.utils.coerce import parse_boolish
 from ripperdoc.utils.log import get_logger
 from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
 from ripperdoc.tools.bash_output_tool import BashOutputTool
@@ -91,6 +92,7 @@ class AgentDefinition:
     model: Optional[str] = None
     color: Optional[str] = None
     filename: Optional[str] = None
+    fork_context: bool = False
 
 
 @dataclass
@@ -234,7 +236,7 @@ def _built_in_agents() -> List[AgentDefinition]:
             system_prompt=EXPLORE_AGENT_PROMPT,
             location=AgentLocation.BUILT_IN,
             color="green",
-            model="task",
+            model="main",
         ),
         AgentDefinition(
             agent_type="plan",
@@ -278,10 +280,15 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
                 body = "\n".join(lines[idx + 1 :])
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
-                except (yaml.YAMLError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+                except (
+                    yaml.YAMLError,
+                    ValueError,
+                    TypeError,
+                ) as exc:  # pragma: no cover - defensive
                     logger.warning(
                         "Invalid frontmatter in agent file: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                         extra={"error": str(exc)},
                     )
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
@@ -312,14 +319,16 @@ def _parse_agent_file(
     except (OSError, IOError, UnicodeDecodeError) as exc:
         logger.warning(
             "Failed to read agent file: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"error": str(exc), "path": str(path)},
         )
         return None, f"Failed to read agent file {path}: {exc}"
 
     frontmatter, body = _split_frontmatter(text)
-    if "__error__" in frontmatter:
-        return None, str(frontmatter["__error__"])
+    error = frontmatter.get("__error__")
+    if error is not None:
+        return None, str(error)
 
     agent_name = frontmatter.get("name")
     description = frontmatter.get("description")
@@ -333,6 +342,7 @@ def _parse_agent_file(
     color_value = frontmatter.get("color")
     model = model_value if isinstance(model_value, str) else None
     color = color_value if isinstance(color_value, str) else None
+    fork_context = parse_boolish(frontmatter.get("fork_context") or frontmatter.get("fork-context"))
 
     agent = AgentDefinition(
         agent_type=agent_name.strip(),
@@ -343,6 +353,7 @@ def _parse_agent_file(
         model=model,
         color=color,
         filename=path.stem,
+        fork_context=fork_context,
     )
     return agent, None
 
@@ -398,6 +409,8 @@ def summarize_agent(agent: AgentDefinition) -> str:
     tool_label = "all tools" if "*" in agent.tools else ", ".join(agent.tools)
     location = getattr(agent.location, "value", agent.location)
     details = [f"tools: {tool_label}"]
+    if agent.fork_context:
+        details.append("context: forked")
     if agent.model:
         details.append(f"model: {agent.model}")
     return f"- {agent.agent_type} ({location}): {agent.when_to_use} [{'; '.join(details)}]"

ripperdoc/core/config.py

@@ -7,8 +7,8 @@ including API keys, model settings, and user preferences.
 import json
 import os
 from pathlib import Path
-from typing import Dict, Optional, Literal
-from pydantic import BaseModel, Field
+from typing import Any, Dict, Optional, Literal
+from pydantic import BaseModel, Field, model_validator
 from enum import Enum
 
 from ripperdoc.utils.log import get_logger
@@ -111,7 +111,7 @@ class ModelProfile(BaseModel):
     # interactions into plain text to support providers that reject tool roles.
     openai_tool_mode: Literal["native", "text"] = "native"
     # Optional override for thinking protocol handling (e.g., "deepseek", "openrouter",
-    # "qwen", "gemini_openai", "openai_reasoning"). When unset, provider heuristics are used.
+    # "qwen", "gemini_openai", "openai"). When unset, provider heuristics are used.
     thinking_mode: Optional[str] = None
     # Pricing (USD per 1M tokens). Leave as 0 to skip cost calculation.
     input_cost_per_million_tokens: float = 0.0
@@ -122,15 +122,13 @@ class ModelPointers(BaseModel):
     """Pointers to different model profiles for different purposes."""
 
     main: str = "default"
-    task: str = "default"
-    reasoning: str = "default"
     quick: str = "default"
 
 
 class GlobalConfig(BaseModel):
     """Global configuration stored in ~/.ripperdoc.json"""
 
-    model_config = {"protected_namespaces": ()}
+    model_config = {"protected_namespaces": (), "populate_by_name": True}
 
     # Model configuration
     model_profiles: Dict[str, ModelProfile] = Field(default_factory=dict)
@@ -139,7 +137,8 @@ class GlobalConfig(BaseModel):
     # User preferences
     theme: str = "dark"
     verbose: bool = False
-    safe_mode: bool = True
+    yolo_mode: bool = Field(default=False)
+    show_full_thinking: bool = Field(default=False)
     auto_compact_enabled: bool = True
     context_token_limit: Optional[int] = None
 
@@ -154,6 +153,18 @@ class GlobalConfig(BaseModel):
     # Statistics
     num_startups: int = 0
 
+    @model_validator(mode="before")
+    @classmethod
+    def _migrate_safe_mode(cls, data: Any) -> Any:
+        """Translate legacy safe_mode to the new yolo_mode flag."""
+        if isinstance(data, dict) and "safe_mode" in data and "yolo_mode" not in data:
+            data = dict(data)
+            try:
+                data["yolo_mode"] = not bool(data.pop("safe_mode"))
+            except Exception:
+                data["yolo_mode"] = False
+        return data
+
 
 class ProjectConfig(BaseModel):
     """Project-specific configuration stored in .ripperdoc/config.json"""
@@ -167,7 +178,7 @@ class ProjectConfig(BaseModel):
     # Path ignore patterns (gitignore-style)
     ignore_patterns: list[str] = Field(
         default_factory=list,
-        description="Gitignore-style patterns for paths to ignore in file operations"
+        description="Gitignore-style patterns for paths to ignore in file operations",
     )
 
     # Context
@@ -179,7 +190,6 @@ class ProjectConfig(BaseModel):
 
     # Project settings
     dont_crawl_directory: bool = False
-    enable_architect_tool: bool = False
 
     # Trust
     has_trust_dialog_accepted: bool = False
@@ -222,10 +232,18 @@ class ConfigManager:
                             "profile_count": len(self._global_config.model_profiles),
                         },
                     )
-                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                except (
+                    json.JSONDecodeError,
+                    OSError,
+                    IOError,
+                    UnicodeDecodeError,
+                    ValueError,
+                    TypeError,
+                ) as e:
                     logger.warning(
                         "Error loading global config: %s: %s",
-                        type(e).__name__, e,
+                        type(e).__name__,
+                        e,
                         extra={"error": str(e)},
                     )
                     self._global_config = GlobalConfig()
@@ -276,10 +294,18 @@ class ConfigManager:
                             "allowed_tools": len(self._project_config.allowed_tools),
                         },
                     )
-                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                except (
+                    json.JSONDecodeError,
+                    OSError,
+                    IOError,
+                    UnicodeDecodeError,
+                    ValueError,
+                    TypeError,
+                ) as e:
                     logger.warning(
                         "Error loading project config: %s: %s",
-                        type(e).__name__, e,
+                        type(e).__name__,
+                        e,
                         extra={"error": str(e), "path": str(config_path)},
                     )
                     self._project_config = ProjectConfig()
@@ -344,10 +370,18 @@ class ConfigManager:
                             "project_path": str(self.current_project_path),
                         },
                     )
-                except (json.JSONDecodeError, OSError, IOError, UnicodeDecodeError, ValueError, TypeError) as e:
+                except (
+                    json.JSONDecodeError,
+                    OSError,
+                    IOError,
+                    UnicodeDecodeError,
+                    ValueError,
+                    TypeError,
+                ) as e:
                     logger.warning(
                         "Error loading project-local config: %s: %s",
-                        type(e).__name__, e,
+                        type(e).__name__,
+                        e,
                         extra={"error": str(e), "path": str(config_path)},
                     )
                     self._project_local_config = ProjectLocalConfig()
@@ -480,7 +514,7 @@ class ConfigManager:
         return config
 
     def set_model_pointer(self, pointer: str, profile_name: str) -> GlobalConfig:
-        """Point a logical model slot (e.g., main/task) to a profile name."""
+        """Point a logical model slot (e.g., main/quick) to a profile name."""
         if pointer not in ModelPointers.model_fields:
             raise ValueError(f"Unknown model pointer '{pointer}'.")
 
@@ -538,7 +572,7 @@ def delete_model_profile(name: str) -> GlobalConfig:
 
 
 def set_model_pointer(pointer: str, profile_name: str) -> GlobalConfig:
-    """Update a model pointer (e.g., main/task) to target a profile."""
+    """Update a model pointer (e.g., main/quick) to target a profile."""
     return config_manager.set_model_pointer(pointer, profile_name)
 
 

ripperdoc/core/custom_commands.py

@@ -14,7 +14,6 @@ Features:
 
 from __future__ import annotations
 
-import asyncio
 import re
 import subprocess
 from dataclasses import dataclass, field
@@ -24,7 +23,6 @@ from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
 
 import yaml
 
-from ripperdoc.utils.coerce import parse_boolish, parse_optional_int
 from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
@@ -96,13 +94,14 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
         for idx in range(1, len(lines)):
             if lines[idx].strip() == "---":
                 frontmatter_text = "\n".join(lines[1:idx])
-                body = "\n".join(lines[idx + 1:])
+                body = "\n".join(lines[idx + 1 :])
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
                 except (yaml.YAMLError, ValueError, TypeError) as exc:
                     logger.warning(
                         "[custom_commands] Invalid frontmatter: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                     )
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
                 return frontmatter, body
@@ -163,7 +162,8 @@ def _load_command_file(
     except (OSError, IOError, UnicodeDecodeError) as exc:
         logger.warning(
             "[custom_commands] Failed to read command file: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(path)},
         )
         return None, CustomCommandLoadError(path=path, reason=f"Failed to read file: {exc}")
@@ -239,7 +239,8 @@ def _load_commands_from_dir(
     except OSError as exc:
         logger.warning(
             "[custom_commands] Failed to scan command directory: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(commands_dir)},
         )