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

ripperdoc/utils/messages.py

@@ -5,7 +5,7 @@ for communication with AI models.
 """
 
 from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from uuid import uuid4
 from enum import Enum
 from ripperdoc.utils.log import get_logger
@@ -35,6 +35,23 @@ class MessageContent(BaseModel):
     name: Optional[str] = None
     input: Optional[Dict[str, object]] = None
     is_error: Optional[bool] = None
+    # Image/vision content fields
+    source_type: Optional[str] = None  # "base64", "url", "file"
+    media_type: Optional[str] = None  # "image/jpeg", "image/png", etc.
+    image_data: Optional[str] = None  # base64-encoded image data or URL
+
+    @field_validator("input", mode="before")
+    @classmethod
+    def validate_input(cls, v):
+        """Ensure input is always a dict, never a Pydantic model."""
+        if v is not None and not isinstance(v, dict):
+            if hasattr(v, "model_dump"):
+                v = v.model_dump()
+            elif hasattr(v, "dict"):
+                v = v.dict()
+            else:
+                v = {"value": str(v)}
+        return v
 
 
 def _content_block_to_api(block: MessageContent) -> Dict[str, Any]:
@@ -53,11 +70,19 @@ def _content_block_to_api(block: MessageContent) -> Dict[str, Any]:
             "signature": getattr(block, "signature", None),
         }
     if block_type == "tool_use":
+        input_value = getattr(block, "input", None) or {}
+        # Ensure input is a dict, not a Pydantic model
+        if hasattr(input_value, "model_dump"):
+            input_value = input_value.model_dump()
+        elif hasattr(input_value, "dict"):
+            input_value = input_value.dict()
+        elif not isinstance(input_value, dict):
+            input_value = {"value": str(input_value)}
         return {
             "type": "tool_use",
             "id": getattr(block, "id", None) or getattr(block, "tool_use_id", "") or "",
             "name": getattr(block, "name", None) or "",
-            "input": getattr(block, "input", None) or {},
+            "input": input_value,
         }
     if block_type == "tool_result":
         result: Dict[str, Any] = {
@@ -73,6 +98,15 @@ def _content_block_to_api(block: MessageContent) -> Dict[str, Any]:
         if getattr(block, "is_error", None) is not None:
             result["is_error"] = block.is_error
         return result
+    if block_type == "image":
+        return {
+            "type": "image",
+            "source": {
+                "type": getattr(block, "source_type", None) or "base64",
+                "media_type": getattr(block, "media_type", None) or "image/jpeg",
+                "data": getattr(block, "image_data", None) or "",
+            },
+        }
     # Default to text block
     return {
         "type": "text",
@@ -124,6 +158,15 @@ def _content_block_to_openai(block: MessageContent) -> Dict[str, Any]:
             "tool_call_id": tool_call_id,
             "content": getattr(block, "text", None) or getattr(block, "content", None) or "",
         }
+    if block_type == "image":
+        # OpenAI uses data URL format for images
+        media_type = getattr(block, "media_type", None) or "image/jpeg"
+        image_data = getattr(block, "image_data", None) or ""
+        data_url = f"data:{media_type};base64,{image_data}"
+        return {
+            "type": "image_url",
+            "image_url": {"url": data_url},
+        }
     # Fallback text message
     return {
         "role": "assistant",
@@ -152,6 +195,7 @@ class UserMessage(BaseModel):
     type: str = "user"
     message: Message
     uuid: str = ""
+    parent_tool_use_id: Optional[str] = None
     tool_use_result: Optional[object] = None
 
     def __init__(self, **data: object) -> None:
@@ -166,6 +210,7 @@ class AssistantMessage(BaseModel):
     type: str = "assistant"
     message: Message
     uuid: str = ""
+    parent_tool_use_id: Optional[str] = None
     cost_usd: float = 0.0
     duration_ms: float = 0.0
     is_api_error_message: bool = False
@@ -175,6 +220,7 @@ class AssistantMessage(BaseModel):
     output_tokens: int = 0
     cache_read_tokens: int = 0
     cache_creation_tokens: int = 0
+    error: Optional[str] = None
 
     def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
@@ -191,6 +237,7 @@ class ProgressMessage(BaseModel):
     content: Any
     normalized_messages: List[Message] = []
     sibling_tool_use_ids: set[str] = set()
+    is_subagent_message: bool = False  # Flag to indicate if content is a subagent message
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     def __init__(self, **data: object) -> None:
@@ -200,7 +247,9 @@ class ProgressMessage(BaseModel):
 
 
 def create_user_message(
-    content: Union[str, List[Dict[str, Any]]], tool_use_result: Optional[object] = None
+    content: Union[str, List[Dict[str, Any]]],
+    tool_use_result: Optional[object] = None,
+    parent_tool_use_id: Optional[str] = None,
 ) -> UserMessage:
     """Create a user message."""
     if isinstance(content, str):
@@ -234,7 +283,39 @@ def create_user_message(
                 f"ids={[getattr(b, 'tool_use_id', None) for b in tool_result_blocks]}"
             )
 
-    return UserMessage(message=message, tool_use_result=tool_use_result)
+    return UserMessage(
+        message=message,
+        tool_use_result=tool_use_result,
+        parent_tool_use_id=parent_tool_use_id,
+    )
+
+
+def _normalize_content_item(item: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize a content item to ensure all fields are JSON-serializable.
+
+    This is needed because some API providers may return Pydantic models
+    for tool input fields, which need to be converted to dicts for proper
+    serialization and later processing.
+
+    Args:
+        item: The content item dict from API response
+
+    Returns:
+        Normalized content item with all fields JSON-serializable
+    """
+    normalized = dict(item)
+
+    # If input is a Pydantic model, convert to dict
+    if 'input' in normalized and normalized['input'] is not None:
+        input_value = normalized['input']
+        if hasattr(input_value, 'model_dump'):
+            normalized['input'] = input_value.model_dump()
+        elif hasattr(input_value, 'dict'):
+            normalized['input'] = input_value.dict()
+        elif not isinstance(input_value, dict):
+            normalized['input'] = {'value': str(input_value)}
+
+    return normalized
 
 
 def create_assistant_message(
@@ -248,12 +329,15 @@ def create_assistant_message(
     output_tokens: int = 0,
     cache_read_tokens: int = 0,
     cache_creation_tokens: int = 0,
+    parent_tool_use_id: Optional[str] = None,
+    error: Optional[str] = None,
 ) -> AssistantMessage:
     """Create an assistant message."""
     if isinstance(content, str):
         message_content: Union[str, List[MessageContent]] = content
     else:
-        message_content = [MessageContent(**item) for item in content]
+        # Normalize content items to ensure tool input is always a dict
+        message_content = [MessageContent(**_normalize_content_item(item)) for item in content]
 
     message = Message(
         role=MessageRole.ASSISTANT,
@@ -271,6 +355,8 @@ def create_assistant_message(
         output_tokens=output_tokens,
         cache_read_tokens=cache_read_tokens,
         cache_creation_tokens=cache_creation_tokens,
+        parent_tool_use_id=parent_tool_use_id,
+        error=error,
     )
 
 
@@ -279,6 +365,7 @@ def create_progress_message(
     sibling_tool_use_ids: set[str],
     content: Any,
     normalized_messages: Optional[List[Message]] = None,
+    is_subagent_message: bool = False,
 ) -> ProgressMessage:
     """Create a progress message."""
     return ProgressMessage(
@@ -286,6 +373,7 @@ def create_progress_message(
         sibling_tool_use_ids=sibling_tool_use_ids,
         content=content,
         normalized_messages=normalized_messages or [],
+        is_subagent_message=is_subagent_message,
     )
 
 
@@ -454,33 +542,90 @@ def normalize_messages_for_api(
             meta = _msg_metadata(msg)
             if isinstance(user_content, list):
                 if protocol == "openai":
-                    # Map each block to an OpenAI-style message
-                    openai_msgs: List[Dict[str, Any]] = []
-                    for block in user_content:
-                        block_type = getattr(block, "type", None)
-                        if block_type == "tool_result":
-                            tool_results_seen += 1
-                            # Skip tool_result blocks that lack a preceding tool_use
-                            tool_id = getattr(block, "tool_use_id", None) or getattr(
-                                block, "id", None
-                            )
-                            if not tool_id:
-                                skipped_tool_results_no_call += 1
-                                continue
-                            call_pos = tool_use_positions.get(tool_id)
-                            if call_pos is None or call_pos >= msg_index:
-                                skipped_tool_results_no_call += 1
-                                continue
-                        mapped = _content_block_to_openai(block)
-                        if mapped:
-                            openai_msgs.append(mapped)
-                    if meta and openai_msgs:
-                        for candidate in openai_msgs:
-                            for key in ("reasoning_content", "reasoning_details", "reasoning"):
-                                if key in meta and meta[key] is not None:
-                                    candidate[key] = meta[key]
-                    normalized.extend(openai_msgs)
-                    continue
+                    # Check if this message contains images
+                    has_images = any(
+                        getattr(block, "type", None) == "image" for block in user_content
+                    )
+                    has_text_only = all(
+                        getattr(block, "type", None) in ("text", "image", "tool_result")
+                        for block in user_content
+                    )
+
+                    # If message has images or only text/images (no tool_result), use content array format
+                    if has_images or (
+                        has_text_only
+                        and not any(
+                            getattr(block, "type", None) == "tool_result" for block in user_content
+                        )
+                    ):
+                        content_array: List[Dict[str, Any]] = []
+                        for block in user_content:
+                            block_type = getattr(block, "type", None)
+                            if block_type == "image":
+                                content_array.append(_content_block_to_openai(block))
+                            elif block_type == "text":
+                                content_array.append(
+                                    {
+                                        "type": "text",
+                                        "text": getattr(block, "text", "") or "",
+                                    }
+                                )
+                            elif block_type == "tool_result":
+                                # Handle tool_result separately
+                                tool_results_seen += 1
+                                tool_id = getattr(block, "tool_use_id", None) or getattr(
+                                    block, "id", None
+                                )
+                                if not tool_id:
+                                    skipped_tool_results_no_call += 1
+                                    continue
+                                call_pos = tool_use_positions.get(tool_id)
+                                if call_pos is None or call_pos >= msg_index:
+                                    skipped_tool_results_no_call += 1
+                                    continue
+                                mapped = _content_block_to_openai(block)
+                                if mapped:
+                                    normalized.append(mapped)
+
+                        if content_array:
+                            user_msg: Dict[str, Any] = {
+                                "role": "user",
+                                "content": content_array,
+                            }
+                            if meta:
+                                for key in ("reasoning_content", "reasoning_details", "reasoning"):
+                                    if key in meta and meta[key] is not None:
+                                        user_msg[key] = meta[key]
+                            normalized.append(user_msg)
+                        continue
+                    else:
+                        # Original behavior for tool_result messages
+                        openai_msgs: List[Dict[str, Any]] = []
+                        for block in user_content:
+                            block_type = getattr(block, "type", None)
+                            if block_type == "tool_result":
+                                tool_results_seen += 1
+                                # Skip tool_result blocks that lack a preceding tool_use
+                                tool_id = getattr(block, "tool_use_id", None) or getattr(
+                                    block, "id", None
+                                )
+                                if not tool_id:
+                                    skipped_tool_results_no_call += 1
+                                    continue
+                                call_pos = tool_use_positions.get(tool_id)
+                                if call_pos is None or call_pos >= msg_index:
+                                    skipped_tool_results_no_call += 1
+                                    continue
+                            mapped = _content_block_to_openai(block)
+                            if mapped:
+                                openai_msgs.append(mapped)
+                        if meta and openai_msgs:
+                            for candidate in openai_msgs:
+                                for key in ("reasoning_content", "reasoning_details", "reasoning"):
+                                    if key in meta and meta[key] is not None:
+                                        candidate[key] = meta[key]
+                        normalized.extend(openai_msgs)
+                        continue
                 api_blocks = []
                 for block in user_content:
                     if getattr(block, "type", None) == "tool_result":

ripperdoc/utils/pending_messages.py

@@ -0,0 +1,50 @@
+"""Thread-safe queue for pending conversation messages.
+
+Allows background tasks or external events to enqueue user messages that
+should be injected into the conversation once the current iteration
+finishes. Messages are drained in FIFO order.
+"""
+
+from collections import deque
+import threading
+from typing import Any, Deque, Dict, List, Optional
+
+from ripperdoc.utils.messages import UserMessage, create_user_message
+
+
+class PendingMessageQueue:
+    """Thread-safe queue for pending user messages."""
+
+    def __init__(self) -> None:
+        self._queue: Deque[UserMessage] = deque()
+        self._lock = threading.Lock()
+
+    def enqueue(self, message: UserMessage) -> None:
+        """Add a pre-built UserMessage to the queue."""
+        with self._lock:
+            self._queue.append(message)
+
+    def enqueue_text(self, text: str, metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Create and enqueue a UserMessage with optional metadata."""
+        message = create_user_message(text)
+        if metadata:
+            try:
+                message.message.metadata.update(metadata)
+            except Exception:
+                # Best-effort metadata attachment; ignore failures.
+                pass
+        self.enqueue(message)
+
+    def drain(self) -> List[UserMessage]:
+        """Drain all pending messages in FIFO order."""
+        with self._lock:
+            if not self._queue:
+                return []
+            messages = list(self._queue)
+            self._queue.clear()
+            return messages
+
+    def has_messages(self) -> bool:
+        """Check if there are pending messages."""
+        with self._lock:
+            return bool(self._queue)

ripperdoc/utils/permissions/shell_command_validation.py

@@ -662,7 +662,7 @@ def validate_shell_command(shell_command: str) -> ValidationResult:
         lex = shlex.shlex(cmd, posix=True)
         lex.whitespace_split = True  # Split on whitespace, better for argument parsing
         lex.commenters = ""  # Don't treat # as comment for security analysis
-        
+
         tokens = []
         try:
             # Get all tokens
@@ -691,7 +691,7 @@ def validate_shell_command(shell_command: str) -> ValidationResult:
                 # Single ; & | are dangerous
                 return True
             i += 1
-        
+
         # Also check for find -exec escaped semicolon pattern
         # shlex will have already parsed \; as separate token ';' (since escaped)
         # We need to check if this ; is part of find -exec pattern
@@ -716,7 +716,7 @@ def validate_shell_command(shell_command: str) -> ValidationResult:
                     continue
                 # Not part of find -exec, so it's dangerous
                 return True
-        
+
         return False
 
     if has_metachars_outside_quotes(sanitized_for_metachar_check):

ripperdoc/utils/permissions/tool_permission_utils.py

@@ -64,7 +64,9 @@ def create_wildcard_tool_rule(rule_name: str, use_glob_style: bool = False) -> L
     Returns:
         List containing a single ToolRule with wildcard pattern
     """
-    return [ToolRule(tool_name="Bash", rule_content=create_wildcard_rule(rule_name, use_glob_style))]
+    return [
+        ToolRule(tool_name="Bash", rule_content=create_wildcard_rule(rule_name, use_glob_style))
+    ]
 
 
 def extract_rule_prefix(rule_string: str) -> Optional[str]:
@@ -273,11 +275,15 @@ def _collect_rule_suggestions(command: str) -> List[ToolRule]:
     if tokens:
         # Legacy prefix format
         suggestions.append(
-            ToolRule(tool_name="Bash", rule_content=create_wildcard_rule(tokens[0], use_glob_style=False))
+            ToolRule(
+                tool_name="Bash", rule_content=create_wildcard_rule(tokens[0], use_glob_style=False)
+            )
         )
         # New glob-style format
         suggestions.append(
-            ToolRule(tool_name="Bash", rule_content=create_wildcard_rule(tokens[0], use_glob_style=True))
+            ToolRule(
+                tool_name="Bash", rule_content=create_wildcard_rule(tokens[0], use_glob_style=True)
+            )
         )
 
     return suggestions

ripperdoc/utils/platform.py

@@ -0,0 +1,198 @@
+"""Platform detection utilities.
+
+This module provides a unified interface for detecting the current operating system
+and platform-specific capabilities. It should be used instead of direct checks
+like `sys.platform == "win32"` or `os.name == "nt"`.
+
+Usage:
+    from ripperdoc.utils.platform import (
+        is_windows,
+        is_linux,
+        is_macos,
+        is_unix,
+        Platform,
+    )
+
+    if is_windows():
+        # Windows-specific code
+    elif is_macos():
+        # macOS-specific code
+    else:
+        # Linux or other Unix-specific code
+"""
+
+import os
+import sys
+from typing import Final, Literal
+
+
+# Platform type definitions
+PlatformType = Literal["windows", "linux", "macos", "unknown"]
+
+
+class Platform:
+    """Platform detection constants and utilities.
+
+    This class provides platform detection methods and constants that should
+    be used throughout the codebase instead of direct checks.
+    """
+
+    # Platform constants (using sys.platform for consistency)
+    WINDOWS: Final = "win32"
+    LINUX: Final = "linux"
+    MACOS: Final = "darwin"
+    FREEBSD: Final = "freebsd"
+    OPENBSD: Final = "openbsd"
+    NETBSD: Final = "netbsd"
+
+    # os.name constants
+    NAME_NT: Final = "nt"  # Windows
+    NAME_POSIX: Final = "posix"  # Unix-like systems
+
+    @staticmethod
+    def get_system() -> PlatformType:
+        """Get the current operating system name.
+
+        Returns:
+            'windows', 'linux', 'macos', or 'unknown'
+        """
+        platform = sys.platform.lower()
+
+        if platform.startswith("win"):
+            return "windows"
+        elif platform.startswith("darwin"):
+            return "macos"
+        elif platform.startswith("linux"):
+            return "linux"
+        elif platform in {"freebsd", "openbsd", "netbsd"}:
+            return "linux"  # Treat BSD as Linux for most purposes
+        else:
+            return "unknown"
+
+    @staticmethod
+    def is_windows() -> bool:
+        """Check if running on Windows."""
+        return sys.platform == Platform.WINDOWS
+
+    @staticmethod
+    def is_linux() -> bool:
+        """Check if running on Linux."""
+        return sys.platform.startswith("linux")
+
+    @staticmethod
+    def is_macos() -> bool:
+        """Check if running on macOS."""
+        return sys.platform == Platform.MACOS
+
+    @staticmethod
+    def is_bsd() -> bool:
+        """Check if running on any BSD variant."""
+        return sys.platform in {Platform.FREEBSD, Platform.OPENBSD, Platform.NETBSD}
+
+    @staticmethod
+    def is_unix() -> bool:
+        """Check if running on any Unix-like system (Linux, macOS, BSD)."""
+        return os.name == Platform.NAME_POSIX
+
+    @staticmethod
+    def is_posix() -> bool:
+        """Check if running on a POSIX-compliant system.
+
+        This is equivalent to is_unix() but uses os.name for the check.
+        """
+        return os.name == Platform.NAME_POSIX
+
+    @staticmethod
+    def get_raw_name() -> str:
+        """Get the raw sys.platform value.
+
+        Returns:
+            The raw sys.platform string (e.g., 'win32', 'linux', 'darwin').
+        """
+        return sys.platform
+
+    @staticmethod
+    def get_os_name() -> str:
+        """Get the os.name value.
+
+        Returns:
+            'nt' for Windows, 'posix' for Unix-like systems.
+        """
+        return os.name
+
+
+# Convenience functions for direct import
+def is_windows() -> bool:
+    """Check if running on Windows."""
+    return Platform.is_windows()
+
+
+def is_linux() -> bool:
+    """Check if running on Linux."""
+    return Platform.is_linux()
+
+
+def is_macos() -> bool:
+    """Check if running on macOS."""
+    return Platform.is_macos()
+
+
+def is_bsd() -> bool:
+    """Check if running on any BSD variant."""
+    return Platform.is_bsd()
+
+
+def is_unix() -> bool:
+    """Check if running on any Unix-like system (Linux, macOS, BSD)."""
+    return Platform.is_unix()
+
+
+def is_posix() -> bool:
+    """Check if running on a POSIX-compliant system."""
+    return Platform.is_posix()
+
+
+# Module-level constants for backward compatibility
+IS_WINDOWS: Final = is_windows()
+IS_LINUX: Final = is_linux()
+IS_MACOS: Final = is_macos()
+IS_BSD: Final = is_bsd()
+IS_UNIX: Final = is_unix()
+IS_POSIX: Final = is_posix()
+
+
+# Platform-specific module availability
+def has_termios() -> bool:
+    """Check if the termios module is available (Unix-like systems only)."""
+    try:
+        import termios  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def has_fcntl() -> bool:
+    """Check if the fcntl module is available (Unix-like systems only)."""
+    try:
+        import fcntl  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+def has_tty() -> bool:
+    """Check if the tty module is available (Unix-like systems only)."""
+    try:
+        import tty  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+# Module-level constants for module availability
+HAS_TERMIOS: Final = has_termios()
+HAS_FCNTL: Final = has_fcntl()
+HAS_TTY: Final = has_tty()

ripperdoc/utils/session_heatmap.py

@@ -127,9 +127,7 @@ def _get_week_grid(
     return weeks, max_count
 
 
-def render_heatmap(
-    console: Console, daily_activity: Dict[str, int], weeks_count: int = 52
-) -> None:
+def render_heatmap(console: Console, daily_activity: Dict[str, int], weeks_count: int = 52) -> None:
     """Render activity heatmap to console.
 
     Args:

ripperdoc/utils/session_history.py

@@ -6,7 +6,7 @@ import json
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.messages import (
@@ -19,7 +19,7 @@ from ripperdoc.utils.path_utils import project_storage_dir
 
 logger = get_logger()
 
-ConversationMessage = UserMessage | AssistantMessage | ProgressMessage
+ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 
 
 @dataclass

ripperdoc/utils/session_stats.py

@@ -123,6 +123,7 @@ def collect_session_stats(project_path: Path, days: int = 32) -> SessionStats:
 
     # Filter by date range (use timezone-aware cutoff if needed)
     from datetime import timezone
+
     cutoff = datetime.now(timezone.utc) - timedelta(days=days)
 
     # Ensure comparison works with both naive and aware datetimes