@nextclaw/ui 0.15.24 → 0.15.26

package/src/features/chat/features/workspace/components/project-files/workspace-new-folder-tree-item.tsx

@@ -0,0 +1,112 @@
+import { useLayoutEffect, useRef, type FormEvent } from 'react';
+import { Check, File, Folder, X } from 'lucide-react';
+import { IconActionButton } from '@/shared/components/ui/actions/icon-action-button';
+import { Input } from '@/shared/components/ui/input';
+import { t } from '@/shared/lib/i18n';
+
+function isValidFolderName(value: string): boolean {
+  const name = value.trim();
+  return Boolean(name && name !== '.' && name !== '..' && !name.includes('/') && !name.includes('\\'));
+}
+
+export function WorkspaceNewFolderTreeItem({
+  error,
+  kind,
+  isCreating,
+  level,
+  name,
+  onCancel,
+  onNameChange,
+  onSubmit,
+}: {
+  error: string | null;
+  kind: 'directory' | 'file';
+  isCreating: boolean;
+  level: number;
+  name: string;
+  onCancel: () => void;
+  onNameChange: (name: string) => void;
+  onSubmit: () => void;
+}) {
+  const rowRef = useRef<HTMLFormElement | null>(null);
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const valid = isValidFolderName(name);
+
+  useLayoutEffect(() => {
+    const row = rowRef.current;
+    if (typeof row?.scrollIntoView === 'function') {
+      row.scrollIntoView({ block: 'nearest' });
+    }
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, []);
+
+  const submit = (event: FormEvent) => {
+    event.preventDefault();
+    if (valid && !isCreating) {
+      onSubmit();
+    }
+  };
+
+  return (
+    <form
+      ref={rowRef}
+      role="treeitem"
+      aria-label={t(kind === 'file' ? 'chatWorkspaceNewFile' : 'chatWorkspaceNewFolder')}
+      className="bg-primary/5"
+      onSubmit={submit}
+    >
+      <div
+        className="flex min-h-8 min-w-0 items-center gap-1 py-0.5 pr-1"
+        style={{ paddingLeft: `${8 + level * 14}px` }}
+      >
+        <span className="inline-flex h-4 w-4 shrink-0" />
+        {kind === 'file' ? (
+          <File className="h-4 w-4 shrink-0 text-gray-500" />
+        ) : (
+          <Folder className="h-4 w-4 shrink-0 text-amber-500" />
+        )}
+        <Input
+          ref={inputRef}
+          aria-label={t(kind === 'file' ? 'chatWorkspaceFileName' : 'chatWorkspaceFolderName')}
+          className="h-7 min-w-0 flex-1 rounded-md px-2 text-xs"
+          disabled={isCreating}
+          placeholder={t(kind === 'file' ? 'chatWorkspaceFileNamePlaceholder' : 'chatWorkspaceFolderNamePlaceholder')}
+          value={name}
+          onChange={(event) => onNameChange(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key === 'Escape') {
+              event.preventDefault();
+              onCancel();
+            }
+          }}
+        />
+        <IconActionButton
+          disabled={!valid || isCreating}
+          icon={<Check className="h-3.5 w-3.5" />}
+          label={t('chatWorkspaceCreateFolder')}
+          size="sm"
+          tooltipSide="top"
+          onClick={onSubmit}
+        />
+        <IconActionButton
+          disabled={isCreating}
+          icon={<X className="h-3.5 w-3.5" />}
+          label={t('cancel')}
+          size="sm"
+          tooltipSide="top"
+          onClick={onCancel}
+        />
+      </div>
+      {error ? (
+        <p
+          role="alert"
+          className="pb-1 pr-2 text-[11px] text-destructive"
+          style={{ paddingLeft: `${42 + level * 14}px` }}
+        >
+          {error}
+        </p>
+      ) : null}
+    </form>
+  );
+}

package/src/features/chat/features/workspace/components/project-files/workspace-project-files-toolbar.tsx

