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

ripperdoc/core/permissions.py

@@ -3,10 +3,17 @@
 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
+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.core.config import config_manager
 from ripperdoc.core.hooks.manager import hook_manager
@@ -14,6 +21,10 @@ from ripperdoc.core.tool import Tool
 from ripperdoc.utils.permissions import PermissionDecision, ToolRule
 from ripperdoc.utils.log import get_logger
 
+if TYPE_CHECKING:
+    from rich.console import Console
+    from prompt_toolkit import PromptSession
+
 logger = get_logger()
 
 
@@ -32,35 +43,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:
@@ -88,17 +101,23 @@ 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."""
-    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 _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]:
@@ -118,9 +137,18 @@ 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,
 ) -> Callable[[Tool[Any, Any], Any], Awaitable[PermissionResult]]:
     """Create a permission checking function for the current project.
 
+    Args:
+        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
+
     In yolo mode, all tool calls are allowed without prompting.
     """
 
@@ -130,14 +158,69 @@ def make_permission_checker(
     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]]) -> str:
-        """Prompt the user without blocking the event loop."""
+    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().
+
+        Args:
+            prompt: The prompt text to display.
+            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()
-        responder = prompt_fn or input
 
         def _ask() -> str:
-            rendered = _render_options_prompt(prompt, options)
-            return responder(rendered)
+            try:
+                # 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)
+
+                # 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,
+                )
+
+                # 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"
+            except EOFError:
+                logger.debug("[permissions] EOFError in choice")
+                return "n"
 
         return await loop.run_in_executor(None, _ask)
 
@@ -310,23 +393,24 @@ 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()
+        answer = (await _prompt_user(prompt, options=options, is_html=True)).strip().lower()
         logger.debug(
             "[permissions] User answer for permission prompt",
             extra={"answer": answer, "tool": getattr(tool, "name", None)},

ripperdoc/core/providers/openai.py

@@ -80,10 +80,18 @@ def _effort_from_tokens(max_thinking_tokens: int) -> Optional[str]:
 
 
 def _detect_openai_vendor(model_profile: ModelProfile) -> str:
-    """Best-effort vendor hint for OpenAI-compatible endpoints."""
+    """Best-effort vendor hint for OpenAI-compatible endpoints.
+
+    If thinking_mode is explicitly set to "none" or "disabled", returns "none"
+    to skip all thinking protocol handling.
+    """
     override = getattr(model_profile, "thinking_mode", None)
     if isinstance(override, str) and override.strip():
-        return override.strip().lower()
+        mode = override.strip().lower()
+        # Allow explicit disable of thinking protocol
+        if mode in ("disabled", "off"):
+            return "none"
+        return mode
     base = (model_profile.api_base or "").lower()
     name = (model_profile.model or "").lower()
     if "openrouter.ai" in base:
@@ -106,21 +114,25 @@ def _build_thinking_kwargs(
     extra_body: Dict[str, Any] = {}
     top_level: Dict[str, Any] = {}
     vendor = _detect_openai_vendor(model_profile)
+
+    # Skip thinking protocol if explicitly disabled
+    if vendor == "none":
+        return extra_body, top_level
+
     effort = _effort_from_tokens(max_thinking_tokens)
 
     if vendor == "deepseek":
         if max_thinking_tokens != 0:
             extra_body["thinking"] = {"type": "enabled"}
     elif vendor == "qwen":
+        # Only send enable_thinking when explicitly enabling thinking mode
+        # Some qwen-compatible APIs don't support this parameter
         if max_thinking_tokens > 0:
             extra_body["enable_thinking"] = True
-        elif max_thinking_tokens == 0:
-            extra_body["enable_thinking"] = False
     elif vendor == "openrouter":
+        # Only send reasoning when explicitly enabling thinking mode
         if max_thinking_tokens > 0:
             extra_body["reasoning"] = {"max_tokens": max_thinking_tokens}
-        elif max_thinking_tokens == 0:
-            extra_body["reasoning"] = {"effort": "none"}
     elif vendor == "gemini_openai":
         google_cfg: Dict[str, Any] = {}
         if max_thinking_tokens > 0:
@@ -250,6 +262,15 @@ class OpenAIClient(ProviderClient):
             model_profile, max_thinking_tokens
         )
 
+        logger.debug(
+            "[openai_client] Starting API request",
+            extra={
+                "model": model_profile.model,
+                "api_base": model_profile.api_base,
+                "request_timeout": request_timeout,
+            },
+        )
+
         logger.debug(
             "[openai_client] Request parameters",
             extra={
@@ -420,12 +441,13 @@ class OpenAIClient(ProviderClient):
             )
 
             if (
-                can_stream_text
+                can_stream
                 and not collected_text
                 and not streamed_tool_calls
                 and not streamed_tool_text
+                and not stream_reasoning_text
             ):
-                logger.debug(
+                logger.warning(
                     "[openai_client] Streaming returned no content; retrying without stream",
                     extra={"model": model_profile.model},
                 )
@@ -450,6 +472,30 @@ class OpenAIClient(ProviderClient):
         if not can_stream and (
             not openai_response or not getattr(openai_response, "choices", None)
         ):
+            # Check for non-standard error response (e.g., iflow returns HTTP 200 with error JSON)
+            error_msg = (
+                getattr(openai_response, "msg", None)
+                or getattr(openai_response, "message", None)
+                or getattr(openai_response, "error", None)
+            )
+            error_status = getattr(openai_response, "status", None)
+            if error_msg or error_status:
+                error_text = f"API Error: {error_msg or 'Unknown error'}"
+                if error_status:
+                    error_text = f"API Error ({error_status}): {error_msg or 'Unknown error'}"
+                logger.error(
+                    "[openai_client] Non-standard error response from API",
+                    extra={
+                        "model": model_profile.model,
+                        "error_status": error_status,
+                        "error_msg": error_msg,
+                    },
+                )
+                return ProviderResponse.create_error(
+                    error_code="api_error",
+                    error_message=error_text,
+                    duration_ms=duration_ms,
+                )
             logger.warning(
                 "[openai_client] No choices returned from OpenAI response",
                 extra={"model": model_profile.model},
@@ -532,7 +578,7 @@ class OpenAIClient(ProviderClient):
             },
         )
 
-        logger.info(
+        logger.debug(
             "[openai_client] Response received",
             extra={
                 "model": model_profile.model,