ripperdoc 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

ripperdoc/core/query_utils.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Mapping, Optional, Union
 from uuid import uuid4
 
 from json_repair import repair_json
@@ -26,17 +26,25 @@ from ripperdoc.utils.messages import (
 logger = get_logger()
 
 
-def _safe_int(value: Any) -> int:
+def _safe_int(value: object) -> int:
     """Best-effort int conversion for usage counters."""
     try:
         if value is None:
             return 0
-        return int(value)
+        if isinstance(value, bool):
+            return int(value)
+        if isinstance(value, (int, float)):
+            return int(value)
+        if isinstance(value, str):
+            return int(value)
+        if hasattr(value, "__int__"):
+            return int(value)  # type: ignore[arg-type]
+        return 0
     except (TypeError, ValueError):
         return 0
 
 
-def _get_usage_field(usage: Any, field: str) -> int:
+def _get_usage_field(usage: Optional[Mapping[str, Any] | object], field: str) -> int:
     """Fetch a usage field from either a dict or object."""
     if usage is None:
         return 0
@@ -45,7 +53,7 @@ def _get_usage_field(usage: Any, field: str) -> int:
     return _safe_int(getattr(usage, field, 0))
 
 
-def anthropic_usage_tokens(usage: Any) -> Dict[str, int]:
+def anthropic_usage_tokens(usage: Optional[Mapping[str, Any] | object]) -> Dict[str, int]:
     """Extract token counts from an Anthropic response usage payload."""
     return {
         "input_tokens": _get_usage_field(usage, "input_tokens"),
@@ -55,7 +63,7 @@ def anthropic_usage_tokens(usage: Any) -> Dict[str, int]:
     }
 
 
-def openai_usage_tokens(usage: Any) -> Dict[str, int]:
+def openai_usage_tokens(usage: Optional[Mapping[str, Any] | object]) -> Dict[str, int]:
     """Extract token counts from an OpenAI-compatible response usage payload."""
     prompt_details = None
     if isinstance(usage, dict):
@@ -73,8 +81,24 @@ def openai_usage_tokens(usage: Any) -> Dict[str, int]:
     }
 
 
+def estimate_cost_usd(model_profile: ModelProfile, usage_tokens: Dict[str, int]) -> float:
+    """Compute USD cost using per-1M token pricing from the model profile."""
+    input_price = getattr(model_profile, "input_cost_per_million_tokens", 0.0) or 0.0
+    output_price = getattr(model_profile, "output_cost_per_million_tokens", 0.0) or 0.0
+
+    total_input_tokens = (
+        _safe_int(usage_tokens.get("input_tokens"))
+        + _safe_int(usage_tokens.get("cache_read_input_tokens"))
+        + _safe_int(usage_tokens.get("cache_creation_input_tokens"))
+    )
+    output_tokens = _safe_int(usage_tokens.get("output_tokens"))
+
+    cost = (total_input_tokens * input_price + output_tokens * output_price) / 1_000_000
+    return float(cost)
+
+
 def resolve_model_profile(model: str) -> ModelProfile:
-    """Resolve a model pointer to a concrete profile or raise if missing."""
+    """Resolve a model pointer to a concrete profile, falling back to a safe default."""
     config = get_global_config()
     profile_name = getattr(config.model_pointers, model, None) or model
     model_profile = config.model_profiles.get(profile_name)
@@ -82,7 +106,11 @@ def resolve_model_profile(model: str) -> ModelProfile:
         fallback_profile = getattr(config.model_pointers, "main", "default")
         model_profile = config.model_profiles.get(fallback_profile)
     if not model_profile:
-        raise ValueError(f"No model profile found for pointer: {model}")
+        logger.warning(
+            "[config] No model profile found; using built-in default profile",
+            extra={"model_pointer": model},
+        )
+        return ModelProfile(provider=ProviderType.OPENAI_COMPATIBLE, model="gpt-4o-mini")
     return model_profile
 
 
