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

ripperdoc/core/permissions.py

@@ -6,13 +6,18 @@ import asyncio
 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 ripperdoc.core.config import config_manager
+from ripperdoc.core.hooks.manager import hook_manager
 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()
 
 
@@ -88,7 +93,7 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
 
 
 def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
-    """Render a simple numbered prompt."""
+    """Render a simple numbered prompt (fallback for non-Rich environments)."""
     border = "─" * 120
     lines = [border, prompt, ""]
     for idx, (_, label) in enumerate(options, start=1):
@@ -100,6 +105,42 @@ def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
     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:
@@ -117,9 +158,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,13 +180,41 @@ 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 without blocking the event loop."""
+        """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"
+
+        # Fallback to simple input() via executor
         loop = asyncio.get_running_loop()
         responder = prompt_fn or input
 
         def _ask() -> str:
-            rendered = _render_options_prompt(prompt, options)
-            return responder(rendered)
+            try:
+                return responder(input_prompt)
+            except (KeyboardInterrupt, EOFError):
+                return "n"
 
         return await loop.run_in_executor(None, _ask)
 
@@ -148,8 +226,9 @@ def make_permission_checker(
             return PermissionResult(result=True)
 
         try:
-            if hasattr(tool, "needs_permissions") and not tool.needs_permissions(parsed_input):
-                return PermissionResult(result=True)
+            needs_permission = True
+            if hasattr(tool, "needs_permissions"):
+                needs_permission = tool.needs_permissions(parsed_input)
         except (TypeError, AttributeError, ValueError) as exc:
             # Tool implementation error - log and deny for safety
             logger.warning(
@@ -166,10 +245,25 @@ def make_permission_checker(
             )
 
         allowed_tools = set(config.allowed_tools or [])
+
+        global_config = config_manager.get_global_config()
+        local_config = config_manager.get_project_local_config(project_path)
+
         allow_rules = {
-            "Bash": set(config.bash_allow_rules or []) | session_tool_rules.get("Bash", set())
+            "Bash": (
+                set(config.bash_allow_rules or [])
+                | set(global_config.user_allow_rules or [])
+                | set(local_config.local_allow_rules or [])
+                | session_tool_rules.get("Bash", set())
+            )
+        }
+        deny_rules = {
+            "Bash": (
+                set(config.bash_deny_rules or [])
+                | set(global_config.user_deny_rules or [])
+                | set(local_config.local_deny_rules or [])
+            )
         }
-        deny_rules = {"Bash": set(config.bash_deny_rules or [])}
         allowed_working_dirs = {
             str(project_path.resolve()),
             *[str(Path(p).resolve()) for p in config.working_directories or []],
@@ -219,6 +313,22 @@ def make_permission_checker(
                 rule_suggestions=[ToolRule(tool_name=tool.name, rule_content=tool.name)],
             )
 
+        # If tool doesn't normally require permission (e.g., read-only Bash),
+        # enforce deny rules but otherwise skip prompting.
+        if not needs_permission:
+            if decision.behavior == "deny":
+                return PermissionResult(
+                    result=False,
+                    message=decision.message or f"Permission denied for tool '{tool.name}'.",
+                    decision=decision,
+                )
+            return PermissionResult(
+                result=True,
+                message=decision.message,
+                updated_input=decision.updated_input,
+                decision=decision,
+            )
+
         if decision.behavior == "allow":
             return PermissionResult(
                 result=True,
@@ -235,6 +345,47 @@ def make_permission_checker(
             )
 
         # Ask/passthrough flows prompt the user.
+        tool_input_dict = (
+            parsed_input.model_dump()
+            if hasattr(parsed_input, "model_dump")
+            else dict(parsed_input)
+            if isinstance(parsed_input, dict)
+            else {}
+        )
+        try:
+            hook_result = await hook_manager.run_permission_request_async(
+                tool.name, tool_input_dict
+            )
+            if hook_result.outputs:
+                updated_input = hook_result.updated_input or decision.updated_input
+                if hook_result.should_allow:
+                    return PermissionResult(
+                        result=True,
+                        message=decision.message,
+                        updated_input=updated_input,
+                        decision=decision,
+                    )
+                if hook_result.should_block or not hook_result.should_continue:
+                    reason = (
+                        hook_result.block_reason
+                        or hook_result.stop_reason
+                        or decision.message
+                        or f"Permission denied for tool '{tool.name}'."
+                    )
+                    return PermissionResult(
+                        result=False,
+                        message=reason,
+                        updated_input=updated_input,
+                        decision=decision,
+                    )
+        except (RuntimeError, ValueError, TypeError, OSError) as exc:
+            logger.warning(
+                "[permissions] PermissionRequest hook failed: %s: %s",
+                type(exc).__name__,
+                exc,
+                extra={"tool": getattr(tool, "name", None)},
+            )
+
         input_preview = _format_input_preview(parsed_input, tool_name=tool.name)
         prompt_lines = [
             f"{tool.name}",

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={
@@ -300,9 +321,10 @@ class OpenAIClient(ProviderClient):
                     if getattr(chunk, "usage", None):
                         streamed_usage.update(openai_usage_tokens(chunk.usage))
 
-                    if not getattr(chunk, "choices", None):
+                    choices = getattr(chunk, "choices", None)
+                    if not choices or len(choices) == 0:
                         continue
-                    delta = getattr(chunk.choices[0], "delta", None)
+                    delta = getattr(choices[0], "delta", None)
                     if not delta:
                         continue
 
@@ -419,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},
                 )
@@ -449,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},
@@ -486,23 +533,32 @@ class OpenAIClient(ProviderClient):
                 )
             finish_reason = "stream"
         else:
-            choice = openai_response.choices[0]
-            content_blocks = content_blocks_from_openai_choice(choice, tool_mode)
-            finish_reason = cast(Optional[str], getattr(choice, "finish_reason", None))
-            message_obj = getattr(choice, "message", None) or choice
-            reasoning_content = getattr(message_obj, "reasoning_content", None)
-            if reasoning_content:
-                response_metadata["reasoning_content"] = reasoning_content
-            reasoning_field = getattr(message_obj, "reasoning", None)
-            if reasoning_field:
-                response_metadata["reasoning"] = reasoning_field
-                if "reasoning_content" not in response_metadata and isinstance(
-                    reasoning_field, str
-                ):
-                    response_metadata["reasoning_content"] = reasoning_field
-            reasoning_details = getattr(message_obj, "reasoning_details", None)
-            if reasoning_details:
-                response_metadata["reasoning_details"] = reasoning_details
+            response_choices = getattr(openai_response, "choices", None)
+            if not response_choices or len(response_choices) == 0:
+                logger.warning(
+                    "[openai_client] Empty choices in response",
+                    extra={"model": model_profile.model},
+                )
+                content_blocks = [{"type": "text", "text": ""}]
+                finish_reason = "error"
+            else:
+                choice = response_choices[0]
+                content_blocks = content_blocks_from_openai_choice(choice, tool_mode)
+                finish_reason = cast(Optional[str], getattr(choice, "finish_reason", None))
+                message_obj = getattr(choice, "message", None) or choice
+                reasoning_content = getattr(message_obj, "reasoning_content", None)
+                if reasoning_content:
+                    response_metadata["reasoning_content"] = reasoning_content
+                reasoning_field = getattr(message_obj, "reasoning", None)
+                if reasoning_field:
+                    response_metadata["reasoning"] = reasoning_field
+                    if "reasoning_content" not in response_metadata and isinstance(
+                        reasoning_field, str
+                    ):
+                        response_metadata["reasoning_content"] = reasoning_field
+                reasoning_details = getattr(message_obj, "reasoning_details", None)
+                if reasoning_details:
+                    response_metadata["reasoning_details"] = reasoning_details
 
         if can_stream:
             if stream_reasoning_text:
@@ -522,7 +578,7 @@ class OpenAIClient(ProviderClient):
             },
         )
 
-        logger.info(
+        logger.debug(
             "[openai_client] Response received",
             extra={
                 "model": model_profile.model,