ripperdoc 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

ripperdoc/tools/multi_edit_tool.py

@@ -5,7 +5,6 @@ Allows performing multiple exact string replacements in a single file atomically
 
 import difflib
 import os
-from pathlib import Path
 from typing import AsyncGenerator, Optional, List
 from textwrap import dedent
 from pydantic import BaseModel, Field
@@ -19,7 +18,13 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
-from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.file_editing import (
+    atomic_write_with_fallback,
+    open_locked_file,
+    resolve_input_path,
+    safe_record_snapshot,
+    select_write_encoding,
+)
 from ripperdoc.tools.file_read_tool import detect_file_encoding
 
 logger = get_logger()
@@ -167,10 +172,7 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
         input_data: MultiEditToolInput,
         context: Optional[ToolUseContext] = None,
     ) -> ValidationResult:
-        path = Path(input_data.file_path).expanduser()
-        if not path.is_absolute():
-            path = Path.cwd() / path
-        resolved_path = str(path.resolve())
+        path, cache_key = resolve_input_path(input_data.file_path)
 
         # Ensure edits differ.
         for edit in input_data.edits:
@@ -197,7 +199,7 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
         # If file exists, check if it has been read before editing
         if path.exists() and not is_creation:
             file_state_cache = getattr(context, "file_state_cache", {}) if context else {}
