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

ripperdoc/tools/task_tool.py

@@ -7,7 +7,7 @@ import os
 import threading
 import time
 from dataclasses import dataclass
-from typing import Any, AsyncGenerator, Callable, Dict, Iterable, List, Optional, Sequence
+from typing import Any, AsyncGenerator, Callable, Dict, Iterable, List, Optional, Sequence, Union
 from uuid import uuid4
 
 from pydantic import BaseModel, Field
@@ -39,7 +39,7 @@ from ripperdoc.utils.log import get_logger
 logger = get_logger()
 
 
-MessageType = UserMessage | AssistantMessage
+MessageType = Union[UserMessage, AssistantMessage]
 
 
 @dataclass
@@ -152,6 +152,7 @@ async def cancel_agent_run(agent_id: str) -> bool:
     record.task = None
     return True
 
+
 class TaskToolInput(BaseModel):
     """Input schema for delegating to a subagent."""
 
@@ -264,7 +265,7 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
             f"- Fetch background results by calling {background_fetch_tool_name} with resume=<agent_id>. If the agent is still running, set wait=true to block or wait=false to get status only.\n"
             "- To continue a completed agent, call Task with resume=<agent_id> and a new prompt.\n"
             "- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.\n"
-            '- Agents can opt into parent context by setting fork_context: true in their frontmatter. When enabled, they receive the full conversation history before the tool call.\n'
+            "- Agents can opt into parent context by setting fork_context: true in their frontmatter. When enabled, they receive the full conversation history before the tool call.\n"
             "- The agent's outputs should generally be trusted\n"
             "- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n"
             "- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.\n"
@@ -439,6 +440,9 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
 
             yield ToolProgress(content=f"Resuming subagent '{record.agent_type}'")
 
+            # Get the Task tool's tool_use_id to set as parent_tool_use_id for subagent messages
+            parent_tool_use_id = context.message_id
+
             assistant_messages: List[AssistantMessage] = []
             tool_use_count = 0
             async for message in query(
@@ -448,8 +452,11 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
                 subagent_context,
                 context.permission_checker,
             ):
-                if getattr(message, "type", "") == "progress":
+                msg_type = getattr(message, "type", "")
+                if msg_type == "progress":
                     continue
