chore: import upstream snapshot with attribution

python/tests/commands/builtin/dify/conftest.py

@@ -0,0 +1,60 @@
+from types import SimpleNamespace
+
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.types import PathSpec
+from mirage.utils.key_prefix import mount_key
+
+
+def document(document_id: str, name: str, slug: str, size: int = 12) -> dict:
+    return {
+        "id": document_id,
+        "name": name,
+        "doc_metadata": [{
+            "name": "slug",
+            "value": slug
+        }],
+        "enabled": True,
+        "indexing_status": "completed",
+        "archived": False,
+        "tokens": 4,
+        "data_source_type": "upload_file",
+        "data_source_detail_dict": {
+            "upload_file": {
+                "size": size
+            }
+        },
+        "created_at": 1716282000,
+    }
+
+
+@pytest.fixture
+def dify_accessor() -> SimpleNamespace:
+    return SimpleNamespace(config=SimpleNamespace(slug_metadata_name="slug"))
+
+
+@pytest.fixture
+def dify_index() -> RAMIndexCacheStore:
+    return RAMIndexCacheStore()
+
+
+@pytest.fixture
+def knowledge_root() -> PathSpec:
+    return PathSpec(resource_path=mount_key("/knowledge", "/knowledge"),
+                    virtual="/knowledge",
+                    directory="/knowledge")
+
+
+@pytest.fixture
+def guide_path() -> PathSpec:
+    return PathSpec.from_str_path(
+        "/knowledge/guides/quickstart.md",
+        mount_key("/knowledge/guides/quickstart.md", "/knowledge"))
+
+
+@pytest.fixture
+def guides_path() -> PathSpec:
+    return PathSpec(resource_path=mount_key("/knowledge/guides", "/knowledge"),
+                    virtual="/knowledge/guides",
+                    directory="/knowledge/guides")

python/tests/commands/builtin/dify/test_cat.py

@@ -0,0 +1,76 @@
+import pytest
+
+from mirage.commands.builtin.dify.cat import make_cat
+from mirage.commands.builtin.generic_bind import CommandIO, with_read_cache
+from mirage.core.dify import read, tree
+from mirage.core.dify.read import read_bytes as _read_bytes
+from mirage.core.dify.read import read_stream as _read_stream
+from mirage.core.dify.readdir import readdir as _readdir
+from mirage.core.dify.stat import stat as _stat
+from mirage.io.types import materialize
+from mirage.types import PathSpec
+from mirage.utils.key_prefix import mount_key
+
+from .conftest import document
+
+cat = make_cat(
+    with_read_cache(
+        CommandIO(
+            readdir=_readdir,
+            read_bytes=_read_bytes,
+            read_stream=_read_stream,
+            stat=_stat,
+            is_mounted=lambda a: True,
+            local=False,
+        )))
+
+
+async def list_basic_documents(config):
+    return [
+        document("doc-1", "Guide", "guides/quickstart.md"),
+        document("doc-2", "Readme", "README.md"),
+    ]
+
+
+async def iter_basic_pages(config, document_id):
+    if document_id == "doc-1":
+        yield [{"content": "alpha\nbeta"}, {"content": "gamma"}]
+    else:
+        yield [{"content": "readme"}]
+
+
+@pytest.mark.asyncio
+async def test_cat_reads_stream_and_records_cache(monkeypatch, dify_accessor,
+                                                  dify_index, guide_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_basic_documents)
+    monkeypatch.setattr(read, "iter_segment_pages", iter_basic_pages)
+
+    stdout, io = await cat(dify_accessor, [guide_path], index=dify_index)
+
+    assert await materialize(stdout) == b"alpha\nbeta\ngamma"
+    assert guide_path.mount_path in io.reads
+    assert io.cache == [guide_path.mount_path]
+
+
+async def get_two_doc_segments(config, document_id):
+    if document_id == "doc-1":
+        return [{"content": "alpha\nbeta"}, {"content": "gamma"}]
+    return [{"content": "readme"}]
+
+
+@pytest.mark.asyncio
+async def test_cat_multifile_caches_materialized_bytes_per_file(
+        monkeypatch, dify_accessor, dify_index, guide_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_basic_documents)
+    monkeypatch.setattr(read, "get_document_segments", get_two_doc_segments)
+
+    readme_path = PathSpec.from_str_path(
+        "/knowledge/README.md", mount_key("/knowledge/README.md",
+                                          "/knowledge"))
+    stdout, io = await cat(dify_accessor, [guide_path, readme_path],
+                           index=dify_index)
+
+    assert io.reads[guide_path.mount_path] == b"alpha\nbeta\ngamma"
+    assert io.reads[readme_path.mount_path] == b"readme"
+    assert all(isinstance(v, bytes) for v in io.reads.values())
+    assert await materialize(stdout) == b"alpha\nbeta\ngammareadme"