-            file_snapshot = file_state_cache.get(resolved_path)
+            file_snapshot = file_state_cache.get(cache_key)
 
             if not file_snapshot:
                 return ValidationResult(
@@ -208,7 +210,7 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
 
             # Check if file has been modified since it was read
             try:
-                current_mtime = os.path.getmtime(resolved_path)
+                current_mtime = os.path.getmtime(cache_key)
                 if current_mtime > file_snapshot.timestamp:
                     return ValidationResult(
                         result=False,
@@ -335,143 +337,289 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
         context: ToolUseContext,
     ) -> AsyncGenerator[ToolOutput, None]:
         """Apply multiple edits atomically."""
-        file_path = Path(input_data.file_path).expanduser()
-        if not file_path.is_absolute():
-            file_path = Path.cwd() / file_path
-        file_path = file_path.resolve()
+        resolved_path, cache_key = resolve_input_path(input_data.file_path)
+        file_state_cache = getattr(context, "file_state_cache", {})
+        file_snapshot = file_state_cache.get(cache_key)
 
-        existing = file_path.exists()
+        existing = resolved_path.exists()
+        created = not existing
         original_content = ""
         file_encoding = "utf-8"
 
-        # Detect file encoding if file exists
         if existing:
-            detected_encoding, _ = detect_file_encoding(str(file_path))
+            detected_encoding, _ = detect_file_encoding(str(resolved_path))
             if detected_encoding:
                 file_encoding = detected_encoding
 
-        try:
-            if existing:
-                original_content = file_path.read_text(encoding=file_encoding)
-        except (OSError, IOError, PermissionError, UnicodeDecodeError) as exc:
-            # pragma: no cover - unlikely permission issue
-            logger.warning(
-                "[multi_edit_tool] Error reading file before edits: %s: %s",
-                type(exc).__name__,
-                exc,
-                extra={"file_path": str(file_path)},
-            )
-            output = MultiEditToolOutput(
-                file_path=str(file_path),
-                replacements_made=0,
-                success=False,
-                message=f"Error reading file: {exc}",
-            )
-            yield ToolResult(
-                data=output, result_for_assistant=self.render_result_for_assistant(output)
+        applied = input_data.edits
+
+        if not existing:
+            try:
+                updated_content, total_replacements = self._apply_edits(original_content, applied)
+            except ValueError as exc:
+                output = MultiEditToolOutput(
+                    file_path=str(resolved_path),
+                    replacements_made=0,
+                    success=False,
+                    message=str(exc),
+                    applied_edits=applied,
+                    created=True,
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+
+            if updated_content == original_content:
+                output = MultiEditToolOutput(
+                    file_path=str(resolved_path),
+                    replacements_made=0,
+                    success=False,
+                    message="Edits produced no changes.",
+                    applied_edits=applied,
+                    created=True,
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+
+            # Ensure parent exists (validated earlier) and write the file.
+            resolved_path.parent.mkdir(parents=True, exist_ok=True)
+
+            write_encoding = select_write_encoding(
+                file_encoding,
+                updated_content,
+                resolved_path,
+                log_prefix="[multi_edit_tool]",
             )
-            return
 
-        applied = input_data.edits
-        try:
-            updated_content, total_replacements = self._apply_edits(original_content, applied)
-        except ValueError as exc:
-            output = MultiEditToolOutput(
-                file_path=str(file_path),
-                replacements_made=0,
-                success=False,
-                message=str(exc),
-                applied_edits=applied,
-                created=not existing and original_content == "",
+            try:
+                with open(resolved_path, "x", encoding=write_encoding) as handle:
+                    handle.write(updated_content)
+            except FileExistsError:
+                output = MultiEditToolOutput(
+                    file_path=str(resolved_path),
+                    replacements_made=0,
+                    success=False,
+                    message=(
+                        "File was created while preparing edits. "
+                        "Read it first before attempting to edit it."
+                    ),
+                    applied_edits=applied,
+                    created=False,
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+            except (OSError, IOError, PermissionError, UnicodeDecodeError) as exc:
+                logger.warning(
+                    "[multi_edit_tool] Error writing edited file: %s: %s",
+                    type(exc).__name__,
+                    exc,
+                    extra={"file_path": str(resolved_path)},
+                )
+                output = MultiEditToolOutput(
+                    file_path=str(resolved_path),
+                    replacements_made=0,
+                    success=False,
+                    message=f"Error writing file: {exc}",
+                    applied_edits=applied,
+                    created=True,
+                )
+                yield ToolResult(
+                    data=output, result_for_assistant=self.render_result_for_assistant(output)
+                )
+                return
+
+            safe_record_snapshot(
+                cache_key,
+                updated_content,
+                file_state_cache,
+                encoding=write_encoding,
+                log_prefix="[multi_edit_tool]",
             )
-            yield ToolResult(
-                data=output, result_for_assistant=self.render_result_for_assistant(output)
+
+            diff_lines, diff_with_line_numbers, additions, deletions = self._build_diff(
+                original_content, updated_content, str(resolved_path)
             )
-            return
 
-        if updated_content == original_content:
             output = MultiEditToolOutput(
-                file_path=str(file_path),
-                replacements_made=0,
-                success=False,
-                message="Edits produced no changes.",
+                file_path=str(resolved_path),
+                replacements_made=total_replacements,
+                success=True,
+                message=(
+                    f"Applied {len(applied)} edit(s) with {total_replacements} replacement(s) "
+                    f"to {resolved_path}"
+                ),
+                additions=additions,
+                deletions=deletions,
+                diff_lines=diff_lines,
+                diff_with_line_numbers=diff_with_line_numbers,
                 applied_edits=applied,
-                created=not existing and original_content == "",
+                created=True,
             )
+
             yield ToolResult(
-                data=output, result_for_assistant=self.render_result_for_assistant(output)
+                data=output,
+                result_for_assistant=self.render_result_for_assistant(output),
             )
             return
 
-        # Ensure parent exists (validated earlier) and write the file.
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Verify content can be encoded, fall back to UTF-8 if needed
+        updated_content = ""
+        total_replacements = 0
         write_encoding = file_encoding
-        try:
-            updated_content.encode(file_encoding)
-        except (UnicodeEncodeError, LookupError):
-            logger.info(
-                "New content cannot be encoded with %s, using UTF-8 for %s",
-                file_encoding,
-                str(file_path),
-            )
-            write_encoding = "utf-8"
 
         try:
-            file_path.write_text(updated_content, encoding=write_encoding)
-            try:
-                record_snapshot(
-                    str(file_path),
+            with open_locked_file(resolved_path, file_encoding) as (
+                handle,
+                pre_lock_mtime,
+                post_lock_mtime,
+            ):
+                if pre_lock_mtime is not None and post_lock_mtime is not None:
+                    if post_lock_mtime > pre_lock_mtime:
+                        output = MultiEditToolOutput(
+                            file_path=str(resolved_path),
+                            replacements_made=0,
+                            success=False,
+                            message="File was modified while acquiring lock. Please retry.",
+                            applied_edits=applied,
+                            created=False,
+                        )
+                        yield ToolResult(
+                            data=output,
+                            result_for_assistant=self.render_result_for_assistant(output),
+                        )
+                        return
+
+                if file_snapshot and post_lock_mtime is not None:
+                    if post_lock_mtime > file_snapshot.timestamp:
+                        output = MultiEditToolOutput(
+                            file_path=str(resolved_path),
+                            replacements_made=0,
+                            success=False,
+                            message=(
+                                "File has been modified since read, either by the user "
+                                "or by a linter. Read it again before attempting to edit it."
+                            ),
+                            applied_edits=applied,
+                            created=False,
+                        )
+                        yield ToolResult(
+                            data=output,
+                            result_for_assistant=self.render_result_for_assistant(output),
+                        )
+                        return
+
+                original_content = handle.read()
+
+                try:
+                    updated_content, total_replacements = self._apply_edits(
+                        original_content, applied
+                    )
+                except ValueError as exc:
+                    output = MultiEditToolOutput(
+                        file_path=str(resolved_path),
+                        replacements_made=0,
+                        success=False,
+                        message=str(exc),
+                        applied_edits=applied,
+                        created=False,
+                    )
+                    yield ToolResult(
+                        data=output, result_for_assistant=self.render_result_for_assistant(output)
+                    )
+                    return
+
+                if updated_content == original_content:
+                    output = MultiEditToolOutput(
+                        file_path=str(resolved_path),
+                        replacements_made=0,
+                        success=False,
+                        message="Edits produced no changes.",
+                        applied_edits=applied,
+                        created=False,
+                    )
+                    yield ToolResult(
+                        data=output, result_for_assistant=self.render_result_for_assistant(output)
+                    )
+                    return
+
+                write_encoding = select_write_encoding(
+                    file_encoding,
                     updated_content,
-                    getattr(context, "file_state_cache", {}),
-                    encoding=write_encoding,
+                    resolved_path,
+                    log_prefix="[multi_edit_tool]",
                 )
-            except (OSError, IOError, RuntimeError) as exc:
-                logger.warning(
-                    "[multi_edit_tool] Failed to record file snapshot: %s: %s",
-                    type(exc).__name__,
-                    exc,
-                    extra={"file_path": str(file_path)},
+                write_error = atomic_write_with_fallback(
+                    handle,
+                    resolved_path,
+                    updated_content,
+                    write_encoding,
+                    original_content,
+                    temp_prefix=".ripperdoc_multi_edit_",
+                    log_prefix="[multi_edit_tool]",
+                    conflict_message="File was modified during atomic write fallback. Please retry.",
                 )
+                if write_error:
+                    output = MultiEditToolOutput(
+                        file_path=str(resolved_path),
+                        replacements_made=0,
+                        success=False,
+                        message=write_error,
+                        applied_edits=applied,
+                        created=False,
+                    )
+                    yield ToolResult(
+                        data=output, result_for_assistant=self.render_result_for_assistant(output)
+                    )
+                    return
         except (OSError, IOError, PermissionError, UnicodeDecodeError) as exc:
+            # pragma: no cover - unlikely permission issue
             logger.warning(
-                "[multi_edit_tool] Error writing edited file: %s: %s",
+                "[multi_edit_tool] Error reading file before edits: %s: %s",
                 type(exc).__name__,
                 exc,
-                extra={"file_path": str(file_path)},
+                extra={"file_path": str(resolved_path)},
             )
             output = MultiEditToolOutput(
-                file_path=str(file_path),
+                file_path=str(resolved_path),
                 replacements_made=0,
                 success=False,
-                message=f"Error writing file: {exc}",
-                applied_edits=applied,
-                created=not existing and original_content == "",
+                message=f"Error reading file: {exc}",
             )
             yield ToolResult(
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
             return
 
+        safe_record_snapshot(
+            cache_key,
+            updated_content,
+            file_state_cache,
+            encoding=write_encoding,
+            log_prefix="[multi_edit_tool]",
+        )
+
         diff_lines, diff_with_line_numbers, additions, deletions = self._build_diff(
-            original_content, updated_content, str(file_path)
+            original_content, updated_content, str(resolved_path)
         )
 
         output = MultiEditToolOutput(
-            file_path=str(file_path),
+            file_path=str(resolved_path),
             replacements_made=total_replacements,
             success=True,
             message=(
                 f"Applied {len(applied)} edit(s) with {total_replacements} replacement(s) "
-                f"to {file_path}"
+                f"to {resolved_path}"
             ),
             additions=additions,
             deletions=deletions,
             diff_lines=diff_lines,
             diff_with_line_numbers=diff_with_line_numbers,
             applied_edits=applied,
-            created=not existing and original_content == "",
+            created=created,
         )
 
         yield ToolResult(

ripperdoc/tools/notebook_edit_tool.py

@@ -4,10 +4,8 @@ Allows performing insert/replace/delete operations on Jupyter notebook cells.
 """
 
 import json
-import os
 import random
 import string
-from pathlib import Path
 from textwrap import dedent
 from typing import AsyncGenerator, List, Optional
 from pydantic import BaseModel, Field
@@ -21,18 +19,12 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
-from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.file_editing import resolve_input_path, safe_record_snapshot
 
 
 logger = get_logger()
 
 
-def _resolve_path(path_str: str) -> Path:
-    """Return an absolute Path, interpreting relative paths from CWD."""
-    path = Path(path_str).expanduser()
-    return path if path.is_absolute() else Path.cwd() / path
-
-
 def _generate_cell_id() -> str:
     """Generate a short random cell id."""
     return "".join(random.choices(string.ascii_lowercase + string.digits, k=12))
@@ -137,8 +129,7 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
     async def validate_input(
         self, input_data: NotebookEditInput, context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
-        path = _resolve_path(input_data.notebook_path)
-        resolved_path = str(path.resolve())
+        path, cache_key = resolve_input_path(input_data.notebook_path)
 
         if not path.exists():
             return ValidationResult(
@@ -175,7 +166,7 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
 
         # Check if file has been read before editing
         file_state_cache = getattr(context, "file_state_cache", {}) if context else {}
-        file_snapshot = file_state_cache.get(resolved_path)
+        file_snapshot = file_state_cache.get(cache_key)
 
         if not file_snapshot:
             return ValidationResult(
@@ -186,7 +177,7 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
 
         # Check if file has been modified since it was read
         try:
-            current_mtime = os.path.getmtime(resolved_path)
+            current_mtime = os.path.getmtime(cache_key)
             if current_mtime > file_snapshot.timestamp:
                 return ValidationResult(
                     result=False,
@@ -249,7 +240,7 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
     async def call(
         self, input_data: NotebookEditInput, context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
-        path = _resolve_path(input_data.notebook_path)
+        path, cache_key = resolve_input_path(input_data.notebook_path)
         mode = (input_data.edit_mode or "replace").lower()
         cell_type = (input_data.cell_type or "").lower() or None
         new_source = input_data.new_source
@@ -315,21 +306,12 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
             )
 
             path.write_text(json.dumps(nb_json, indent=1), encoding="utf-8")
-            # Use resolved absolute path to ensure consistency with validation lookup
-            abs_notebook_path = str(path.resolve())
-            try:
-                record_snapshot(
-                    abs_notebook_path,
-                    json.dumps(nb_json, indent=1),
-                    getattr(context, "file_state_cache", {}),
-                )
-            except (OSError, IOError, RuntimeError) as exc:
-                logger.warning(
-                    "[notebook_edit_tool] Failed to record file snapshot: %s: %s",
-                    type(exc).__name__,
-                    exc,
-                    extra={"file_path": abs_notebook_path},
-                )
+            safe_record_snapshot(
+                cache_key,
+                json.dumps(nb_json, indent=1),
+                getattr(context, "file_state_cache", {}),
+                log_prefix="[notebook_edit_tool]",
+            )
 
             output = NotebookEditOutput(
                 new_source=new_source,

ripperdoc/utils/file_editing.py

@@ -0,0 +1,164 @@
+"""Shared helpers for safe file editing."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import tempfile
+from pathlib import Path
+from typing import Generator, Optional, TextIO, Union
+
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
+from ripperdoc.utils.platform import HAS_FCNTL
+
+logger = get_logger()
+
+PathLike = Union[str, Path]
+
+
+def resolve_input_path(input_path: str) -> tuple[Path, str]:
+    """Return resolved path plus cache key (abspath preserves symlink usage)."""
+    path = Path(input_path).expanduser()
+    if not path.is_absolute():
+        path = Path.cwd() / path
+    return path.resolve(), os.path.abspath(input_path)
+
+
+def safe_record_snapshot(
+    file_path: str,
+    content: str,
+    cache: dict,
+    *,
+    encoding: str = "utf-8",
+    log_prefix: str = "",
+) -> None:
+    """Record file snapshot with shared error handling."""
+    try:
+        record_snapshot(
+            file_path,
+            content,
+            cache,
+            encoding=encoding,
+        )
+    except (OSError, IOError, RuntimeError) as exc:
+        prefix = f"{log_prefix} " if log_prefix else ""
+        logger.warning(
+            "%sFailed to record file snapshot: %s: %s",
+            prefix,
+            type(exc).__name__,
+            exc,
+            extra={"file_path": file_path},
+        )
+
+
+@contextlib.contextmanager
+def file_lock(file_handle: TextIO, exclusive: bool = True) -> Generator[None, None, None]:
+    """Acquire a file lock, with fallback for systems without fcntl."""
+    if not HAS_FCNTL:
+        yield
+        return
+
+    import fcntl
+
+    lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
+    try:
+        fcntl.flock(file_handle.fileno(), lock_type)
+        yield
+    finally:
+        with contextlib.suppress(OSError):
+            fcntl.flock(file_handle.fileno(), fcntl.LOCK_UN)
+
+
+@contextlib.contextmanager
+def open_locked_file(
+    file_path: PathLike, encoding: str
+) -> Generator[tuple[TextIO, Optional[float], Optional[float]], None, None]:
+    """Open a file for read/write and acquire an exclusive lock."""
+    with open(str(file_path), "r+", encoding=encoding) as handle:
+        try:
+            pre_lock_mtime = os.fstat(handle.fileno()).st_mtime
+        except OSError:
+            pre_lock_mtime = None
+
+        with file_lock(handle, exclusive=True):
+            try:
+                post_lock_mtime = os.fstat(handle.fileno()).st_mtime
+            except OSError:
+                post_lock_mtime = None
+            yield handle, pre_lock_mtime, post_lock_mtime
+
+
+def select_write_encoding(
+    file_encoding: str,
+    updated_content: str,
+    file_path: PathLike,
+    *,
+    log_prefix: str = "",
+) -> str:
+    """Return a safe encoding for writing updated content."""
+    try:
+        updated_content.encode(file_encoding)
+        return file_encoding
+    except (UnicodeEncodeError, LookupError):
+        prefix = f"{log_prefix} " if log_prefix else ""
+        logger.info(
+            "%sNew content cannot be encoded with %s, using UTF-8 for %s",
+            prefix,
+            file_encoding,
+            str(file_path),
+        )
+        return "utf-8"
+
+
+def atomic_write_with_fallback(
+    handle: TextIO,
+    file_path: PathLike,
+    updated_content: str,
+    write_encoding: str,
+    original_content: str,
+    *,
+    temp_prefix: str,
+    log_prefix: str,
+    conflict_message: str,
+) -> Optional[str]:
+    """Atomically write content, falling back to in-place write if needed."""
+    try:
+        file_dir = os.path.dirname(str(file_path))
+        try:
+            fd, temp_path = tempfile.mkstemp(
+                dir=file_dir,
+                prefix=temp_prefix,
+                suffix=".tmp",
+            )
+            try:
+                with os.fdopen(fd, "w", encoding=write_encoding) as temp_f:
+                    temp_f.write(updated_content)
+                original_stat = os.fstat(handle.fileno())
+                os.chmod(temp_path, original_stat.st_mode)
+                os.replace(temp_path, str(file_path))
+            except Exception:
+                with contextlib.suppress(OSError):
+                    os.unlink(temp_path)
+                raise
+        except OSError as atomic_error:
+            handle.seek(0)
+            current_content = handle.read()
+            if current_content != original_content:
+                return conflict_message
+            handle.seek(0)
+            handle.truncate()
+            handle.write(updated_content)
+            prefix = f"{log_prefix} " if log_prefix else ""
+            logger.debug("%sAtomic write failed, used fallback: %s", prefix, atomic_error)
+    except (OSError, IOError, PermissionError, UnicodeDecodeError) as exc:
+        prefix = f"{log_prefix} " if log_prefix else ""
+        logger.warning(
+            "%sError writing edited file: %s: %s",
+            prefix,
+            type(exc).__name__,
+            exc,
+            extra={"file_path": str(file_path)},
+        )
+        return f"Error writing file: {exc}"
+    return None