+
+                # Track the message for internal state
                 tool_use_count, updates = self._track_subagent_message(
                     message,
                     record.history,
@@ -459,6 +466,12 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
                 for update in updates:
                     yield ToolProgress(content=update)
 
+                # CRITICAL: Also yield subagent messages to SDK for compatibility
+                if msg_type in ("assistant", "user"):
+                    # Set parent_tool_use_id to link subagent messages to the Task tool call
+                    message_with_parent = message.model_copy(update={"parent_tool_use_id": parent_tool_use_id})
+                    yield ToolProgress(content=message_with_parent, is_subagent_message=True)
+
             duration_ms = (time.time() - record.start_time) * 1000
             result_text = (
                 self._extract_text(assistant_messages[-1])
@@ -563,6 +576,9 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
 
         yield ToolProgress(content=f"Launching subagent '{target_agent.agent_type}'")
 
+        # Get the Task tool's tool_use_id to set as parent_tool_use_id for subagent messages
+        parent_tool_use_id = context.message_id
+
         assistant_messages = []
         tool_use_count = 0
         async for message in query(
@@ -572,8 +588,11 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
             subagent_context,
             context.permission_checker,
         ):
-            if getattr(message, "type", "") == "progress":
+            msg_type = getattr(message, "type", "")
+            if msg_type == "progress":
                 continue
+
+            # Track the message for internal state
             tool_use_count, updates = self._track_subagent_message(
                 message,
                 record.history,
@@ -583,6 +602,14 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
             for update in updates:
                 yield ToolProgress(content=update)
 
+            # CRITICAL: Also yield subagent messages to SDK for compatibility
+            # This allows SDK clients to see the full subagent conversation
+            if msg_type in ("assistant", "user"):
+                # Set parent_tool_use_id to link subagent messages to the Task tool call
+                # Use model_copy() to create a new message with the parent_tool_use_id set
+                message_with_parent = message.model_copy(update={"parent_tool_use_id": parent_tool_use_id})
+                yield ToolProgress(content=message_with_parent, is_subagent_message=True)
+
         duration_ms = (time.time() - record.start_time) * 1000
         result_text = (
             self._extract_text(assistant_messages[-1])
@@ -634,9 +661,7 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
             error=error_override or record.error,
         )
 
-    def _coerce_parent_history(
-        self, messages: Optional[Sequence[object]]
-    ) -> List[MessageType]:
+    def _coerce_parent_history(self, messages: Optional[Sequence[object]]) -> List[MessageType]:
         if not messages:
             return []
         history: List[MessageType] = []

ripperdoc/utils/file_watch.py

@@ -8,7 +8,7 @@ import sys
 import threading
 from collections import OrderedDict
 from dataclasses import dataclass
-from typing import Dict, Iterator, List, Optional, Tuple
+from typing import Dict, Iterator, List, Optional, Tuple, Union
 
 from ripperdoc.utils.log import get_logger
 
@@ -27,6 +27,7 @@ class FileSnapshot:
     timestamp: float
     offset: int = 0
     limit: Optional[int] = None
+    encoding: str = "utf-8"
 
     def memory_size(self) -> int:
         """Estimate memory usage of this snapshot in bytes."""
@@ -230,7 +231,7 @@ class ChangedFileNotice:
 
 
 # Type alias for cache - supports both Dict and BoundedFileCache
-FileCacheType = Dict[str, FileSnapshot] | BoundedFileCache
+FileCacheType = Union[Dict[str, FileSnapshot], BoundedFileCache]
 
 
 def record_snapshot(
@@ -240,6 +241,7 @@ def record_snapshot(
     *,
     offset: int = 0,
     limit: Optional[int] = None,
+    encoding: str = "utf-8",
 ) -> None:
     """Store the current contents and mtime for a file."""
     try:
@@ -247,12 +249,14 @@ def record_snapshot(
     except OSError:
         timestamp = 0.0
     cache[file_path] = FileSnapshot(
-        content=content, timestamp=timestamp, offset=offset, limit=limit
+        content=content, timestamp=timestamp, offset=offset, limit=limit, encoding=encoding
     )
 
 
-def _read_portion(file_path: str, offset: int, limit: Optional[int]) -> str:
-    with open(file_path, "r", encoding="utf-8", errors="replace") as handle:
+def _read_portion(
+    file_path: str, offset: int, limit: Optional[int], encoding: str = "utf-8"
+) -> str:
+    with open(file_path, "r", encoding=encoding, errors="replace") as handle:
         lines = handle.readlines()
     start = max(offset, 0)
     if limit is None:
@@ -304,7 +308,9 @@ def detect_changed_files(
             continue
 
         try:
-            new_content = _read_portion(file_path, snapshot.offset, snapshot.limit)
+            new_content = _read_portion(
+                file_path, snapshot.offset, snapshot.limit, snapshot.encoding
+            )
         except (
             OSError,
             IOError,

ripperdoc/utils/image_utils.py

@@ -0,0 +1,125 @@
+"""Image processing utilities for Ripperdoc."""
+
+import base64
+import mimetypes
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+# Supported image formats
+SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"}
+SUPPORTED_IMAGE_MIME_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp", "image/bmp"}
+
+MAX_IMAGE_SIZE_BYTES = 32 * 1024 * 1024  # 32MB
+
+
+def is_image_file(file_path: Path) -> bool:
+    """Check if a file is a supported image format.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        True if the file has a supported image extension
+    """
+    return file_path.suffix.lower() in SUPPORTED_IMAGE_EXTENSIONS
+
+
+def detect_mime_type(file_path: Path) -> str:
+    """Detect the MIME type of an image file.
+
+    Args:
+        file_path: Path to the image file
+
+    Returns:
+        MIME type string (e.g., "image/jpeg", "image/png")
+    """
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type in SUPPORTED_IMAGE_MIME_TYPES:
+        return mime_type
+
+    # Fallback to extension-based detection
+    ext = file_path.suffix.lower()
+    if ext in {".jpg", ".jpeg"}:
+        return "image/jpeg"
+    if ext == ".png":
+        return "image/png"
+    if ext == ".gif":
+        return "image/gif"
+    if ext == ".webp":
+        return "image/webp"
+    if ext == ".bmp":
+        return "image/bmp"
+    return "image/jpeg"  # Default fallback
+
+
+def read_image_as_base64(file_path: Path) -> Optional[Tuple[str, str]]:
+    """Read an image file and return its base64-encoded data and MIME type.
+
+    Args:
+        file_path: Absolute path to the image file
+
+    Returns:
+        (base64_data, mime_type) tuple or None if reading fails
+    """
+    if not file_path.exists():
+        logger.warning(
+            "[image_utils] Image file not found",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    if not file_path.is_file():
+        logger.warning(
+            "[image_utils] Not a file",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    # Check file size
+    file_size = file_path.stat().st_size
+    if file_size > MAX_IMAGE_SIZE_BYTES:
+        logger.warning(
+            "[image_utils] Image too large",
+            extra={
+                "path": str(file_path),
+                "size_bytes": file_size,
+                "max_bytes": MAX_IMAGE_SIZE_BYTES,
+            },
+        )
+        return None
+
+    if not is_image_file(file_path):
+        logger.warning(
+            "[image_utils] Not a supported image format",
+            extra={"path": str(file_path)},
+        )
+        return None
+
+    try:
+        with open(file_path, "rb") as f:
+            image_bytes = f.read()
+
+        base64_data = base64.b64encode(image_bytes).decode("utf-8")
+        mime_type = detect_mime_type(file_path)
+
+        logger.debug(
+            "[image_utils] Loaded image",
+            extra={
+                "path": str(file_path),
+                "size_bytes": len(image_bytes),
+                "mime_type": mime_type,
+            },
+        )
+
+        return (base64_data, mime_type)
+
+    except (OSError, IOError) as e:
+        logger.error(
+            "[image_utils] Failed to read image",
+            extra={"path": str(file_path), "error": str(e)},
+        )
+        return None

ripperdoc/utils/log.py

@@ -4,13 +4,40 @@ import json
 import logging
 import sys
 import os
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
 from ripperdoc.utils.path_utils import sanitize_project_path
 
 
+class SpinnerSafeStreamHandler(logging.StreamHandler):
+    """StreamHandler that clears the current line before ERROR/WARNING messages.
+
+    This prevents log messages from appearing after a spinner's text,
+    which would cause formatting issues.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Emit a log record, clearing the line first for ERROR/WARNING."""
+        try:
+            msg = self.format(record)
+            stream = self.stream
+
+            # Clear the current line before ERROR/WARNING to avoid spinner interference
+            if record.levelno >= logging.ERROR:
+                # Use \r to return to start, then clear with spaces, then \r again
+                stream.write("\r" + " " * 100 + "\r")
+            elif record.levelno >= logging.WARNING:
+                # Also clear for WARNING
+                stream.write("\r" + " " * 100 + "\r")
+
+            stream.write(msg + self.terminator)
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+
 _LOG_RECORD_FIELDS = {
     "name",
     "msg",
@@ -42,7 +69,7 @@ class StructuredFormatter(logging.Formatter):
     """Formatter with ISO timestamps and context."""
 
     def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
-        timestamp = datetime.utcfromtimestamp(record.created)
+        timestamp = datetime.fromtimestamp(record.created, tz=timezone.utc)
         return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
 
     def format(self, record: logging.LogRecord) -> str:
@@ -74,7 +101,7 @@ class RipperdocLogger:
 
         # Avoid adding duplicate handlers if an existing logger is reused.
         if not self.logger.handlers:
-            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler = SpinnerSafeStreamHandler(sys.stderr)
             console_handler.setLevel(level)
             console_formatter = logging.Formatter("%(levelname)s: %(message)s")
             console_handler.setFormatter(console_formatter)

ripperdoc/utils/lsp.py

@@ -15,6 +15,7 @@ from urllib.parse import unquote, urlparse
 
 from ripperdoc.utils.git_utils import get_git_root, is_git_repository
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.platform import is_windows
 
 
 logger = get_logger()
@@ -102,7 +103,7 @@ def uri_to_path(uri: str) -> Optional[Path]:
     if parsed.scheme and parsed.scheme != "file":
         return None
     path = unquote(parsed.path)
-    if os.name == "nt" and re.match(r"^/[A-Za-z]:", path):
+    if is_windows() and re.match(r"^/[A-Za-z]:", path):
         path = path[1:]
     return Path(path)
 
@@ -227,7 +228,9 @@ def _parse_server_config(name: str, raw: Dict[str, Any]) -> Optional[LspServerCo
     env = {str(k): str(v) for k, v in env.items()} if env else {}
 
     initialization_options = (
-        raw.get("initializationOptions") if isinstance(raw.get("initializationOptions"), dict) else {}
+        raw.get("initializationOptions")
+        if isinstance(raw.get("initializationOptions"), dict)
+        else {}
     )
     settings = raw.get("settings") if isinstance(raw.get("settings"), dict) else {}
 
@@ -432,7 +435,10 @@ class LspServer:
                     break
                 logger.debug(
                     "[lsp] stderr",
-                    extra={"server": self.config.name, "line": line.decode(errors="replace").strip()},
+                    extra={
+                        "server": self.config.name,
+                        "line": line.decode(errors="replace").strip(),
+                    },
                 )
         except (asyncio.CancelledError, RuntimeError):
             return

ripperdoc/utils/mcp.py

@@ -17,12 +17,13 @@ from ripperdoc.utils.token_estimation import estimate_tokens
 
 logger = get_logger()
 
+
 try:
     import mcp.types as mcp_types  # type: ignore[import-not-found]
     from mcp.client.session import ClientSession  # type: ignore[import-not-found]
     from mcp.client.sse import sse_client  # type: ignore[import-not-found]
     from mcp.client.stdio import StdioServerParameters, stdio_client  # type: ignore[import-not-found]
-    from mcp.client.streamable_http import streamablehttp_client  # type: ignore[import-not-found]
+    from mcp.client.streamable_http import streamable_http_client  # type: ignore[import-not-found]
 
     MCP_AVAILABLE = True
 except (ImportError, ModuleNotFoundError):  # pragma: no cover - handled gracefully at runtime
@@ -217,6 +218,14 @@ class McpRuntime:
         self.sessions: Dict[str, ClientSession] = {}
         self.servers: List[McpServerInfo] = []
         self._closed = False
+        # Track MCP streams for proper cleanup ordering
+        # We need to close write streams BEFORE exiting the stdio_client context
+        # to allow the internal tasks to exit cleanly
+        self._mcp_write_streams: List[Any] = []
+        # Track the underlying async generators from @asynccontextmanager wrappers
+        # These need to be explicitly closed after exit stack cleanup to prevent
+        # shutdown_asyncgens() from trying to close them in a different task
+        self._raw_async_generators: List[Any] = []
 
     async def connect(self, configs: Dict[str, McpServerInfo]) -> List[McpServerInfo]:
         logger.info(
@@ -281,19 +290,24 @@ class McpRuntime:
             if config.type in ("sse", "sse-ide"):
                 if not config.url:
                     raise ValueError("SSE MCP server requires a 'url'.")
-                read_stream, write_stream = await self._exit_stack.enter_async_context(
-                    sse_client(config.url, headers=config.headers or None)
-                )
+                cm = sse_client(config.url, headers=config.headers or None)
+                # Track the underlying async generator for explicit cleanup
+                if hasattr(cm, "gen"):
+                    self._raw_async_generators.append(cm.gen)
+                read_stream, write_stream = await self._exit_stack.enter_async_context(cm)
+                self._mcp_write_streams.append(write_stream)
             elif config.type in ("http", "streamable-http"):
                 if not config.url:
                     raise ValueError("HTTP MCP server requires a 'url'.")
-                read_stream, write_stream, _ = await self._exit_stack.enter_async_context(
-                    streamablehttp_client(
-                        url=config.url,
-                        headers=config.headers or None,
-                        terminate_on_close=True,
-                    )
+                cm = streamable_http_client(  # type: ignore[call-arg]
+                    url=config.url,
+                    terminate_on_close=True,
                 )
+                # Track the underlying async generator for explicit cleanup
+                if hasattr(cm, "gen"):
+                    self._raw_async_generators.append(cm.gen)
+                read_stream, write_stream, _ = await self._exit_stack.enter_async_context(cm)
+                self._mcp_write_streams.append(write_stream)
             else:
                 if not config.command:
                     raise ValueError("Stdio MCP server requires a 'command'.")
@@ -303,9 +317,12 @@ class McpRuntime:
                     env=config.env or None,
                     cwd=self.project_path,
                 )
-                read_stream, write_stream = await self._exit_stack.enter_async_context(
-                    stdio_client(stdio_params)
-                )
+                cm = stdio_client(stdio_params)
+                # Track the underlying async generator for explicit cleanup
+                if hasattr(cm, "gen"):
+                    self._raw_async_generators.append(cm.gen)
+                read_stream, write_stream = await self._exit_stack.enter_async_context(cm)
+                self._mcp_write_streams.append(write_stream)
 
             if read_stream is None or write_stream is None:
                 raise ValueError("Failed to create read/write streams for MCP server")
@@ -392,17 +409,39 @@ class McpRuntime:
             "[mcp] Shutting down MCP runtime",
             extra={"project_path": str(self.project_path), "session_count": len(self.sessions)},
         )
+
+        # CRITICAL: Close all MCP write streams FIRST to signal internal tasks to stop.
+        for write_stream in self._mcp_write_streams:
+            try:
+                await write_stream.aclose()
+            except BaseException:  # pragma: no cover
+                pass
+        self._mcp_write_streams.clear()
+
+        # Small delay to allow internal tasks to notice stream closure and exit
+        await asyncio.sleep(0.1)
+
+        # CRITICAL: Close the raw async generators BEFORE the exit stack cleanup.
+        # This prevents asyncio's shutdown_asyncgens() from trying to close them
+        # later, which would cause the "cancel scope in different task" error.
+        for gen in self._raw_async_generators:
+            try:
+                await gen.aclose()
+            except BaseException:  # pragma: no cover
+                pass
+        self._raw_async_generators.clear()
+
+        # Now close the exit stack
         try:
             await self._exit_stack.aclose()
         except BaseException as exc:  # pragma: no cover - defensive shutdown
-            # Swallow noisy ExceptionGroups from stdio_client cancel scopes during exit.
             logger.debug(
-                "[mcp] Suppressed MCP shutdown error",
+                "[mcp] Suppressed MCP shutdown error during exit_stack.aclose()",
                 extra={"error": str(exc), "project_path": str(self.project_path)},
             )
-        finally:
-            self.sessions.clear()
-            self.servers.clear()
+
+        self.sessions.clear()
+        self.servers.clear()
 
 
 _runtime_var: contextvars.ContextVar[Optional[McpRuntime]] = contextvars.ContextVar(
@@ -453,6 +492,29 @@ async def ensure_mcp_runtime(project_path: Optional[Path] = None) -> McpRuntime:
     # Keep a module-level reference so sync callers that hop event loops can reuse it.
     global _global_runtime
     _global_runtime = runtime
+
+    # Install custom exception handler to suppress MCP asyncgen cleanup errors.
+    # These errors occur due to anyio cancel scope issues when stdio_client async
+    # generators are finalized by Python's asyncgen hooks. The errors are harmless
+    # but noisy, so we suppress them here.
+    loop = asyncio.get_running_loop()
+    original_handler = loop.get_exception_handler()
+
+    def mcp_exception_handler(loop: asyncio.AbstractEventLoop, context: Dict[str, Any]) -> None:
+        asyncgen = context.get("asyncgen")
+        # Suppress MCP stdio_client asyncgen cleanup errors
+        if asyncgen and "stdio_client" in str(asyncgen):
+            logger.debug("[mcp] Suppressed asyncgen cleanup error for stdio_client")
+            return
+        # Call original handler for other errors
+        if original_handler:
+            original_handler(loop, context)
+        else:
+            loop.default_exception_handler(context)
+
+    loop.set_exception_handler(mcp_exception_handler)
+    logger.debug("[mcp] Installed custom exception handler for asyncgen cleanup")
+
     return runtime
 
 

ripperdoc/utils/message_formatting.py

@@ -151,10 +151,10 @@ def format_reasoning_preview(reasoning: Any, show_full_thinking: bool = False) -
         text = "\n".join(p for p in parts if p)
     else:
         text = str(reasoning)
-    
+
     if show_full_thinking:
         return text
-    
+
     lines = text.strip().splitlines()
     if not lines:
         return ""