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

ripperdoc/core/default_tools.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, List
+from typing import Any, List, Optional
 
 from ripperdoc.core.tool import Tool
 
@@ -17,6 +17,7 @@ from ripperdoc.tools.file_write_tool import FileWriteTool
 from ripperdoc.tools.glob_tool import GlobTool
 from ripperdoc.tools.ls_tool import LSTool
 from ripperdoc.tools.grep_tool import GrepTool
+from ripperdoc.tools.lsp_tool import LspTool
 from ripperdoc.tools.skill_tool import SkillTool
 from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
 from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
@@ -34,8 +35,73 @@ from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
 
+# Canonical tool names for --tools filtering
+BUILTIN_TOOL_NAMES = [
+    "Bash",
+    "BashOutput",
+    "KillBash",
+    "Read",
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
+    "Write",
+    "Glob",
+    "LS",
+    "Grep",
+    "LSP",
+    "Skill",
+    "TodoRead",
+    "TodoWrite",
+    "AskUserQuestion",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "ToolSearch",
+    "ListMcpServers",
+    "ListMcpResources",
+    "ReadMcpResource",
+    "Task",
+]
 
-def get_default_tools() -> List[Tool[Any, Any]]:
+
+def filter_tools_by_names(
+    tools: List[Tool[Any, Any]], tool_names: List[str]
+) -> List[Tool[Any, Any]]:
+    """Filter a tool list to only include tools with matching names.
+
+    Args:
+        tools: The full list of tools to filter.
+        tool_names: List of tool names to include.
+
+    Returns:
+        Filtered list of tools. If Task is included, it's recreated with
+        the filtered base tools.
+    """
+    if not tool_names:
+        return []
+
+    name_set = set(tool_names)
+    filtered: List[Tool[Any, Any]] = []
+    has_task = False
+
+    for tool in tools:
+        tool_name = getattr(tool, "name", tool.__class__.__name__)
+        if tool_name in name_set:
+            if tool_name == "Task":
+                has_task = True
+            else:
+                filtered.append(tool)
+
+    # If Task is requested, recreate it with the filtered base tools
+    if has_task:
+        def _filtered_base_provider() -> List[Tool[Any, Any]]:
+            return [t for t in filtered if getattr(t, "name", None) != "Task"]
+
+        filtered.append(TaskTool(_filtered_base_provider))
+
+    return filtered
+
+
+def get_default_tools(allowed_tools: Optional[List[str]] = None) -> List[Tool[Any, Any]]:
     """Construct the default tool set (base tools + Task subagent launcher)."""
     base_tools: List[Tool[Any, Any]] = [
         BashTool(),
@@ -49,6 +115,7 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         GlobTool(),
         LSTool(),
         GrepTool(),
+        LspTool(),
         SkillTool(),
         TodoReadTool(),
         TodoWriteTool(),
@@ -68,21 +135,43 @@ def get_default_tools() -> List[Tool[Any, Any]]:
             if isinstance(tool, Tool):
                 base_tools.append(tool)
                 dynamic_tools.append(tool)
-    except (ImportError, ModuleNotFoundError, OSError, RuntimeError, ConnectionError, ValueError, TypeError) as exc:
+    except (
+        ImportError,
+        ModuleNotFoundError,
+        OSError,
+        RuntimeError,
+        ConnectionError,
+        ValueError,
+        TypeError,
+    ) as exc:
         # If MCP runtime is not available, continue with base tools only.
         logger.warning(
             "[default_tools] Failed to load dynamic MCP tools: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
         )
 
     task_tool = TaskTool(lambda: base_tools)
     all_tools = base_tools + [task_tool]
-    logger.debug(
-        "[default_tools] Built tool inventory",
-        extra={
-            "base_tools": len(base_tools),
-            "dynamic_mcp_tools": len(dynamic_tools),
-            "total_tools": len(all_tools),
-        },
-    )
+
+    # Apply allowed_tools filter if specified
+    if allowed_tools is not None:
+        all_tools = filter_tools_by_names(all_tools, allowed_tools)
+        logger.debug(
+            "[default_tools] Filtered tool inventory",
+            extra={
+                "allowed_tools": allowed_tools,
+                "filtered_tools": len(all_tools),
+            },
+        )
+    else:
+        logger.debug(
+            "[default_tools] Built tool inventory",
+            extra={
+                "base_tools": len(base_tools),
+                "dynamic_mcp_tools": len(dynamic_tools),
+                "total_tools": len(all_tools),
+            },
+        )
+
     return all_tools

ripperdoc/core/hooks/config.py

@@ -234,9 +234,7 @@ def _parse_hooks_file(data: Dict[str, Any]) -> HooksConfig:
                 hook_definitions.append(hook_def)
 
             if hook_definitions:
-                parsed_matchers.append(
-                    HookMatcher(matcher=matcher_pattern, hooks=hook_definitions)
-                )
+                parsed_matchers.append(HookMatcher(matcher=matcher_pattern, hooks=hook_definitions))
 
         if parsed_matchers:
             parsed_hooks[event_name] = parsed_matchers

ripperdoc/core/hooks/events.py

@@ -5,10 +5,9 @@ as well as the input/output data structures for each event type.
 """
 
 import json
-import os
 from enum import Enum
-from typing import Any, Dict, List, Literal, Optional, Union
-from pydantic import BaseModel, Field
+from typing import Any, Dict, Literal, Optional, Union
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class HookEvent(str, Enum):
@@ -73,8 +72,7 @@ class HookInput(BaseModel):
     permission_mode: str = "default"  # "default", "plan", "acceptEdits", "bypassPermissions"
     hook_event_name: str = ""
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class PreToolUseInput(HookInput):
@@ -150,6 +148,8 @@ class StopInput(HookInput):
 
     hook_event_name: str = "Stop"
     stop_hook_active: bool = False  # True if already continuing from a stop hook
+    reason: Optional[str] = None
+    stop_sequence: Optional[str] = None
 
 
 class SubagentStopInput(HookInput):
@@ -210,6 +210,8 @@ class SessionEndInput(HookInput):
 
     hook_event_name: str = "SessionEnd"
     reason: str = ""  # "clear", "logout", "prompt_input_exit", "other"
+    duration_seconds: Optional[float] = None
+    message_count: Optional[int] = None
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -232,8 +234,7 @@ class PreToolUseHookOutput(BaseModel):
     )  # Modified tool input
     additional_context: Optional[str] = Field(default=None, alias="additionalContext")
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class PermissionRequestDecision(BaseModel):
@@ -244,8 +245,7 @@ class PermissionRequestDecision(BaseModel):
     message: Optional[str] = None
     interrupt: bool = False
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class PermissionRequestHookOutput(BaseModel):
@@ -254,8 +254,7 @@ class PermissionRequestHookOutput(BaseModel):
     hook_event_name: Literal["PermissionRequest"] = "PermissionRequest"
     decision: Optional[PermissionRequestDecision] = None
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class PostToolUseHookOutput(BaseModel):
@@ -264,8 +263,7 @@ class PostToolUseHookOutput(BaseModel):
     hook_event_name: Literal["PostToolUse"] = "PostToolUse"
     additional_context: Optional[str] = Field(default=None, alias="additionalContext")
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class UserPromptSubmitHookOutput(BaseModel):
@@ -274,8 +272,7 @@ class UserPromptSubmitHookOutput(BaseModel):
     hook_event_name: Literal["UserPromptSubmit"] = "UserPromptSubmit"
     additional_context: Optional[str] = Field(default=None, alias="additionalContext")
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 class SessionStartHookOutput(BaseModel):
@@ -284,8 +281,7 @@ class SessionStartHookOutput(BaseModel):
     hook_event_name: Literal["SessionStart"] = "SessionStart"
     additional_context: Optional[str] = Field(default=None, alias="additionalContext")
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
 
 HookSpecificOutput = Union[
@@ -325,7 +321,7 @@ class HookOutput(BaseModel):
     )
 
     # Additional context to inject
-    additional_context: Optional[str] = None
+    additional_context: Optional[str] = Field(default=None, alias="additionalContext")
 
     # Raw output (for non-JSON responses)
     raw_output: Optional[str] = None
@@ -336,8 +332,7 @@ class HookOutput(BaseModel):
     exit_code: int = 0
     timed_out: bool = False
 
-    class Config:
-        populate_by_name = True
+    model_config = ConfigDict(populate_by_name=True)
 
     @classmethod
     def from_raw(
@@ -420,10 +415,10 @@ class HookOutput(BaseModel):
                 # Handle PreToolUse specific fields
                 if event_name == "PreToolUse":
                     output.hook_specific_output = PreToolUseHookOutput(
-                        permission_decision=hso.get("permissionDecision"),
-                        permission_decision_reason=hso.get("permissionDecisionReason"),
-                        updated_input=hso.get("updatedInput"),
-                        additional_context=hso.get("additionalContext"),
+                        permissionDecision=hso.get("permissionDecision"),
+                        permissionDecisionReason=hso.get("permissionDecisionReason"),
+                        updatedInput=hso.get("updatedInput"),
+                        additionalContext=hso.get("additionalContext"),
                     )
                     # Map permissionDecision to decision
                     perm_decision = hso.get("permissionDecision")
@@ -444,7 +439,7 @@ class HookOutput(BaseModel):
                     if isinstance(decision_obj, dict):
                         decision_data = PermissionRequestDecision(
                             behavior=decision_obj.get("behavior", ""),
-                            updated_input=decision_obj.get("updatedInput"),
+                            updatedInput=decision_obj.get("updatedInput"),
                             message=decision_obj.get("message"),
                             interrupt=decision_obj.get("interrupt", False),
                         )
@@ -462,7 +457,7 @@ class HookOutput(BaseModel):
                 # Handle PostToolUse specific fields
                 elif event_name == "PostToolUse":
                     output.hook_specific_output = PostToolUseHookOutput(
-                        additional_context=hso.get("additionalContext"),
+                        additionalContext=hso.get("additionalContext"),
                     )
                     if hso.get("additionalContext"):
                         output.additional_context = hso["additionalContext"]
@@ -470,7 +465,7 @@ class HookOutput(BaseModel):
                 # Handle UserPromptSubmit specific fields
                 elif event_name == "UserPromptSubmit":
                     output.hook_specific_output = UserPromptSubmitHookOutput(
-                        additional_context=hso.get("additionalContext"),
+                        additionalContext=hso.get("additionalContext"),
                     )
                     if hso.get("additionalContext"):
                         output.additional_context = hso["additionalContext"]
@@ -478,7 +473,7 @@ class HookOutput(BaseModel):
                 # Handle SessionStart specific fields
                 elif event_name == "SessionStart":
                     output.hook_specific_output = SessionStartHookOutput(
-                        additional_context=hso.get("additionalContext"),
+                        additionalContext=hso.get("additionalContext"),
                     )
                     if hso.get("additionalContext"):
                         output.additional_context = hso["additionalContext"]
@@ -520,6 +515,10 @@ class HookOutput(BaseModel):
         """Get updated input from PreToolUse hook."""
         if isinstance(self.hook_specific_output, PreToolUseHookOutput):
             return self.hook_specific_output.updated_input
+        if isinstance(self.hook_specific_output, PermissionRequestHookOutput):
+            decision = self.hook_specific_output.decision
+            if decision and decision.updated_input:
+                return decision.updated_input
         if isinstance(self.hook_specific_output, dict):
             return self.hook_specific_output.get("updatedInput")
         return None

ripperdoc/core/hooks/executor.py

@@ -14,7 +14,7 @@ import os
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Awaitable
+from typing import Callable, Dict, Optional, Awaitable
 
 from ripperdoc.core.hooks.config import HookDefinition
 from ripperdoc.core.hooks.events import AnyHookInput, HookOutput, HookDecision, SessionStartInput
@@ -191,7 +191,7 @@ class HookExecutor:
             pass
 
         # Not JSON, treat as additional context
-        return HookOutput(raw_output=response, additional_context=response)
+        return HookOutput(raw_output=response, additionalContext=response)
 
     async def execute_prompt_async(
         self,
@@ -224,7 +224,7 @@ class HookExecutor:
         prompt = self._expand_prompt(hook.prompt, input_data)
 
         logger.debug(
-            f"Executing prompt hook",
+            "Executing prompt hook",
             extra={
                 "event": input_data.hook_event_name,
                 "timeout": hook.timeout,
@@ -277,9 +277,7 @@ class HookExecutor:
         """
         # Prompt hooks require async - skip in sync mode
         if hook.is_prompt_hook():
-            logger.warning(
-                "Prompt hook skipped in sync mode. Use execute_async for prompt hooks."
-            )
+            logger.warning("Prompt hook skipped in sync mode. Use execute_async for prompt hooks.")
             return HookOutput()
 
         return self._execute_command_sync(hook, input_data)

ripperdoc/core/hooks/integration.py

@@ -4,11 +4,9 @@ This module provides convenient integration points for running hooks
 as part of tool execution flows.
 """
 
-from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Tuple, TypeVar, Union
 
-from ripperdoc.core.hooks.events import HookDecision
-from ripperdoc.core.hooks.manager import HookManager, HookResult, hook_manager
+from ripperdoc.core.hooks.manager import HookManager, hook_manager
 from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
@@ -98,9 +96,7 @@ class HookInterceptor:
         Returns:
             Tuple of (should_continue, block_reason, additional_context)
         """
-        result = self.manager.run_post_tool_use(
-            tool_name, tool_input, tool_output, tool_error
-        )
+        result = self.manager.run_post_tool_use(tool_name, tool_input, tool_output, tool_error)
 
         if result.should_block:
             return False, result.block_reason, result.additional_context
@@ -129,7 +125,7 @@ class HookInterceptor:
         tool_name: str,
         tool_input: Dict[str, Any],
         execute_fn: Callable[[], T],
-    ) -> Tuple[bool, Union[T, str], Optional[str]]:
+    ) -> Tuple[bool, Union[T, str, None], Optional[str]]:
         """Wrap synchronous tool execution with pre/post hooks.
 
         Args:
@@ -141,9 +137,7 @@ class HookInterceptor:
             Tuple of (success, result_or_error, additional_context)
         """
         # Run pre-tool hooks
