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

ripperdoc/core/permissions.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import asyncio
+import html
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Optional, Set, TYPE_CHECKING, TYPE_CHECKING as TYPE_CHECKING
 
+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
@@ -36,35 +38,37 @@ def _format_input_preview(parsed_input: Any, tool_name: Optional[str] = None) ->
 
     For Bash commands, shows full details for security review.
     For other tools, shows a concise preview.
+    Returns HTML-formatted text with color tags.
     """
     # For Bash tool, show full command details for security review
     if tool_name == "Bash" and hasattr(parsed_input, "command"):
-        lines = [f"Command: {getattr(parsed_input, 'command')}"]
+        command = html.escape(getattr(parsed_input, "command"))
+        lines = [f"<label>Command:</label> <value>{command}</value>"]
 
         # Add other relevant parameters
         if hasattr(parsed_input, "timeout") and parsed_input.timeout:
-            lines.append(f"Timeout: {parsed_input.timeout}ms")
+            lines.append(f"<label>Timeout:</label> <value>{parsed_input.timeout}ms</value>")
         if hasattr(parsed_input, "sandbox"):
-            lines.append(f"Sandbox: {parsed_input.sandbox}")
+            lines.append(f"<label>Sandbox:</label> <value>{parsed_input.sandbox}</value>")
         if hasattr(parsed_input, "run_in_background"):
-            lines.append(f"Background: {parsed_input.run_in_background}")
+            lines.append(f"<label>Background:</label> <value>{parsed_input.run_in_background}</value>")
         if hasattr(parsed_input, "shell_executable") and parsed_input.shell_executable:
-            lines.append(f"Shell: {parsed_input.shell_executable}")
+            lines.append(f"<label>Shell:</label> <value>{html.escape(parsed_input.shell_executable)}</value>")
 
         return "\n  ".join(lines)
 
     # For other tools with commands, show concise preview
     if hasattr(parsed_input, "command"):
-        return f"command='{getattr(parsed_input, 'command')}'"
+        return f"<label>command:</label> <value>'{html.escape(getattr(parsed_input, 'command'))}'</value>"
     if hasattr(parsed_input, "file_path"):
-        return f"file='{getattr(parsed_input, 'file_path')}'"
+        return f"<label>file:</label> <value>'{html.escape(getattr(parsed_input, 'file_path'))}'</value>"
     if hasattr(parsed_input, "path"):
-        return f"path='{getattr(parsed_input, 'path')}'"
+        return f"<label>path:</label> <value>'{html.escape(getattr(parsed_input, 'path'))}'</value>"
 
     preview = str(parsed_input)
     if len(preview) > 140:
-        return preview[:137] + "..."
-    return preview
+        preview = preview[:137] + "..."
+    return f"<value>{html.escape(preview)}</value>"
 
 
 def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
@@ -92,55 +96,6 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
     return tool.name
 
 
-def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
-    """Render a simple numbered prompt (fallback for non-Rich environments)."""
-    border = "─" * 120
-    lines = [border, prompt, ""]
-    for idx, (_, label) in enumerate(options, start=1):
-        prefix = "❯" if idx == 1 else " "
-        lines.append(f"{prefix} {idx}. {label}")
-    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-    shortcut_choices = "/".join(opt[0] for opt in options)
-    lines.append(f"Choice ({numeric_choices} or {shortcut_choices}): ")
-    return "\n".join(lines)
-
-
-def _render_options_prompt_rich(
-    console: "Console",
-    prompt: str,
-    options: list[tuple[str, str]]
-) -> None:
-    """Render permission dialog using Rich Panel for better visual consistency."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    # Build option lines with markup
-    option_lines = []
-    for idx, (_, label) in enumerate(options, start=1):
-        prefix = "[cyan]❯[/cyan]" if idx == 1 else " "
-        option_lines.append(f"{prefix} {idx}. {label}")
-
-    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-    shortcut_choices = "/".join(opt[0] for opt in options)
-
-    # Build the prompt content as a markup string
-    markup_content = f"{prompt}\n\n" + "\n".join(option_lines) + "\n"
-    markup_content += f"Choice ([cyan]{numeric_choices}[/cyan] or [cyan]{shortcut_choices}[/cyan]): "
-
-    # Parse markup to create a Text object
-    content = Text.from_markup(markup_content)
-
-    # Render the panel
-    panel = Panel(
-        content,
-        title=Text.from_markup("[yellow]Permission Required[/yellow]"),
-        title_align="left",
-        border_style="yellow",
-        padding=(0, 1),
-    )
-    console.print(panel)
-
-
 def _rule_strings(rule_suggestions: Optional[Any]) -> list[str]:
     """Normalize rule suggestions to simple strings."""
     if not rule_suggestions:
