dfdf

cmdlet/merge_file.py

@@ -112,6 +112,107 @@ def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
         item = files_to_merge[0]
         ctx.emit(item)
         return 0
+
+    def _resolve_existing_path(item: Dict[str, Any]) -> Optional[Path]:
+        raw_path = get_pipe_object_path(item)
+        target_path: Optional[Path] = None
+        if isinstance(raw_path, Path):
+            target_path = raw_path
+        elif isinstance(raw_path, str) and raw_path.strip():
+            candidate = Path(raw_path).expanduser()
+            if candidate.exists():
+                target_path = candidate
+        if target_path and target_path.exists():
+            return target_path
+        return None
+
+    def _extract_url(item: Dict[str, Any]) -> Optional[str]:
+        u = get_field(item, "url") or get_field(item, "target")
+        if isinstance(u, str):
+            s = u.strip()
+            if s.lower().startswith(("http://", "https://")):
+                return s
+        return None
+
+    # If the user piped URL-only playlist selections (no local paths yet), download first.
+    # This keeps the pipeline order intuitive:
+    #   @* | merge-file | add-file -store ...
+    urls_to_download: List[str] = []
+    for it in files_to_merge:
+        if _resolve_existing_path(it) is not None:
+            continue
+        u = _extract_url(it)
+        if u:
+            urls_to_download.append(u)
+
+    if urls_to_download and len(urls_to_download) >= 2:
+        try:
+            # Compute a batch hint (audio vs video + single-format id) once.
+            mode_hint: Optional[str] = None
+            forced_format: Optional[str] = None
+            try:
+                from cmdlet.download_media import list_formats
+                from tool.ytdlp import YtDlpTool
+
+                sample_url = urls_to_download[0]
+                cookiefile = None
+                try:
+                    cookie_path = YtDlpTool(config).resolve_cookiefile()
+                    if cookie_path is not None and cookie_path.is_file():
+                        cookiefile = str(cookie_path)
+                except Exception:
+                    cookiefile = None
+
+                fmts = list_formats(sample_url, no_playlist=False, playlist_items=None, cookiefile=cookiefile)
+                if isinstance(fmts, list) and fmts:
+                    has_video = False
+                    for f in fmts:
+                        if not isinstance(f, dict):
+                            continue
+                        vcodec = str(f.get("vcodec", "none") or "none").strip().lower()
+                        if vcodec and vcodec != "none":
+                            has_video = True
+                            break
+                    mode_hint = "video" if has_video else "audio"
+
+                    if len(fmts) == 1 and isinstance(fmts[0], dict):
+                        fid = str(fmts[0].get("format_id") or "").strip()
+                        if fid:
+                            forced_format = fid
+            except Exception:
+                mode_hint = None
+                forced_format = None
+
+            from cmdlet.add_file import Add_File
+
+            expanded: List[Dict[str, Any]] = []
+            downloaded_any = False
+            for it in files_to_merge:
+                if _resolve_existing_path(it) is not None:
+                    expanded.append(it)
+                    continue
+                u = _extract_url(it)
+                if not u:
+                    expanded.append(it)
+                    continue
+
+                downloaded = Add_File._download_streaming_url_as_pipe_objects(
+                    u,
+                    config,
+                    mode_hint=mode_hint,
+                    ytdl_format_hint=forced_format,
+                )
+                if downloaded:
+                    expanded.extend(downloaded)
+                    downloaded_any = True
+                else:
+                    expanded.append(it)
+
+            if downloaded_any:
+                files_to_merge = expanded
+        except Exception:
+            # If downloads fail, we fall back to the existing path-based merge behavior.
+            pass
     
     # Extract file paths and metadata from result objects
     source_files: List[Path] = []
@@ -120,14 +221,7 @@ def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
     source_tags: List[str] = []  # tags read from .tag sidecars
     source_item_tag_lists: List[List[str]] = []  # tags carried in-memory on piped items
     for item in files_to_merge:
-        raw_path = get_pipe_object_path(item)
-        target_path = None
-        if isinstance(raw_path, Path):
-            target_path = raw_path
-        elif isinstance(raw_path, str) and raw_path.strip():
-            candidate = Path(raw_path).expanduser()
-            if candidate.exists():
-                target_path = candidate
+        target_path = _resolve_existing_path(item)
         
         if target_path and target_path.exists():
             source_files.append(target_path)