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

ripperdoc/core/skills.py

@@ -84,10 +84,15 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
                 body = "\n".join(lines[idx + 1 :])
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
-                except (yaml.YAMLError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+                except (
+                    yaml.YAMLError,
+                    ValueError,
+                    TypeError,
+                ) as exc:  # pragma: no cover - defensive
                     logger.warning(
                         "[skills] Invalid frontmatter in SKILL.md: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                     )
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
                 return frontmatter, body
@@ -118,7 +123,8 @@ def _load_skill_file(
     except (OSError, IOError, UnicodeDecodeError) as exc:
         logger.warning(
             "[skills] Failed to read skill file: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(path)},
         )
         return None, SkillLoadError(path=path, reason=f"Failed to read file: {exc}")

ripperdoc/core/system_prompt.py

@@ -49,7 +49,8 @@ def _detect_git_repo(cwd: Path) -> bool:
     except (OSError, subprocess.SubprocessError) as exc:
         logger.warning(
             "[system_prompt] Failed to detect git repository: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"cwd": str(cwd)},
         )
         return False
@@ -393,7 +394,8 @@ def build_system_prompt(
         except (OSError, ValueError, RuntimeError) as exc:
             logger.warning(
                 "Failed to load agent definitions: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
             agent_section = (
                 "# Subagents\nTask tool available, but agent definitions could not be loaded."

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
 
 
@@ -37,13 +37,20 @@ class ToolUseContext(BaseModel):
 
     message_id: Optional[str] = None
     agent_id: Optional[str] = None
-    safe_mode: bool = False
+    yolo_mode: bool = False
     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(default_factory=dict)
+    # 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
@@ -110,7 +117,7 @@ class Tool(ABC, Generic[TInput, TOutput]):
         pass
 
     @abstractmethod
-    async def prompt(self, safe_mode: bool = False) -> str:
+    async def prompt(self, yolo_mode: bool = False) -> str:
         """Get the system prompt for this tool."""
         pass
 
@@ -213,7 +220,8 @@ async def build_tool_description(
     except (TypeError, ValueError, AttributeError, KeyError) as exc:
         logger.warning(
             "[tool] Failed to build input example section: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"tool": getattr(tool, "name", None)},
         )
         return description_text
@@ -233,7 +241,8 @@ def tool_input_examples(tool: Tool[Any, Any], limit: int = 5) -> List[Dict[str,
         except (TypeError, ValueError, AttributeError) as exc:
             logger.warning(
                 "[tool] Failed to format tool input example: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"tool": getattr(tool, "name", None)},
             )
             continue

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 (
@@ -83,7 +88,7 @@ class RipperdocOptions:
     tools: Optional[Sequence[Tool[Any, Any]]] = None
     allowed_tools: Optional[Sequence[str]] = None
     disallowed_tools: Optional[Sequence[str]] = None
-    safe_mode: bool = False
+    yolo_mode: bool = False
     verbose: bool = False
     model: str = "main"
     max_thinking_tokens: int = 0
@@ -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,17 +261,32 @@ 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(
             tools=self._tools,
             max_thinking_tokens=self.options.max_thinking_tokens,
-            safe_mode=self.options.safe_mode,
+            yolo_mode=self.options.yolo_mode,
             model=self.options.model,
             verbose=self.options.verbose,
         )
@@ -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,

ripperdoc/tools/ask_user_question_tool.py

@@ -228,7 +228,8 @@ async def prompt_user_for_answer(
         except (OSError, RuntimeError, ValueError) as e:
             logger.warning(
                 "[ask_user_question_tool] Error during prompt: %s: %s",
-                type(e).__name__, e,
+                type(e).__name__,
+                e,
             )
             return None
 
@@ -275,7 +276,7 @@ class AskUserQuestionTool(Tool[AskUserQuestionToolInput, AskUserQuestionToolOutp
     def input_schema(self) -> type[AskUserQuestionToolInput]:
         return AskUserQuestionToolInput
 
-    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+    async def prompt(self, yolo_mode: bool = False) -> str:  # noqa: ARG002
         return ASK_USER_QUESTION_PROMPT
 
     def user_facing_name(self) -> str:
@@ -410,7 +411,8 @@ class AskUserQuestionTool(Tool[AskUserQuestionToolInput, AskUserQuestionToolOutp
         except (OSError, RuntimeError, ValueError, KeyError) as exc:
             logger.warning(
                 "[ask_user_question_tool] Error collecting answers: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
             output = AskUserQuestionToolOutput(
                 questions=questions,