chore: import upstream snapshot with attribution

python/mirage/core/github/find.py

@@ -0,0 +1,104 @@
+# ========= Copyright 2026 @ Strukto.AI All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2026 @ Strukto.AI All Rights Reserved. =========
+
+from mirage.accessor.github import GitHubAccessor
+from mirage.cache.index import IndexCacheStore
+from mirage.commands.builtin.find_eval import (FindEntry, PredNode, build_tree,
+                                               emit_start_path, keep,
+                                               start_basename)
+from mirage.types import PathSpec
+
+
+async def find(
+    accessor: GitHubAccessor,
+    path: PathSpec,
+    name: str | None = None,
+    type: str | None = None,
+    min_size: int | None = None,
+    max_size: int | None = None,
+    maxdepth: int | None = None,
+    name_exclude: str | None = None,
+    or_names: list[str] | None = None,
+    mtime_min: float | None = None,
+    mtime_max: float | None = None,
+    iname: str | None = None,
+    mindepth: int | None = None,
+    path_pattern: str | None = None,
+    empty: bool = False,
+    tree: PredNode | None = None,
+    index: IndexCacheStore = None,
+) -> list[str]:
+    if isinstance(path, str):
+        path = PathSpec(virtual=path,
+                        directory=path,
+                        resource_path=path.strip("/"))
+    if index is None:
+        raise ValueError("find: no tree loaded")
+    base = path.mount_path.strip("/")
+    base_depth = 0 if base == "" else base.count("/") + 1
+    start_name = start_basename(path)
+    results: list[str] = []
+    tree = tree if tree is not None else build_tree(name=name,
+                                                    iname=iname,
+                                                    path_pattern=path_pattern,
+                                                    type=type,
+                                                    name_exclude=name_exclude,
+                                                    or_names=or_names)
+    start_kind = "d" if base == "" else None
+    start_size = 0
+    has_child = False
+    for entry_path in sorted(index._entries):
+        p = entry_path.lstrip("/")
+        if p == base:
+            meta = index._entries[entry_path]
+            start_kind = "d" if meta.resource_type == "folder" else "f"
+            start_size = meta.size or 0
+            continue
+        if base and not p.startswith(base + "/"):
+            continue
+        has_child = True
+        entry_meta = index._entries[entry_path]
+        is_dir = entry_meta.resource_type == "folder"
+        full_path = "/" + p
+        depth = p.count("/") + 1 - base_depth
+        if maxdepth is not None and depth > maxdepth:
+            continue
+        entry = FindEntry(key=full_path,
+                          name=p.rsplit("/", 1)[-1],
+                          kind="d" if is_dir else "f",
+                          depth=depth)
+        if not keep(entry, tree, mindepth):
+            continue
+        # Directories count as size 0 for -size (deliberate GNU divergence).
+        size = 0 if is_dir else (entry_meta.size or 0)
+        if min_size is not None and size < min_size:
+            continue
+        if max_size is not None and size > max_size:
+            continue
+        results.append(full_path)
+    if start_kind is not None or has_child:
+        root_kind = start_kind or "d"
+        emit_start_path(results,
+                        "/" + base if base else "/",
+                        start_name,
+                        kind=root_kind,
+                        is_empty=None,
+                        exists=True,
+                        tree=tree,
+                        maxdepth=maxdepth,
+                        mindepth=mindepth,
+                        size=start_size if root_kind == "f" else None,
+                        min_size=min_size,
+                        max_size=max_size)
+    return sorted(results)