Update base.py

Author: beacoder

python_agent_harness/tools/base.py

@@ -14,90 +14,6 @@
 from ..core.models import ToolSpec
 
 
-def atomic_write_text(path: str, content: str) -> None:
-    """Replace PATH's contents with CONTENT atomically.
-
-    THE single write path for every tool that rewrites a file (``Edit``,
-    ``Insert``, ``Write``, and the pure-Python diff applier).  It lives
-    here, in the module every tool already imports, so the four callers
-    cannot drift apart -- and because ``base`` imports nothing from
-    ``tools``, putting it here is also the only placement that avoids a
-    circular import: ``filesystem.py`` re-imports ``edit``/``write``/
-    ``insert`` at its bottom, so a helper defined *there* would make
-    ``edit`` import a half-initialised ``filesystem``.
-
-    A plain ``open(path, "w")`` TRUNCATES the file before writing, so a
-    write that fails partway through -- ENOSPC, a quota, an I/O error,
-    the process being killed -- left the file empty and the user's
-    content unrecoverable while the tool returned a tidy "Error: ..."
-    string.  Instead the new content goes to a sibling temp file which is
-    then renamed over the target, mirroring the tmp-write + ``os.replace``
-    discipline in ``SessionPersistence.save``.  ``os.replace`` is atomic:
-    a reader sees either the complete old file or the complete new one,
-    and ANY failure before it leaves PATH untouched.  The temp file is
-    removed on the error path.
-
-    Deliberate details:
-
-    - ``errors="surrogateescape"`` and ``newline=""`` match the tools'
-      read side, so invalid UTF-8 bytes (Latin-1, GBK, ...) round-trip
-      and the content is written byte-for-byte instead of having "\\n"
-      translated to ``os.linesep`` on Windows.
-    - The temp name carries a random suffix rather than a fixed ".tmp":
-      concurrent sub-agents can edit the same path, and a shared name
-      would let one writer rename the other's half-written file into
-      place.
-    - An existing file's permission bits are copied onto the
-      replacement, so editing an executable script does not drop its
-      ``+x``.  A file that does not exist yet keeps the umask-derived
-      permissions a plain ``open(path, "w")`` would have produced.  Only
-      the "no such file" case is tolerated: any other stat/chmod failure
-      propagates rather than silently shipping the wrong mode.
-
-    There is deliberately no ``fsync``: the failures this guards against
-    are process-level (a failed write, a kill, Ctrl-C), and in all of
-    them the rename never happens.  Surviving a power loss in the window
-    between write and rename would need an fsync here and on the parent
-    directory, which ``SessionPersistence.save`` does not do either.
-
-    Consequences of replacing the file rather than rewriting it in place,
-    all inherent to the atomic-replace approach:
-
-    - PATH must already be symlink-resolved.  ``os.replace`` onto a
-      symlink overwrites the LINK with a regular file, where an in-place
-      write would have followed it.  Every caller resolves the real path
-      first (``Edit``/``Insert``/``Write`` via ``os.path.realpath`` on
-      entry, ``_apply_section`` on its resolved target).
-    - Hard links are broken: the new content lands on a new inode, so
-      other links to the old inode keep the old content.
-    - Owner/group, ACLs, SELinux labels and chattr flags are NOT carried
-      over (only the mode bits are).  This matters mainly for an agent
-      running as root over files owned by someone else.
-    - On a crash between the write and the rename the temp file survives
-      as ``<name>.<hex>.tmp``; the original is still intact, but the
-      stray file is visible to Glob/Grep and to ``git status``.
-
-    Raises OSError on failure.  Note this needs write permission on the
-    DIRECTORY, not just on the file -- the one behavioural difference
-    from a truncating in-place write (GNU ``patch``, used by ``Edit``'s
-    diff mode, has always had the same requirement).
-    """
-    try:
-        mode: int | None = stat.S_IMODE(os.stat(path).st_mode)
-    except FileNotFoundError:
-        mode = None  # brand-new file: keep the umask default from write_text
-    tmp = f"{path}.{uuid.uuid4().hex[:8]}.tmp"
-    try:
-        Path(tmp).write_text(content, encoding="utf-8", errors="surrogateescape", newline="")
-        if mode is not None:
-            os.chmod(tmp, mode)
-        os.replace(tmp, path)
-    except OSError:
-        with contextlib.suppress(OSError):
-            os.unlink(tmp)
-        raise
-
-
 class PendingToolResult:
     """Handle for an asynchronous tool result (mirrors ``:async t``).