Rename, New Folder, and New Folder with Items

async fn create_directory(&self, path: &Path, recursive: bool) -> Result<(), VolumeError>;

async fn create_directory(&self, path: &Path, recursive: bool) -> Result<(), VolumeError> {
    let full_path = self.resolve_path(path);
    if recursive {
        fs::create_dir_all(&full_path).await.map_err(VolumeError::Io)?;
    } else {
        fs::create_dir(&full_path).await.map_err(VolumeError::Io)?;
    }
    Ok(())
}

core/src/ops/files/rename/
├── mod.rs          # Module exports
├── input.rs        # FileRenameInput
├── action.rs       # FileRenameAction
└── validation.rs   # Filename validation

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct FileRenameInput {
    pub target: SdPath,
    pub new_name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileRenameAction {
    pub target: SdPath,
    pub new_name: String,
}

impl LibraryAction for FileRenameAction {
    type Input = FileRenameInput;
    type Output = JobReceipt;

    async fn validate(...) -> Result<ValidationResult, ActionError> {
        // 1. Validate target exists
        // 2. Validate new_name (no path separators, not empty, valid chars)
        // 3. Check if destination already exists (conflict detection)
        // 4. Validate target is not Content/Sidecar path
    }

    async fn execute(...) -> Result<JobReceipt, ActionError> {
        // Dispatch FileCopyJob::new_rename(target, new_name)
        // Return job receipt for tracking
    }
}

register_library_action!(FileRenameAction, "files.rename");

core/src/ops/files/create_folder/
├── mod.rs          # Module exports
├── input.rs        # CreateFolderInput
├── output.rs       # CreateFolderOutput
└── action.rs       # CreateFolderAction

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct CreateFolderInput {
    pub parent: SdPath,
    pub name: String,
    #[serde(default)]
    pub items: Vec<SdPath>,  // Optional items to move into folder
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateFolderOutput {
    pub folder_path: SdPath,
    pub job_handle: Option<JobReceipt>,  // Present if items were provided
}

impl LibraryAction for CreateFolderAction {
    type Input = CreateFolderInput;
    type Output = CreateFolderOutput;

    async fn validate(...) -> Result<ValidationResult, ActionError> {
        // 1. Validate parent exists and is a directory
        // 2. Validate folder name
        // 3. Check if folder already exists
        // 4. Validate items (if provided) exist
    }

    async fn execute(...) -> Result<CreateFolderOutput, ActionError> {
        // 1. Construct destination path: parent.join(name)
        // 2. Create directory using VolumeBackend
        let volume_manager = library.volumes();
        let backend = volume_manager.get_backend_for_path(&parent)?;
        backend.create_directory(&folder_path, false).await?;

        // 3. If items provided, dispatch FileCopyJob
        let job_handle = if !self.items.is_empty() {
            let job = FileCopyJob::new(
                SdPathBatch::new(self.items),
                folder_path.clone()
            );
            Some(library.jobs().dispatch(job).await?)
        } else {
            None
        };

        Ok(CreateFolderOutput {
            folder_path,
            job_handle: job_handle.map(|h| h.into()),
        })
    }
}

register_library_action!(CreateFolderAction, "files.createFolder");

interface SelectionContextValue {
	// ... existing fields
	renamingFileId: string | null;
	startRename: (fileId: string) => void;
	cancelRename: () => void;
	saveRename: (newName: string) => Promise<void>;
}

const [renamingFileId, setRenamingFileId] = useState<string | null>(null);
const renameFile = useLibraryMutation("files.rename");

const startRename = useCallback(
	(fileId: string) => {
		if (selectedFiles.length === 1) {
			setRenamingFileId(fileId);
		}
	},
	[selectedFiles],
);

const cancelRename = useCallback(() => {
	setRenamingFileId(null);
}, []);

const saveRename = useCallback(
	async (newName: string) => {
		if (!renamingFileId) return;

		const file = selectedFiles.find((f) => f.id === renamingFileId);
		if (!file) return;

		try {
			await renameFile.mutateAsync({
				target: file.sd_path,
				new_name: newName,
			});
			setRenamingFileId(null);
		} catch (error) {
			// Keep in edit mode, show error
			console.error("Rename failed:", error);
			throw error;
		}
	},
	[renamingFileId, selectedFiles, renameFile],
);

import { useState, useEffect, useRef } from 'react';
import { Input } from '@sd/ui';
import type { File } from '@sd/ts-client';

interface InlineNameEditProps {
  file: File;
  onSave: (newName: string) => void;
  onCancel: () => void;
  className?: string;
}

export function InlineNameEdit({ file, onSave, onCancel, className }: InlineNameEditProps) {
  // Split name and extension
  const nameWithoutExtension = file.extension
    ? file.name
    : file.name;

  const [value, setValue] = useState(nameWithoutExtension);
  const inputRef = useRef<HTMLInputElement>(null);

  // Auto-focus and select on mount
  useEffect(() => {
    if (inputRef.current) {
      inputRef.current.focus();
      inputRef.current.select();
    }
  }, []);

  const handleKeyDown = (e: React.KeyboardEvent) => {
    if (e.key === 'Enter') {
      e.preventDefault();
      e.stopPropagation();
      if (value.trim()) {
        onSave(file.extension ? `${value}.${file.extension}` : value);
      } else {
        onCancel();
      }
    } else if (e.key === 'Escape') {
      e.preventDefault();
      e.stopPropagation();
      onCancel();
    }
  };

  const handleBlur = () => {
    onCancel();
  };

  return (
    <Input
      ref={inputRef}
      value={value}
      onChange={(e) => setValue(e.target.value)}
      onKeyDown={handleKeyDown}
      onBlur={handleBlur}
      variant="transparent"
      size="sm"
      className={className}
    />
  );
}

import { InlineNameEdit } from '../../components/InlineNameEdit';
import { useSelection } from '../../SelectionContext';

// Inside FileCard component:
const { renamingFileId, saveRename, cancelRename } = useSelection();

// In render (around line 160):
{renamingFileId === file.id ? (
  <InlineNameEdit
    file={file}
    onSave={saveRename}
    onCancel={cancelRename}
    className="text-sm truncate px-2 py-0.5"
  />
) : (
  <div className="text-sm truncate px-2 py-0.5">
    {file.name}
  </div>
)}

import { InlineNameEdit } from '../../components/InlineNameEdit';
import { useSelection } from '../../SelectionContext';

// Inside NameCell:
const { renamingFileId, saveRename, cancelRename } = useSelection();

{renamingFileId === file.id ? (
  <InlineNameEdit
    file={file}
    onSave={saveRename}
    onCancel={cancelRename}
    className="truncate text-sm text-ink"
  />
) : (
  <span className="truncate text-sm text-ink">
    {file.name}
  </span>
)}

import { useKeybind } from "../../../hooks/useKeybind";

useKeybind(
	"explorer.renameFile",
	() => {
		if (selectedFiles.length === 1) {
			startRename(selectedFiles[0].id);
		}
	},
	{ enabled: selectedFiles.length === 1 },
);

import { Pencil, FolderPlus } from '@phosphor-icons/react';

{
  icon: Pencil,
  label: "Rename",
  onClick: () => {
    startRename(file.id);
  },
  keybindId: "explorer.renameFile",
  condition: () => selected && selectedFiles.length === 1,
},
{ type: "separator" },
{
  icon: FolderPlus,
  label: "New Folder",
  onClick: () => createFolder(),
  // keybindId: "explorer.newFolder", // Add to registry if needed
},
{
  icon: FolderPlus,
  label: "New Folder with Items",
  onClick: () => createFolderWithItems(),
  condition: () => selectedFiles.length > 0,
}

const createFolderMutation = useLibraryMutation("files.createFolder");

const createFolder = async () => {
	// Create with default name, then enter rename mode
	const result = await createFolderMutation.mutateAsync({
		parent: currentPath,
		name: "Untitled Folder",
		items: [],
	});
	// TODO: Select new folder and enter rename mode
};

const createFolderWithItems = async () => {
	const result = await createFolderMutation.mutateAsync({
		parent: currentPath,
		name: "New Folder",
		items: selectedFiles.map((f) => f.sd_path),
	});
	// result.job_handle tracks copy progress
};