@@ -158,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.
 
@@ -167,12 +122,13 @@ 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)
 
@@ -180,40 +136,37 @@ def make_permission_checker(
     session_tool_rules: dict[str, Set[str]] = defaultdict(set)
 
     async def _prompt_user(prompt: str, options: list[tuple[str, str]]) -> str:
-        """Prompt the user with proper interrupt handling."""
-        # Build the prompt message
-        if console is not None:
-            # Use Rich Panel for the dialog
-            _render_options_prompt_rich(console, prompt, options)
-            # Build simple prompt for the input line
-            numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
-            shortcut_choices = "/".join(opt[0] for opt in options)
-            input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
-        else:
-            # Use plain text rendering
-            rendered = _render_options_prompt(prompt, options)
-            input_prompt = rendered
-
-        # Try to use PromptSession if available (better interrupt handling)
-        if prompt_session is not None:
-            try:
-                # PromptSession.prompt() can handle Ctrl+C gracefully
-                return await prompt_session.prompt_async(input_prompt)
-            except KeyboardInterrupt:
-                logger.debug("[permissions] KeyboardInterrupt in prompt_session")
-                return "n"
-            except EOFError:
-                logger.debug("[permissions] EOFError in prompt_session")
-                return "n"
+        """Prompt the user with proper interrupt handling using unified choice component.
 
-        # Fallback to simple input() via executor
+        Args:
+            prompt: The prompt text to display (supports HTML formatting).
+            options: List of (value, label) tuples for choices.
+        """
         loop = asyncio.get_running_loop()
-        responder = prompt_fn or input
 
         def _ask() -> str:
             try:
-                return responder(input_prompt)
-            except (KeyboardInterrupt, EOFError):
+                # If a custom prompt_fn is provided (e.g., for tests), use it directly
+                responder = prompt_fn or None
+                if responder is not None:
+                    # Build a simple text prompt for the prompt_fn
+                    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
+                    shortcut_choices = "/".join(opt[0] for opt in options)
+                    input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
+                    return responder(input_prompt)
+
+                # Use the unified choice component
+                return prompt_choice(
+                    message=prompt,
+                    options=options,
+                    allow_esc=True,
+                    esc_value="n",  # ESC means no
+                )
+            except KeyboardInterrupt:
+                logger.debug("[permissions] KeyboardInterrupt in choice")
+                return "n"
+            except EOFError:
+                logger.debug("[permissions] EOFError in choice")
                 return "n"
 
         return await loop.run_in_executor(None, _ask)
@@ -264,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 []],
@@ -281,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,
                     },
                 )
@@ -315,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,
@@ -387,20 +348,21 @@ def make_permission_checker(
             )
 
         input_preview = _format_input_preview(parsed_input, tool_name=tool.name)
-        prompt_lines = [
-            f"{tool.name}",
-            "",
-            f"  {input_preview}",
-        ]
+        # Use inline styles for prompt_toolkit HTML formatting
+        # The style names must match keys in the _permission_style() dict
+        prompt_html = f"""<title>{html.escape(tool.name)}</title>
+
+  <description>{input_preview}</description>"""
         if decision.message:
-            prompt_lines.append(f"  {decision.message}")
-        prompt_lines.append("  Do you want to proceed?")
-        prompt = "\n".join(prompt_lines)
+            # Use warning style for warning messages
+            prompt_html += f"\n  <warning>{html.escape(decision.message)}</warning>"
+        prompt_html += "\n  <question>Do you want to proceed?</question>"
+        prompt = prompt_html
 
         options = [
-            ("y", "Yes"),
-            ("s", "Yes, for this session"),
-            ("n", "No"),
+            ("y", "<yes-option>Yes</yes-option>"),
+            ("s", "<yes-option>Yes, for this session</yes-option>"),
+            ("n", "<no-option>No</no-option>"),
         ]
 
         answer = (await _prompt_user(prompt, options=options)).strip().lower()

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