@vibe-forge/client 3.0.0-alpha.6 → 3.0.0

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

@@ -1,341 +0,0 @@
-/* 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, 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={placement}
-      trigger={['click']}
-      onOpenChange={onOpenChange}
-      dropdownRender={() => (
-        <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
-                className={`chat-header-git__menu-row chat-header-git__menu-row--toggle ${
-                  mode.disabled ? 'is-disabled' : ''
-                }`}
-              >
-                <span className='chat-header-git__menu-row-main'>
-                  <span className='chat-header-git__row-icon material-symbols-rounded'>
-                    {getDraftStrategyIcon(true)}
-                  </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 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'>{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>
-    </Dropdown>
-  )
-}

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

@@ -1,148 +0,0 @@
-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/git-branch-utils.ts

@@ -1,88 +0,0 @@
-import type { GitBranchSummary } from '@vibe-forge/types'
-
-const normalizeBranchText = (value: string) => value.trim().toLowerCase()
-const normalizeWorktreePath = (value: string) => value.trim().replace(/[/\\]+$/, '').replace(/\\/g, '/')
-
-export const formatGitWorktreePathLabel = (value: string) => {
-  const segments = normalizeWorktreePath(value).split('/').filter(Boolean)
-  if (segments.length >= 2) {
-    return segments.slice(-2).join('/')
-  }
-  return segments[0] ?? value.trim()
-}
-
-export const isGitBranchCheckedOutInOtherWorktree = (
-  branch: GitBranchSummary,
-  currentWorktreePath: string
-) => {
-  if (branch.kind !== 'local' || branch.worktreePath == null || branch.worktreePath.trim() === '') {
-    return false
-  }
-
-  return normalizeWorktreePath(branch.worktreePath) !== normalizeWorktreePath(currentWorktreePath)
-}
-
-export const getGitBranchCheckoutBlockedPath = (
-  branch: GitBranchSummary,
-  branches: GitBranchSummary[],
-  currentWorktreePath: string
-) => {
-  if (branch.kind === 'local') {
-    return isGitBranchCheckedOutInOtherWorktree(branch, currentWorktreePath)
-      ? branch.worktreePath?.trim() ?? null
-      : null
-  }
-
-  const localPeer = branches.find(item => item.kind === 'local' && item.localName === branch.localName)
-  if (localPeer == null) {
-    return null
-  }
-
-  return isGitBranchCheckedOutInOtherWorktree(localPeer, currentWorktreePath)
-    ? localPeer.worktreePath?.trim() ?? null
-    : null
-}
-
-export const getGitBranchViewState = (
-  visibleBranches: GitBranchSummary[],
-  allBranches: GitBranchSummary[],
-  currentWorktreePath: string
-) => {
-  const localBranches = visibleBranches.filter(branch => branch.kind === 'local')
-  const isSwitchableBranch = (branch: GitBranchSummary) =>
-    getGitBranchCheckoutBlockedPath(branch, allBranches, currentWorktreePath) == null
-  const availableLocalBranches = localBranches.filter(isSwitchableBranch)
-  const remoteBranches = visibleBranches.filter(branch => branch.kind === 'remote' && isSwitchableBranch(branch))
-
-  return {
-    availableLocalBranches,
-    hasResults: availableLocalBranches.length > 0 || remoteBranches.length > 0,
-    remoteBranches
-  }
-}
-
-const getBranchSearchTokens = (branch: GitBranchSummary) => {
-  const tokens = [branch.name, branch.localName]
-  if (branch.remoteName != null && branch.remoteName !== '') {
-    tokens.push(branch.remoteName, `${branch.remoteName}/${branch.localName}`)
-  }
-  return tokens.map(token => normalizeBranchText(token))
-}
-
-export const filterGitBranches = (branches: GitBranchSummary[], query: string) => {
-  const normalizedQuery = normalizeBranchText(query)
-  if (normalizedQuery === '') {
-    return branches
-  }
-
-  return branches.filter(branch => getBranchSearchTokens(branch).some(token => token.includes(normalizedQuery)))
-}
-
-export const hasExactGitBranchMatch = (branches: GitBranchSummary[], query: string) => {
-  const normalizedQuery = normalizeBranchText(query)
-  if (normalizedQuery === '') {
-    return false
-  }
-
-  return branches.some(branch => getBranchSearchTokens(branch).includes(normalizedQuery))
-}

package/src/components/chat/git-controls/git-commit-utils.ts

@@ -1,79 +0,0 @@
-import type { GitChangeSummary, GitRepositoryState } from '@vibe-forge/types'
-
-import { isGitOperationDisabled } from './git-operation-utils'
-
-export type GitCommitNextStep = 'commit' | 'commit-and-push'
-export type GitCommitBlockedReason =
-  | 'amend-unavailable'
-  | 'message-required'
-  | 'no-changes'
-  | 'no-staged-changes'
-  | null
-
-const EMPTY_GIT_CHANGE_SUMMARY: GitChangeSummary = {
-  changedFiles: 0,
-  additions: 0,
-  deletions: 0
-}
-
-export const getGitCommitSummary = (
-  repoState: GitRepositoryState,
-  includeUnstagedChanges: boolean
-): GitChangeSummary => {
-  return includeUnstagedChanges
-    ? repoState.workingTreeSummary ?? EMPTY_GIT_CHANGE_SUMMARY
-    : repoState.stagedSummary ?? EMPTY_GIT_CHANGE_SUMMARY
-}
-
-export const getGitCommitBlockedReason = (
-  repoState: GitRepositoryState,
-  options: {
-    includeUnstagedChanges: boolean
-    amend: boolean
-    commitMessage: string
-  }
-): GitCommitBlockedReason => {
-  const hasCommitChanges = options.includeUnstagedChanges
-    ? repoState.hasChanges === true
-    : repoState.hasStagedChanges === true
-  const hasMessage = options.commitMessage.trim() !== ''
-
-  if (options.amend && repoState.headCommit == null) {
-    return 'amend-unavailable'
-  }
-
-  if (options.amend) {
-    return hasCommitChanges || hasMessage
-      ? null
-      : options.includeUnstagedChanges
-      ? 'no-changes'
-      : 'no-staged-changes'
-  }
-
-  if (!hasCommitChanges) {
-    return options.includeUnstagedChanges
-      ? 'no-changes'
-      : 'no-staged-changes'
-  }
-
-  return hasMessage ? null : 'message-required'
-}
-
-export const canSubmitGitCommit = (
-  repoState: GitRepositoryState,
-  options: {
-    includeUnstagedChanges: boolean
-    amend: boolean
-    commitMessage: string
-  }
-) => {
-  return getGitCommitBlockedReason(repoState, options) == null
-}
-
-export const canGitCommitAndPush = (repoState: GitRepositoryState) => {
-  return !isGitOperationDisabled(repoState, 'push')
-}
-
-export const isGitCommitMessageRequired = (amend: boolean) => {
-  return !amend
-}