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

ripperdoc/core/hooks/manager.py

@@ -6,7 +6,7 @@ throughout the application lifecycle.
 
 import os
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from ripperdoc.core.hooks.config import (
     HooksConfig,
@@ -47,10 +47,7 @@ class HookResult:
     @property
     def should_block(self) -> bool:
         """Check if any hook returned a blocking decision."""
-        return any(
-            o.decision in (HookDecision.DENY, HookDecision.BLOCK)
-            for o in self.outputs
-        )
+        return any(o.decision in (HookDecision.DENY, HookDecision.BLOCK) for o in self.outputs)
 
     @property
     def should_allow(self) -> bool:
@@ -431,9 +428,7 @@ class HookManager:
 
     # --- Notification ---
 
-    def run_notification(
-        self, message: str, notification_type: str = "info"
-    ) -> HookResult:
+    def run_notification(self, message: str, notification_type: str = "info") -> HookResult:
         """Run Notification hooks synchronously.
 
         Args:
@@ -478,11 +473,18 @@ class HookManager:
 
     # --- Stop ---
 
-    def run_stop(self, stop_hook_active: bool = False) -> HookResult:
+    def run_stop(
+        self,
+        stop_hook_active: bool = False,
+        reason: Optional[str] = None,
+        stop_sequence: Optional[str] = None,
+    ) -> HookResult:
         """Run Stop hooks synchronously.
 
         Args:
             stop_hook_active: True if already continuing from a stop hook
+            reason: Reason for stopping
+            stop_sequence: Stop sequence that triggered the stop
         """
         hooks = self._get_hooks(HookEvent.STOP)
         if not hooks:
@@ -490,6 +492,8 @@ class HookManager:
 
         input_data = StopInput(
             stop_hook_active=stop_hook_active,
+            reason=reason,
+            stop_sequence=stop_sequence,
             session_id=self.session_id,
             transcript_path=self.transcript_path,
             cwd=self._get_cwd(),
@@ -499,7 +503,12 @@ class HookManager:
         outputs = self.executor.execute_hooks_sync(hooks, input_data)
         return HookResult(outputs)
 
-    async def run_stop_async(self, stop_hook_active: bool = False) -> HookResult:
+    async def run_stop_async(
+        self,
+        stop_hook_active: bool = False,
+        reason: Optional[str] = None,
+        stop_sequence: Optional[str] = None,
+    ) -> HookResult:
         """Run Stop hooks asynchronously."""
         hooks = self._get_hooks(HookEvent.STOP)
         if not hooks:
@@ -507,6 +516,8 @@ class HookManager:
 
         input_data = StopInput(
             stop_hook_active=stop_hook_active,
+            reason=reason,
+            stop_sequence=stop_sequence,
             session_id=self.session_id,
             transcript_path=self.transcript_path,
             cwd=self._get_cwd(),
@@ -558,9 +569,7 @@ class HookManager:
 
     # --- Pre Compact ---
 
-    def run_pre_compact(
-        self, trigger: str, custom_instructions: str = ""
-    ) -> HookResult:
+    def run_pre_compact(self, trigger: str, custom_instructions: str = "") -> HookResult:
         """Run PreCompact hooks synchronously.
 
         Args:
@@ -645,11 +654,18 @@ class HookManager:
 
     # --- Session End ---
 
-    def run_session_end(self, reason: str) -> HookResult:
+    def run_session_end(
+        self,
+        reason: str,
+        duration_seconds: Optional[float] = None,
+        message_count: Optional[int] = None,
+    ) -> HookResult:
         """Run SessionEnd hooks synchronously.
 
         Args:
             reason: "clear", "logout", "prompt_input_exit", or "other"
+            duration_seconds: How long the session lasted
+            message_count: Number of messages in the session
         """
         hooks = self._get_hooks(HookEvent.SESSION_END)
         if not hooks:
@@ -657,6 +673,8 @@ class HookManager:
 
         input_data = SessionEndInput(
             reason=reason,
+            duration_seconds=duration_seconds,
+            message_count=message_count,
             session_id=self.session_id,
             transcript_path=self.transcript_path,
             cwd=self._get_cwd(),
@@ -666,7 +684,12 @@ class HookManager:
         outputs = self.executor.execute_hooks_sync(hooks, input_data)
         return HookResult(outputs)
 
-    async def run_session_end_async(self, reason: str) -> HookResult:
+    async def run_session_end_async(
+        self,
+        reason: str,
+        duration_seconds: Optional[float] = None,
+        message_count: Optional[int] = None,
+    ) -> HookResult:
         """Run SessionEnd hooks asynchronously."""
         hooks = self._get_hooks(HookEvent.SESSION_END)
         if not hooks:
@@ -674,6 +697,8 @@ class HookManager:
 
         input_data = SessionEndInput(
             reason=reason,
+            duration_seconds=duration_seconds,
+            message_count=message_count,
             session_id=self.session_id,
             transcript_path=self.transcript_path,
             cwd=self._get_cwd(),

ripperdoc/core/permissions.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Any, Awaitable, Callable, Optional, Set
 
 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
@@ -26,8 +27,29 @@ class PermissionResult:
     decision: Optional[PermissionDecision] = None
 
 
-def _format_input_preview(parsed_input: Any) -> str:
-    """Create a short, human-friendly preview for prompts."""
+def _format_input_preview(parsed_input: Any, tool_name: Optional[str] = None) -> str:
+    """Create a human-friendly preview for prompts.
+
+    For Bash commands, shows full details for security review.
+    For other tools, shows a concise preview.
+    """
+    # 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')}"]
+
+        # Add other relevant parameters
+        if hasattr(parsed_input, "timeout") and parsed_input.timeout:
+            lines.append(f"Timeout: {parsed_input.timeout}ms")
+        if hasattr(parsed_input, "sandbox"):
+            lines.append(f"Sandbox: {parsed_input.sandbox}")
+        if hasattr(parsed_input, "run_in_background"):
+            lines.append(f"Background: {parsed_input.run_in_background}")
+        if hasattr(parsed_input, "shell_executable") and parsed_input.shell_executable:
+            lines.append(f"Shell: {parsed_input.shell_executable}")
+
+        return "\n  ".join(lines)
+
+    # For other tools with commands, show concise preview
     if hasattr(parsed_input, "command"):
         return f"command='{getattr(parsed_input, 'command')}'"
     if hasattr(parsed_input, "file_path"):
@@ -94,10 +116,13 @@ def _rule_strings(rule_suggestions: Optional[Any]) -> list[str]:
 
 def make_permission_checker(
     project_path: Path,
-    safe_mode: bool,
+    yolo_mode: bool,
     prompt_fn: Optional[Callable[[str], str]] = None,
 ) -> Callable[[Tool[Any, Any], Any], Awaitable[PermissionResult]]:
-    """Create a permission checking function for the current project."""
+    """Create a permission checking function for the current project.
+
+    In yolo mode, all tool calls are allowed without prompting.
+    """
 
     project_path = project_path.resolve()
     config_manager.get_project_config(project_path)
@@ -120,17 +145,22 @@ def make_permission_checker(
         """Check and optionally persist permission for a tool invocation."""
         config = config_manager.get_project_config(project_path)
 
-        if not safe_mode:
+        if yolo_mode:
             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(
                 "[permissions] Tool needs_permissions check failed",
-                extra={"tool": getattr(tool, "name", None), "error": str(exc), "error_type": type(exc).__name__},
+                extra={
+                    "tool": getattr(tool, "name", None),
+                    "error": str(exc),
+                    "error_type": type(exc).__name__,
+                },
             )
             return PermissionResult(
                 result=False,
@@ -138,10 +168,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 []],
@@ -172,7 +217,11 @@ def make_permission_checker(
                 # Tool implementation error - fall back to asking user
                 logger.warning(
                     "[permissions] Tool check_permissions failed",
-                    extra={"tool": getattr(tool, "name", None), "error": str(exc), "error_type": type(exc).__name__},
+                    extra={
+                        "tool": getattr(tool, "name", None),
+                        "error": str(exc),
+                        "error_type": type(exc).__name__,
+                    },
                 )
                 decision = PermissionDecision(
                     behavior="ask",
@@ -187,6 +236,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,
@@ -203,7 +268,48 @@ def make_permission_checker(
             )
 
         # Ask/passthrough flows prompt the user.
-        input_preview = _format_input_preview(parsed_input)
+        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/anthropic.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import time
 from typing import Any, Awaitable, Callable, Dict, List, Optional
 from uuid import uuid4
@@ -73,17 +74,21 @@ def _content_blocks_from_stream_state(
 
     # Add thinking block if present
     if collected_thinking:
-        blocks.append({
-            "type": "thinking",
-            "thinking": "".join(collected_thinking),
-        })
+        blocks.append(
+            {
+                "type": "thinking",
+                "thinking": "".join(collected_thinking),
+            }
+        )
 
     # Add text block if present
     if collected_text:
-        blocks.append({
-            "type": "text",
-            "text": "".join(collected_text),
-        })
+        blocks.append(
+            {
+                "type": "text",
+                "text": "".join(collected_text),
+            }
+        )
 
     # Add tool_use blocks
     for idx in sorted(collected_tool_calls.keys()):
@@ -92,12 +97,14 @@ def _content_blocks_from_stream_state(
         if not name:
             continue
         tool_use_id = call.get("id") or str(uuid4())
-        blocks.append({
-            "type": "tool_use",
-            "tool_use_id": tool_use_id,
-            "name": name,
-            "input": call.get("input", {}),
-        })
+        blocks.append(
+            {
+                "type": "tool_use",
+                "tool_use_id": tool_use_id,
+                "name": name,
+                "input": call.get("input", {}),
+            }
+        )
 
     return blocks
 
@@ -110,25 +117,31 @@ def _content_blocks_from_response(response: Any) -> List[Dict[str, Any]]:
         if btype == "text":
             blocks.append({"type": "text", "text": getattr(block, "text", "")})
         elif btype == "thinking":
-            blocks.append({
-                "type": "thinking",
-                "thinking": getattr(block, "thinking", None) or "",
-                "signature": getattr(block, "signature", None),
-            })
+            blocks.append(
+                {
+                    "type": "thinking",
+                    "thinking": getattr(block, "thinking", None) or "",
+                    "signature": getattr(block, "signature", None),
+                }
+            )
         elif btype == "redacted_thinking":
-            blocks.append({
-                "type": "redacted_thinking",
-                "data": getattr(block, "data", None),
-                "signature": getattr(block, "signature", None),
-            })
+            blocks.append(
+                {
+                    "type": "redacted_thinking",
+                    "data": getattr(block, "data", None),
+                    "signature": getattr(block, "signature", None),
+                }
+            )
         elif btype == "tool_use":
             raw_input = getattr(block, "input", {}) or {}
-            blocks.append({
-                "type": "tool_use",
-                "tool_use_id": getattr(block, "id", None) or str(uuid4()),
-                "name": getattr(block, "name", None),
-                "input": raw_input if isinstance(raw_input, dict) else {},
-            })
+            blocks.append(
+                {
+                    "type": "tool_use",
+                    "tool_use_id": getattr(block, "id", None) or str(uuid4()),
+                    "name": getattr(block, "name", None),
+                    "input": raw_input if isinstance(raw_input, dict) else {},
+                }
+            )
     return blocks
 
 
@@ -188,6 +201,15 @@ class AnthropicClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_anthropic_error(exc)
+            logger.debug(
+                "[anthropic_client] Exception details",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[anthropic_client] API call failed",
                 extra={
@@ -222,6 +244,17 @@ class AnthropicClient(ProviderClient):
         tool_schemas = await build_anthropic_tool_schemas(tools)
         response_metadata: Dict[str, Any] = {}
 
+        logger.debug(
+            "[anthropic_client] Preparing request",
+            extra={
+                "model": model_profile.model,
+                "tool_mode": tool_mode,
+                "stream": stream,
+                "max_thinking_tokens": max_thinking_tokens,
+                "num_tools": len(tool_schemas),
+            },
+        )
+
         anthropic_kwargs: Dict[str, Any] = {}
         if model_profile.api_base:
             anthropic_kwargs["base_url"] = model_profile.api_base
@@ -239,9 +272,9 @@ class AnthropicClient(ProviderClient):
             # The read timeout applies to waiting for each chunk from the server
             timeout_config = httpx.Timeout(
                 connect=60.0,  # 60 seconds to establish connection
-                read=600.0,    # 10 minutes to wait for each chunk (model may be thinking)
-                write=60.0,    # 60 seconds to send request
-                pool=60.0,     # 60 seconds to get connection from pool
+                read=600.0,  # 10 minutes to wait for each chunk (model may be thinking)
+                write=60.0,  # 60 seconds to send request
+                pool=60.0,  # 60 seconds to get connection from pool
             )
             anthropic_kwargs["timeout"] = timeout_config
         elif request_timeout and request_timeout > 0:
@@ -267,6 +300,21 @@ class AnthropicClient(ProviderClient):
         if thinking_payload:
             request_kwargs["thinking"] = thinking_payload
 
+        logger.debug(
+            "[anthropic_client] Request parameters",
+            extra={
+                "model": model_profile.model,
+                "request_kwargs": json.dumps(
+                    {k: v for k, v in request_kwargs.items() if k != "messages"},
+                    ensure_ascii=False,
+                    default=str,
+                )[:1000],
+                "thinking_payload": json.dumps(thinking_payload, ensure_ascii=False)
+                if thinking_payload
+                else None,
+            },
+        )
+
         async with await self._client(anthropic_kwargs) as client:
             if stream:
                 # Streaming mode: use event-based streaming with per-token timeout
@@ -294,6 +342,16 @@ class AnthropicClient(ProviderClient):
             model_profile.model, duration_ms=duration_ms, cost_usd=cost_usd, **usage_tokens
         )
 
+        logger.debug(
+            "[anthropic_client] Response content blocks",
+            extra={
+                "model": model_profile.model,
+                "content_blocks": json.dumps(content_blocks, ensure_ascii=False)[:1000],
+                "usage_tokens": json.dumps(usage_tokens, ensure_ascii=False),
+                "metadata": json.dumps(response_metadata, ensure_ascii=False)[:500],
+            },
+        )
+
         logger.info(
             "[anthropic_client] Response received",
             extra={
@@ -354,6 +412,13 @@ class AnthropicClient(ProviderClient):
             event_count = 0
             message_stop_received = False
 
+            logger.debug(
+                "[anthropic_client] Initiating stream request",
+                extra={
+                    "model": request_kwargs.get("model"),
+                },
+            )
+
             # Create the stream - this initiates the connection
             stream = client.messages.stream(**request_kwargs)
 
@@ -448,7 +513,12 @@ class AnthropicClient(ProviderClient):
                 else:
                     raise
 
-        if last_error and not collected_text and not collected_thinking and not collected_tool_calls:
+        if (
+            last_error
+            and not collected_text
+            and not collected_thinking
+            and not collected_tool_calls
+        ):
             raise RuntimeError(f"Stream failed after {attempts} attempts") from last_error
 
         # Store reasoning content in metadata
@@ -542,7 +612,8 @@ class AnthropicClient(ProviderClient):
                         except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                             logger.warning(
                                 "[anthropic_client] Progress callback failed: %s: %s",
-                                type(cb_exc).__name__, cb_exc,
+                                type(cb_exc).__name__,
+                                cb_exc,
                             )
 
             elif delta_type == "text_delta":
@@ -556,7 +627,8 @@ class AnthropicClient(ProviderClient):
                         except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                             logger.warning(
                                 "[anthropic_client] Progress callback failed: %s: %s",
-                                type(cb_exc).__name__, cb_exc,
+                                type(cb_exc).__name__,
+                                cb_exc,
                             )
 
             elif delta_type == "input_json_delta":
@@ -599,6 +671,7 @@ class AnthropicClient(ProviderClient):
             # Parse accumulated JSON for tool calls
             if index in collected_tool_calls:
                 import json
+
                 json_str = collected_tool_calls[index].get("input_json", "")
                 if json_str:
                     try: