feat: Add --dry-run option to cloud upload command

Allows users to preview what files would be uploaded without actually
uploading them. Useful for:
- Checking which files will be uploaded before committing
- Verifying ignore patterns are working correctly
- Estimating upload size and file count

Features:
- Shows list of files that would be uploaded with their sizes
- Works with --verbose to show detailed filtering info
- Displays total file count and size
- Skips actual upload and sync when enabled

Usage:
  bm cloud upload ./files --project test --dry-run
  bm cloud upload ./notes --project work --dry-run --verbose

Includes comprehensive test coverage for dry-run functionality.

Author: phernandez

src/basic_memory/cli/commands/cloud/upload.py

@@ -12,7 +12,11 @@
 
 
 async def upload_path(
-    local_path: Path, project_name: str, verbose: bool = False, use_gitignore: bool = True
+    local_path: Path,
+    project_name: str,
+    verbose: bool = False,
+    use_gitignore: bool = True,
+    dry_run: bool = False,
 ) -> bool:
     """
     Upload a file or directory to cloud project via WebDAV.
@@ -22,6 +26,7 @@ async def upload_path(
         project_name: Name of cloud project (destination)
         verbose: Show detailed information about filtering and upload
         use_gitignore: If False, skip .gitignore patterns (still use .bmignore)
+        dry_run: If True, show what would be uploaded without uploading
 
     Returns:
         True if upload succeeded, False otherwise
@@ -54,34 +59,50 @@ async def upload_path(
 
         print(f"Found {len(files_to_upload)} file(s) to upload")
 
-        # Upload files using httpx
-        total_bytes = 0
-
-        async with get_client() as client:
-            for i, (file_path, relative_path) in enumerate(files_to_upload, 1):
-                # Build remote path: /webdav/{project_name}/{relative_path}
-                remote_path = f"/webdav/{project_name}/{relative_path}"
-                print(f"Uploading {relative_path} ({i}/{len(files_to_upload)})")
-
-                # Read file content asynchronously
-                async with aiofiles.open(file_path, "rb") as f:
-                    content = await f.read()
-
-                # Upload via HTTP PUT to WebDAV endpoint
-                response = await call_put(client, remote_path, content=content)
-                response.raise_for_status()
-
-                total_bytes += file_path.stat().st_size
-
-        # Format size based on magnitude
+        # Calculate total size
+        total_bytes = sum(file_path.stat().st_size for file_path, _ in files_to_upload)
+
+        # If dry run, just show what would be uploaded
+        if dry_run:
+            print("\nFiles that would be uploaded:")
+            for file_path, relative_path in files_to_upload:
+                size = file_path.stat().st_size
+                if size < 1024:
+                    size_str = f"{size} bytes"
+                elif size < 1024 * 1024:
+                    size_str = f"{size / 1024:.1f} KB"
+                else:
+                    size_str = f"{size / (1024 * 1024):.1f} MB"
+                print(f"  {relative_path} ({size_str})")
+        else:
+            # Upload files using httpx
+            async with get_client() as client:
+                for i, (file_path, relative_path) in enumerate(files_to_upload, 1):
+                    # Build remote path: /webdav/{project_name}/{relative_path}
+                    remote_path = f"/webdav/{project_name}/{relative_path}"
+                    print(f"Uploading {relative_path} ({i}/{len(files_to_upload)})")
+
+                    # Read file content asynchronously
+                    async with aiofiles.open(file_path, "rb") as f:
+                        content = await f.read()
+
+                    # Upload via HTTP PUT to WebDAV endpoint
+                    response = await call_put(client, remote_path, content=content)
+                    response.raise_for_status()
+
+        # Format total size based on magnitude
         if total_bytes < 1024:
             size_str = f"{total_bytes} bytes"
         elif total_bytes < 1024 * 1024:
             size_str = f"{total_bytes / 1024:.1f} KB"
         else:
             size_str = f"{total_bytes / (1024 * 1024):.1f} MB"
 
-        print(f"✓ Upload complete: {len(files_to_upload)} file(s) ({size_str})")
+        if dry_run:
+            print(f"\nTotal: {len(files_to_upload)} file(s) ({size_str})")
+        else:
+            print(f"✓ Upload complete: {len(files_to_upload)} file(s) ({size_str})")
+
         return True
 
     except httpx.HTTPStatusError as e:

src/basic_memory/cli/commands/cloud/upload_command.py

@@ -54,6 +54,11 @@ def upload(
         "--no-gitignore",
         help="Skip .gitignore patterns (still respects .bmignore)",
     ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show what would be uploaded without actually uploading",
+    ),
 ) -> None:
     """Upload local files or directories to cloud project via WebDAV.
 
