ripperdoc 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

ripperdoc/cli/ui/wizard.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Tuple
 import click
 from rich.console import Console
 
+from ripperdoc.cli.ui.choice import ChoiceOption, onboarding_style, prompt_choice
 from ripperdoc.cli.ui.provider_options import (
     KNOWN_PROVIDERS,
     ProviderOption,
@@ -66,38 +67,64 @@ def check_onboarding() -> bool:
 
 def run_onboarding_wizard(config: GlobalConfig) -> bool:
     """Run interactive onboarding wizard."""
-    provider_keys = KNOWN_PROVIDERS.keys() + ["custom"]
+    provider_keys = list(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,
+    # Build provider choice options with rich styling
+    provider_options = [
+        ChoiceOption(
+            key,
+            key,  # Plain text, not colored
+            is_default=(key == 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]"
-            )
+        for key in provider_keys
+    ]
+
+    # Prompt for provider choice using unified choice component
+    provider_choice = prompt_choice(
+        message="Choose your model provider",
+        options=provider_options,
+        title="Available providers",
+        allow_esc=True,
+        esc_value=default_choice_key,
+        style=onboarding_style(),
+    )
+
+    # Validate the choice (in case user typed an invalid value)
+    validated_choice = resolve_provider_choice(provider_choice, provider_keys)
+    if validated_choice is None:
+        console.print(
+            f"[red]Invalid choice. Please enter a provider name or number (1-{len(provider_keys)}).[/red]"
+        )
+        return run_onboarding_wizard(config)
+    provider_choice = validated_choice
 
     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,
+        # Build protocol choice options
+        protocol_options = [
+            ChoiceOption(
+                p.value,
+                p.value,  # Plain text
+                is_default=(p == ProviderType.OPENAI_COMPATIBLE),
+            )
+            for p in ProviderType
+        ]
+
+        protocol_input = prompt_choice(
+            message="Choose the protocol family (for API compatibility)",
+            options=protocol_options,
+            title="Custom Provider - Protocol Selection",
+            allow_esc=True,
+            esc_value=ProviderType.OPENAI_COMPATIBLE.value,
+            style=onboarding_style(),
         )
         protocol = ProviderType(protocol_input)
-        api_base_override = click.prompt("API Base URL")
+
+        # Get API base URL - use click.prompt for free-form text input
+        console.print("\n[dim]Now we need your API Base URL.[/dim]")
+        api_base_override = click.prompt("API Base URL").strip()
+
         provider_option = ProviderOption(
             key="custom",
             protocol=protocol,
@@ -160,29 +187,55 @@ def get_model_name_with_suggestions(
     default_model = provider.default_model or default_model_for_protocol(provider.protocol)
     suggestions = list(provider.model_suggestions)
 
-    # Show suggestions if available
+    # Prompt for model name using unified choice component if suggestions exist
     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
+        # Create choice options for models
+        model_options = [
+            ChoiceOption(model, model)  # Plain text
+            for model in suggestions[:5]  # Show top 5
+        ]
+        # Add custom option
+        model_options.append(ChoiceOption("custom", "<dim>Custom model...</dim>"))
+
+        model = prompt_choice(
+            message="Select a model or choose 'Custom' to enter manually",
+            options=model_options,
+            title="Available models for this provider",
+            description=f"Default: {default_model}",
+            allow_esc=True,
+            esc_value=default_model,
+            style=onboarding_style(),
+        )
+
+        # If user chose custom, prompt for manual input using click.prompt
+        if model == "custom":
+            console.print("\n[dim]Enter your custom model name:[/dim]")
+            model = click.prompt("Model name", default=default_model).strip()
     else:
-        model = click.prompt("Model name", default=default_model)
+        # No suggestions, use default
+        model = default_model
+
+    # Prompt for API base if still not set (for OpenAI-compatible providers)
+    if provider.protocol == ProviderType.OPENAI_COMPATIBLE and api_base is None:
+        api_base_input = prompt_choice(
+            message="Enter API base URL (or press Enter to skip)",
+            options=[ChoiceOption("", "<dim>Skip</dim>")],
+            title="API base URL (optional)",
+            allow_esc=True,
+            esc_value="",
+            style=onboarding_style(),
+        )
+        api_base = api_base_input or None
+    elif provider.protocol == ProviderType.GEMINI and api_base is None:
+        api_base_input = prompt_choice(
+            message="Enter API base URL (or press Enter to skip)",
+            options=[ChoiceOption("", "<dim>Skip</dim>")],
+            title="API base URL (optional)",
+            allow_esc=True,
+            esc_value="",
+            style=onboarding_style(),
+        )
+        api_base = api_base_input or None
 
     return model, api_base
 

ripperdoc/core/config.py

@@ -230,6 +230,7 @@ class GlobalConfig(BaseModel):
     # User-level permission rules (applied globally)
     user_allow_rules: list[str] = Field(default_factory=list)
     user_deny_rules: list[str] = Field(default_factory=list)
+    user_ask_rules: list[str] = Field(default_factory=list)
 
     # Onboarding
     has_completed_onboarding: bool = False
@@ -258,6 +259,7 @@ class ProjectConfig(BaseModel):
     allowed_tools: list[str] = Field(default_factory=list)
     bash_allow_rules: list[str] = Field(default_factory=list)
     bash_deny_rules: list[str] = Field(default_factory=list)
+    bash_ask_rules: list[str] = Field(default_factory=list)
     working_directories: list[str] = Field(default_factory=list)
 
     # Path ignore patterns (gitignore-style)
@@ -291,6 +293,7 @@ class ProjectLocalConfig(BaseModel):
     # Local permission rules (project-specific but not shared)
     local_allow_rules: list[str] = Field(default_factory=list)
     local_deny_rules: list[str] = Field(default_factory=list)
+    local_ask_rules: list[str] = Field(default_factory=list)
 
 
 class ConfigManager:

ripperdoc/core/permissions.py

@@ -9,12 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Optional, Set, TYPE_CHECKING, TYPE_CHECKING as TYPE_CHECKING
 
-from prompt_toolkit.filters import is_done
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.shortcuts import choice
-from prompt_toolkit.styles import Style
-
+from ripperdoc.cli.ui.choice import prompt_choice
 from ripperdoc.core.config import config_manager
 from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.tool import Tool
@@ -101,25 +96,6 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
     return tool.name
 
 
-def _permission_style() -> Style:
-    """Create the style for permission choice prompts."""
-    return Style.from_dict(
-        {
-            "frame.border": "#d4a017",  # Golden/amber border
-            "selected-option": "bold",
-            "option": "#5fd7ff",  # Cyan for unselected options
-            "title": "#ffaf00",  # Orange/amber for tool name
-            "description": "#ffffff",  # White for descriptions
-            "question": "#ffd700",  # Gold for the question
-            "label": "#87afff",  # Light blue for field labels (Command:, Sandbox:, etc.)
-            "warning": "#ff5555",  # Red for warnings
-            "yes-option": "#ffffff",  # Neutral for Yes options
-            "no-option": "#ffffff",  # Neutral for No option
-            "value": "#f8f8f2",  # Off-white for values
-        }
-    )
-
-
 def _rule_strings(rule_suggestions: Optional[Any]) -> list[str]:
     """Normalize rule suggestions to simple strings."""
     if not rule_suggestions:
@@ -137,8 +113,8 @@ def make_permission_checker(
     project_path: Path,
     yolo_mode: bool,
     prompt_fn: Optional[Callable[[str], str]] = None,
-    console: Optional["Console"] = None,
-    prompt_session: Optional["PromptSession"] = None,
+    console: Optional["Console"] = None,  # noqa: ARG001 (kept for backward compatibility)
+    prompt_session: Optional["PromptSession"] = None,  # noqa: ARG001 (kept for backward compatibility)
 ) -> Callable[[Tool[Any, Any], Any], Awaitable[PermissionResult]]:
     """Create a permission checking function for the current project.
 
@@ -146,25 +122,25 @@ def make_permission_checker(
         project_path: Path to the project directory
         yolo_mode: If True, all tool calls are allowed without prompting
         prompt_fn: Optional function to use for prompting (defaults to input())
-        console: Optional Rich console for rich permission dialogs
-        prompt_session: Optional PromptSession for better interrupt handling
+        console: (Deprecated) No longer used, kept for backward compatibility
+        prompt_session: (Deprecated) No longer used, kept for backward compatibility
 
     In yolo mode, all tool calls are allowed without prompting.
     """
 
+    _ = console, prompt_session  # Mark as intentionally unused
     project_path = project_path.resolve()
     config_manager.get_project_config(project_path)
 
     session_allowed_tools: Set[str] = set()
     session_tool_rules: dict[str, Set[str]] = defaultdict(set)
 
-    async def _prompt_user(prompt: str, options: list[tuple[str, str]], is_html: bool = False) -> str:
-        """Prompt the user with proper interrupt handling using choice().
+    async def _prompt_user(prompt: str, options: list[tuple[str, str]]) -> str:
+        """Prompt the user with proper interrupt handling using unified choice component.
 
         Args:
-            prompt: The prompt text to display.
+            prompt: The prompt text to display (supports HTML formatting).
             options: List of (value, label) tuples for choices.
-            is_html: If True, prompt is already formatted HTML and should not be escaped.
         """
         loop = asyncio.get_running_loop()
 
@@ -179,42 +155,13 @@ def make_permission_checker(
                     input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
                     return responder(input_prompt)
 
-                # Convert options to choice() format (value, label)
-                # Labels can be HTML-formatted strings
-                choice_options = [(value, HTML(label) if "<" in label else label) for value, label in options]
-
-                # Build formatted message with prompt text
-                # Add visual separation with lines
-                if is_html:
-                    # Prompt is already HTML formatted
-                    formatted_prompt = HTML(f"\n{prompt}\n")
-                else:
-                    # Escape HTML special characters in plain text prompt
-                    formatted_prompt = HTML(f"\n{html.escape(prompt)}\n")
-
-                esc_bindings = KeyBindings()
-
-                @esc_bindings.add("escape", eager=True)
-                def _esc_to_deny(event: Any) -> None:
-                    event.app.exit(result="n", style="class:aborting")
-
-                result = choice(
-                    message=formatted_prompt,
-                    options=choice_options,
-                    style=_permission_style(),
-                    show_frame=~is_done,  # Frame disappears after selection
-                    key_bindings=esc_bindings,
+                # Use the unified choice component
+                return prompt_choice(
+                    message=prompt,
+                    options=options,
+                    allow_esc=True,
+                    esc_value="n",  # ESC means no
                 )
-
-                # Clear the entire prompt after selection
-                # ANSI codes: ESC[F = move cursor to beginning of previous line
-                #              ESC[2K = clear entire line
-                # We need to clear: blank + prompt + blank + options (each option takes 1 line)
-                # plus frame borders (top and bottom) = approximately 6-8 lines
-                for _ in range(12):  # Clear enough lines to cover the prompt
-                    print("\033[F\033[2K", end="", flush=True)
-
-                return result
             except KeyboardInterrupt:
                 logger.debug("[permissions] KeyboardInterrupt in choice")
                 return "n"
@@ -270,6 +217,13 @@ def make_permission_checker(
                 | set(local_config.local_deny_rules or [])
             )
         }
+        ask_rules = {
+            "Bash": (
+                set(config.bash_ask_rules or [])
+                | set(global_config.user_ask_rules or [])
+                | set(local_config.local_ask_rules or [])
+            )
+        }
         allowed_working_dirs = {
             str(project_path.resolve()),
             *[str(Path(p).resolve()) for p in config.working_directories or []],
@@ -287,6 +241,7 @@ def make_permission_checker(
                     {
                         "allowed_rules": allow_rules.get(tool.name, set()),
                         "denied_rules": deny_rules.get(tool.name, set()),
+                        "ask_rules": ask_rules.get(tool.name, set()),
                         "allowed_working_directories": allowed_working_dirs,
                     },
                 )
@@ -321,7 +276,7 @@ def make_permission_checker(
 
         # If tool doesn't normally require permission (e.g., read-only Bash),
         # enforce deny rules but otherwise skip prompting.
-        if not needs_permission:
+        if not needs_permission and decision.behavior != "ask":
             if decision.behavior == "deny":
                 return PermissionResult(
                     result=False,
@@ -410,7 +365,7 @@ def make_permission_checker(
             ("n", "<no-option>No</no-option>"),
         ]
 
-        answer = (await _prompt_user(prompt, options=options, is_html=True)).strip().lower()
+        answer = (await _prompt_user(prompt, options=options)).strip().lower()
         logger.debug(
             "[permissions] User answer for permission prompt",
             extra={"answer": answer, "tool": getattr(tool, "name", None)},

ripperdoc/core/providers/anthropic.py

@@ -689,6 +689,17 @@ class AnthropicClient(ProviderClient):
             if usage:
                 # Update with final usage - output_tokens comes here
                 usage_tokens["output_tokens"] = getattr(usage, "output_tokens", 0)
+                # Some APIs (like zhipu) may also include input_tokens here
+                input_tokens = getattr(usage, "input_tokens", None)
+                if input_tokens is not None:
+                    usage_tokens["input_tokens"] = input_tokens
+                # Also check for cache tokens
+                cache_read = getattr(usage, "cache_read_input_tokens", None)
+                if cache_read is not None:
+                    usage_tokens["cache_read_input_tokens"] = cache_read
+                cache_creation = getattr(usage, "cache_creation_input_tokens", None)
+                if cache_creation is not None:
+                    usage_tokens["cache_creation_input_tokens"] = cache_creation
 
         elif event_type == "message_stop":
             # Message complete

ripperdoc/protocol/stdio.py

@@ -23,7 +23,7 @@ from typing import Any, AsyncGenerator, Callable, TypeVar
 import click
 
 from ripperdoc.core.config import get_project_config, get_effective_model_profile
-from ripperdoc.core.default_tools import get_default_tools
+from ripperdoc.core.default_tools import filter_tools_by_names, get_default_tools
 from ripperdoc.core.query import query, QueryContext
 from ripperdoc.core.query_utils import resolve_model_profile
 from ripperdoc.core.system_prompt import build_system_prompt
@@ -431,6 +431,8 @@ class StdioProtocolHandler:
             dynamic_tools = await load_dynamic_mcp_tools_async(self._project_path)
             if dynamic_tools:
                 tools = merge_tools_with_dynamic(tools, dynamic_tools)
+                if allowed_tools is not None:
+                    tools = filter_tools_by_names(tools, allowed_tools)
                 self._query_context.tools = tools
 
             mcp_instructions = format_mcp_instructions(servers)

ripperdoc/tools/bash_tool.py

@@ -316,6 +316,7 @@ build projects, run tests, and interact with the file system."""
 
         allow_rules = permission_context.get("allowed_rules") or set()
         deny_rules = permission_context.get("denied_rules") or set()
+        ask_rules = permission_context.get("ask_rules") or set()
         allowed_dirs = permission_context.get("allowed_working_directories") or {safe_get_cwd()}
 
         # Check for sensitive directory access with read-only commands (cd, find).
@@ -340,6 +341,7 @@ build projects, run tests, and interact with the file system."""
             input_data,
             allow_rules,
             deny_rules,
+            ask_rules,
             allowed_dirs,
             # danger_detector uses default: validate_shell_command(cmd).behavior != "passthrough"
             # read_only_detector uses default: _is_command_read_only