@@ -103,12 +131,10 @@ def _parse_text_mode_json_blocks(text: str) -> Optional[List[Dict[str, Any]]]:
     if not text or not isinstance(text, str):
         return None
 
-    code_blocks = re.findall(
-        r"```(?:\s*json)?\s*([\s\S]*?)\s*```", text, flags=re.IGNORECASE
-    )
+    code_blocks = re.findall(r"```(?:\s*json)?\s*([\s\S]*?)\s*```", text, flags=re.IGNORECASE)
     candidates = [blk.strip() for blk in code_blocks if blk.strip()]
 
-    def _normalize_blocks(parsed: Any) -> Optional[List[Dict[str, Any]]]:
+    def _normalize_blocks(parsed: object) -> Optional[List[Dict[str, Any]]]:
         raw_blocks = parsed if isinstance(parsed, list) else [parsed]
         normalized: List[Dict[str, Any]] = []
         for raw in raw_blocks:
@@ -204,7 +230,9 @@ def _tool_prompt_for_text_mode(tools: List[Tool[Any, Any]]) -> str:
 
         schema_json = ""
         try:
-            schema_json = json.dumps(tool.input_schema.model_json_schema(), ensure_ascii=False, indent=2)
+            schema_json = json.dumps(
+                tool.input_schema.model_json_schema(), ensure_ascii=False, indent=2
+            )
         except (AttributeError, TypeError, ValueError) as exc:
             logger.debug(
                 "[tool_prompt] Failed to render input_schema",
@@ -218,7 +246,12 @@ def _tool_prompt_for_text_mode(tools: List[Tool[Any, Any]]) -> str:
 
     example_blocks = [
         {"type": "text", "text": "好的，我来帮你查看一下README.md文件"},
-        {"type": "tool_use", "tool_use_id": "tool_id_000001", "tool": "View", "input": {"file_path": "README.md"}},
+        {
+            "type": "tool_use",
+            "tool_use_id": "tool_id_000001",
+            "tool": "View",
+            "input": {"file_path": "README.md"},
+        },
     ]
     lines.append("Example:")
     lines.append("```json")
@@ -228,7 +261,9 @@ def _tool_prompt_for_text_mode(tools: List[Tool[Any, Any]]) -> str:
     return "\n".join(lines)
 
 
-def text_mode_history(messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]]) -> List[Union[UserMessage, AssistantMessage]]:
+def text_mode_history(
+    messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]],
+) -> List[Union[UserMessage, AssistantMessage]]:
     """Convert a message history into text-only form for text mode."""
 
     def _normalize_block(block: Any) -> Optional[Dict[str, Any]]:
