weakincentives 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

weakincentives/tools/vfs.py

@@ -44,14 +44,14 @@ _VFS_SECTION_TEMPLATE: Final[str] = (
     " specific files; keep listings focused to reduce output.\n"
     "2. Fetch file contents with `vfs_read_file` and work from the returned version"
     " to avoid conflicts.\n"
-    "3. Create or update files with `vfs_write_file`; supply ASCII content up to"
+    "3. Create or update files with `vfs_write_file`; supply UTF-8 content up to"
     " 48k characters and prefer overwriting full files unless streaming append"
     " updates.\n"
     "4. Remove obsolete files or directories with `vfs_delete_entry` to keep the"
     " snapshot tidy.\n"
     "5. Host mounts are session-initialization only; agents cannot mount additional"
     " directories later.\n"
-    "6. Avoid mirroring large repositories or binary assets—only ASCII text is"
+    "6. Avoid mirroring large repositories or binary assets—only UTF-8 text is"
     " accepted and host mounts remain constrained by their configuration."
 )
 
@@ -140,18 +140,19 @@ class VfsToolsSection(MarkdownSection[_VfsSectionParams]):
         allowed_roots = tuple(_normalize_root(path) for path in allowed_host_roots)
         session.register_reducer(VirtualFileSystem, replace_latest)
         mount_snapshot = _materialize_mounts(mounts, allowed_roots)
+        session.seed_slice(VirtualFileSystem, (mount_snapshot,))
         session.register_reducer(
             WriteFile,
-            _make_write_reducer(mount_snapshot),
+            _make_write_reducer(),
             slice_type=VirtualFileSystem,
         )
         session.register_reducer(
             DeleteEntry,
-            _make_delete_reducer(mount_snapshot),
+            _make_delete_reducer(),
             slice_type=VirtualFileSystem,
         )
 
