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

ripperdoc/core/query.py

@@ -43,7 +43,11 @@ from ripperdoc.core.query_utils import (
 from ripperdoc.core.tool import Tool, ToolProgress, ToolResult, ToolUseContext
 from ripperdoc.utils.coerce import parse_optional_int
 from ripperdoc.utils.context_length_errors import detect_context_length_error
-from ripperdoc.utils.file_watch import ChangedFileNotice, FileSnapshot, detect_changed_files
+from ripperdoc.utils.file_watch import (
+    BoundedFileCache,
+    ChangedFileNotice,
+    detect_changed_files,
+)
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.messages import (
     AssistantMessage,
@@ -131,7 +135,7 @@ async def _check_tool_permissions(
     parsed_input: Any,
     query_context: "QueryContext",
     can_use_tool_fn: Optional[ToolPermissionCallable],
-) -> tuple[bool, Optional[str]]:
+) -> tuple[bool, Optional[str], Optional[Any]]:
     """Evaluate whether a tool call is allowed."""
     try:
         if can_use_tool_fn is not None:
@@ -139,12 +143,14 @@ async def _check_tool_permissions(
             if inspect.isawaitable(decision):
                 decision = await decision
             if isinstance(decision, PermissionResult):
-                return decision.result, decision.message
+                return decision.result, decision.message, decision.updated_input
             if isinstance(decision, dict) and "result" in decision:
-                return bool(decision.get("result")), decision.get("message")
+                return bool(decision.get("result")), decision.get("message"), decision.get(
+                    "updated_input"
+                )
             if isinstance(decision, tuple) and len(decision) == 2:
-                return bool(decision[0]), decision[1]
-            return bool(decision), None
+                return bool(decision[0]), decision[1], None
+            return bool(decision), None, None
 
         if not query_context.yolo_mode and tool.needs_permissions(parsed_input):
             loop = asyncio.get_running_loop()
@@ -155,15 +161,15 @@ async def _check_tool_permissions(
             )
             prompt = f"Allow tool '{tool.name}' with input {input_preview}? [y/N]: "
             response = await loop.run_in_executor(None, lambda: input(prompt))
-            return response.strip().lower() in ("y", "yes"), None
+            return response.strip().lower() in ("y", "yes"), None, None
 
-        return True, None
+        return True, None, None
     except (TypeError, AttributeError, ValueError) as exc:
         logger.warning(
             f"Error checking permissions for tool '{tool.name}': {type(exc).__name__}: {exc}",
             extra={"tool": getattr(tool, "name", None), "error_type": type(exc).__name__},
         )
-        return False, None
+        return False, None, None
 
 
 def _format_changed_file_notice(notices: List[ChangedFileNotice]) -> str:
@@ -182,6 +188,18 @@ def _format_changed_file_notice(notices: List[ChangedFileNotice]) -> str:
     return "\n".join(lines)
 
 
+def _append_hook_context(context: Dict[str, str], label: str, payload: Optional[str]) -> None:
+    """Append hook-supplied context to the shared context dict."""
+    if not payload:
+        return
+    key = f"Hook:{label}"
+    existing = context.get(key)
+    if existing:
+        context[key] = f"{existing}\n{payload}"
+    else:
+        context[key] = payload
+
+
 async def _run_tool_use_generator(
     tool: Tool[Any, Any],
     tool_use_id: str,
@@ -189,6 +207,7 @@ async def _run_tool_use_generator(
     parsed_input: Any,
     sibling_ids: set[str],
     tool_context: ToolUseContext,
+    context: Dict[str, str],
 ) -> AsyncGenerator[Union[UserMessage, ProgressMessage], None]:
     """Execute a single tool_use and yield progress/results."""
     # Get tool input as dict for hooks
@@ -235,6 +254,9 @@ async def _run_tool_use_generator(
             f"[query] PreToolUse hook added context for {tool_name}",
             extra={"context": pre_result.additional_context[:100]},
         )
+        _append_hook_context(context, f"PreToolUse:{tool_name}", pre_result.additional_context)
+    if pre_result.system_message:
+        _append_hook_context(context, f"PreToolUse:{tool_name}:system", pre_result.system_message)
 
     tool_output = None
 
@@ -271,9 +293,18 @@ async def _run_tool_use_generator(
         yield tool_result_message(tool_use_id, f"Error executing tool: {str(exc)}", is_error=True)
 
     # Run PostToolUse hooks
-    await hook_manager.run_post_tool_use_async(
+    post_result = await hook_manager.run_post_tool_use_async(
         tool_name, tool_input_dict, tool_response=tool_output, tool_use_id=tool_use_id
     )
+    if post_result.additional_context:
+        _append_hook_context(context, f"PostToolUse:{tool_name}", post_result.additional_context)
+    if post_result.system_message:
+        _append_hook_context(
+            context, f"PostToolUse:{tool_name}:system", post_result.system_message
+        )
+    if post_result.should_block:
+        reason = post_result.block_reason or post_result.stop_reason or "Blocked by hook."
+        yield create_user_message(f"PostToolUse hook blocked: {reason}")
 
 
 def _group_tool_calls_by_concurrency(prepared_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -345,6 +376,7 @@ async def _run_concurrent_tool_uses(
     """Drain multiple tool generators concurrently and stream outputs."""
     if not generators:
         return
+        yield  # Make this a proper async generator that yields nothing
 
     queue: asyncio.Queue[Optional[Union[UserMessage, ProgressMessage]]] = asyncio.Queue()
 
@@ -528,6 +560,14 @@ def _apply_skill_context_updates(
 class QueryContext:
     """Context for a query session."""
 
+    # Thresholds for memory warnings
+    MESSAGE_COUNT_WARNING_THRESHOLD = int(
+        os.getenv("RIPPERDOC_MESSAGE_WARNING_THRESHOLD", "500")
+    )
+    MESSAGE_COUNT_CRITICAL_THRESHOLD = int(
+        os.getenv("RIPPERDOC_MESSAGE_CRITICAL_THRESHOLD", "1000")
+    )
+
     def __init__(
         self,
         tools: List[Tool[Any, Any]],
@@ -537,6 +577,9 @@ class QueryContext:
         verbose: bool = False,
         pause_ui: Optional[Callable[[], None]] = None,
         resume_ui: Optional[Callable[[], None]] = None,
+        stop_hook: str = "stop",
+        file_cache_max_entries: int = 500,
+        file_cache_max_memory_mb: float = 50.0,
     ) -> None:
         self.tool_registry = ToolRegistry(tools)
         self.max_thinking_tokens = max_thinking_tokens
@@ -544,9 +587,16 @@ class QueryContext:
         self.model = model
         self.verbose = verbose
         self.abort_controller = asyncio.Event()
-        self.file_state_cache: Dict[str, FileSnapshot] = {}
+        # Use BoundedFileCache instead of plain Dict to prevent unbounded growth
+        self.file_state_cache: BoundedFileCache = BoundedFileCache(
+            max_entries=file_cache_max_entries,
+            max_memory_mb=file_cache_max_memory_mb,
+        )
         self.pause_ui = pause_ui
         self.resume_ui = resume_ui
+        self.stop_hook = stop_hook
+        self.stop_hook_active = False
+        self._last_message_warning_count = 0
 
     @property
     def tools(self) -> List[Tool[Any, Any]]:
@@ -566,6 +616,44 @@ class QueryContext:
         """Return all known tools (active + deferred)."""
         return self.tool_registry.all_tools
 
+    def check_message_count(self, message_count: int) -> None:
+        """Check message count and log warnings if thresholds are exceeded.
+
+        This helps detect potential memory issues in long sessions.
+        """
+        if message_count >= self.MESSAGE_COUNT_CRITICAL_THRESHOLD:
+            if self._last_message_warning_count < self.MESSAGE_COUNT_CRITICAL_THRESHOLD:
+                logger.warning(
+                    "[query] Critical: Message history is very large. "
+                    "Consider compacting or starting a new session.",
+                    extra={
+                        "message_count": message_count,
+                        "threshold": self.MESSAGE_COUNT_CRITICAL_THRESHOLD,
+                        "file_cache_stats": self.file_state_cache.stats(),
+                    },
+                )
+                self._last_message_warning_count = message_count
+        elif message_count >= self.MESSAGE_COUNT_WARNING_THRESHOLD:
+            # Only warn once per threshold crossing
+            if self._last_message_warning_count < self.MESSAGE_COUNT_WARNING_THRESHOLD:
+                logger.info(
+                    "[query] Message history growing large; automatic compaction may trigger soon",
+                    extra={
+                        "message_count": message_count,
+                        "threshold": self.MESSAGE_COUNT_WARNING_THRESHOLD,
+                        "file_cache_stats": self.file_state_cache.stats(),
+                    },
+                )
+                self._last_message_warning_count = message_count
+
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """Return memory usage statistics for monitoring."""
+        return {
+            "file_cache": self.file_state_cache.stats(),
+            "tool_count": len(self.tool_registry.all_tools),
+            "active_tool_count": len(self.tool_registry.active_tools),
+        }
+
 
 async def query_llm(
     messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]],
@@ -598,7 +686,6 @@ async def query_llm(
         AssistantMessage with the model's response
     """
     request_timeout = request_timeout or DEFAULT_REQUEST_TIMEOUT_SEC
-    request_timeout = request_timeout or DEFAULT_REQUEST_TIMEOUT_SEC
     model_profile = resolve_model_profile(model)
 
     # Normalize messages based on protocol family (Anthropic allows tool blocks; OpenAI-style prefers text-only)
@@ -657,13 +744,25 @@ async def query_llm(
     start_time = time.time()
 
     try:
-        client: Optional[ProviderClient] = get_provider_client(model_profile.provider)
+        try:
+            client: Optional[ProviderClient] = get_provider_client(model_profile.provider)
+        except RuntimeError as exc:
+            duration_ms = (time.time() - start_time) * 1000
+            error_msg = create_assistant_message(
+                content=str(exc),
+                duration_ms=duration_ms,
+            )
+            error_msg.is_api_error_message = True
+            return error_msg
         if client is None:
             duration_ms = (time.time() - start_time) * 1000
+            provider_label = getattr(model_profile.provider, "value", None) or str(
+                model_profile.provider
+            )
             error_msg = create_assistant_message(
                 content=(
-                    "Gemini protocol is not supported yet in Ripperdoc. "
-                    "Please configure an Anthropic or OpenAI-compatible model."
+                    f"No provider client available for '{provider_label}'. "
+                    "Check your model configuration and provider dependencies."
                 ),
                 duration_ms=duration_ms,
             )
@@ -715,6 +814,13 @@ async def query_llm(
             cost_usd=provider_response.cost_usd,
             duration_ms=provider_response.duration_ms,
             metadata=provider_response.metadata,
+            model=model_profile.model,
+            input_tokens=provider_response.usage_tokens.get("input_tokens", 0),
+            output_tokens=provider_response.usage_tokens.get("output_tokens", 0),
+            cache_read_tokens=provider_response.usage_tokens.get("cache_read_input_tokens", 0),
+            cache_creation_tokens=provider_response.usage_tokens.get(
+                "cache_creation_input_tokens", 0
+            ),
         )
 
     except CancelledError:
@@ -830,7 +936,7 @@ async def _run_query_iteration(
     )
 
     # Stream LLM response
-    progress_queue: asyncio.Queue[Optional[ProgressMessage]] = asyncio.Queue()
+    progress_queue: asyncio.Queue[Optional[ProgressMessage]] = asyncio.Queue(maxsize=1000)
 
     async def _stream_progress(chunk: str) -> None:
         if not chunk:
@@ -883,23 +989,23 @@ async def _run_query_iteration(
             progress = progress_queue.get_nowait()
         except asyncio.QueueEmpty:
             waiter = asyncio.create_task(progress_queue.get())
-            # Use timeout to periodically check abort_controller during LLM request
+            abort_waiter = asyncio.create_task(query_context.abort_controller.wait())
             done, pending = await asyncio.wait(
-                {assistant_task, waiter},
+                {assistant_task, waiter, abort_waiter},
                 return_when=asyncio.FIRST_COMPLETED,
-                timeout=0.1,  # Check abort_controller every 100ms
             )
-            if not done:
-                # Timeout - cancel waiter and continue loop to check abort_controller
-                waiter.cancel()
-                try:
-                    await waiter
-                except asyncio.CancelledError:
-                    pass
+            for task in pending:
+                # Don't cancel assistant_task here - it should only be cancelled
+                # through abort_controller in the main loop
+                if task is not assistant_task:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+            if abort_waiter in done:
                 continue
             if assistant_task in done:
-                for task in pending:
-                    task.cancel()
                 assistant_message = await assistant_task
                 break
             progress = waiter.result()
@@ -912,7 +1018,8 @@ async def _run_query_iteration(
         if residual:
             yield residual
 
-    assert assistant_message is not None
+    if assistant_message is None:
+        raise RuntimeError("assistant_message was unexpectedly None after LLM query")
     result.assistant_message = assistant_message
 
     # Check for abort
@@ -937,6 +1044,27 @@ async def _run_query_iteration(
 
     if not tool_use_blocks:
         logger.debug("[query] No tool_use blocks; returning response to user.")
+        stop_hook = query_context.stop_hook
+        stop_result = (
+            await hook_manager.run_subagent_stop_async(
+                stop_hook_active=query_context.stop_hook_active
+            )
+            if stop_hook == "subagent"
+            else await hook_manager.run_stop_async(stop_hook_active=query_context.stop_hook_active)
+        )
+        if stop_result.additional_context:
+            _append_hook_context(context, f"{stop_hook}:context", stop_result.additional_context)
+        if stop_result.system_message:
+            _append_hook_context(context, f"{stop_hook}:system", stop_result.system_message)
+        if stop_result.should_block:
+            reason = stop_result.block_reason or stop_result.stop_reason or "Blocked by hook."
+            result.tool_results = [create_user_message(f"{stop_hook} hook blocked: {reason}")]
+            for msg in result.tool_results:
+                yield msg
+            query_context.stop_hook_active = True
+            result.should_stop = False
+            return
+        query_context.stop_hook_active = False
         result.should_stop = True
         return
 
@@ -962,7 +1090,8 @@ async def _run_query_iteration(
             tool_results.append(missing_msg)
             yield missing_msg
             continue
-        assert tool is not None
+        if tool is None:
+            raise RuntimeError(f"Tool '{tool_name}' resolved to None unexpectedly")
 
         try:
             parsed_input = tool.input_schema(**tool_input)
@@ -977,6 +1106,7 @@ async def _run_query_iteration(
                 permission_checker=can_use_tool_fn,
                 tool_registry=query_context.tool_registry,
                 file_state_cache=query_context.file_state_cache,
+                conversation_messages=messages,
                 abort_signal=query_context.abort_controller,
                 pause_ui=query_context.pause_ui,
                 resume_ui=query_context.resume_ui,
@@ -997,7 +1127,7 @@ async def _run_query_iteration(
                 continue
 
             if not query_context.yolo_mode or can_use_tool_fn is not None:
-                allowed, denial_message = await _check_tool_permissions(
+                allowed, denial_message, updated_input = await _check_tool_permissions(
                     tool, parsed_input, query_context, can_use_tool_fn
                 )
                 if not allowed:
@@ -1010,6 +1140,29 @@ async def _run_query_iteration(
                     yield denial_msg
                     permission_denied = True
                     break
+                if updated_input:
+                    try:
+                        parsed_input = tool.input_schema(**updated_input)
+                    except ValidationError as ve:
+                        detail_text = format_pydantic_errors(ve)
+                        error_msg = tool_result_message(
+                            tool_use_id,
+                            f"Invalid permission-updated input for tool '{tool_name}': {detail_text}",
+                            is_error=True,
+                        )
+                        tool_results.append(error_msg)
+                        yield error_msg
+                        continue
+                    validation = await tool.validate_input(parsed_input, tool_context)
+                    if not validation.result:
+                        error_msg = tool_result_message(
+                            tool_use_id,
+                            validation.message or "Tool input validation failed.",
+                            is_error=True,
+                        )
+                        tool_results.append(error_msg)
+                        yield error_msg
+                        continue
 
             prepared_calls.append(
                 {
@@ -1021,6 +1174,7 @@ async def _run_query_iteration(
                         parsed_input,
                         sibling_ids,
                         tool_context,
+                        context,
                     ),
                 }
             )
@@ -1122,6 +1276,9 @@ async def query(
     # do not interfere with the loop or normalization.
     messages = list(messages)
 
+    # Check initial message count for memory warnings
+    query_context.check_message_count(len(messages))
+
     for iteration in range(1, MAX_QUERY_ITERATIONS + 1):
         result = IterationResult()
 
@@ -1144,6 +1301,10 @@ async def query(
             messages = messages + [result.assistant_message] + result.tool_results  # type: ignore[operator]
         else:
             messages = messages + result.tool_results  # type: ignore[operator]
+
+        # Check message count after each iteration for memory warnings
+        query_context.check_message_count(len(messages))
+
         logger.debug(
             f"[query] Continuing loop with {len(messages)} messages after tools; "
             f"tool_results_count={len(result.tool_results)}"

ripperdoc/core/tool.py

@@ -8,7 +8,7 @@ import json
 from abc import ABC, abstractmethod
 from typing import Annotated, Any, AsyncGenerator, Dict, List, Optional, TypeVar, Generic, Union
 from pydantic import BaseModel, ConfigDict, Field, SkipValidation
-from ripperdoc.utils.file_watch import FileSnapshot
+from ripperdoc.utils.file_watch import FileCacheType
 from ripperdoc.utils.log import get_logger
 
 
@@ -41,11 +41,16 @@ class ToolUseContext(BaseModel):
     verbose: bool = False
     permission_checker: Optional[Any] = None
     read_file_timestamps: Dict[str, float] = Field(default_factory=dict)
-    # SkipValidation prevents Pydantic from copying the dict during validation,
-    # ensuring Read and Edit tools share the same cache instance
-    file_state_cache: Annotated[Dict[str, FileSnapshot], SkipValidation] = Field(
+    # SkipValidation prevents Pydantic from copying the cache during validation,
+    # ensuring Read and Edit tools share the same cache instance.
+    # FileCacheType supports both Dict[str, FileSnapshot] and BoundedFileCache.
+    file_state_cache: Annotated[FileCacheType, SkipValidation] = Field(
         default_factory=dict
     )
+    conversation_messages: Annotated[Optional[List[Any]], SkipValidation] = Field(
+        default=None,
+        description="Full conversation history for tools that need parent context.",
+    )
     tool_registry: Optional[Any] = None
     abort_signal: Optional[Any] = None
     # UI control callbacks for tools that need user interaction

ripperdoc/sdk/client.py

@@ -8,6 +8,8 @@ from __future__ import annotations
 
 import asyncio
 import os
+import time
+import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import (
@@ -24,6 +26,8 @@ from typing import (
 )
 
 from ripperdoc.core.default_tools import get_default_tools
+from ripperdoc.core.hooks.llm_callback import build_hook_llm_callback
+from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.query import QueryContext, query as _core_query
 from ripperdoc.core.permissions import PermissionResult
 from ripperdoc.core.system_prompt import build_system_prompt
@@ -36,6 +40,7 @@ from ripperdoc.utils.messages import (
     AssistantMessage,
     ProgressMessage,
     UserMessage,
+    create_assistant_message,
     create_user_message,
 )
 from ripperdoc.utils.mcp import (
@@ -159,6 +164,10 @@ class RipperdocClient:
         self._current_context: Optional[QueryContext] = None
         self._connected = False
         self._previous_cwd: Optional[Path] = None
+        self._session_hook_contexts: List[str] = []
+        self._session_id: Optional[str] = None
+        self._session_start_time: Optional[float] = None
+        self._session_end_sent: bool = False
 
     @property
     def tools(self) -> List[Tool[Any, Any]]:
@@ -182,6 +191,22 @@ class RipperdocClient:
                 self._previous_cwd = Path.cwd()
                 os.chdir(_coerce_to_path(self.options.cwd))
             self._connected = True
+            project_path = _coerce_to_path(self.options.cwd or Path.cwd())
+            hook_manager.set_project_dir(project_path)
+            self._session_id = self._session_id or str(uuid.uuid4())
+            hook_manager.set_session_id(self._session_id)
+            hook_manager.set_llm_callback(build_hook_llm_callback())
+            try:
+                result = await hook_manager.run_session_start_async("startup")
+                self._session_hook_contexts = self._collect_hook_contexts(result)
+                self._session_start_time = time.time()
+                self._session_end_sent = False
+            except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+                logger.warning(
+                    "[sdk] SessionStart hook failed: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                )
 
         if prompt:
             await self.query(prompt)
@@ -203,6 +228,25 @@ class RipperdocClient:
             self._previous_cwd = None
 
         self._connected = False
+        if not self._session_end_sent:
+            duration = (
+                max(time.time() - self._session_start_time, 0.0)
+                if self._session_start_time is not None
+                else None
+            )
+            try:
+                await hook_manager.run_session_end_async(
+                    "other",
+                    duration_seconds=duration,
+                    message_count=len(self._history),
+                )
+            except (OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+                logger.warning(
+                    "[sdk] SessionEnd hook failed: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                )
+            self._session_end_sent = True
         await shutdown_mcp_runtime()
 
     async def query(self, prompt: str) -> None:
@@ -217,11 +261,26 @@ class RipperdocClient:
 
         self._queue = asyncio.Queue()
 
+        hook_result = await hook_manager.run_user_prompt_submit_async(prompt)
+        if hook_result.should_block or not hook_result.should_continue:
+            reason = (
+                hook_result.block_reason
+                or hook_result.stop_reason
+                or "Prompt blocked by hook."
+            )
+            blocked_message = create_assistant_message(str(reason))
+            self._history.append(blocked_message)
+            await self._queue.put(blocked_message)
+            await self._queue.put(_END_OF_STREAM)
+            self._current_task = asyncio.create_task(asyncio.sleep(0))
+            return
+        hook_instructions = self._collect_hook_contexts(hook_result)
+
         user_message = create_user_message(prompt)
         history = list(self._history) + [user_message]
         self._history.append(user_message)
 
-        system_prompt = await self._build_system_prompt(prompt)
+        system_prompt = await self._build_system_prompt(prompt, hook_instructions)
         context = dict(self.options.context)
 
         query_context = QueryContext(
@@ -280,7 +339,9 @@ class RipperdocClient:
 
         await self._queue.put(_END_OF_STREAM)
 
-    async def _build_system_prompt(self, user_prompt: str) -> str:
+    async def _build_system_prompt(
+        self, user_prompt: str, hook_instructions: Optional[List[str]] = None
+    ) -> str:
         if self.options.system_prompt:
             return self.options.system_prompt
 
@@ -299,6 +360,10 @@ class RipperdocClient:
         memory = build_memory_instructions()
         if memory:
             instructions.append(memory)
+        if self._session_hook_contexts:
+            instructions.extend(self._session_hook_contexts)
+        if hook_instructions:
+            instructions.extend([text for text in hook_instructions if text])
 
         dynamic_tools = await load_dynamic_mcp_tools_async(project_path)
         if dynamic_tools:
@@ -315,6 +380,16 @@ class RipperdocClient:
             mcp_instructions=mcp_instructions,
         )
 
+    def _collect_hook_contexts(self, hook_result: Any) -> List[str]:
+        contexts: List[str] = []
+        system_message = getattr(hook_result, "system_message", None)
+        additional_context = getattr(hook_result, "additional_context", None)
+        if system_message:
+            contexts.append(str(system_message))
+        if additional_context:
+            contexts.append(str(additional_context))
+        return contexts
+
 
 async def query(
     prompt: str,