@vibe-forge/client 0.11.2 → 1.0.0

package/src/components/chat/git-controls/GitWorktreeDropdown.tsx

@@ -1,65 +1,338 @@
-import { Button, Dropdown } from 'antd'
+/* eslint-disable max-lines */
+
+import { Button, Dropdown, Empty, Input, Switch } from 'antd'
+import { useEffect, useMemo, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 
-import type { GitWorktreeSummary } from '@vibe-forge/types'
+import type { GitWorktreeSummary, SessionWorkspace } from '@vibe-forge/types'
 
 import { formatGitWorktreePathLabel } from './git-branch-utils'
 
+interface DraftWorktreeMenuMode {
+  type: 'draft'
+  createWorktree: boolean
+  disabled?: boolean
+  onCreateWorktreeChange: (checked: boolean) => void
+}
+
+interface SessionWorktreeMenuMode {
+  type: 'session'
+  isBusy: boolean
+  canCreateManagedWorktree: boolean
+  canTransferToLocal: boolean
+  onCreateManagedWorktree: () => void
+  onTransferToLocal: () => void
+}
+
+const getWorkspaceKindIcon = (kind: SessionWorkspace['kind']) => {
+  switch (kind) {
+    case 'managed_worktree':
+      return 'account_tree'
+    case 'external_workspace':
+      return 'folder_open'
+    default:
+      return 'folder'
+  }
+}
+
+const getWorkspaceKindLabel = (kind: SessionWorkspace['kind'], t: (key: string) => string) => {
+  switch (kind) {
+    case 'managed_worktree':
+      return t('chat.sessionWorkspaceManaged')
+    case 'external_workspace':
+      return t('chat.sessionWorkspaceExternal')
+    default:
+      return t('chat.sessionWorkspaceShared')
+  }
+}
+
+const getDraftStrategyIcon = (createWorktree: boolean) => (
+  createWorktree ? 'create_new_folder' : 'folder_open'
+)
+
+const getDraftStrategyLabel = (createWorktree: boolean, t: (key: string) => string) => (
+  createWorktree
+    ? t('chat.sessionWorkspaceDraftStrategyManaged')
+    : t('chat.sessionWorkspaceDraftStrategyLocal')
+)
+
+const getWorktreeMenuTitle = (
+  mode: DraftWorktreeMenuMode | SessionWorktreeMenuMode,
+  t: (key: string) => string
+) => (
+  mode.type === 'draft'
+    ? t('chat.sessionWorkspaceMenuWorktreeList')
+    : t('chat.sessionWorkspaceMenuCurrentWorktree')
+)
+
+const getWorkspaceStateLabel = (
+  state: SessionWorkspace['state'],
+  t: (key: string) => string
+) => {
+  switch (state) {
+    case 'provisioning':
+      return t('chat.sessionWorkspaceStateProvisioning')
+    case 'deleting':
+      return t('chat.sessionWorkspaceStateDeleting')
+    case 'deleted':
+      return t('chat.sessionWorkspaceStateDeleted')
+    case 'broken':
+      return t('chat.sessionWorkspaceStateBroken')
+    default:
+      return t('chat.sessionWorkspaceStateReady')
+  }
+}
+
+const joinWorkspaceSummary = (parts: Array<string | null | undefined>) =>
+  parts.filter(part => part != null && part.trim() !== '').join(' · ')
+
+const filterGitWorktrees = (worktrees: GitWorktreeSummary[], query: string) => {
+  const keyword = query.trim().toLowerCase()
+  if (keyword === '') {
+    return worktrees
+  }
+
+  return worktrees.filter(worktree => {
+    const pathLabel = formatGitWorktreePathLabel(worktree.path).toLowerCase()
+    const branchLabel = worktree.branchName?.toLowerCase() ?? ''
+    const fullPath = worktree.path.toLowerCase()
+    return pathLabel.includes(keyword) || branchLabel.includes(keyword) || fullPath.includes(keyword)
+  })
+}
+
 export function GitWorktreeDropdown({
+  compact = false,
   open,
+  workspace,
   worktrees,
+  currentBranch,
+  mode,
+  placement = 'bottomLeft',
   onOpenChange
 }: {
+  compact?: boolean
   open: boolean
+  workspace?: SessionWorkspace
   worktrees: GitWorktreeSummary[]
+  currentBranch?: string | null
+  mode: DraftWorktreeMenuMode | SessionWorktreeMenuMode
+  placement?: 'bottomLeft' | 'topLeft'
   onOpenChange: (open: boolean) => void
 }) {
   const { t } = useTranslation()
+  const [isWorktreeSubmenuOpen, setIsWorktreeSubmenuOpen] = useState(false)
+  const [worktreeQuery, setWorktreeQuery] = useState('')
+
+  useEffect(() => {
+    if (!open) {
+      setIsWorktreeSubmenuOpen(false)
+      setWorktreeQuery('')
+    }
+  }, [open])
+
+  const currentWorkspaceTitle = useMemo(() => {
+    if (workspace?.workspaceFolder?.trim()) {
+      return formatGitWorktreePathLabel(workspace.workspaceFolder)
+    }
+    const currentWorktree = worktrees.find(item => item.isCurrent)
+    return currentWorktree != null
+      ? formatGitWorktreePathLabel(currentWorktree.path)
+      : t('chat.gitWorktree')
+  }, [t, workspace?.workspaceFolder, worktrees])
+
+  const currentWorkspaceSubtitle = useMemo(() => {
+    if (workspace == null) {
+      return currentBranch?.trim() || t('chat.gitDetachedHead')
+    }
+
+    return joinWorkspaceSummary([
+      getWorkspaceKindLabel(workspace.kind, t),
+      currentBranch?.trim() || t('chat.gitDetachedHead'),
+      workspace.state !== 'ready' ? getWorkspaceStateLabel(workspace.state, t) : null
+    ])
+  }, [currentBranch, t, workspace])
+
+  const filteredWorktrees = useMemo(
+    () => filterGitWorktrees(worktrees, worktreeQuery),
+    [worktreeQuery, worktrees]
+  )
+  const worktreeMenuTitle = getWorktreeMenuTitle(mode, t)
+
+  const triggerLabel = mode.type === 'draft'
+    ? getDraftStrategyLabel(mode.createWorktree, t)
+    : currentWorkspaceTitle
+  const triggerIcon = mode.type === 'draft'
+    ? getDraftStrategyIcon(mode.createWorktree)
+    : workspace != null
+    ? getWorkspaceKindIcon(workspace.kind)
+    : 'account_tree'
+  const triggerTitle = mode.type === 'draft'
+    ? triggerLabel
+    : workspace != null
+    ? workspace.workspaceFolder
+    : currentWorkspaceSubtitle
 
   return (
     <Dropdown
       open={open}
-      placement='bottomLeft'
+      placement={placement}
       trigger={['click']}
       onOpenChange={onOpenChange}
       dropdownRender={() => (
-        <div className='chat-header-git__overlay chat-header-git__overlay--worktrees'>
-          <div className='chat-header-git__worktree-list'>
-            {worktrees.map(worktree => (
+        <div className='chat-header-git__menu-shell'>
+          <div className='chat-header-git__overlay chat-header-git__overlay--worktree-root'>
+            <button
+              type='button'
+              className={`chat-header-git__menu-row ${isWorktreeSubmenuOpen ? 'is-active' : ''}`}
+              onClick={() => setIsWorktreeSubmenuOpen(value => !value)}
+            >
+              <span className='chat-header-git__menu-row-main'>
+                <span className='chat-header-git__row-icon material-symbols-rounded'>
+                  {workspace != null ? getWorkspaceKindIcon(workspace.kind) : 'account_tree'}
+                </span>
+                <span className='chat-header-git__menu-row-title'>
+                  {worktreeMenuTitle}
+                </span>
+              </span>
+              <span className='chat-header-git__menu-row-trailing'>
+                {mode.type === 'session' && (
+                  <span className='chat-header-git__menu-row-value' title={workspace?.workspaceFolder}>
+                    {currentWorkspaceTitle}
+                  </span>
+                )}
+                <span className='material-symbols-rounded'>chevron_right</span>
+              </span>
+            </button>
+
+            {mode.type === 'draft' && (
               <div
-                key={worktree.path}
-                className='chat-header-git__worktree-row'
-                title={worktree.path}
+                className={`chat-header-git__menu-row chat-header-git__menu-row--toggle ${
+                  mode.disabled ? 'is-disabled' : ''
+                }`}
               >
-                <div className='chat-header-git__branch-row-main'>
-                  <span className='chat-header-git__row-icon material-symbols-rounded'>folder_open</span>
-                  <span className='chat-header-git__row-copy'>
-                    <span className='chat-header-git__row-title'>
-                      {formatGitWorktreePathLabel(worktree.path)}
-                    </span>
-                    <span className='chat-header-git__row-subtitle'>
-                      {worktree.branchName?.trim() || t('chat.gitDetachedHead')}
-                    </span>
+                <span className='chat-header-git__menu-row-main'>
+                  <span className='chat-header-git__row-icon material-symbols-rounded'>
+                    {getDraftStrategyIcon(true)}
                   </span>
-                </div>
-                {worktree.isCurrent && (
-                  <span className='chat-header-git__row-state material-symbols-rounded'>check</span>
-                )}
+                  <span className='chat-header-git__menu-row-title'>
+                    {t('chat.sessionWorkspaceMenuLaunchInWorktree')}
+                  </span>
+                </span>
+                <Switch
+                  checked={mode.createWorktree}
+                  disabled={mode.disabled}
+                  size='small'
+                  onChange={mode.onCreateWorktreeChange}
+                  onClick={(checked, event) => {
+                    event?.stopPropagation()
+                  }}
+                />
               </div>
-            ))}
+            )}
+
+            {mode.type === 'session' && mode.canTransferToLocal && (
+              <button
+                type='button'
+                className='chat-header-git__menu-row'
+                disabled={mode.isBusy}
+                onClick={mode.onTransferToLocal}
+              >
+                <span className='chat-header-git__menu-row-main'>
+                  <span className='chat-header-git__row-icon material-symbols-rounded'>drive_export</span>
+                  <span className='chat-header-git__menu-row-title'>
+                    {t('chat.sessionWorkspaceMenuTransferToLocal')}
+                  </span>
+                </span>
+              </button>
+            )}
+
+            {mode.type === 'session' && mode.canCreateManagedWorktree && (
+              <button
+                type='button'
+                className='chat-header-git__menu-row'
+                disabled={mode.isBusy}
+                onClick={mode.onCreateManagedWorktree}
+              >
+                <span className='chat-header-git__menu-row-main'>
+                  <span className='chat-header-git__row-icon material-symbols-rounded'>add</span>
+                  <span className='chat-header-git__menu-row-title'>
+                    {t('chat.sessionWorkspaceMenuCreateWorktree')}
+                  </span>
+                </span>
+              </button>
+            )}
           </div>
+
+          {isWorktreeSubmenuOpen && (
+            <div className='chat-header-git__overlay chat-header-git__overlay--worktree-submenu'>
+              <div className='chat-header-git__worktree-submenu-body'>
+                {filteredWorktrees.length > 0
+                  ? (
+                    <div className='chat-header-git__worktree-list'>
+                      {filteredWorktrees.map(worktree => (
+                        <div
+                          key={worktree.path}
+                          className='chat-header-git__worktree-row'
+                          title={worktree.path}
+                        >
+                          <div className='chat-header-git__worktree-row-main'>
+                            <span className='chat-header-git__row-icon material-symbols-rounded'>folder_open</span>
+                            <span className='chat-header-git__row-copy'>
+                              <span className='chat-header-git__row-title'>
+                                {formatGitWorktreePathLabel(worktree.path)}
+                              </span>
+                              <span className='chat-header-git__row-subtitle'>
+                                {worktree.branchName?.trim() || t('chat.gitDetachedHead')}
+                              </span>
+                            </span>
+                          </div>
+                          {mode.type === 'session' && worktree.isCurrent && (
+                            <span className='chat-header-git__worktree-chip'>
+                              {t('chat.sessionWorkspaceCurrentSession')}
+                            </span>
+                          )}
+                        </div>
+                      ))}
+                    </div>
+                  )
+                  : (
+                    <div className='chat-header-git__empty chat-header-git__empty--worktrees'>
+                      <Empty
+                        image={Empty.PRESENTED_IMAGE_SIMPLE}
+                        description={t('chat.sessionWorkspaceNoWorktrees')}
+                      />
+                    </div>
+                  )}
+              </div>
+
+              <Input
+                allowClear
+                autoFocus
+                className='chat-header-git__search'
+                placeholder={t('chat.sessionWorkspaceSearchWorktrees')}
+                prefix={<span className='material-symbols-rounded'>search</span>}
+                value={worktreeQuery}
+                onChange={(event) => setWorktreeQuery(event.target.value)}
+                onMouseDown={(event) => {
+                  event.stopPropagation()
+                }}
+              />
+            </div>
+          )}
         </div>
       )}
     >
       <Button
         type='text'
-        className={`chat-header-git__trigger ${open ? 'is-open' : ''}`}
-        title={t('chat.gitWorktree')}
-        aria-label={t('chat.gitWorktree')}
+        className={`chat-header-git__trigger chat-header-git__trigger--worktree ${open ? 'is-open' : ''} ${
+          mode.type === 'session' && mode.isBusy ? 'is-disabled' : ''
+        } ${compact ? 'is-compact' : ''}`.trim()}
+        title={triggerTitle}
+        aria-label={t('chat.sessionWorkspace')}
       >
         <span className='chat-header-git__trigger-main'>
-          <span className='material-symbols-rounded'>account_tree</span>
-          <span className='chat-header-git__trigger-label'>{t('chat.gitWorktree')}</span>
+          <span className='material-symbols-rounded'>{triggerIcon}</span>
+          <span className='chat-header-git__trigger-label'>{triggerLabel}</span>
         </span>
         <span className='chat-header-git__trigger-chevron material-symbols-rounded'>expand_more</span>
       </Button>

package/src/components/chat/git-controls/git-branch-tree.ts

@@ -0,0 +1,148 @@
+import type { GitBranchSummary } from '@vibe-forge/types'
+
+export type GitBranchDisplayMode = 'flat' | 'tree'
+
+export interface GitBranchTreeFolder {
+  entries: GitBranchTreeEntry[]
+  hasCurrentBranch: boolean
+  key: string
+  label: string
+}
+
+export type GitBranchTreeEntry =
+  | {
+    type: 'branch'
+    branch: GitBranchSummary
+    label: string
+    subtitle?: string
+  }
+  | {
+    type: 'folder'
+    folder: GitBranchTreeFolder
+  }
+
+interface BranchTreeDraftFolder {
+  branches: GitBranchSummary[]
+  children: Map<string, BranchTreeDraftFolder>
+  hasCurrentBranch: boolean
+  key: string
+  label: string
+}
+
+const createDraftFolder = (key: string, label: string): BranchTreeDraftFolder => ({
+  branches: [],
+  children: new Map(),
+  hasCurrentBranch: false,
+  key,
+  label
+})
+
+const getBranchSegments = (branch: GitBranchSummary) => (
+  branch.kind === 'remote'
+    ? [branch.remoteName ?? 'remote', ...branch.localName.split('/').filter(Boolean)]
+    : branch.name.split('/').filter(Boolean)
+)
+
+export const getGitBranchTreeLabel = (branch: GitBranchSummary) => {
+  const segments = getBranchSegments(branch)
+  return segments.at(-1) ?? branch.localName ?? branch.name
+}
+
+const sortBranchEntries = (left: GitBranchSummary, right: GitBranchSummary) => {
+  if (left.isCurrent !== right.isCurrent) {
+    return left.isCurrent ? -1 : 1
+  }
+
+  return getGitBranchTreeLabel(left).localeCompare(getGitBranchTreeLabel(right))
+}
+
+const finalizeDraftFolder = (folder: BranchTreeDraftFolder): GitBranchTreeFolder => {
+  const folderEntries = Array.from(folder.children.values())
+    .sort((left, right) => {
+      if (left.hasCurrentBranch !== right.hasCurrentBranch) {
+        return left.hasCurrentBranch ? -1 : 1
+      }
+
+      return left.label.localeCompare(right.label)
+    })
+    .map(child => ({
+      type: 'folder' as const,
+      folder: finalizeDraftFolder(child)
+    }))
+
+  const branchEntries = [...folder.branches]
+    .sort(sortBranchEntries)
+    .map(branch => ({
+      type: 'branch' as const,
+      branch,
+      label: getGitBranchTreeLabel(branch)
+    }))
+
+  return {
+    entries: [...folderEntries, ...branchEntries],
+    hasCurrentBranch: folder.hasCurrentBranch,
+    key: folder.key,
+    label: folder.label
+  }
+}
+
+export const buildGitBranchTree = (branches: GitBranchSummary[], keyPrefix = '') => {
+  const root = createDraftFolder(keyPrefix, 'root')
+
+  for (const branch of branches) {
+    const segments = getBranchSegments(branch)
+    const leafLabel = segments.pop()
+    const branchIsCurrent = branch.isCurrent === true
+    const pathParts = keyPrefix === '' ? [] : [keyPrefix]
+    root.hasCurrentBranch = root.hasCurrentBranch || branchIsCurrent
+    if (leafLabel == null || leafLabel.trim() === '') {
+      root.branches.push(branch)
+      continue
+    }
+
+    let cursor = root
+    for (const segment of segments) {
+      pathParts.push(segment)
+      const existing = cursor.children.get(segment)
+      if (existing != null) {
+        cursor = existing
+        cursor.hasCurrentBranch = cursor.hasCurrentBranch || branchIsCurrent
+        continue
+      }
+
+      const nextFolder = createDraftFolder(pathParts.join('/'), segment)
+      nextFolder.hasCurrentBranch = branchIsCurrent
+      cursor.children.set(segment, nextFolder)
+      cursor = nextFolder
+    }
+
+    cursor.hasCurrentBranch = cursor.hasCurrentBranch || branchIsCurrent
+    cursor.branches.push(branch)
+  }
+
+  return finalizeDraftFolder(root).entries
+}
+
+export const collectGitBranchTreeFolderKeys = (entries: GitBranchTreeEntry[]): string[] => {
+  return entries.flatMap(entry => {
+    if (entry.type !== 'folder') {
+      return []
+    }
+
+    return [entry.folder.key, ...collectGitBranchTreeFolderKeys(entry.folder.entries)]
+  })
+}
+
+export const getGitBranchTreeFolderKeysForBranch = (branch: GitBranchSummary, keyPrefix = '') => {
+  const segments = getBranchSegments(branch)
+  segments.pop()
+
+  const folderKeys = keyPrefix === '' ? [] : [keyPrefix]
+  const pathParts = keyPrefix === '' ? [] : [keyPrefix]
+  for (const segment of segments) {
+    pathParts.push(segment)
+    folderKeys.push(pathParts.join('/'))
+  }
+
+  return folderKeys
+}

package/src/components/chat/git-controls/use-chat-draft-git-controls.ts

@@ -0,0 +1,168 @@
+import { useEffect, useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import useSWR from 'swr'
+
+import type { GitBranchSummary, GitRepositoryState } from '@vibe-forge/types'
+
+import { getWorkspaceGitState, listWorkspaceGitBranches, listWorkspaceGitWorktrees } from '#~/api'
+import type { ChatSessionWorkspaceDraft } from '#~/hooks/chat/chat-session-workspace-draft'
+
+import {
+  filterGitBranches,
+  getGitBranchCheckoutBlockedPath,
+  getGitBranchViewState,
+  hasExactGitBranchMatch
+} from './git-branch-utils'
+import { getGitControlState } from './git-operation-utils'
+import { getGitWorktreeViewState } from './git-worktree-utils'
+
+const EMPTY_REPO_STATE: GitRepositoryState = {
+  available: false,
+  cwd: ''
+}
+
+export function useChatDraftGitControls({
+  draft,
+  onChange
+}: {
+  draft: ChatSessionWorkspaceDraft
+  onChange: (nextDraft: ChatSessionWorkspaceDraft) => void
+}) {
+  const { t } = useTranslation()
+  const [branchMenuOpen, setBranchMenuOpen] = useState(false)
+  const [worktreeMenuOpen, setWorktreeMenuOpen] = useState(false)
+  const [shouldLoadBranches, setShouldLoadBranches] = useState(false)
+  const [branchQuery, setBranchQuery] = useState('')
+
+  const { data: repoState } = useSWR<GitRepositoryState>(
+    'workspace-git-state',
+    () => getWorkspaceGitState(),
+    { revalidateOnFocus: false }
+  )
+  const { data: branchData, isLoading: isBranchListLoading } = useSWR(
+    shouldLoadBranches ? 'workspace-git-branches' : null,
+    () => listWorkspaceGitBranches(),
+    { revalidateOnFocus: false }
+  )
+  const { data: worktreeData } = useSWR(
+    repoState?.available === true ? 'workspace-git-worktrees' : null,
+    () => listWorkspaceGitWorktrees(),
+    { revalidateOnFocus: false }
+  )
+
+  useEffect(() => {
+    if (!branchMenuOpen) {
+      setBranchQuery('')
+    }
+  }, [branchMenuOpen])
+
+  const allBranches = branchData?.branches ?? []
+  const filteredBranches = useMemo(() => filterGitBranches(allBranches, branchQuery), [allBranches, branchQuery])
+  const currentWorktreePath = draft.createWorktree ? '' : repoState?.repositoryRoot ?? ''
+  const { availableLocalBranches, hasResults: hasBranchResults, remoteBranches } = useMemo(
+    () => getGitBranchViewState(filteredBranches, allBranches, currentWorktreePath),
+    [allBranches, currentWorktreePath, filteredBranches]
+  )
+  const canCreateBranch = branchQuery.trim() !== '' && !hasExactGitBranchMatch(allBranches, branchQuery)
+  const worktreeViewState = useMemo(() =>
+    getGitWorktreeViewState({
+      currentBranch: repoState?.currentBranch,
+      enabled: repoState?.available === true,
+      repositoryRoot: repoState?.repositoryRoot,
+      worktrees: worktreeData?.worktrees
+    }), [repoState?.available, repoState?.currentBranch, repoState?.repositoryRoot, worktreeData?.worktrees])
+  const { currentBranchLabel: repoBranchLabel } = getGitControlState(repoState, false, {
+    detachedHead: t('chat.gitDetachedHead'),
+    pushNeedsSyncOrForce: t('chat.gitPushNeedsSyncOrForce'),
+    pushUnavailable: t('common.operationFailed')
+  })
+
+  const currentBranchLabel = draft.branch == null
+    ? repoBranchLabel
+    : draft.branch.mode === 'create'
+    ? t('chat.sessionWorkspaceDraftCreateBranchLabel', { branch: draft.branch.name })
+    : draft.branch.name
+
+  const handleDraftChange = (nextDraft: ChatSessionWorkspaceDraft) => {
+    onChange(nextDraft)
+  }
+
+  const handleBranchSwitch = (branch: GitBranchSummary) => {
+    handleDraftChange({
+      ...draft,
+      branch: {
+        mode: 'checkout',
+        name: branch.name,
+        kind: branch.kind
+      }
+    })
+    setBranchMenuOpen(false)
+  }
+
+  const handleCreateBranch = (name: string) => {
+    const trimmedName = name.trim()
+    if (trimmedName === '') {
+      return
+    }
+
+    handleDraftChange({
+      ...draft,
+      branch: {
+        mode: 'create',
+        name: trimmedName
+      }
+    })
+    setBranchMenuOpen(false)
+  }
+
+  const handleCreateWorktreeChange = (checked: boolean) => {
+    if (draft.branch == null || draft.branch.mode === 'create') {
+      handleDraftChange({
+        ...draft,
+        createWorktree: checked
+      })
+      return
+    }
+
+    const selectedBranch = allBranches.find(branch =>
+      branch.kind === draft.branch?.kind && branch.name === draft.branch?.name
+    )
+    if (selectedBranch == null) {
+      handleDraftChange({
+        ...draft,
+        createWorktree: checked
+      })
+      return
+    }
+
+    const nextCurrentWorktreePath = checked ? '' : repoState?.repositoryRoot ?? ''
+    const blockedPath = getGitBranchCheckoutBlockedPath(selectedBranch, allBranches, nextCurrentWorktreePath)
+    handleDraftChange({
+      ...draft,
+      createWorktree: checked,
+      branch: blockedPath == null ? draft.branch : undefined
+    })
+  }
+
+  return {
+    availableLocalBranches,
+    branchMenuOpen,
+    branchQuery,
+    canCreateBranch,
+    currentBranchLabel,
+    handleBranchSwitch,
+    handleCreateBranch,
+    handleCreateWorktreeChange,
+    hasBranchResults,
+    isBranchListLoading,
+    repoState: repoState ?? EMPTY_REPO_STATE,
+    remoteBranches,
+    setBranchMenuOpen,
+    setBranchQuery,
+    setShouldLoadBranches,
+    setWorktreeMenuOpen,
+    shouldLoadBranches,
+    worktreeMenuOpen,
+    worktrees: worktreeViewState.worktrees
+  }
+}