@@ -0,0 +1,64 @@
+import { ChevronsUp, FilePlus2, FolderPlus, MoreHorizontal, RefreshCw } from 'lucide-react';
+import { IconActionButton } from '@/shared/components/ui/actions/icon-action-button';
+import { ContextMenuTrigger } from '@/shared/components/ui/context-menu/context-menu';
+import { t } from '@/shared/lib/i18n';
+
+export function WorkspaceProjectFilesToolbar({
+  disabled,
+  rootLabel,
+  onCollapseAll,
+  onNewFile,
+  onNewFolder,
+  onRefresh,
+}: {
+  disabled: boolean;
+  rootLabel: string;
+  onCollapseAll: () => void;
+  onNewFile: () => void;
+  onNewFolder: () => void;
+  onRefresh: () => void;
+}) {
+  return (
+    <div className="flex h-9 shrink-0 items-center gap-0.5 border-b border-gray-200/80 bg-gray-50/55 px-1.5">
+      <span
+        className="min-w-0 flex-1 truncate px-0.5 text-[11px] font-semibold uppercase tracking-[0.03em] text-gray-800"
+        title={rootLabel}
+      >
+        {rootLabel}
+      </span>
+      <IconActionButton
+        icon={<FilePlus2 className="h-4 w-4" />}
+        label={t('chatWorkspaceNewFile')}
+        size="sm"
+        disabled={disabled}
+        onClick={onNewFile}
+      />
+      <IconActionButton
+        icon={<FolderPlus className="h-4 w-4" />}
+        label={t('chatWorkspaceNewFolder')}
+        size="sm"
+        disabled={disabled}
+        onClick={onNewFolder}
+      />
+      <IconActionButton
+        icon={<RefreshCw className="h-4 w-4" />}
+        label={t('chatWorkspaceRefreshExplorer')}
+        size="sm"
+        onClick={onRefresh}
+      />
+      <IconActionButton
+        icon={<ChevronsUp className="h-4 w-4" />}
+        label={t('chatWorkspaceCollapseAll')}
+        size="sm"
+        onClick={onCollapseAll}
+      />
+      <ContextMenuTrigger>
+        <IconActionButton
+          icon={<MoreHorizontal className="h-4 w-4" />}
+          label={t('chatWorkspaceRootMoreActions')}
+          size="sm"
+        />
+      </ContextMenuTrigger>
+    </div>
+  );
+}

package/src/features/chat/features/workspace/hooks/use-workspace-explorer-layout.ts

