mantis-agent-sdk 2.2.0__tar.gz → 2.3.0__tar.gz

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/CHANGELOG.md

@@ -74,6 +74,18 @@ The full versioning policy is in [SEMVER.md](SEMVER.md).
   Three new public exports: `ResponseFormatError`,
   `normalize_response_format`, `translate_response_format`.
 
+## [2.3.0] — 2026-06-30
+
+### Added
+
+- **Read-before-write guard** (Claude Code's readFileState). `write_file` now
+  refuses to clobber an existing file the tools haven't *seen* this session, or
+  one that changed on disk since it was read — so unseen or newer content is
+  never silently destroyed by a blind overwrite. The tools (`read_file`,
+  `write_file`, `edit_file`, `multi_edit`) track each file's mtime; new files and
+  read-then-write / write-then-overwrite flows pass freely, and the error tells
+  the model to read first (recoverable in one step).
+
 ## [2.2.0] — 2026-06-30
 
 ### Fixed

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mantis-agent-sdk
-Version: 2.2.0
+Version: 2.3.0
 Summary: Drop-in open-source agent SDK. Multi-model, streaming, MCP, sub-agents.
 Project-URL: Homepage, https://github.com/teddyoweh/mantis-agent-sdk
 Project-URL: Repository, https://github.com/teddyoweh/mantis-agent-sdk

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/mantis_agent/__init__.py

@@ -284,7 +284,7 @@ def _detect_version() -> str:
 
         return version("mantis-agent-sdk")
     except Exception:  # pragma: no cover - extremely defensive
-        return "2.2.0"
+        return "2.3.0"
 
 
 __version__ = _detect_version()

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/mantis_agent/builtin_tools/fs.py

@@ -34,6 +34,43 @@ _MAX_LINE = 2000  # chars per line before truncation
 _MAX_MATCHES = 200  # grep/glob hits returned
 
 
+# ---------------------------------------------------------------------------
+# Read-before-write guard (Claude Code's readFileState). Tracks the mtime of
+# every file a tool has *seen* (read or written) this process. write_file then
+# refuses to clobber an existing file the tools haven't seen, or one changed on
+# disk since — so unseen/newer content is never silently destroyed. New files
+# pass freely.
+# ---------------------------------------------------------------------------
+_FILE_READS: dict[str, float] = {}
+
+
+def _record_seen(p: Path) -> None:
+    try:
+        _FILE_READS[str(p.resolve())] = p.stat().st_mtime
+    except OSError:
+        pass
+
+
+def _check_write_guard(p: Path) -> None:
+    if not p.exists() or not p.is_file():
+        return  # new file — nothing to clobber
+    seen = _FILE_READS.get(str(p.resolve()))
+    if seen is None:
+        raise ValueError(
+            f"{p} already exists but hasn't been read this session. Read it first "
+            f"so you don't overwrite content you haven't seen (write_file replaces "
+            f"the ENTIRE file). Use edit_file for a targeted change."
+        )
+    try:
+        if p.stat().st_mtime > seen + 1e-6:
+            raise ValueError(
+                f"{p} was modified on disk since you last read it. Read it again "
+                f"before writing so you don't clobber the newer version."
+            )
+    except OSError:
+        pass
+
+
 def _truncate(text: str, limit: int = _MAX_OUTPUT) -> str:
     if len(text) <= limit:
         return text
@@ -423,6 +460,7 @@ async def read_file(path: str, offset: int = 1, limit: int = _MAX_READ_LINES) ->
     if p.is_dir():
         raise IsADirectoryError(f"{path} is a directory — use ls instead")
 
+    _record_seen(p)  # the agent has now seen this file — write_file may touch it
     suffix = p.suffix.lower()
     if suffix in _IMAGE_READ_EXTS:
         import base64  # noqa: PLC0415
@@ -480,6 +518,7 @@ async def write_file(path: str, content: str) -> str:
         content = str(content)
 
     p = Path(path).expanduser()
+    _check_write_guard(p)  # don't blind-overwrite an unseen / externally-changed file
     old = ""
     if p.exists() and p.is_file():
         old = await anyio.to_thread.run_sync(lambda: p.read_text("utf-8", "replace"))
@@ -489,6 +528,7 @@ async def write_file(path: str, content: str) -> str:
         p.write_text(content, "utf-8")
 
     await anyio.to_thread.run_sync(_write)
+    _record_seen(p)  # we just wrote it — subsequent writes/edits are fine
     return _edit_summary("Wrote" if not old else "Updated", str(p), old, content)
 
 
@@ -522,6 +562,7 @@ async def edit_file(
         )
     updated = text.replace(old_string, new_string)
     await anyio.to_thread.run_sync(lambda: p.write_text(updated, "utf-8"))
+    _record_seen(p)
     return _edit_summary("Updated", str(p), text, updated)
 
 
@@ -565,6 +606,7 @@ async def multi_edit(path: str, edits: list[dict]) -> str:
         applied += 1
 
     await anyio.to_thread.run_sync(lambda: p.write_text(text, "utf-8"))
+    _record_seen(p)
     return _edit_summary("Updated", str(p), original, text)
 
 

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/mantis_agent/tui_fullscreen.py

@@ -716,12 +716,88 @@ async def run_fullscreen(tui: Any) -> int:
                 # /models [partial] → picker overlay, pre-filtered if given.
                 _open_model_picker(arg or "")
             return True
+        if cmd == "/disable":
+            from . import catalog  # noqa: PLC0415
+
+            enabled = [p.id for p in catalog.CATALOG if catalog.is_enabled(p)]
+            pid = arg.strip().lower()
+            if not pid:
+                await _print(lambda e=enabled: tui.console.print(
+                    "[ansibrightblack]usage: [white]/disable <provider>[/]  · enabled: "
+                    f"[white]{', '.join(e) or 'none'}[/][/]"))
+                return True
+            prov = catalog.BY_ID.get(pid)
+            if prov is None:
+                await _print(lambda: tui.console.print(
+                    f"[ansibrightblack](unknown provider [white]{pid}[/] — try one of: "
+                    f"{', '.join(p.id for p in catalog.CATALOG)})[/]"))
+                return True
+            removed = catalog.clear_key(pid)
+            if pid == "anthropic":
+                import os as _os  # noqa: PLC0415
+                _os.environ.pop("ANTHROPIC_AUTH_TOKEN", None)
+                removed = True
+            state.pop("model_cache", None)  # picker reflects the change
+            await _print(lambda r=removed, lbl=prov.label: tui.console.print(
+                f"[ansibrightblack]({'forgot ' + lbl if r else 'no saved key for ' + lbl})[/]"))
+            return True
+        if cmd == "/enable":
+            from . import catalog  # noqa: PLC0415
+
+            pid = arg.strip().lower()
+            prov = catalog.BY_ID.get(pid)
+            if prov is None:
+                await _print(lambda: tui.console.print(
+                    "[ansibrightblack]usage: [white]/enable <provider>[/]  · providers: "
+                    f"[white]{', '.join(p.id for p in catalog.CATALOG)}[/][/]"))
+                return True
+            # Reuse the picker's inline key-entry: prompt (masked) for the key,
+            # then validate + enable + switch to the provider's flagship model.
+            state["awaiting_key"] = {"provider_id": pid, "model": prov.models[0]}
+            input_buffer.reset()
+            await _announce(f"paste your {prov.api_key_env} to enable {pid} · enter to confirm · esc to cancel")
+            return True
+        if cmd == "/connect":
+            parts = arg.split()
+            if not parts or not parts[0].startswith(("http://", "https://")):
+                await _print(lambda: tui.console.print(
+                    "[ansibrightblack]usage: [white]/connect <url> [model][/] — e.g. "
+                    "[white]/connect http://localhost:8000/v1 qwen2.5-coder:7b[/][/]"))
+                return True
+            url = parts[0].rstrip("/")
+            model = parts[1] if len(parts) > 1 else tui.model
+            tui.backend, tui.model = url, model
+            tui.agent = tui._build_agent()
+            if tui.agent is not None and tui.agent.permissions is not None:
+                tui.agent.permissions.asker = _ask_permission
+            try:
+                from . import catalog  # noqa: PLC0415
+                catalog.set_last_model(model, url)
+            except Exception:  # noqa: BLE001
+                pass
+            state.pop("model_cache", None)
+            await _print(lambda u=url, m=model: tui.console.print(
+                f"[ansibrightblack](connected · [white]{m}[/] @ [white]{u}[/] · self-hosted)[/]"))
+            return True
         if cmd == "/help":
-            await _print(lambda: tui.console.print(
-                "\n[bold]commands[/]  [white]/model[/] <id> · [white]/clear[/] · "
-                "[white]/cwd[/] · [white]/exit[/]\n"
-                "[ansibrightblack]@file to attach a path · shift+tab cycles mode · esc/Ctrl+C interrupts a "
-                "running reply (Ctrl+C also quits when idle) · Ctrl+D quits[/]\n"))
+            def _help() -> None:
+                w, d = "white", "ansibrightblack"
+                tui.console.print("\n[bold]commands[/]")
+                tui.console.print(
+                    f"  [{d}]models[/]   [{w}]/models[/] [{d}][filter][/] browse & pick (type to filter) · "
+                    f"[{w}]/model[/] <id> switch")
+                tui.console.print(
+                    f"  [{d}]      [/]   [{w}]/enable[/] <provider> · [{w}]/disable[/] <provider> · "
+                    f"[{w}]/connect[/] <url> [model] (self-host)")
+                tui.console.print(
+                    f"  [{d}]session[/]  [{w}]/clear[/] · [{w}]/memory[/] · [{w}]/context[/] · "
+                    f"[{w}]/copy[/] · [{w}]/export[/] · [{w}]/diff[/] · [{w}]/cwd[/]")
+                tui.console.print(
+                    f"  [{d}]quit[/]     [{w}]/exit[/]  (or Ctrl+D · Ctrl+C when idle)")
+                tui.console.print(
+                    f"  [{d}]keys[/]     [{d}]@file to attach a path · shift+tab cycles mode · "
+                    f"esc/Ctrl+C interrupts a running reply[/]\n")
+            await _print(_help)
             return True
         return False  # unknown → treat as a normal prompt
 

{mantis_agent_sdk-2.2.0 → mantis_agent_sdk-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mantis-agent-sdk"
-version = "2.2.0"
+version = "2.3.0"
 description = "Drop-in open-source agent SDK. Multi-model, streaming, MCP, sub-agents."
 readme = "README.md"
 requires-python = ">=3.11"

mantis_agent_sdk-2.3.0/tests/test_write_guard.py

@@ -0,0 +1,70 @@
+"""Read-before-write guard: write_file won't blind-clobber an unseen/stale file."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import anyio
+import pytest
+
+import mantis_agent.builtin_tools.fs as fs
+from mantis_agent.builtin_tools.fs import edit_file, read_file, write_file
+
+
+@pytest.fixture(autouse=True)
+def _clear_tracker():
+    fs._FILE_READS.clear()
+    yield
+    fs._FILE_READS.clear()
+
+
+def test_new_file_writes_freely(tmp_path: Path) -> None:
+    p = tmp_path / "new.txt"
+    out = anyio.run(lambda: write_file.fn(path=str(p), content="hello"))
+    assert p.read_text() == "hello"
+    assert "Wrote" in out
+
+
+def test_existing_unread_file_is_guarded(tmp_path: Path) -> None:
+    p = tmp_path / "exists.txt"
+    p.write_text("precious unseen content")
+    with pytest.raises(ValueError, match="hasn't been read"):
+        anyio.run(lambda: write_file.fn(path=str(p), content="clobbered"))
+    assert p.read_text() == "precious unseen content"   # untouched
+
+
+def test_read_then_write_allowed(tmp_path: Path) -> None:
+    p = tmp_path / "f.txt"
+    p.write_text("original")
+    anyio.run(lambda: read_file.fn(path=str(p)))          # now seen
+    anyio.run(lambda: write_file.fn(path=str(p), content="new"))
+    assert p.read_text() == "new"
+
+
+def test_write_then_overwrite_allowed(tmp_path: Path) -> None:
+    p = tmp_path / "f.txt"
+    anyio.run(lambda: write_file.fn(path=str(p), content="v1"))   # creates + records
+    anyio.run(lambda: write_file.fn(path=str(p), content="v2"))   # allowed
+    assert p.read_text() == "v2"
+
+
+def test_modified_since_read_is_guarded(tmp_path: Path) -> None:
+    p = tmp_path / "f.txt"
+    p.write_text("v1")
+    anyio.run(lambda: read_file.fn(path=str(p)))
+    # simulate an external edit AFTER our read (bump mtime into the future)
+    future = os.stat(p).st_mtime + 100
+    os.utime(p, (future, future))
+    with pytest.raises(ValueError, match="modified on disk"):
+        anyio.run(lambda: write_file.fn(path=str(p), content="v2"))
+
+
+def test_edit_records_so_write_is_allowed(tmp_path: Path) -> None:
+    p = tmp_path / "f.txt"
+    p.write_text("alpha beta")
+    anyio.run(lambda: read_file.fn(path=str(p)))
+    anyio.run(lambda: edit_file.fn(path=str(p), old_string="alpha", new_string="ALPHA"))
+    # edit updated the tracker's mtime → a following write_file doesn't false-trip
+    anyio.run(lambda: write_file.fn(path=str(p), content="rewritten"))
+    assert p.read_text() == "rewritten"