@@ -63,6 +68,7 @@ def upload(
       bm cloud upload ~/docs --project work --no-sync
       bm cloud upload ./history --project proto --verbose
       bm cloud upload ./notes --project work --no-gitignore
+      bm cloud upload ./files --project test --dry-run
     """
 
     async def _upload():
@@ -85,19 +91,26 @@ async def _upload():
                 )
                 raise typer.Exit(1)
 
-        # Perform upload
-        console.print(f"[blue]Uploading {path} to project '{project}'...[/blue]")
+        # Perform upload (or dry run)
+        if dry_run:
+            console.print(f"[yellow]DRY RUN: Showing what would be uploaded to '{project}'[/yellow]")
+        else:
+            console.print(f"[blue]Uploading {path} to project '{project}'...[/blue]")
+
         success = await upload_path(
-            path, project, verbose=verbose, use_gitignore=not no_gitignore
+            path, project, verbose=verbose, use_gitignore=not no_gitignore, dry_run=dry_run
         )
         if not success:
             console.print("[red]Upload failed[/red]")
             raise typer.Exit(1)
 
-        console.print(f"[green]✅ Successfully uploaded to '{project}'[/green]")
+        if dry_run:
+            console.print(f"[yellow]DRY RUN complete - no files were uploaded[/yellow]")
+        else:
+            console.print(f"[green]✅ Successfully uploaded to '{project}'[/green]")
 
-        # Sync project if requested
-        if sync:
+        # Sync project if requested (skip on dry run)
+        if sync and not dry_run:
             console.print(f"[blue]Syncing project '{project}'...[/blue]")
             try:
                 await sync_project(project)

tests/cli/test_upload.py

@@ -414,3 +414,48 @@ def test_wildcard_gitignore_filters_all_files(self, tmp_path):
         # With use_gitignore=False, should include files
         result = _get_files_to_upload(tmp_path, verbose=False, use_gitignore=False)
         assert len(result) == 2
+
+    @pytest.mark.asyncio
+    async def test_dry_run_shows_files_without_uploading(self, tmp_path, capsys):
+        """Test that --dry-run shows what would be uploaded without uploading."""
+        # Create test files
+        (tmp_path / "file1.txt").write_text("content1")
+        (tmp_path / "file2.txt").write_text("content2")
+
+        # Don't mock anything - we want to verify no actual upload happens
+        result = await upload_path(tmp_path, "test-project", dry_run=True)
+
+        # Should return success
+        assert result is True
+
+        # Check output shows dry run info
+        captured = capsys.readouterr()
+        assert "Found 2 file(s) to upload" in captured.out
+        assert "Files that would be uploaded:" in captured.out
+        assert "file1.txt" in captured.out
+        assert "file2.txt" in captured.out
+        assert "Total:" in captured.out
+
+    @pytest.mark.asyncio
+    async def test_dry_run_with_verbose(self, tmp_path, capsys):
+        """Test that --dry-run works with --verbose."""
+        # Create test files
+        (tmp_path / "keep.txt").write_text("keep")
+        (tmp_path / "ignore.pyc").write_text("ignore")
+
+        # Create .gitignore
+        gitignore_file = tmp_path / ".gitignore"
+        gitignore_file.write_text("*.pyc\n")
+
+        result = await upload_path(tmp_path, "test-project", verbose=True, dry_run=True)
+
+        # Should return success
+        assert result is True
+
+        # Check output shows both verbose and dry run info
+        captured = capsys.readouterr()
+        assert "Scanning directory:" in captured.out
+        assert "[INCLUDE] keep.txt" in captured.out
+        assert "[IGNORED] ignore.pyc" in captured.out
+        assert "Files that would be uploaded:" in captured.out
+        assert "keep.txt" in captured.out