upload_command.py

"""Upload CLI commands for basic-memory projects."""

from pathlib import Path

import typer
from rich.console import Console

from basic_memory.cli.app import cloud_app
from basic_memory.cli.commands.command_utils import run_with_cleanup
from basic_memory.cli.commands.cloud.cloud_utils import (
    create_cloud_project,
    project_exists,
    sync_project,
)
from basic_memory.cli.commands.cloud.upload import upload_path
from basic_memory.config import ConfigManager
from basic_memory.mcp.async_client import get_cloud_control_plane_client

console = Console()


@cloud_app.command("upload")
def upload(
    path: Path = typer.Argument(
        ...,
        help="Path to local file or directory to upload",
        exists=True,
        readable=True,
        resolve_path=True,
    ),
    project: str = typer.Option(
        ...,
        "--project",
        "-p",
        help="Cloud project name (destination)",
    ),
    create_project: bool = typer.Option(
        False,
        "--create-project",
        "-c",
        help="Create project if it doesn't exist",
    ),
    sync: bool = typer.Option(
        True,
        "--sync/--no-sync",
        help="Sync project after upload (default: true)",
    ),
    verbose: bool = typer.Option(
        False,
        "--verbose",
        "-v",
        help="Show detailed information about file filtering and upload",
    ),
    no_gitignore: bool = typer.Option(
        False,
        "--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.

    Examples:
      bm cloud upload ~/my-notes --project research
      bm cloud upload notes.md --project research --create-project
      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():
        # Resolve workspace: per-project workspace_id, then default_workspace
        config = ConfigManager().config
        workspace = None
        entry = config.projects.get(project)
        if entry and entry.workspace_id:
            workspace = entry.workspace_id
        elif config.default_workspace:
            workspace = config.default_workspace

        # Check if project exists
        if not await project_exists(project, workspace=workspace):
            if create_project:
                console.print(f"[blue]Creating cloud project '{project}'...[/blue]")
                try:
                    await create_cloud_project(project, workspace=workspace)
                    console.print(f"[green]Created project '{project}'[/green]")
                except Exception as e:
                    console.print(f"[red]Failed to create project: {e}[/red]")
                    raise typer.Exit(1)
            else:
                console.print(
                    f"[red]Project '{project}' does not exist.[/red]\n"
                    f"[yellow]Options:[/yellow]\n"
                    f"  1. Create it first: bm project add {project} --cloud\n"
                    f"  2. Use --create-project flag to create automatically"
                )
                raise typer.Exit(1)

        # Perform upload (or dry run)
        if workspace:
            console.print(f"[dim]Using workspace: {workspace}[/dim]")
        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]")

        def _client_factory():
            return get_cloud_control_plane_client(workspace=workspace)

        success = await upload_path(
            path,
            project,
            verbose=verbose,
            use_gitignore=not no_gitignore,
            dry_run=dry_run,
            client_cm_factory=_client_factory,
        )
        if not success:
            console.print("[red]Upload failed[/red]")
            raise typer.Exit(1)

        if dry_run:
            console.print("[yellow]DRY RUN complete - no files were uploaded[/yellow]")
        else:
            console.print(f"[green]Successfully uploaded to '{project}'[/green]")

        # Sync project if requested (skip on dry run)
        # Force full scan after bisync to ensure database is up-to-date with synced files
        if sync and not dry_run:
            console.print(f"[blue]Syncing project '{project}'...[/blue]")
            try:
                await sync_project(project, force_full=True)
            except Exception as e:
                console.print(f"[yellow]Warning: Sync failed: {e}[/yellow]")
                console.print("[dim]Files uploaded but may not be indexed yet[/dim]")

    run_with_cleanup(_upload())