-        should_proceed, block_reason, pre_context = self.check_pre_tool_use(
-            tool_name, tool_input
-        )
+        should_proceed, block_reason, pre_context = self.check_pre_tool_use(tool_name, tool_input)
 
         if not should_proceed:
             return False, block_reason or "Blocked by hook", pre_context
@@ -157,9 +151,7 @@ class HookInterceptor:
             tool_error = str(e)
 
         # Run post-tool hooks
-        _, _, post_context = self.run_post_tool_use(
-            tool_name, tool_input, result, tool_error
-        )
+        _, _, post_context = self.run_post_tool_use(tool_name, tool_input, result, tool_error)
 
         # Combine contexts
         combined_context = None
@@ -168,7 +160,7 @@ class HookInterceptor:
             combined_context = "\n".join(parts) if parts else None
 
         if tool_error:
-            return False, tool_error, combined_context
+            return False, tool_error or "", combined_context
 
         return True, result, combined_context
 
@@ -177,7 +169,7 @@ class HookInterceptor:
         tool_name: str,
         tool_input: Dict[str, Any],
         execute_fn: Callable[[], T],
-    ) -> Tuple[bool, Union[T, str], Optional[str]]:
+    ) -> Tuple[bool, Union[T, str, None], Optional[str]]:
         """Wrap async tool execution with pre/post hooks."""
         # Run pre-tool hooks
         should_proceed, block_reason, pre_context = await self.check_pre_tool_use_async(
@@ -190,6 +182,7 @@ class HookInterceptor:
         # Execute the tool
         try:
             import asyncio
+
             if asyncio.iscoroutinefunction(execute_fn):
                 result = await execute_fn()
             else:
@@ -211,7 +204,7 @@ class HookInterceptor:
             combined_context = "\n".join(parts) if parts else None
 
         if tool_error:
-            return False, tool_error, combined_context
+            return False, tool_error or "", combined_context
 
         return True, result, combined_context
 
@@ -241,9 +234,7 @@ def run_post_tool_use(
     tool_error: Optional[str] = None,
 ) -> Tuple[bool, Optional[str], Optional[str]]:
     """Convenience function to run post-tool hooks using global interceptor."""
-    return hook_interceptor.run_post_tool_use(
-        tool_name, tool_input, tool_output, tool_error
-    )
+    return hook_interceptor.run_post_tool_use(tool_name, tool_input, tool_output, tool_error)
 
 
 async def run_post_tool_use_async(
@@ -333,7 +324,7 @@ def check_stop(
         - should_stop: True if agent should stop
         - continue_reason: Reason to continue if blocked
     """
-    result = hook_manager.run_stop(reason, stop_sequence)
+    result = hook_manager.run_stop(False, reason, stop_sequence)
 
     if result.should_block:
         return False, result.block_reason
@@ -345,7 +336,7 @@ async def check_stop_async(
     reason: Optional[str] = None, stop_sequence: Optional[str] = None
 ) -> Tuple[bool, Optional[str]]:
     """Async version of check_stop."""
-    result = await hook_manager.run_stop_async(reason, stop_sequence)
+    result = await hook_manager.run_stop_async(False, reason, stop_sequence)
 
     if result.should_block:
         return False, result.block_reason

ripperdoc/core/hooks/llm_callback.py

@@ -0,0 +1,59 @@
+"""LLM callback helper for prompt-based hooks."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ripperdoc.core.hooks.executor import LLMCallback
+from ripperdoc.core.query import query_llm
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.messages import AssistantMessage, create_user_message
+
+logger = get_logger()
+
+
+def _extract_text(message: AssistantMessage) -> str:
+    content = message.message.content
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for block in content:
+            text = getattr(block, "text", None) or (
+                block.get("text") if isinstance(block, dict) else None
+            )
+            if text:
+                parts.append(str(text))
+        return "\n".join(parts)
+    return ""
+
+
+def build_hook_llm_callback(
+    *,
+    model: str = "quick",
+    max_thinking_tokens: int = 0,
+    system_prompt: Optional[str] = None,
+) -> LLMCallback:
+    """Build an async callback for prompt hooks using the configured model."""
+
+    async def _callback(prompt: str) -> str:
+        try:
+            assistant = await query_llm(
+                [create_user_message(prompt)],
+                system_prompt or "",
+                [],
+                max_thinking_tokens=max_thinking_tokens,
+                model=model,
+                stream=False,
+            )
+            return _extract_text(assistant).strip()
+        except Exception as exc:
+            logger.warning(
+                "[hooks] Prompt hook LLM callback failed: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
+            return f"Prompt hook evaluation failed: {exc}"
+
+    return _callback
+