python/tests/commands/builtin/dify/test_find.py

@@ -0,0 +1,98 @@
+import pytest
+
+from mirage.commands.builtin.dify.find import find
+from mirage.core.dify import tree
+from mirage.io.types import materialize
+from mirage.types import PathSpec
+from mirage.utils.key_prefix import mount_key
+
+from .conftest import document
+
+
+async def list_basic_documents(config):
+    return [
+        document("doc-1", "Guide", "guides/quickstart.md"),
+        document("doc-2", "Readme", "README.md"),
+    ]
+
+
+async def list_nested_documents(config):
+    return [
+        document("doc-1", "Guide", "guides/quickstart.md"),
+        document("doc-2", "Guide 2", "guides/deep/note.md"),
+        document("doc-3", "Readme", "README.md"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_find_matches_name_pattern(monkeypatch, dify_accessor,
+                                         dify_index, knowledge_root):
+    monkeypatch.setattr(tree, "list_all_documents", list_basic_documents)
+
+    stdout, _ = await find(dify_accessor, [knowledge_root],
+                           "quick*.md",
+                           index=dify_index)
+
+    assert await materialize(stdout) == b"/knowledge/guides/quickstart.md\n"
+
+
+@pytest.mark.asyncio
+async def test_find_handles_file_missing_and_maxdepth(monkeypatch,
+                                                      dify_accessor,
+                                                      dify_index,
+                                                      knowledge_root,
+                                                      guide_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_basic_documents)
+
+    file_stdout, file_io = await find(dify_accessor, [guide_path],
+                                      index=dify_index)
+    assert await materialize(file_stdout
+                             ) == b"/knowledge/guides/quickstart.md\n"
+    assert file_io.exit_code == 0
+
+    maxdepth_stdout, maxdepth_io = await find(dify_accessor, [knowledge_root],
+                                              maxdepth="0",
+                                              index=dify_index)
+    assert await materialize(maxdepth_stdout) == b"/knowledge\n"
+    assert maxdepth_io.exit_code == 0
+
+    missing = PathSpec.from_str_path(
+        "/knowledge/missing.md",
+        mount_key("/knowledge/missing.md", "/knowledge"))
+    missing_stdout, missing_io = await find(dify_accessor, [missing],
+                                            index=dify_index)
+    assert await materialize(missing_stdout) == b""
+    assert missing_io.stderr is not None
+    assert b"/knowledge/missing.md" in missing_io.stderr
+    assert missing_io.exit_code == 1
+
+
+@pytest.mark.asyncio
+async def test_find_uses_cwd_when_path_missing(monkeypatch, dify_accessor,
+                                               dify_index, guides_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_nested_documents)
+
+    stdout, io = await find(dify_accessor, [],
+                            "quick*.md",
+                            cwd=guides_path,
+                            index=dify_index)
+
+    assert await materialize(stdout) == b"/knowledge/guides/quickstart.md\n"
+    assert io.exit_code == 0
+
+
+@pytest.mark.asyncio
+async def test_find_resolves_glob_patterns(monkeypatch, dify_accessor,
+                                           dify_index):
+    monkeypatch.setattr(tree, "list_all_documents", list_nested_documents)
+    path = PathSpec(resource_path=mount_key("/knowledge/guides/*.md",
+                                            "/knowledge"),
+                    virtual="/knowledge/guides/*.md",
+                    directory="/knowledge/guides",
+                    pattern="*.md",
+                    resolved=False)
+
+    stdout, io = await find(dify_accessor, [path], index=dify_index)
+
+    assert await materialize(stdout) == b"/knowledge/guides/quickstart.md\n"
+    assert io.exit_code == 0

python/tests/commands/builtin/dify/test_search.py

@@ -0,0 +1,108 @@
+from types import SimpleNamespace
+
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.io.types import materialize
+from mirage.types import PathSpec
+from mirage.utils.key_prefix import mount_key
+
+
+def document(document_id: str, name: str, slug: str | None = None) -> dict:
+    metadata = []
+    if slug is not None:
+        metadata = [{"name": "slug", "value": slug}]
+    return {
+        "id": document_id,
+        "name": name,
+        "doc_metadata": metadata,
+        "enabled": True,
+        "indexing_status": "completed",
+        "archived": False,
+        "tokens": 4,
+        "data_source_type": "upload_file",
+        "data_source_detail_dict": {
+            "upload_file": {
+                "size": 12
+            }
+        },
+        "created_at": 1716282000,
+    }
+
+
+def accessor() -> SimpleNamespace:
+    return SimpleNamespace(config=SimpleNamespace(slug_metadata_name="slug"))
+
+
+@pytest.mark.asyncio
+async def test_search_command_resolves_globs_and_passes_multiple_documents(
+        monkeypatch):
+    from mirage.commands.builtin.dify import search as command_search
+    from mirage.core.dify import search, tree
+
+    calls: list[tuple[list[PathSpec], dict]] = []
+
+    async def list_documents(config):
+        return [
+            document("doc-1", "API", "guides/api.md"),
+            document("doc-2", "Auth", "guides/auth.md"),
+        ]
+
+    async def search_segments(accessor, query, paths, index, **kwargs):
+        calls.append((paths, kwargs))
+        return b"api\nauth"
+
+    monkeypatch.setattr(tree, "list_all_documents", list_documents)
+    monkeypatch.setattr(search, "search_segments", search_segments)
+
+    stdout, io = await command_search(
+        accessor(),
+        [
+            PathSpec(resource_path=mount_key("/knowledge/guides/*.md",
+                                             "/knowledge"),
+                     virtual="/knowledge/guides/*.md",
+                     directory="/knowledge/guides",
+                     pattern="*.md",
+                     resolved=False)
+        ],
+        "login",
+        index=RAMIndexCacheStore(),
+    )
+
+    assert await materialize(stdout) == b"api\nauth"
+    assert io.reads == {}
+    assert io.cache == []
+    assert [path.virtual for path in calls[0][0]] == [
+        "/knowledge/guides/api.md",
+        "/knowledge/guides/auth.md",
+    ]
+    assert calls[0][1]["mount_prefix"] == "/knowledge"
+
+
+@pytest.mark.asyncio
+async def test_search_command_root_searches_whole_dataset(monkeypatch):
+    from mirage.commands.builtin.dify import search as command_search
+    from mirage.core.dify import search
+
+    calls: list[tuple[list[PathSpec], dict]] = []
+
+    async def search_segments(accessor, query, paths, index, **kwargs):
+        calls.append((paths, kwargs))
+        return b"dataset"
+
+    monkeypatch.setattr(search, "search_segments", search_segments)
+    root = PathSpec(resource_path=mount_key("/knowledge", "/knowledge"),
+                    virtual="/knowledge",
+                    directory="/knowledge")
+
+    stdout, _ = await command_search(accessor(), [root],
+                                     "anything",
+                                     index=RAMIndexCacheStore())
+
+    assert await materialize(stdout) == b"dataset"
+    assert calls == [([], {
+        "method": "semantic",
+        "top_k": 10,
+        "threshold": 0.0,
+        "mount_prefix": "/knowledge"
+    })]

python/tests/commands/builtin/dify/test_sed.py

@@ -0,0 +1,53 @@
+import pytest
+
+from mirage.commands.builtin.dify import COMMANDS
+from mirage.core.dify import read, tree
+from mirage.io.types import materialize
+
+from .conftest import document
+
+
+def _sed_command():
+    for cmd in COMMANDS:
+        for rc in cmd._registered_commands:
+            if rc.name == "sed":
+                return cmd
+    raise LookupError("sed not registered for dify")
+
+
+sed = _sed_command()
+
+
+async def list_documents(config):
+    return [document("doc-1", "Guide", "guides/quickstart.md")]
+
+
+async def get_segments(config, document_id):
+    return [{"content": "alpha beta"}]
+
+
+@pytest.mark.asyncio
+async def test_sed_transforms_dify_document(monkeypatch, dify_accessor,
+                                            dify_index, guide_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_documents)
+    monkeypatch.setattr(read, "get_document_segments", get_segments)
+
+    stdout, io = await sed(dify_accessor, [guide_path],
+                           "s/alpha/gamma/",
+                           index=dify_index)
+
+    assert await materialize(stdout) == b"gamma beta"
+    assert io.exit_code == 0
+
+
+@pytest.mark.asyncio
+async def test_sed_rejects_in_place(monkeypatch, dify_accessor, dify_index,
+                                    guide_path):
+    monkeypatch.setattr(tree, "list_all_documents", list_documents)
+
+    with pytest.raises(PermissionError,
+                       match="-i not supported on this backend"):
+        await sed(dify_accessor, [guide_path],
+                  "s/alpha/gamma/",
+                  i=True,
+                  index=dify_index)