deepanalysts 0.7.2__tar.gz → 0.7.3__tar.gz

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.7.2
+Version: 0.7.3
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/deepanalysts/backends/composite.py

@@ -9,7 +9,8 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from typing import cast
+from dataclasses import replace
+from typing import TypeVar, cast
 
 from deepanalysts.backends.protocol import (
     BackendProtocol,
@@ -49,6 +50,29 @@ def _remap_file_info_path(fi: FileInfo, route_prefix: str) -> FileInfo:
     )
 
 
+_ResultT = TypeVar("_ResultT", WriteResult, EditResult)
+
+
+def _remap_result_paths(res: _ResultT, route_prefix: str | None) -> _ResultT:
+    """Re-prepend a matched route prefix to a write/edit result's paths.
+
+    Child backends receive route-stripped paths, so the ``path`` (and
+    ``files_update`` keys) they return are relative to the route root. Tool
+    confirmations echo ``res.path`` back to the model — leaving it stripped
+    hands the model a path that routes to a *different* backend on the next
+    call (e.g. ``/shared/x.md`` written, ``/x.md`` echoed, follow-up read of
+    ``/x.md`` hits the default sandbox and fails).
+    """
+    if route_prefix is None:
+        return res
+    prefix = route_prefix.rstrip("/")
+    path = f"{prefix}{res.path}" if res.path else res.path
+    files_update = res.files_update
+    if files_update is not None:
+        files_update = {f"{prefix}{k}": v for k, v in files_update.items()}
+    return replace(res, path=path, files_update=files_update)
+
+
 def _strip_route_from_pattern(pattern: str, route_prefix: str) -> str:
     """Strip a route prefix from a glob pattern when the pattern targets that route.
 
@@ -163,8 +187,8 @@ class CompositeBackend(SandboxBackendProtocol):
         return backend.read(backend_path, offset=offset, limit=limit)
 
     def write(self, file_path: str, content: str) -> WriteResult:
-        backend, backend_path, _rp = self._route(file_path)
-        return backend.write(backend_path, content)
+        backend, backend_path, route_prefix = self._route(file_path)
+        return _remap_result_paths(backend.write(backend_path, content), route_prefix)
 
     def edit(
         self,
@@ -173,8 +197,11 @@ class CompositeBackend(SandboxBackendProtocol):
         new_string: str,
         replace_all: bool = False,
     ) -> EditResult:
-        backend, backend_path, _rp = self._route(file_path)
-        return backend.edit(backend_path, old_string, new_string, replace_all=replace_all)
+        backend, backend_path, route_prefix = self._route(file_path)
+        return _remap_result_paths(
+            backend.edit(backend_path, old_string, new_string, replace_all=replace_all),
+            route_prefix,
+        )
 
     def grep(
         self,
@@ -309,8 +336,8 @@ class CompositeBackend(SandboxBackendProtocol):
         return await backend.aread_result(backend_path, offset=offset, limit=limit)
 
     async def awrite(self, file_path: str, content: str) -> WriteResult:
-        backend, backend_path, _rp = self._route(file_path)
-        return await backend.awrite(backend_path, content)
+        backend, backend_path, route_prefix = self._route(file_path)
+        return _remap_result_paths(await backend.awrite(backend_path, content), route_prefix)
 
     async def aedit(
         self,
@@ -319,8 +346,11 @@ class CompositeBackend(SandboxBackendProtocol):
         new_string: str,
         replace_all: bool = False,
     ) -> EditResult:
-        backend, backend_path, _rp = self._route(file_path)
-        return await backend.aedit(backend_path, old_string, new_string, replace_all=replace_all)
+        backend, backend_path, route_prefix = self._route(file_path)
+        return _remap_result_paths(
+            await backend.aedit(backend_path, old_string, new_string, replace_all=replace_all),
+            route_prefix,
+        )
 
     async def agrep(
         self,

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/deepanalysts/backends/supabase_storage.py

@@ -337,6 +337,12 @@ class SupabaseStorageBackend(BackendProtocol):
         except StorageListError as e:
             return LsResult(error=f"Error: {e}")
 
+        # Entries must carry the full virtual path, not the bare object name —
+        # listing "/research/x/" with entries rendered as "/README.md" reads as
+        # a root-level file and the model then read_files the wrong path.
+        base = "/" + path.strip("/")
+        base = base if base == "/" else f"{base}/"
+
         entries: list[FileInfo] = []
         for item in items:
             name = item.get("name", "")
@@ -344,12 +350,12 @@ class SupabaseStorageBackend(BackendProtocol):
                 continue
 
             if item.get("id") is None:
-                entries.append(FileInfo(path=f"/{name}/", is_dir=True, size=0, modified_at=""))
+                entries.append(FileInfo(path=f"{base}{name}/", is_dir=True, size=0, modified_at=""))
             else:
                 metadata = item.get("metadata") or {}
                 entries.append(
                     FileInfo(
-                        path=f"/{name}",
+                        path=f"{base}{name}",
                         is_dir=False,
                         size=metadata.get("size", 0),
                         modified_at=item.get("updated_at", ""),

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/deepanalysts/middleware/filesystem.py

@@ -736,19 +736,22 @@ class FilesystemMiddleware(AgentMiddleware):
             res: WriteResult = resolved_backend.write(file_path, content)
             if res.error:
                 return res.error
+            # Byte count lets the model verify a large write completed even
+            # after history compaction truncates the content argument.
+            confirmation = f"Updated file {res.path} ({len(content.encode('utf-8'))} bytes written)"
             if res.files_update is not None:
                 return Command(
                     update={
                         "files": res.files_update,
                         "messages": [
                             ToolMessage(
-                                content=f"Updated file {res.path}",
+                                content=confirmation,
                                 tool_call_id=runtime.tool_call_id,
                             )
                         ],
                     }
                 )
-            return f"Updated file {res.path}"
+            return confirmation
 
         async def async_write_file(
             file_path: Annotated[str, "Absolute path to the file to write."],
@@ -763,19 +766,22 @@ class FilesystemMiddleware(AgentMiddleware):
             res: WriteResult = await resolved_backend.awrite(file_path, content)
             if res.error:
                 return res.error
+            # Byte count lets the model verify a large write completed even
+            # after history compaction truncates the content argument.
+            confirmation = f"Updated file {res.path} ({len(content.encode('utf-8'))} bytes written)"
             if res.files_update is not None:
                 return Command(
                     update={
                         "files": res.files_update,
                         "messages": [
                             ToolMessage(
-                                content=f"Updated file {res.path}",
+                                content=confirmation,
                                 tool_call_id=runtime.tool_call_id,
                             )
                         ],
                     }
                 )
-            return f"Updated file {res.path}"
+            return confirmation
 
         return StructuredTool.from_function(
             name="write_file",

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/deepanalysts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.7.2
+Version: 0.7.3
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepanalysts"
-version = "0.7.2"
+version = "0.7.3"
 description = "LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support"
 readme = "README.md"
 license = { text = "MIT" }

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/tests/test_composite_backend.py

@@ -44,7 +44,7 @@ class TestCompositeBackendRouting:
         )
         result = composite.write("/memories/user.md", "preferences")
         assert result.error is None
-        assert result.path == "/user.md"  # Prefix stripped
+        assert result.path == "/memories/user.md"  # Full virtual path echoed
 
     def test_route_to_default(self):
         """Test unmatched paths use default backend."""
@@ -79,8 +79,8 @@ class TestCompositeBackendRouting:
         # The /skills/trading/ should match before /skills/
         result = composite.write("/skills/trading/fib.md", "content")
         assert result.error is None
-        # Path stripped to /fib.md (not /trading/fib.md)
-        assert result.path == "/fib.md"
+        # Result path is the full virtual path, whichever route matched
+        assert result.path == "/skills/trading/fib.md"
 
 
 class TestCompositeBackendExecution:
@@ -217,7 +217,7 @@ class TestCompositeBackendAsync:
 
             result = await composite.awrite("/memories/new.md", "new content")
             assert result.error is None
-            assert result.path == "/new.md"  # Prefix stripped
+            assert result.path == "/memories/new.md"  # Full virtual path echoed
 
         asyncio.run(run_test())
 
@@ -475,3 +475,88 @@ class TestPathHelpers:
     def test_strip_route_leading_slash_agnostic(self):
         result = _strip_route_from_pattern("memories/**/*.md", "/memories/")
         assert result == "**/*.md"
+
+
+# ---------------------------------------------------------------------------
+# Regression: write/edit results must echo the full virtual path
+# ---------------------------------------------------------------------------
+
+
+class TestWriteEditResultPathRemap:
+    """Regression for the /shared/ path-stripping bug.
+
+    Routed backends see route-stripped paths, so their results carried e.g.
+    ``/research/x.md`` for a write to ``/shared/research/x.md``. The tool
+    confirmation echoed that stripped path, and a follow-up read of it routed
+    to the *default* backend and failed. Write/edit results must round-trip.
+    """
+
+    def test_write_result_path_roundtrips_through_read(self):
+        composite = CompositeBackend(
+            default=make_store_backend(),
+            routes={"/shared/": make_store_backend()},
+        )
+        result = composite.write("/shared/research/x/README.md", "# hi")
+        assert result.error is None
+        assert result.path == "/shared/research/x/README.md"
+        # The echoed path must be readable as-is (this failed pre-fix: the
+        # stripped path routed to the default backend).
+        assert "hi" in composite.read(result.path)
+
+    def test_edit_result_path_is_full_virtual_path(self):
+        store = make_store_backend()
+        composite = CompositeBackend(
+            default=make_store_backend(),
+            routes={"/shared/": store},
+        )
+        store.write("/note.md", "hello world")
+        result = composite.edit("/shared/note.md", "hello", "goodbye")
+        assert result.error is None
+        assert result.path == "/shared/note.md"
+
+    def test_awrite_files_update_keys_are_remapped(self):
+        async def run_test():
+            composite = CompositeBackend(
+                default=make_store_backend(),
+                routes={"/memories/": make_store_backend()},
+            )
+            result = await composite.awrite("/memories/a/b.md", "content")
+            assert result.error is None
+            assert result.path == "/memories/a/b.md"
+            if result.files_update is not None:
+                assert all(k.startswith("/memories/") for k in result.files_update)
+
+        asyncio.run(run_test())
+
+    def test_aedit_result_path_is_full_virtual_path(self):
+        async def run_test():
+            store = make_store_backend()
+            composite = CompositeBackend(
+                default=make_store_backend(),
+                routes={"/shared/": store},
+            )
+            store.write("/x.md", "old text")
+            result = await composite.aedit("/shared/x.md", "old", "new")
+            assert result.error is None
+            assert result.path == "/shared/x.md"
+
+        asyncio.run(run_test())
+
+    def test_default_route_write_path_unchanged(self):
+        composite = CompositeBackend(
+            default=make_store_backend(),
+            routes={"/memories/": make_store_backend()},
+        )
+        result = composite.write("/scratch.txt", "tmp")
+        assert result.error is None
+        assert result.path == "/scratch.txt"
+
+    def test_error_result_passes_through(self):
+        store = make_store_backend()
+        composite = CompositeBackend(
+            default=make_store_backend(),
+            routes={"/shared/": store},
+        )
+        result = composite.edit("/shared/missing.md", "a", "b")
+        assert result.error is not None
+        assert result.path is None

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/tests/test_filesystem_middleware.py

@@ -29,6 +29,14 @@ def _make_store_backend() -> StoreBackend:
     return StoreBackend(_make_mock_runtime())
 
 
+def _invoke_write_file(middleware: FilesystemMiddleware, file_path: str, content: str):
+    """Invoke the write_file tool's sync function directly (see _invoke_read_file)."""
+    write_file_tool = next(t for t in middleware.tools if t.name == "write_file")
+    runtime = MagicMock()
+    runtime.tool_call_id = "test-call-id"
+    return write_file_tool.func(file_path=file_path, content=content, runtime=runtime)
+
+
 def _invoke_read_file(middleware: FilesystemMiddleware, file_path: str, offset: int = 0, limit: int = 500) -> str:
     """Invoke the read_file tool's sync function directly.
 
@@ -44,6 +52,33 @@ def _invoke_read_file(middleware: FilesystemMiddleware, file_path: str, offset:
     return sync_fn(file_path=file_path, runtime=runtime, offset=offset, limit=limit)
 
 
+class TestWriteFileConfirmation:
+    """Regression: the confirmation must state how many bytes were written.
+
+    History compaction later truncates the write's content argument to a
+    20-char preview ("...(argument truncated)"), so without a byte count the
+    model cannot tell whether a large write completed and tends to retry it.
+    """
+
+    def test_confirmation_reports_byte_count(self):
+        backend = _make_store_backend()
+        middleware = FilesystemMiddleware(backend=backend)
+        content = "x" * 1234
+        result = _invoke_write_file(middleware, "/report.md", content)
+        # StoreBackend returns files_update, so the confirmation rides a Command
+        message = result.update["messages"][0].content if hasattr(result, "update") else result
+        assert "/report.md" in message
+        assert "1234 bytes written" in message
+
+    def test_byte_count_is_utf8_bytes_not_chars(self):
+        backend = _make_store_backend()
+        middleware = FilesystemMiddleware(backend=backend)
+        content = "é" * 10  # 10 chars, 20 UTF-8 bytes
+        result = _invoke_write_file(middleware, "/unicode.md", content)
+        message = result.update["messages"][0].content if hasattr(result, "update") else result
+        assert "20 bytes written" in message
+
+
 class TestReadFileTruncation:
     """Tests for read_file tool truncation behavior."""
 

{deepanalysts-0.7.2 → deepanalysts-0.7.3}/tests/test_supabase_storage_backend.py

@@ -258,6 +258,41 @@ class TestAls:
 
         asyncio.run(run())
 
+    def test_list_subdirectory_entries_carry_full_path(self):
+        """Regression: entries were rendered as bare names ("/README.md"), so
+        listing a subdirectory looked like a listing of the tree root and the
+        model then read the wrong path."""
+
+        async def run():
+            b = make_backend()
+            items = [
+                {"name": "README.md", "id": "abc", "metadata": {"size": 10}, "updated_at": "2024-01-01"},
+                {"name": "data", "id": None},  # folder
+            ]
+            with patch.object(b, "_list_objects", new_callable=AsyncMock, return_value=items):
+                result = await b.als("/research/ai-supply-chain/")
+                assert result.error is None
+                paths = [fi["path"] for fi in (result.entries or [])]
+                assert "/research/ai-supply-chain/README.md" in paths
+                assert "/research/ai-supply-chain/data/" in paths
+                assert "/README.md" not in paths
+
+        asyncio.run(run())
+
+    def test_list_subdirectory_without_trailing_slash(self):
+        async def run():
+            b = make_backend()
+            items = [
+                {"name": "notes.md", "id": "x", "metadata": {"size": 5}, "updated_at": "2024-01-01"},
+            ]
+            with patch.object(b, "_list_objects", new_callable=AsyncMock, return_value=items):
+                result = await b.als("/research")
+                assert result.error is None
+                paths = [fi["path"] for fi in (result.entries or [])]
+                assert paths == ["/research/notes.md"]
+
+        asyncio.run(run())
+
 
 class TestAgrep:
     def test_grep_finds_matches(self):