@@ -269,9 +304,13 @@ def text_mode_history(messages: List[Union[UserMessage, AssistantMessage, Progre
         if isinstance(content, list):
             normalized_blocks = []
             for block in content:
-                block_type = getattr(block, "type", None) or (block.get("type") if isinstance(block, dict) else None)
-                block_text = getattr(block, "text", None) if hasattr(block, "text") else (
-                    block.get("text") if isinstance(block, dict) else None
+                block_type = getattr(block, "type", None) or (
+                    block.get("type") if isinstance(block, dict) else None
+                )
+                block_text = (
+                    getattr(block, "text", None)
+                    if hasattr(block, "text")
+                    else (block.get("text") if isinstance(block, dict) else None)
                 )
                 if block_type == "text" and isinstance(block_text, str):
                     parsed_nested = _parse_text_mode_json_blocks(block_text)
@@ -287,7 +326,9 @@ def text_mode_history(messages: List[Union[UserMessage, AssistantMessage, Progre
         elif isinstance(content, str):
             parsed_blocks = _parse_text_mode_json_blocks(content)
             if parsed_blocks:
-                text_content = f"```json\n{json.dumps(parsed_blocks, ensure_ascii=False, indent=2)}\n```"
+                text_content = (
+                    f"```json\n{json.dumps(parsed_blocks, ensure_ascii=False, indent=2)}\n```"
+                )
             else:
                 text_content = content
         else:
@@ -301,7 +342,9 @@ def text_mode_history(messages: List[Union[UserMessage, AssistantMessage, Progre
     return converted
 
 
-def _maybe_convert_json_block_to_tool_use(content_blocks: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def _maybe_convert_json_block_to_tool_use(
+    content_blocks: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
     """Convert any text blocks containing JSON content to structured content blocks."""
     if not content_blocks:
         return content_blocks
@@ -437,9 +480,7 @@ async def build_openai_tool_schemas(tools: List[Tool[Any, Any]]) -> List[Dict[st
     return openai_tools
 
 
-def content_blocks_from_anthropic_response(
-    response: Any, tool_mode: str
-) -> List[Dict[str, Any]]:
+def content_blocks_from_anthropic_response(response: Any, tool_mode: str) -> List[Dict[str, Any]]:
     """Normalize Anthropic response content to our internal block format."""
     blocks: List[Dict[str, Any]] = []
     for block in getattr(response, "content", []) or []:

ripperdoc/core/tool.py

@@ -8,6 +8,7 @@ import json
 from abc import ABC, abstractmethod
 from typing import Any, AsyncGenerator, Dict, List, Optional, TypeVar, Generic, Union
 from pydantic import BaseModel, ConfigDict, Field
+from ripperdoc.utils.file_watch import FileSnapshot
 from ripperdoc.utils.log import get_logger
 
 
@@ -39,7 +40,8 @@ class ToolUseContext(BaseModel):
     safe_mode: bool = False
     verbose: bool = False
     permission_checker: Optional[Any] = None
-    read_file_timestamps: Dict[str, float] = {}
+    read_file_timestamps: Dict[str, float] = Field(default_factory=dict)
+    file_state_cache: Dict[str, "FileSnapshot"] = Field(default_factory=dict)
     tool_registry: Optional[Any] = None
     abort_signal: Optional[Any] = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -202,7 +204,7 @@ async def build_tool_description(
     except Exception:
         logger.exception(
             "[tool] Failed to build input example section",
-            extra={"tool": getattr(tool, 'name', None)},
+            extra={"tool": getattr(tool, "name", None)},
         )
         return description_text
 
@@ -221,7 +223,7 @@ def tool_input_examples(tool: Tool[Any, Any], limit: int = 5) -> List[Dict[str,
         except Exception:
             logger.exception(
                 "[tool] Failed to format tool input example",
-                extra={"tool": getattr(tool, 'name', None)},
+                extra={"tool": getattr(tool, "name", None)},
             )
             continue
     return results

ripperdoc/sdk/client.py

@@ -19,11 +19,13 @@ from typing import (
     List,
     Optional,
     Sequence,
+    Tuple,
     Union,
 )
 
 from ripperdoc.core.default_tools import get_default_tools
 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
 from ripperdoc.core.tool import Tool
 from ripperdoc.tools.task_tool import TaskTool
@@ -42,7 +44,16 @@ from ripperdoc.utils.mcp import (
 )
 
 MessageType = Union[UserMessage, AssistantMessage, ProgressMessage]
-PermissionChecker = Callable[[Tool[Any, Any], Any], Union[Awaitable[Any], Any]]
+PermissionChecker = Callable[
+    [Tool[Any, Any], Any],
+    Union[
+        PermissionResult,
+        Dict[str, Any],
+        Tuple[bool, Optional[str]],
+        bool,
+        Awaitable[Union[PermissionResult, Dict[str, Any], Tuple[bool, Optional[str]], bool]],
+    ],
+]
 QueryRunner = Callable[
     [
         List[MessageType],

ripperdoc/tools/background_shell.py

@@ -14,6 +14,9 @@ import uuid
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
+import atexit
+
+from ripperdoc.utils.shell_utils import build_shell_command, find_suitable_shell
 from ripperdoc.utils.log import get_logger
 
 
@@ -43,6 +46,7 @@ _tasks_lock = threading.Lock()
 _background_loop: Optional[asyncio.AbstractEventLoop] = None
 _background_thread: Optional[threading.Thread] = None
 _loop_lock = threading.Lock()
+_shutdown_registered = False
 
 
 def _ensure_background_loop() -> asyncio.AbstractEventLoop:
@@ -74,9 +78,18 @@ def _ensure_background_loop() -> asyncio.AbstractEventLoop:
 
         _background_loop = loop
         _background_thread = thread
+        _register_shutdown_hook()
         return loop
 
 
+def _register_shutdown_hook() -> None:
+    global _shutdown_registered
+    if _shutdown_registered:
+        return
+    atexit.register(shutdown_background_shell)
+    _shutdown_registered = True
+
+
 def _submit_to_background_loop(coro: Any) -> concurrent.futures.Future:
     """Run a coroutine on the background loop and return a thread-safe future."""
     loop = _ensure_background_loop()
@@ -153,24 +166,15 @@ async def _start_background_command(
     command: str, timeout: Optional[float] = None, shell_executable: Optional[str] = None
 ) -> str:
     """Launch a background shell command on the dedicated loop."""
-    if shell_executable:
-        process = await asyncio.create_subprocess_exec(
-            shell_executable,
-            "-c",
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            stdin=asyncio.subprocess.DEVNULL,
-            start_new_session=False,
-        )
-    else:
-        process = await asyncio.create_subprocess_shell(
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            stdin=asyncio.subprocess.DEVNULL,
-            start_new_session=False,
-        )
+    selected_shell = shell_executable or find_suitable_shell()
+    argv = build_shell_command(selected_shell, command)
+    process = await asyncio.create_subprocess_exec(
+        *argv,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+        start_new_session=False,
+    )
 
     task_id = f"bash_{uuid.uuid4().hex[:8]}"
     record = BackgroundTask(
@@ -295,3 +299,35 @@ def list_background_tasks() -> List[str]:
     """Return known background task ids."""
     with _tasks_lock:
         return list(_tasks.keys())
+
+
+def shutdown_background_shell() -> None:
+    """Stop background tasks/loop to avoid asyncio 'Event loop is closed' warnings."""
+    global _background_loop, _background_thread
+
+    loop = _background_loop
+    with _tasks_lock:
+        tasks = list(_tasks.values())
+        _tasks.clear()
+
+    for task in tasks:
+        try:
+            task.killed = True
+            task.process.kill()
+        except Exception:
+            pass
+        for reader in task.reader_tasks:
+            if loop and loop.is_running():
+                loop.call_soon_threadsafe(reader.cancel)
+        task.done_event.set()
+
+    if loop and loop.is_running():
+        try:
+            loop.call_soon_threadsafe(loop.stop)
+        except Exception:
+            pass
+    if _background_thread and _background_thread.is_alive():
+        _background_thread.join(timeout=2)
+
+    _background_loop = None
+    _background_thread = None

ripperdoc/tools/bash_tool.py

@@ -49,6 +49,7 @@ from ripperdoc.utils.permissions.tool_permission_utils import (
 from ripperdoc.utils.permissions import PermissionDecision
 from ripperdoc.utils.sandbox_utils import create_sandbox_wrapper, is_sandbox_available
 from ripperdoc.utils.safe_get_cwd import get_original_cwd, safe_get_cwd
+from ripperdoc.utils.shell_utils import build_shell_command, find_suitable_shell
 from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
@@ -151,6 +152,15 @@ build projects, run tests, and interact with the file system."""
 
     async def prompt(self, safe_mode: bool = False) -> str:
         sandbox_available = is_sandbox_available()
+        try:
+            current_shell = find_suitable_shell()
+        except Exception as exc:  # pragma: no cover - defensive guard
+            current_shell = f"Unavailable ({exc})"
+
+        shell_info = (
+            f"Current shell used for execution: {current_shell}\n"
+            f"- Override via RIPPERDOC_SHELL or RIPPERDOC_SHELL_PATH env vars, or pass shellExecutable input.\n"
+        )
 
         read_only_section = ""
         if sandbox_available:
@@ -235,6 +245,8 @@ build projects, run tests, and interact with the file system."""
             f"""\
             Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
 
+            {shell_info}
+
             Before executing the command, please follow these steps:
 
             1. Directory Verification:
@@ -486,6 +498,23 @@ build projects, run tests, and interact with the file system."""
         """Execute the bash command."""
 
         effective_command, auto_background = self._detect_auto_background(input_data.command)
+        try:
+            resolved_shell = input_data.shell_executable or find_suitable_shell()
+        except Exception as exc:  # pragma: no cover - defensive guard
+            error_output = BashToolOutput(
+                stdout="",
+                stderr=f"Failed to select shell: {exc}",
+                exit_code=-1,
+                command=effective_command,
+                sandbox=bool(input_data.sandbox),
+                is_error=True,
+            )
+            yield ToolResult(
+                data=error_output,
+                result_for_assistant=self.render_result_for_assistant(error_output),
+            )
+            return
+
         timeout_ms = input_data.timeout or DEFAULT_TIMEOUT_MS
         if MAX_BASH_TIMEOUT_MS:
             timeout_ms = min(timeout_ms, MAX_BASH_TIMEOUT_MS)
@@ -544,18 +573,9 @@ build projects, run tests, and interact with the file system."""
             should_background = False
 
         async def _spawn_process() -> asyncio.subprocess.Process:
-            if input_data.shell_executable:
-                return await asyncio.create_subprocess_exec(
-                    input_data.shell_executable,
-                    "-c",
-                    final_command,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    stdin=asyncio.subprocess.DEVNULL,
-                    start_new_session=False,
-                )
-            return await asyncio.create_subprocess_shell(
-                final_command,
+            argv = build_shell_command(resolved_shell, final_command)
+            return await asyncio.create_subprocess_exec(
+                *argv,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
                 stdin=asyncio.subprocess.DEVNULL,
@@ -592,7 +612,7 @@ build projects, run tests, and interact with the file system."""
                     else (timeout_seconds if timeout_seconds > 0 else None)
                 )
                 task_id = await start_background_command(
-                    final_command, timeout=bg_timeout, shell_executable=input_data.shell_executable
+                    final_command, timeout=bg_timeout, shell_executable=resolved_shell
                 )
 
                 output = BashToolOutput(

ripperdoc/tools/file_edit_tool.py

@@ -16,6 +16,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 logger = get_logger()
 
@@ -185,6 +186,18 @@ match exactly (including whitespace and indentation)."""
             with open(input_data.file_path, "w", encoding="utf-8") as f:
                 f.write(new_content)
 
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    new_content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[file_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             # Generate diff for display
             import difflib
 

ripperdoc/tools/file_read_tool.py

@@ -16,6 +16,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 logger = get_logger()
 
@@ -143,6 +144,21 @@ and limit to read only a portion of the file."""
 
             content = "".join(selected_lines)
 
+            # Remember what we read so we can detect user edits later.
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    content,
+                    getattr(context, "file_state_cache", {}),
+                    offset=offset,
+                    limit=limit,
+                )
+            except Exception:
+                logger.exception(
+                    "[file_read_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             output = FileReadToolOutput(
                 content=content,
                 file_path=input_data.file_path,

ripperdoc/tools/file_write_tool.py

@@ -17,6 +17,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 logger = get_logger()
 
@@ -125,6 +126,18 @@ NEVER write new files unless explicitly required by the user."""
 
             bytes_written = len(input_data.content.encode("utf-8"))
 
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    input_data.content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[file_write_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             output = FileWriteToolOutput(
                 file_path=input_data.file_path,
                 bytes_written=bytes_written,

ripperdoc/tools/glob_tool.py

@@ -112,7 +112,11 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
         rendered_path = ""
         if input_data.path:
             candidate_path = Path(input_data.path)
-            absolute_path = candidate_path if candidate_path.is_absolute() else (base_path / candidate_path).resolve()
+            absolute_path = (
+                candidate_path
+                if candidate_path.is_absolute()
+                else (base_path / candidate_path).resolve()
+            )
 
             try:
                 relative_path = absolute_path.relative_to(base_path)

ripperdoc/tools/ls_tool.py

@@ -142,22 +142,22 @@ def _should_skip(
     path: Path,
     root_path: Path,
     patterns: list[str],
-    ignore_map: Optional[Dict[Optional[Path], List[str]]] = None
+    ignore_map: Optional[Dict[Optional[Path], List[str]]] = None,
 ) -> bool:
     name = path.name
     if name.startswith("."):
         return True
     if "__pycache__" in path.parts:
         return True
-    
+
     # Check against ignore patterns
     if ignore_map and should_ignore_path(path, root_path, ignore_map):
         return True
-    
+
     # Also check against direct patterns for backward compatibility
     if patterns and _matches_ignore(path, root_path, patterns):
         return True
-    
+
     return False
 
 
@@ -346,7 +346,9 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
         try:
             root_path = _resolve_directory_path(input_data.path)
         except Exception:
-            return ValidationResult(result=False, message=f"Unable to resolve path: {input_data.path}")
+            return ValidationResult(
+                result=False, message=f"Unable to resolve path: {input_data.path}"
+            )
 
         if not root_path.is_absolute():
             return ValidationResult(result=False, message=f"Path is not absolute: {root_path}")
@@ -392,7 +394,9 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
             return f'path: "{input_data.path}"{ignore_display}'
 
         try:
-            relative_path = _relative_path_for_display(resolved_path, base_path) or resolved_path.as_posix()
+            relative_path = (
+                _relative_path_for_display(resolved_path, base_path) or resolved_path.as_posix()
+            )
         except Exception:
             relative_path = str(resolved_path)
 
@@ -431,18 +435,18 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
             git_root = get_git_root(root_path)
             if git_root:
                 git_info["repository"] = str(git_root)
-                
+
                 branch = get_current_git_branch(root_path)
                 if branch:
                     git_info["branch"] = branch
-                
+
                 commit_hash = get_git_commit_hash(root_path)
                 if commit_hash:
                     git_info["commit"] = commit_hash
-                
+
                 is_clean = is_working_directory_clean(root_path)
                 git_info["clean"] = "yes" if is_clean else "no (uncommitted changes)"
-                
+
                 tracked, untracked = get_git_status_files(root_path)
                 if tracked or untracked:
                     status_info = []

ripperdoc/tools/multi_edit_tool.py

@@ -18,6 +18,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 logger = get_logger()
 
@@ -360,6 +361,17 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
         file_path.parent.mkdir(parents=True, exist_ok=True)
         try:
             file_path.write_text(updated_content, encoding="utf-8")
+            try:
+                record_snapshot(
+                    str(file_path),
+                    updated_content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[multi_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": str(file_path)},
+                )
         except Exception as exc:
             logger.exception(
                 "[multi_edit_tool] Error writing edited file",

ripperdoc/tools/notebook_edit_tool.py

@@ -20,6 +20,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 
 logger = get_logger()
@@ -272,6 +273,17 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
             )
 
             path.write_text(json.dumps(nb_json, indent=1), encoding="utf-8")
+            try:
+                record_snapshot(
+                    input_data.notebook_path,
+                    json.dumps(nb_json, indent=1),
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[notebook_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.notebook_path},
+                )
 
             output = NotebookEditOutput(
                 new_source=new_source,