-        tools = _build_tools(session=session, mount_snapshot=mount_snapshot)
+        tools = _build_tools(session=session)
         super().__init__(
             title="Virtual Filesystem Tools",
             key="vfs.tools",
@@ -162,9 +163,9 @@ class VfsToolsSection(MarkdownSection[_VfsSectionParams]):
 
 
 def _build_tools(
-    *, session: Session, mount_snapshot: VirtualFileSystem
+    *, session: Session
 ) -> tuple[Tool[SupportsDataclass, SupportsDataclass], ...]:
-    suite = _VfsToolSuite(session=session, mount_snapshot=mount_snapshot)
+    suite = _VfsToolSuite(session=session)
     return (
         Tool[ListDirectory, ListDirectoryResult](
             name="vfs_list_directory",
@@ -192,9 +193,8 @@ def _build_tools(
 class _VfsToolSuite:
     """Collection of VFS handlers bound to a session instance."""
 
-    def __init__(self, *, session: Session, mount_snapshot: VirtualFileSystem) -> None:
+    def __init__(self, *, session: Session) -> None:
         self._session = session
-        self._mount_snapshot = mount_snapshot
 
     def list_directory(self, params: ListDirectory) -> ToolResult[ListDirectoryResult]:
         target = _normalize_optional_path(params.path)
@@ -229,9 +229,7 @@ class _VfsToolSuite:
         file = _find_file(snapshot.files, path)
         if file is None:
             raise ToolValidationError("File does not exist in the virtual filesystem.")
-        message = (
-            f"Read {file.size_bytes} bytes from {'/'.join(file.path.segments) or '.'}."
-        )
+        message = _format_read_file_message(file)
         return ToolResult(message=message, value=file)
 
     def write_file(self, params: WriteFile) -> ToolResult[WriteFile]:
@@ -247,31 +245,27 @@ class _VfsToolSuite:
         if mode in {"overwrite", "append"} and existing is None:
             raise ToolValidationError("File does not exist for the requested mode.")
         normalized = WriteFile(path=path, content=content, mode=mode)
-        action = {
-            "create": "created",
-            "overwrite": "overwritten",
-            "append": "appended",
-        }[mode]
-        message = f"File {'/'.join(path.segments) or '.'} {action}."
+        message = _format_write_file_message(path, content, mode)
         return ToolResult(message=message, value=normalized)
 
     def delete_entry(self, params: DeleteEntry) -> ToolResult[DeleteEntry]:
         path = _normalize_path(params.path)
         snapshot = self._latest_snapshot()
-        deleted_count = _count_matching(snapshot.files, path)
+        matches = tuple(
+            file
+            for file in snapshot.files
+            if _is_path_prefix(file.path.segments, path.segments)
+        )
+        deleted_count = len(matches)
         if deleted_count == 0:
             raise ToolValidationError("No files matched the provided path.")
         normalized = DeleteEntry(path=path)
-        message = f"Deleted {deleted_count} entr{'ies' if deleted_count != 1 else 'y'}."
+        message = _format_delete_message(path, matches)
         return ToolResult(message=message, value=normalized)
 
     def _latest_snapshot(self) -> VirtualFileSystem:
         snapshot = select_latest(self._session, VirtualFileSystem)
-        if snapshot is not None:
-            return snapshot
-        return (
-            self._mount_snapshot if self._mount_snapshot.files else VirtualFileSystem()
-        )
+        return snapshot or VirtualFileSystem()
 
 
 def _normalize_content(content: str) -> str:
@@ -279,7 +273,6 @@ def _normalize_content(content: str) -> str:
         raise ToolValidationError(
             "Content exceeds maximum length of 48,000 characters."
         )
-    _ensure_ascii(content, "content")
     return content
 
 
@@ -352,24 +345,49 @@ def _is_path_prefix(path: Sequence[str], prefix: Sequence[str]) -> bool:
     return all(path[index] == prefix[index] for index in range(len(prefix)))
 
 
-def _count_matching(files: Iterable[VfsFile], path: VfsPath) -> int:
-    target = path.segments
-    return sum(1 for file in files if _is_path_prefix(file.path.segments, target))
-
-
 def _format_directory_message(
     path: VfsPath, directories: tuple[str, ...], files: tuple[str, ...]
 ) -> str:
-    prefix = "/".join(path.segments) or "."
-    directory_count = len(directories)
-    file_count = len(files)
+    prefix = _format_path(path)
+    directory_list = ", ".join(directories) if directories else "(none)"
+    file_list = ", ".join(files) if files else "(none)"
+    return f"Directory {prefix}\nsubdirectories: {directory_list}\nfiles: {file_list}"
+
+
+def _format_read_file_message(file: VfsFile) -> str:
+    path_label = _format_path(file.path)
+    header = (
+        f"Read file {path_label} (version {file.version}, {file.size_bytes} bytes)."
+    )
+    body = file.content if file.content else "(empty file)"
+    return f"{header}\n{body}"
+
+
+def _format_write_file_message(path: VfsPath, content: str, mode: WriteMode) -> str:
+    path_label = _format_path(path)
+    action = {
+        "create": "create",
+        "overwrite": "overwrite",
+        "append": "append",
+    }[mode]
+    header = f"Staged {action} for {path_label} ({len(content)} characters)."
+    body = content if content else "(empty content)"
+    return f"{header}\n{body}"
+
+
+def _format_delete_message(path: VfsPath, files: Sequence[VfsFile]) -> str:
+    path_label = _format_path(path)
+    deleted_paths = ", ".join(_format_path(file.path) for file in files)
     return (
-        f"Directory {prefix} contains {directory_count} subdirector"
-        f"{'ies' if directory_count != 1 else 'y'} and {file_count} file"
-        f"{'s' if file_count != 1 else ''}."
+        f"Deleted {len(files)} entr{'ies' if len(files) != 1 else 'y'} under {path_label}:"
+        f" {deleted_paths}"
     )
 
 
+def _format_path(path: VfsPath) -> str:
+    return "/".join(path.segments) or "."
+
+
 def _normalize_root(path: os.PathLike[str] | str) -> Path:
     root = Path(path).expanduser().resolve()
     if not root.exists():
@@ -425,7 +443,6 @@ def _load_mount(mount: HostMount, allowed_roots: Sequence[Path]) -> tuple[VfsFil
             content = path.read_text(encoding=_DEFAULT_ENCODING)
         except UnicodeDecodeError as error:  # pragma: no cover - defensive guard
             raise ToolValidationError("Mounted file must be valid UTF-8.") from error
-        _ensure_ascii(content, "mounted file content")
         size = len(content.encode(_DEFAULT_ENCODING))
         if mount.max_bytes is not None and consumed_bytes + size > mount.max_bytes:
             raise ToolValidationError("Host mount exceeded the configured byte budget.")
@@ -481,15 +498,13 @@ def _iter_mount_files(root: Path, follow_symlinks: bool) -> Iterable[Path]:
             yield current / name
 
 
-def _make_write_reducer(
-    mount_snapshot: VirtualFileSystem,
-) -> Callable[
+def _make_write_reducer() -> Callable[
     [tuple[VirtualFileSystem, ...], DataEvent], tuple[VirtualFileSystem, ...]
 ]:
     def reducer(
         slice_values: tuple[VirtualFileSystem, ...], event: DataEvent
     ) -> tuple[VirtualFileSystem, ...]:
-        previous = _latest_virtual_filesystem(slice_values, mount_snapshot)
+        previous = slice_values[-1] if slice_values else VirtualFileSystem()
         params = cast(WriteFile, event.value)
         timestamp = _now()
         files = list(previous.files)
@@ -527,15 +542,13 @@ def _make_write_reducer(
     return reducer
 
 
-def _make_delete_reducer(
-    mount_snapshot: VirtualFileSystem,
-) -> Callable[
+def _make_delete_reducer() -> Callable[
     [tuple[VirtualFileSystem, ...], DataEvent], tuple[VirtualFileSystem, ...]
 ]:
     def reducer(
         slice_values: tuple[VirtualFileSystem, ...], event: DataEvent
     ) -> tuple[VirtualFileSystem, ...]:
-        previous = _latest_virtual_filesystem(slice_values, mount_snapshot)
+        previous = slice_values[-1] if slice_values else VirtualFileSystem()
         params = cast(DeleteEntry, event.value)
         target = params.path.segments
         files = [
@@ -550,16 +563,6 @@ def _make_delete_reducer(
     return reducer
 
 
-def _latest_virtual_filesystem(
-    values: tuple[VirtualFileSystem, ...], mount_snapshot: VirtualFileSystem
-) -> VirtualFileSystem:
-    if values:
-        return values[-1]
-    if mount_snapshot.files:
-        return mount_snapshot
-    return VirtualFileSystem()
-
-
 def _index_of(files: list[VfsFile], path: VfsPath) -> int | None:
     for index, file in enumerate(files):
         if file.path.segments == path.segments: