ripperdoc 0.2.8__py3-none-any.whl → 0.2.9__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

@@ -26,8 +26,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 +115,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,7 +144,7 @@ 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:
@@ -130,7 +154,11 @@ def make_permission_checker(
             # 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,
@@ -172,7 +200,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",
@@ -203,7 +235,7 @@ def make_permission_checker(
             )
 
         # Ask/passthrough flows prompt the user.
-        input_preview = _format_input_preview(parsed_input)
+        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:

ripperdoc/core/providers/gemini.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import inspect
+import json
 import os
 import time
 from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
@@ -240,9 +241,7 @@ async def _async_build_tool_declarations(tools: List[Tool[Any, Any]]) -> List[Di
                 description=description,
                 parameters_json_schema=parameters_schema,
             )
-            declarations.append(
-                func_decl.model_dump(mode="json", exclude_none=True)
-            )
+            declarations.append(func_decl.model_dump(mode="json", exclude_none=True))
         else:
             declarations.append(
                 {
@@ -385,6 +384,17 @@ class GeminiClient(ProviderClient):
     ) -> ProviderResponse:
         start_time = time.time()
 
+        logger.debug(
+            "[gemini_client] Preparing request",
+            extra={
+                "model": model_profile.model,
+                "tool_mode": tool_mode,
+                "stream": stream,
+                "max_thinking_tokens": max_thinking_tokens,
+                "num_tools": len(tools),
+            },
+        )
+
         try:
             client = await self._client(model_profile)
         except asyncio.CancelledError:
@@ -392,6 +402,15 @@ class GeminiClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_gemini_error(exc)
+            logger.debug(
+                "[gemini_client] Exception details during init",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[gemini_client] Initialization failed",
                 extra={
@@ -422,7 +441,12 @@ class GeminiClient(ProviderClient):
                 from google.genai import types as genai_types  # type: ignore
 
                 config["thinking_config"] = genai_types.ThinkingConfig(**thinking_config)
-            except (ImportError, ModuleNotFoundError, TypeError, ValueError):  # pragma: no cover - fallback when SDK not installed
+            except (
+                ImportError,
+                ModuleNotFoundError,
+                TypeError,
+                ValueError,
+            ):  # pragma: no cover - fallback when SDK not installed
                 config["thinking_config"] = thinking_config
         if declarations:
             config["tools"] = [{"function_declarations": declarations}]
@@ -432,6 +456,23 @@ class GeminiClient(ProviderClient):
             "contents": contents,
             "config": config,
         }
+
+        logger.debug(
+            "[gemini_client] Request parameters",
+            extra={
+                "model": model_profile.model,
+                "config": json.dumps(
+                    {k: v for k, v in config.items() if k != "system_instruction"},
+                    ensure_ascii=False,
+                    default=str,
+                )[:1000],
+                "num_declarations": len(declarations),
+                "thinking_config": json.dumps(thinking_config, ensure_ascii=False)
+                if thinking_config
+                else None,
+            },
+        )
+
         usage_tokens: Dict[str, int] = {}
         collected_text: List[str] = []
         function_calls: List[Dict[str, Any]] = []
@@ -483,6 +524,10 @@ class GeminiClient(ProviderClient):
 
         try:
             if stream:
+                logger.debug(
+                    "[gemini_client] Initiating stream request",
+                    extra={"model": model_profile.model},
+                )
                 stream_resp = await _call_generate(streaming=True)
 
                 # Normalize streams into an async iterator to avoid StopIteration surfacing through
@@ -523,7 +568,8 @@ class GeminiClient(ProviderClient):
                                 except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                                     logger.warning(
                                         "[gemini_client] Stream callback failed: %s: %s",
-                                        type(cb_exc).__name__, cb_exc,
+                                        type(cb_exc).__name__,
+                                        cb_exc,
                                     )
                         if text_chunk:
                             collected_text.append(text_chunk)
@@ -552,6 +598,15 @@ class GeminiClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_gemini_error(exc)
+            logger.debug(
+                "[gemini_client] Exception details",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[gemini_client] API call failed",
                 extra={
@@ -595,6 +650,16 @@ class GeminiClient(ProviderClient):
             **(usage_tokens or {}),
         )
 
+        logger.debug(
+            "[gemini_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(
             "[gemini_client] Response received",
             extra={