@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useRef, useState, type PointerEvent as ReactPointerEvent } from 'react';
+import { usePresenter } from '@/features/chat/components/providers/chat-presenter.provider';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import {
+  CHAT_WORKSPACE_EXPLORER_COMPACT_THRESHOLD,
+  normalizeChatWorkspaceExplorerWidth,
+} from '@/features/chat/features/workspace/utils/chat-workspace-panel-layout.utils';
+
+export function useWorkspaceExplorerLayout({
+  fileActive,
+  projectFilesActive,
+}: {
+  fileActive: boolean;
+  projectFilesActive: boolean;
+}) {
+  const presenter = usePresenter();
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const resizeRef = useRef<{ startX: number; startWidth: number; width: number } | null>(null);
+  const explorerOpen = useChatThreadStore((state) => state.snapshot.workspaceExplorerOpen);
+  const persistedExplorerWidth = useChatThreadStore((state) => state.snapshot.workspaceExplorerWidth);
+  const setSnapshot = useChatThreadStore((state) => state.setSnapshot);
+  const [compact, setCompact] = useState(false);
+  const [explorerDragWidth, setExplorerDragWidth] = useState<number | null>(null);
+  const explorerWidth = explorerDragWidth ?? persistedExplorerWidth;
+  const setExplorerOpen = useCallback(
+    (open: boolean) => setSnapshot({ workspaceExplorerOpen: open }),
+    [setSnapshot],
+  );
+
+  useEffect(() => {
+    const node = containerRef.current;
+    if (!node || typeof ResizeObserver === 'undefined') return;
+    const update = () => setCompact(node.getBoundingClientRect().width < CHAT_WORKSPACE_EXPLORER_COMPACT_THRESHOLD);
+    update();
+    const observer = new ResizeObserver(update);
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+
+  useEffect(() => {
+    if (!fileActive || !compact || !explorerOpen) return;
+    const closeOnEscape = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') setExplorerOpen(false);
+    };
+    window.addEventListener('keydown', closeOnEscape);
+    return () => window.removeEventListener('keydown', closeOnEscape);
+  }, [compact, explorerOpen, fileActive, setExplorerOpen]);
+
+  const onResizeStart = (event: ReactPointerEvent<HTMLDivElement>) => {
+    if (compact || !fileActive) return;
+    event.preventDefault();
+    event.currentTarget.setPointerCapture?.(event.pointerId);
+    resizeRef.current = { startX: event.clientX, startWidth: explorerWidth, width: explorerWidth };
+    const onMove = (moveEvent: PointerEvent) => {
+      const resizing = resizeRef.current;
+      if (!resizing) return;
+      const width = normalizeChatWorkspaceExplorerWidth(resizing.startWidth + moveEvent.clientX - resizing.startX);
+      resizing.width = width;
+      setExplorerDragWidth(width);
+    };
+    const onUp = () => {
+      const width = resizeRef.current?.width;
+      if (typeof width === 'number') presenter.chatThreadManager.setWorkspaceExplorerWidth(width);
+      setExplorerDragWidth(null);
+      resizeRef.current = null;
+      window.removeEventListener('pointermove', onMove);
+      window.removeEventListener('pointerup', onUp);
+      window.removeEventListener('pointercancel', onUp);
+    };
+    window.addEventListener('pointermove', onMove);
+    window.addEventListener('pointerup', onUp);
+    window.addEventListener('pointercancel', onUp);
+  };
+
+  return {
+    compact,
+    containerRef,
+    explorerOpen,
+    explorerOverlay: fileActive && compact && explorerOpen,
+    explorerWidth,
+    onResizeStart,
+    setExplorerOpen,
+    showExplorer: projectFilesActive || (fileActive && explorerOpen),
+  };
+}

package/src/features/chat/features/workspace/hooks/use-workspace-file-actions.ts

@@ -0,0 +1,357 @@
+import { useRef, useState } from 'react';
+import { NextClawClientError } from '@nextclaw/client-sdk';
+import { toast } from 'sonner';
+import type { useConfirmDialog } from '@/shared/hooks/use-confirm-dialog';
+import {
+  createServerPathDirectory,
+  createServerPathFile,
+  deleteServerPathEntry,
+  renameServerPathEntry,
+  uploadServerPathFiles,
+  type ServerPathEntryView,
+} from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+
+type WorkspaceFilePendingAction = 'create-directory' | 'create-file' | 'delete' | 'rename' | 'upload';
+type Confirm = ReturnType<typeof useConfirmDialog>['confirm'];
+
+export type RefreshDirectory = () => Promise<unknown>;
+
+export type WorkspaceDirectoryActionTarget = {
+  label: string;
+  path: string;
+  refresh: RefreshDirectory;
+  expand?: () => void;
+};
+
+export type WorkspaceTreeSelection = {
+  path: string;
+  createTarget: WorkspaceDirectoryActionTarget;
+};
+
+type WorkspaceTreeSelectionState = {
+  activeRelativePath: string | null;
+  selection: WorkspaceTreeSelection;
+};
+
+function readErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function replaceCount(text: string, count: number): string {
+  return text.replace('{count}', String(count));
+}
+
+function useWorkspaceFileActions() {
+  const [pendingAction, setPendingAction] = useState<WorkspaceFilePendingAction | null>(null);
+  const pendingActionRef = useRef<WorkspaceFilePendingAction | null>(null);
+
+  const run = async <T>(action: WorkspaceFilePendingAction, operation: () => Promise<T>): Promise<T> => {
+    if (pendingActionRef.current) {
+      throw new Error('another workspace file operation is already running');
+    }
+    pendingActionRef.current = action;
+    setPendingAction(action);
+    try {
+      return await operation();
+    } finally {
+      pendingActionRef.current = null;
+      setPendingAction(null);
+    }
+  };
+
+  return {
+    pendingAction,
+    createDirectory: (params: { basePath: string; parentPath: string; name: string }) =>
+      run('create-directory', () => createServerPathDirectory(params)),
+    createFile: (params: { basePath: string; parentPath: string; name: string }) =>
+      run('create-file', () => createServerPathFile(params)),
+    deleteEntry: (params: { basePath: string; path: string }) => run('delete', () => deleteServerPathEntry(params)),
+    renameEntry: (params: { basePath: string; path: string; name: string }) =>
+      run('rename', () => renameServerPathEntry(params)),
+    uploadFiles: (params: { basePath: string; targetPath: string; files: readonly File[]; overwrite?: boolean }) =>
+      run('upload', () => uploadServerPathFiles(params)),
+  };
+}
+
+type WorkspaceFileActions = ReturnType<typeof useWorkspaceFileActions>;
+
+async function uploadWorkspaceFiles({
+  actions,
+  confirm,
+  files,
+  rootPath,
+  target,
+}: {
+  actions: WorkspaceFileActions;
+  confirm: Confirm;
+  files: readonly File[];
+  rootPath: string;
+  target: WorkspaceDirectoryActionTarget;
+}) {
+  try {
+    let result;
+    try {
+      result = await actions.uploadFiles({
+        basePath: rootPath,
+        targetPath: target.path,
+        files,
+      });
+    } catch (error) {
+      if (!(error instanceof NextClawClientError) || error.code !== 'SERVER_PATH_FILE_EXISTS') {
+        throw error;
+      }
+      const conflicts = Array.isArray(error.details?.conflicts) ? error.details.conflicts.length : files.length;
+      const shouldReplace = await confirm({
+        title: t('chatWorkspaceUploadConflictTitle'),
+        description: replaceCount(t('chatWorkspaceUploadConflictDescription'), conflicts),
+        confirmLabel: t('chatWorkspaceReplaceFiles'),
+        variant: 'destructive',
+      });
+      if (!shouldReplace) return;
+      result = await actions.uploadFiles({
+        basePath: rootPath,
+        targetPath: target.path,
+        files,
+        overwrite: true,
+      });
+    }
+    await target.refresh();
+    toast.success(replaceCount(t('chatWorkspaceUploadSucceeded'), result.files.length));
+  } catch (error) {
+    toast.error(`${t('chatWorkspaceUploadFailed')}: ${readErrorMessage(error)}`);
+  }
+}
+
+async function deleteWorkspaceEntry({
+  actions,
+  confirm,
+  entry,
+  refresh,
+  rootPath,
+}: {
+  actions: WorkspaceFileActions;
+  confirm: Confirm;
+  entry: ServerPathEntryView;
+  refresh: RefreshDirectory;
+  rootPath: string;
+}) {
+  const isDirectory = entry.kind === 'directory';
+  const confirmed = await confirm({
+    title: t(isDirectory ? 'chatWorkspaceDeleteFolderTitle' : 'chatWorkspaceDeleteFileTitle').replace(
+      '{name}',
+      entry.name,
+    ),
+    description: t(isDirectory ? 'chatWorkspaceDeleteFolderDescription' : 'chatWorkspaceDeleteFileDescription'),
+    confirmLabel: t('chatWorkspaceDelete'),
+    variant: 'destructive',
+  });
+  if (!confirmed) return;
+  const toastId = toast.loading(t('chatWorkspaceDeleting').replace('{name}', entry.name));
+  try {
+    const deleted = await actions.deleteEntry({
+      basePath: rootPath,
+      path: entry.path,
+    });
+    await refresh();
+    toast.dismiss(toastId);
+    toast.success(t('chatWorkspaceDeleteSucceeded').replace('{name}', entry.name));
+    return deleted;
+  } catch (error) {
+    toast.dismiss(toastId);
+    toast.error(`${t('chatWorkspaceDeleteFailed').replace('{name}', entry.name)}: ${readErrorMessage(error)}`);
+    return null;
+  }
+}
+
+async function createWorkspaceEntry({
+  actions,
+  kind,
+  name,
+  rootPath,
+  setError,
+  target,
+}: {
+  actions: WorkspaceFileActions;
+  kind: 'directory' | 'file';
+  name: string;
+  rootPath: string;
+  setError: (error: string | null) => void;
+  target: WorkspaceDirectoryActionTarget;
+}) {
+  setError(null);
+  try {
+    const created = await (kind === 'file' ? actions.createFile : actions.createDirectory)({
+      basePath: rootPath,
+      parentPath: target.path,
+      name,
+    });
+    await target.refresh();
+    toast.success(t(kind === 'file' ? 'chatWorkspaceFileCreated' : 'chatWorkspaceFolderCreated'));
+    return created;
+  } catch (error) {
+    setError(
+      `${t(kind === 'file' ? 'chatWorkspaceFileCreateFailed' : 'chatWorkspaceFolderCreateFailed')}: ${readErrorMessage(error)}`,
+    );
+    return null;
+  }
+}
+
+type WorkspaceProjectFilesControllerOptions = {
+  activeRelativePath: string | null;
+  confirm: Confirm;
+  onEntryDeleted?: (path: string) => void;
+  onEntryRenamed?: (params: { previousPath: string; path: string; label: string }) => void;
+  rootPath: string | null;
+};
+
+export function useWorkspaceProjectFilesController({
+  activeRelativePath,
+  confirm,
+  onEntryDeleted,
+  onEntryRenamed,
+  rootPath,
+}: WorkspaceProjectFilesControllerOptions) {
+  const fileInputRef = useRef<HTMLInputElement | null>(null);
+  const actions = useWorkspaceFileActions();
+  const [createTarget, setCreateTarget] = useState<WorkspaceDirectoryActionTarget | null>(null);
+  const [createName, setCreateName] = useState('');
+  const [createKind, setCreateKind] = useState<'directory' | 'file'>('directory');
+  const [createError, setCreateError] = useState<string | null>(null);
+  const [selectionState, setSelectionState] = useState<WorkspaceTreeSelectionState | null>(null);
+  const [revealPath, setRevealPath] = useState<string | null>(null);
+  const [uploadTarget, setUploadTarget] = useState<WorkspaceDirectoryActionTarget | null>(null);
+  const selectedEntry =
+    selectionState?.activeRelativePath === activeRelativePath ? selectionState.selection : null;
+
+  const requestUpload = (target: WorkspaceDirectoryActionTarget) => {
+    setUploadTarget(target);
+    if (!fileInputRef.current) return;
+    fileInputRef.current.value = '';
+    fileInputRef.current.click();
+  };
+  const selectEntry = (selection: WorkspaceTreeSelection) => {
+    setSelectionState({ activeRelativePath, selection });
+  };
+  const openCreate = (kind: 'directory' | 'file', target: WorkspaceDirectoryActionTarget) => {
+    target.expand?.();
+    setCreateKind(kind);
+    setCreateName('');
+    setCreateError(null);
+    setCreateTarget(target);
+  };
+  const uploadFiles = async (files: readonly File[]) => {
+    if (!rootPath || !uploadTarget || files.length === 0) return;
+    await uploadWorkspaceFiles({
+      actions,
+      confirm,
+      files,
+      rootPath,
+      target: uploadTarget,
+    });
+  };
+  const deleteEntry = async (entry: ServerPathEntryView, refresh: RefreshDirectory) => {
+    if (!rootPath) return;
+    const deleted = await deleteWorkspaceEntry({
+      actions,
+      confirm,
+      entry,
+      refresh,
+      rootPath,
+    });
+    if (deleted) onEntryDeleted?.(deleted.path);
+  };
+  const renameEntry = async (entry: ServerPathEntryView, name: string, refresh: RefreshDirectory) => {
+    if (!rootPath) return null;
+    const renamed = await actions.renameEntry({
+      basePath: rootPath,
+      path: entry.path,
+      name,
+    });
+    onEntryRenamed?.({
+      previousPath: renamed.oldPath,
+      path: renamed.path,
+      label: renamed.name,
+    });
+    await refresh();
+    setSelectionState((state) =>
+      state?.activeRelativePath === activeRelativePath
+        ? {
+            activeRelativePath,
+            selection: {
+              path: renamed.path,
+              createTarget:
+                state.selection.createTarget.path === entry.path
+                  ? { ...state.selection.createTarget, label: renamed.name, path: renamed.path }
+                  : state.selection.createTarget,
+            },
+          }
+        : null,
+    );
+    setRevealPath(renamed.path);
+    toast.success(t('chatWorkspaceRenameSucceeded').replace('{name}', renamed.name));
+    return renamed;
+  };
+  const submitCreate = async () => {
+    if (!rootPath || !createTarget) return;
+    const created = await createWorkspaceEntry({
+      actions,
+      kind: createKind,
+      name: createName,
+      rootPath,
+      setError: setCreateError,
+      target: createTarget,
+    });
+    if (!created) return;
+    setCreateTarget(null);
+    setSelectionState({
+      activeRelativePath,
+      selection: {
+        path: created.path,
+        createTarget: {
+          label: createName.trim(),
+          path: created.path,
+          refresh: createTarget.refresh,
+        },
+      },
+    });
+    setRevealPath(created.path);
+  };
+
+  return {
+    actions: {
+      cancelCreateFolder: () => {
+        setCreateTarget(null);
+        setCreateName('');
+        setCreateError(null);
+      },
+      clearSelection: () => {
+        setSelectionState(null);
+      },
+      completeReveal: () => setRevealPath(null),
+      deleteEntry,
+      openCreateFile: (target: WorkspaceDirectoryActionTarget) => openCreate('file', target),
+      openCreateFolder: (target: WorkspaceDirectoryActionTarget) => openCreate('directory', target),
+      renameEntry,
+      requestUpload,
+      selectEntry,
+      setCreateError,
+      setCreateName,
+      submitCreate,
+      uploadFiles,
+    },
+    refs: {
+      fileInputRef,
+    },
+    state: {
+      createError,
+      createKind,
+      createName,
+      createTarget,
+      pendingAction: actions.pendingAction,
+      revealPath,
+      selectedCreateTarget: selectedEntry?.createTarget ?? null,
+      selectedPath: selectedEntry?.path ?? null,
+    },
+  };
+}

package/src/features/chat/features/workspace/utils/chat-workspace-file-path-mutation.utils.ts

@@ -0,0 +1,58 @@
+import type { ChatThreadSnapshot, ChatWorkspaceNavigationEntry } from '@/features/chat/stores/chat-thread.store';
+import { closeWorkspaceTabSnapshot } from '@/features/chat/features/workspace/utils/chat-thread-workspace-session.utils';
+import { replaceWorkspaceFileTabPath } from '@/features/chat/features/workspace/utils/chat-workspace-file-tab.utils';
+
+function replaceWorkspacePathPrefix(candidate: string, previousPath: string, nextPath: string): string | null {
+  if (candidate === previousPath) return nextPath;
+  if (candidate.startsWith(`${previousPath}/`) || candidate.startsWith(`${previousPath}\\`)) {
+    return `${nextPath}${candidate.slice(previousPath.length)}`;
+  }
+  return null;
+}
+
+export function createRenamedWorkspacePathPatch(
+  snapshot: ChatThreadSnapshot,
+  params: { previousPath: string; path: string; label: string },
+): Partial<ChatThreadSnapshot> | null {
+  const previousPath = params.previousPath.trim();
+  const path = params.path.trim();
+  if (!previousPath || !path || previousPath === path) return null;
+
+  const keyMap = new Map<string, string>();
+  const workspaceFileTabs = snapshot.workspaceFileTabs.map((tab) => {
+    const nextPath = replaceWorkspacePathPrefix(tab.path, previousPath, path);
+    if (!nextPath) return tab;
+    const nextTab = replaceWorkspaceFileTabPath(tab, nextPath, tab.path === previousPath ? params.label : tab.label);
+    keyMap.set(tab.key, nextTab.key);
+    return nextTab;
+  });
+  if (keyMap.size === 0) return null;
+
+  const remapEntry = (entry: ChatWorkspaceNavigationEntry): ChatWorkspaceNavigationEntry =>
+    entry.kind === 'file' && keyMap.has(entry.key) ? { kind: 'file', key: keyMap.get(entry.key)! } : entry;
+  return {
+    workspaceFileTabs,
+    activeWorkspaceFileKey: snapshot.activeWorkspaceFileKey
+      ? (keyMap.get(snapshot.activeWorkspaceFileKey) ?? snapshot.activeWorkspaceFileKey)
+      : null,
+    closedWorkspaceTabEntries: snapshot.closedWorkspaceTabEntries.map(remapEntry),
+    workspaceNavigationHistory: snapshot.workspaceNavigationHistory.map(remapEntry),
+  };
+}
+
+export function createRemovedWorkspacePathSnapshot(
+  snapshot: ChatThreadSnapshot,
+  path: string,
+): ChatThreadSnapshot | null {
+  const normalizedPath = path.trim();
+  if (!normalizedPath) return null;
+  let nextSnapshot = snapshot;
+  const matchingKeys = snapshot.workspaceFileTabs
+    .filter((tab) => replaceWorkspacePathPrefix(tab.path, normalizedPath, normalizedPath) !== null)
+    .map((tab) => tab.key);
+  for (const key of matchingKeys) {
+    const patch = closeWorkspaceTabSnapshot(nextSnapshot, { kind: 'file', key });
+    if (patch) nextSnapshot = { ...nextSnapshot, ...patch };
+  }
+  return matchingKeys.length > 0 ? nextSnapshot : null;
+}