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

ripperdoc/core/query.py

@@ -29,6 +29,7 @@ from pydantic import ValidationError
 from ripperdoc.core.config import provider_protocol
 from ripperdoc.core.providers import ProviderClient, get_provider_client
 from ripperdoc.core.permissions import PermissionResult
+from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.query_utils import (
     build_full_system_prompt,
     determine_tool_mode,
@@ -154,6 +155,52 @@ async def _run_tool_use_generator(
     tool_context: ToolUseContext,
 ) -> AsyncGenerator[Union[UserMessage, ProgressMessage], None]:
     """Execute a single tool_use and yield progress/results."""
+    # Get tool input as dict for hooks
+    tool_input_dict = (
+        parsed_input.model_dump()
+        if hasattr(parsed_input, "model_dump")
+        else dict(parsed_input) if isinstance(parsed_input, dict) else {}
+    )
+
+    # Run PreToolUse hooks
+    pre_result = await hook_manager.run_pre_tool_use_async(
+        tool_name, tool_input_dict, tool_use_id=tool_use_id
+    )
+    if pre_result.should_block:
+        block_reason = pre_result.block_reason or f"Blocked by hook: {tool_name}"
+        logger.info(
+            f"[query] Tool {tool_name} blocked by PreToolUse hook",
+            extra={"tool_use_id": tool_use_id, "reason": block_reason},
+        )
+        yield tool_result_message(tool_use_id, f"Hook blocked: {block_reason}", is_error=True)
+        return
+
+    # Handle updated input from hooks
+    if pre_result.updated_input:
+        logger.debug(
+            f"[query] PreToolUse hook modified input for {tool_name}",
+            extra={"tool_use_id": tool_use_id},
+        )
+        # Re-parse the input with the updated values
+        try:
+            parsed_input = tool.input_schema(**pre_result.updated_input)
+            tool_input_dict = pre_result.updated_input
+        except (ValueError, TypeError) as exc:
+            logger.warning(
+                f"[query] Failed to apply updated input from hook: {exc}",
+                extra={"tool_use_id": tool_use_id},
+            )
+
+    # Add hook context if provided
+    if pre_result.additional_context:
+        logger.debug(
+            f"[query] PreToolUse hook added context for {tool_name}",
+            extra={"context": pre_result.additional_context[:100]},
+        )
+
+    tool_output = None
+    tool_error = None
+
     try:
         async for output in tool.call(parsed_input, tool_context):
             if isinstance(output, ToolProgress):
@@ -164,6 +211,7 @@ async def _run_tool_use_generator(
                 )
                 logger.debug(f"[query] Progress from tool_use_id={tool_use_id}: {output.content}")
             elif isinstance(output, ToolResult):
+                tool_output = output.data
                 result_content = output.result_for_assistant or str(output.data)
                 result_msg = tool_result_message(
                     tool_use_id, result_content, tool_use_result=output.data
@@ -176,6 +224,7 @@ async def _run_tool_use_generator(
     except CancelledError:
         raise  # Don't suppress task cancellation
     except (RuntimeError, ValueError, TypeError, OSError, IOError, AttributeError, KeyError) as exc:
+        tool_error = str(exc)
         logger.warning(
             "Error executing tool '%s': %s: %s",
             tool_name, type(exc).__name__, exc,
@@ -183,6 +232,11 @@ 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(
+        tool_name, tool_input_dict, tool_response=tool_output, tool_use_id=tool_use_id
+    )
+
 
 def _group_tool_calls_by_concurrency(prepared_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group consecutive tool calls by their concurrency safety."""
@@ -624,12 +678,12 @@ async def query_llm(
         )
         duration_ms = (time.time() - start_time) * 1000
         context_error = detect_context_length_error(e)
-        metadata = None
+        error_metadata: Optional[Dict[str, Any]] = None
         content = f"Error querying AI model: {str(e)}"
 
         if context_error:
             content = f"The request exceeded the model's context window. {context_error.message}"
-            metadata = {
+            error_metadata = {
                 "context_length_exceeded": True,
                 "context_length_provider": context_error.provider,
                 "context_length_error_code": context_error.error_code,
@@ -645,7 +699,7 @@ async def query_llm(
             )
 
         error_msg = create_assistant_message(
-            content=content, duration_ms=duration_ms, metadata=metadata
+            content=content, duration_ms=duration_ms, metadata=error_metadata
         )
         error_msg.is_api_error_message = True
         return error_msg
@@ -1042,7 +1096,10 @@ async def query(
             return
 
         # Update messages for next iteration
-        messages = messages + [result.assistant_message] + result.tool_results
+        if result.assistant_message is not None:
+            messages = messages + [result.assistant_message] + result.tool_results  # type: ignore[operator]
+        else:
+            messages = messages + result.tool_results  # type: ignore[operator]
         logger.debug(
             f"[query] Continuing loop with {len(messages)} messages after tools; "
             f"tool_results_count={len(result.tool_results)}"

ripperdoc/core/query_utils.py

@@ -276,7 +276,7 @@ def _tool_prompt_for_text_mode(tools: List[Tool[Any, Any]]) -> str:
         {
             "type": "tool_use",
             "tool_use_id": "tool_id_000001",
-            "tool": "View",
+            "tool": "Read",
             "input": {"file_path": "README.md"},
         },
     ]

ripperdoc/core/tool.py

@@ -42,7 +42,7 @@ class ToolUseContext(BaseModel):
     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 View/Read and Edit tools share the same cache instance
+    # ensuring Read and Edit tools share the same cache instance
     file_state_cache: Annotated[Dict[str, FileSnapshot], SkipValidation] = Field(default_factory=dict)
     tool_registry: Optional[Any] = None
     abort_signal: Optional[Any] = None

ripperdoc/tools/bash_tool.py

@@ -270,7 +270,7 @@ build projects, run tests, and interact with the file system."""
               - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
               - If the output exceeds {MAX_OUTPUT_CHARS} characters, output will be truncated before being returned to you.
               - You can use the `run_in_background` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the BashOutput tool as it becomes available. Never use `run_in_background` to run 'sleep' as it will return immediately. You do not need to use '&' at the end of the command when using this parameter.
-              - VERY IMPORTANT: You MUST avoid using search commands like `find` and `grep`. Instead use the Grep, Glob, or Task tools to search. Prefer the View and LS tools instead of shell commands like `cat`, `head`, `tail`, or `ls` when reading files and directories.
+              - VERY IMPORTANT: You MUST avoid using search commands like `find` and `grep`. Instead use the Grep, Glob, or Task tools to search. Prefer the Read and LS tools instead of shell commands like `cat`, `head`, `tail`, or `ls` when reading files and directories.
               - When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings).
               - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the user explicitly requests it.
                 <good-example>
@@ -652,7 +652,7 @@ build projects, run tests, and interact with the file system."""
             # Emit progress updates for newly received output chunks
             while not queue.empty():
                 label, text = queue.get_nowait()
-                yield ToolProgress(content=f"{label}: {text}")
+                yield ToolProgress(content=f"{label}: {text}")  # type: ignore[misc]
 
             # Report progress at intervals
             if now - last_progress_time >= PROGRESS_INTERVAL_SECONDS:
@@ -660,7 +660,7 @@ build projects, run tests, and interact with the file system."""
                 if combined_output:
                     preview = get_last_n_lines(combined_output, 5)
                     elapsed = format_duration((now - start_time) * 1000)
-                    yield ToolProgress(content=f"Running... ({elapsed})\n{preview}")
+                    yield ToolProgress(content=f"Running... ({elapsed})\n{preview}")  # type: ignore[misc]
                 last_progress_time = now
 
             # Check timeout
@@ -907,14 +907,14 @@ build projects, run tests, and interact with the file system."""
 
                 while not queue.empty():
                     label, text = queue.get_nowait()
-                    yield ToolProgress(content=f"{label}: {text}")
+                    yield ToolProgress(content=f"{label}: {text}")  # type: ignore[misc]
 
                 if now - last_progress_time >= PROGRESS_INTERVAL_SECONDS:
                     combined_output = "".join(stdout_lines + stderr_lines)
                     if combined_output:
                         preview = get_last_n_lines(combined_output, 5)
                         elapsed = format_duration((now - start) * 1000)
-                        yield ToolProgress(content=f"Running... ({elapsed})\n{preview}")
+                        yield ToolProgress(content=f"Running... ({elapsed})\n{preview}")  # type: ignore[misc]
                     last_progress_time = now
 
                 if deadline is not None and now >= deadline:

ripperdoc/tools/file_edit_tool.py

@@ -88,8 +88,8 @@ match exactly (including whitespace and indentation)."""
         return (
             "Performs exact string replacements in files.\n\n"
             "Usage:\n"
-            "- You must use your `View` tool at least once in the conversation to read the file before editing; edits will fail if you skip reading.\n"
-            "- When editing text from View output, preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix is formatted as spaces + line number + tab. Never include any part of the prefix in old_string or new_string.\n"
+            "- You must use your `Read` tool at least once in the conversation to read the file before editing; edits will fail if you skip reading.\n"
+            "- When editing text from Read output, preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix is formatted as spaces + line number + tab. Never include any part of the prefix in old_string or new_string.\n"
             "- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n"
             "- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n"
             "- The edit will FAIL if `old_string` is not unique in the file. Provide more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`.\n"

ripperdoc/tools/file_read_tool.py

@@ -18,7 +18,7 @@ from ripperdoc.core.tool import (
 )
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.file_watch import record_snapshot
-from ripperdoc.utils.path_ignore import check_path_for_tool, is_path_ignored
+from ripperdoc.utils.path_ignore import check_path_for_tool
 
 logger = get_logger()
 
@@ -48,7 +48,7 @@ class FileReadTool(Tool[FileReadToolInput, FileReadToolOutput]):
 
     @property
     def name(self) -> str:
-        return "View"
+        return "Read"
 
     async def description(self) -> str:
         return """Read the contents of a file. You can optionally specify an offset

ripperdoc/tools/multi_edit_tool.py

@@ -25,7 +25,7 @@ logger = get_logger()
 
 
 DEFAULT_ACTION = "Edit"
-TOOL_NAME_READ = "View"
+TOOL_NAME_READ = "Read"
 NOTEBOOK_EDIT_TOOL_NAME = "NotebookEdit"
 
 MULTI_EDIT_DESCRIPTION = dedent(