fdf

cmdlet/add_file.py

@@ -441,6 +441,35 @@ class Add_File(Cmdlet):
         ctx.emit(pipe_obj.to_dict())
         ctx.set_current_stage_table(None)
 
+    @staticmethod
+    def _emit_storage_result(payload: Dict[str, Any]) -> None:
+        """Emit a storage-style result payload.
+
+        - Always emits the dict downstream (when in a pipeline).
+        - If this is the last stage (or not in a pipeline), prints a search-store-like table
+          and sets an overlay table/items for @N selection.
+        """
+        # Always emit for downstream commands (no-op if not in a pipeline)
+        ctx.emit(payload)
+
+        stage_ctx = ctx.get_stage_context()
+        is_last = (stage_ctx is None) or bool(getattr(stage_ctx, "is_last_stage", False))
+        if not is_last:
+            return
+
+        try:
+            from result_table import ResultTable
+            table = ResultTable("Result")
+            table.add_result(payload)
+            # Overlay so @1 refers to this add-file result without overwriting search history
+            ctx.set_last_result_table_overlay(table, [payload], subject=payload)
+        except Exception:
+            # If table rendering fails, still keep @ selection items
+            try:
+                ctx.set_last_result_items_only([payload])
+            except Exception:
+                pass
+
     @staticmethod
     def _prepare_metadata(
         result: Any,
@@ -788,7 +817,55 @@ class Add_File(Cmdlet):
                     "url": url,
                 },
             )
-            Add_File._emit_pipe_object(pipe_obj)
+
+            # Emit a search-store-like payload for consistent tables and natural piping.
+            # Keep hash/store for downstream commands (get-tag, get-file, etc.).
+            resolved_hash = file_identifier if len(file_identifier) == 64 else (f_hash or file_identifier or "unknown")
+
+            meta: Dict[str, Any] = {}
+            try:
+                meta = backend.get_metadata(resolved_hash) or {}
+            except Exception:
+                meta = {}
+
+            # Determine size bytes
+            size_bytes: Optional[int] = None
+            for key in ("size_bytes", "size", "filesize", "file_size"):
+                try:
+                    raw_size = meta.get(key)
+                    if raw_size is not None:
+                        size_bytes = int(raw_size)
+                        break
+                except Exception:
+                    pass
+            if size_bytes is None:
+                try:
+                    size_bytes = int(media_path.stat().st_size)
+                except Exception:
+                    size_bytes = None
+
+            # Determine title/ext
+            title_out = (
+                meta.get("title")
+                or title
+                or pipe_obj.title
+                or media_path.stem
+                or media_path.name
+            )
+            ext_out = (meta.get("ext") or media_path.suffix.lstrip("."))
+
+            payload: Dict[str, Any] = {
+                "title": title_out,
+                "ext": str(ext_out or ""),
+                "size_bytes": size_bytes,
+                "store": backend_name,
+                "hash": resolved_hash,
+                # Preserve extra fields for downstream commands (kept hidden by default table rules)
+                "path": stored_path,
+                "tag": list(tags or []),
+                "url": list(url or []),
+            }
+            Add_File._emit_storage_result(payload)
             
             Add_File._cleanup_after_success(media_path, delete_source=delete_after)
             return 0