@vibe-forge/client 3.0.0-alpha.5 → 3.0.0-alpha.7

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

@@ -1,273 +0,0 @@
-/* eslint-disable max-lines */
-
-import { App } from 'antd'
-import { useEffect, useMemo, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-import useSWR from 'swr'
-
-import type { GitBranchListResult, GitBranchSummary, GitRepositoryState, SessionWorkspace } from '@vibe-forge/types'
-
-import {
-  checkoutSessionGitBranch,
-  createSessionGitBranch,
-  createSessionManagedWorktree,
-  getApiErrorMessage,
-  getSessionGitState,
-  getSessionWorkspace,
-  listSessionGitBranches,
-  transferSessionWorkspaceToLocal
-} from '#~/api'
-
-import { filterGitBranches, getGitBranchViewState, hasExactGitBranchMatch } from './git-branch-utils'
-import { runGitControlMutation, runSessionGitPush } from './git-mutation-utils'
-import { getGitControlState } from './git-operation-utils'
-import { useChatGitCommit } from './use-chat-git-commit'
-import { useChatGitPushState } from './use-chat-git-push-state'
-import { useChatGitWorktrees } from './use-chat-git-worktrees'
-
-type GitActionKind =
-  | 'branch-create'
-  | 'branch-switch'
-  | 'commit'
-  | 'commit-and-push'
-  | 'push'
-  | 'sync'
-  | 'workspace-create'
-  | 'workspace-transfer'
-
-export function useChatGitControls(sessionId: string) {
-  const { t } = useTranslation()
-  const { message } = App.useApp()
-  const [branchMenuOpen, setBranchMenuOpen] = useState(false)
-  const [operationsMenuOpen, setOperationsMenuOpen] = useState(false)
-  const [shouldLoadBranches, setShouldLoadBranches] = useState(false)
-  const [branchQuery, setBranchQuery] = useState('')
-  const [pendingAction, setPendingAction] = useState<GitActionKind | null>(null)
-  const push = useChatGitPushState()
-
-  const { data: workspaceData, mutate: mutateWorkspaceData } = useSWR<{ workspace: SessionWorkspace }>(
-    ['session-workspace', sessionId],
-    () => getSessionWorkspace(sessionId),
-    { revalidateOnFocus: false }
-  )
-  const { data: repoState, mutate: mutateRepoState } = useSWR<GitRepositoryState>(
-    ['session-git-state', sessionId],
-    () => getSessionGitState(sessionId),
-    { revalidateOnFocus: false }
-  )
-  const { data: branchData, isLoading: isBranchListLoading, mutate: mutateBranchData } = useSWR<GitBranchListResult>(
-    shouldLoadBranches ? ['session-git-branches', sessionId] : null,
-    () => listSessionGitBranches(sessionId),
-    { revalidateOnFocus: false }
-  )
-  const worktree = useChatGitWorktrees({
-    currentBranch: repoState?.currentBranch,
-    enabled: repoState?.available === true,
-    repositoryRoot: repoState?.repositoryRoot,
-    sessionId
-  })
-
-  useEffect(() => {
-    setBranchMenuOpen(false)
-    setOperationsMenuOpen(false)
-    worktree.setWorktreeMenuOpen(false)
-    setShouldLoadBranches(false)
-    setBranchQuery('')
-    setPendingAction(null)
-    push.resetPushState()
-  }, [sessionId])
-
-  const refreshGitState = async (nextRepo?: GitRepositoryState) => {
-    if (nextRepo != null) {
-      await mutateRepoState(nextRepo, { revalidate: false })
-    } else {
-      await mutateRepoState()
-    }
-
-    if (shouldLoadBranches) {
-      await mutateBranchData()
-    }
-
-    if (repoState?.available === true || nextRepo?.available === true) {
-      await worktree.mutateWorktreeData()
-    }
-  }
-
-  const refreshWorkspaceState = async (nextWorkspace?: SessionWorkspace) => {
-    if (nextWorkspace != null) {
-      await mutateWorkspaceData({ workspace: nextWorkspace }, { revalidate: false })
-      return
-    }
-
-    await mutateWorkspaceData()
-  }
-
-  const commit = useChatGitCommit({
-    closeOperationsMenu: () => setOperationsMenuOpen(false),
-    refreshGitState,
-    repoState,
-    sessionId,
-    setPendingAction
-  })
-
-  const allBranches = branchData?.branches ?? []
-  const filteredBranches = useMemo(() => filterGitBranches(allBranches, branchQuery), [allBranches, branchQuery])
-  const currentWorktreePath = repoState?.available === true ? repoState.repositoryRoot ?? '' : ''
-  const { availableLocalBranches, hasResults: hasBranchResults, remoteBranches } = useMemo(
-    () => getGitBranchViewState(filteredBranches, allBranches, currentWorktreePath),
-    [allBranches, filteredBranches, currentWorktreePath]
-  )
-  const canCreateBranch = branchQuery.trim() !== '' && !hasExactGitBranchMatch(allBranches, branchQuery)
-  const isBusy = pendingAction != null
-
-  const { currentBranchLabel, pushBlockedMessage, pushBlockedReason } = getGitControlState(repoState, push.pushForce, {
-    detachedHead: t('chat.gitDetachedHead'),
-    pushNeedsSyncOrForce: t('chat.gitPushNeedsSyncOrForce'),
-    pushUnavailable: t('common.operationFailed')
-  })
-
-  const runMutation = async (
-    action: Exclude<GitActionKind, 'commit' | 'commit-and-push'>,
-    task: () => Promise<{ repo: GitRepositoryState }>,
-    successMessage: string,
-    onSuccess?: () => void
-  ) =>
-    runGitControlMutation({
-      action,
-      notifyError: error => void message.error(getApiErrorMessage(error, t('common.operationFailed'))),
-      notifySuccess: nextMessage => void message.success(nextMessage),
-      onSuccess,
-      refreshGitState,
-      setPendingAction,
-      successMessage,
-      task
-    })
-
-  const runWorkspaceMutation = async (
-    action: Extract<GitActionKind, 'workspace-create' | 'workspace-transfer'>,
-    task: () => Promise<{ workspace: SessionWorkspace }>,
-    successMessage: string,
-    onSuccess?: () => void
-  ) => {
-    setPendingAction(action)
-    try {
-      const result = await task()
-      await refreshWorkspaceState(result.workspace)
-      await refreshGitState()
-      onSuccess?.()
-      void message.success(successMessage)
-    } catch (error) {
-      void message.error(getApiErrorMessage(error, t('common.operationFailed')))
-    } finally {
-      setPendingAction(null)
-    }
-  }
-
-  const closeBranchMenu = () => {
-    setBranchMenuOpen(false)
-    setBranchQuery('')
-  }
-
-  const handleBranchSwitch = (branch: GitBranchSummary) => {
-    void runMutation(
-      'branch-switch',
-      () => checkoutSessionGitBranch(sessionId, { name: branch.name, kind: branch.kind }),
-      t('chat.gitSwitchBranchSuccess', { branch: branch.kind === 'local' ? branch.name : branch.localName }),
-      closeBranchMenu
-    )
-  }
-
-  const handleCreateBranch = (name: string) => {
-    const trimmedName = name.trim()
-    if (trimmedName === '') {
-      return
-    }
-
-    void runMutation(
-      'branch-create',
-      () => createSessionGitBranch(sessionId, { name: trimmedName }),
-      t('chat.gitCreateBranchSuccess', { branch: trimmedName }),
-      closeBranchMenu
-    )
-  }
-
-  const handleOpenPushModal = () => {
-    setOperationsMenuOpen(false)
-    push.setPushModalOpen(true)
-  }
-
-  const handlePush = () => {
-    void runSessionGitPush({
-      blockedMessage: pushBlockedMessage,
-      blockedReason: pushBlockedReason,
-      force: push.pushForce,
-      notifyBlocked: nextMessage => void message.error(nextMessage),
-      onSuccess: push.resetPushState,
-      repoState,
-      runMutation,
-      sessionId,
-      successMessage: push.pushForce ? t('chat.gitForcePushSuccess') : t('chat.gitPushSuccess')
-    })
-  }
-
-  const handleCreateManagedWorktree = () => {
-    void runWorkspaceMutation(
-      'workspace-create',
-      () => createSessionManagedWorktree(sessionId),
-      t('chat.sessionWorkspaceCreateWorktreeSuccess'),
-      () => {
-        worktree.setWorktreeMenuOpen(false)
-        setBranchMenuOpen(false)
-      }
-    )
-  }
-
-  const handleTransferWorkspaceToLocal = () => {
-    void runWorkspaceMutation(
-      'workspace-transfer',
-      () => transferSessionWorkspaceToLocal(sessionId),
-      t('chat.sessionWorkspaceTransferToLocalSuccess'),
-      () => {
-        worktree.setWorktreeMenuOpen(false)
-      }
-    )
-  }
-
-  return {
-    branchMenuOpen,
-    branchQuery,
-    canCreateBranch,
-    currentBranchLabel,
-    handleBranchSwitch,
-    handleCreateBranch,
-    handleCreateManagedWorktree,
-    handleOpenPushModal,
-    handlePush,
-    handleTransferWorkspaceToLocal,
-    hasBranchResults,
-    isBranchListLoading,
-    isBusy,
-    availableLocalBranches,
-    operationsMenuOpen,
-    pendingAction,
-    pushBlockedMessage,
-    pushForce: push.pushForce,
-    pushModalOpen: push.pushModalOpen,
-    remoteBranches,
-    repoState,
-    workspace: workspaceData?.workspace,
-    runMutation,
-    showWorktreeButton: worktree.showWorktreeButton,
-    worktreeMenuOpen: worktree.worktreeMenuOpen,
-    worktrees: worktree.worktrees,
-    setBranchMenuOpen,
-    setBranchQuery,
-    setOperationsMenuOpen,
-    setPushForce: push.setPushForce,
-    setPushModalOpen: push.setPushModalOpen,
-    setShouldLoadBranches,
-    setWorktreeMenuOpen: worktree.setWorktreeMenuOpen,
-    resetPushState: push.resetPushState,
-    ...commit
-  }
-}

package/src/components/chat/git-controls/use-chat-git-push-state.ts

@@ -1,19 +0,0 @@
-import { useState } from 'react'
-
-export function useChatGitPushState() {
-  const [pushModalOpen, setPushModalOpen] = useState(false)
-  const [pushForce, setPushForce] = useState(false)
-
-  const resetPushState = () => {
-    setPushModalOpen(false)
-    setPushForce(false)
-  }
-
-  return {
-    pushForce,
-    pushModalOpen,
-    resetPushState,
-    setPushForce,
-    setPushModalOpen
-  }
-}

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

@@ -1,39 +0,0 @@
-import { useMemo, useState } from 'react'
-import useSWR from 'swr'
-
-import type { GitWorktreeListResult } from '@vibe-forge/types'
-
-import { listSessionGitWorktrees } from '#~/api'
-import { getGitWorktreeViewState } from './git-worktree-utils'
-
-export function useChatGitWorktrees(input: {
-  currentBranch?: string | null
-  enabled: boolean
-  repositoryRoot?: string
-  sessionId: string
-}) {
-  const [worktreeMenuOpen, setWorktreeMenuOpen] = useState(false)
-  const { data: worktreeData, mutate: mutateWorktreeData } = useSWR<GitWorktreeListResult>(
-    input.enabled ? ['session-git-worktrees', input.sessionId] : null,
-    () => listSessionGitWorktrees(input.sessionId),
-    { revalidateOnFocus: false }
-  )
-  const viewState = useMemo(
-    () =>
-      getGitWorktreeViewState({
-        currentBranch: input.currentBranch,
-        enabled: input.enabled,
-        repositoryRoot: input.repositoryRoot,
-        worktrees: worktreeData?.worktrees
-      }),
-    [input.currentBranch, input.enabled, input.repositoryRoot, worktreeData?.worktrees]
-  )
-
-  return {
-    mutateWorktreeData,
-    showWorktreeButton: viewState.showWorktreeButton,
-    worktreeMenuOpen,
-    worktrees: viewState.worktrees,
-    setWorktreeMenuOpen
-  }
-}

package/src/components/chat/messages/MessageContextMenu.scss

@@ -1,145 +0,0 @@
-.message-context-menu {
-  min-width: 196px;
-  padding: 4px;
-  border: 1px solid var(--border-color);
-  border-radius: 10px;
-  background-color: var(--bg-color);
-  box-shadow: 0 10px 30px rgba(15, 23, 42, .14);
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-}
-
-.message-context-menu__item {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  width: 100%;
-  min-height: 32px;
-  padding: 6px 10px;
-  border: 0;
-  border-radius: 8px;
-  background: transparent;
-  color: var(--text-color);
-  text-align: left;
-  cursor: pointer;
-  transition: background-color .18s ease, color .18s ease;
-
-  &:hover {
-    background-color: color-mix(
-      in srgb,
-      var(--primary-color) 8%,
-      var(--bg-color)
-    );
-  }
-
-  &.is-confirming {
-    background-color: color-mix(
-      in srgb,
-      var(--primary-color) 12%,
-      var(--bg-color)
-    );
-  }
-
-  &.is-danger {
-    color: #dc2626;
-
-    &:hover {
-      background-color: rgba(220, 38, 38, .12);
-      color: #b91c1c;
-    }
-
-    &.is-confirming {
-      background-color: rgba(220, 38, 38, .12);
-    }
-  }
-}
-
-.message-context-menu__meta {
-  min-width: 0;
-  display: inline-flex;
-  align-items: center;
-  gap: 10px;
-}
-
-.message-context-menu__icon {
-  font-size: 16px;
-  line-height: 1;
-  flex-shrink: 0;
-}
-
-.message-context-menu__item--copy .message-context-menu__icon,
-.message-context-menu__item--copy-id .message-context-menu__icon,
-.message-context-menu__item--copy-timestamp .message-context-menu__icon {
-  color: #64748b;
-}
-
-.message-context-menu__item--copy-link .message-context-menu__icon {
-  color: #2563eb;
-}
-
-.message-context-menu__item--edit .message-context-menu__icon {
-  color: var(--sub-text-color);
-}
-
-.message-context-menu__item--recall .message-context-menu__icon {
-  color: #dc2626;
-}
-
-.message-context-menu__item--fork .message-context-menu__icon {
-  color: #0891b2;
-}
-
-.message-context-menu__item--copy-json .message-context-menu__icon {
-  color: #7c3aed;
-}
-
-.message-context-menu__label {
-  min-width: 0;
-  font-size: 12px;
-  line-height: 1.4;
-}
-
-.message-context-menu__confirm-actions {
-  display: inline-flex;
-  align-items: center;
-  gap: 4px;
-  margin-left: 12px;
-  flex-shrink: 0;
-}
-
-.message-context-menu__confirm-btn {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 20px;
-  height: 20px;
-  padding: 0;
-  border: 0;
-  border-radius: 999px;
-  background: transparent;
-  color: inherit;
-  cursor: pointer;
-  transition: background-color .18s ease, color .18s ease;
-
-  .material-symbols-rounded {
-    font-size: 14px;
-    line-height: 1;
-  }
-
-  &.is-accept:hover {
-    background-color: rgba(34, 197, 94, .14);
-    color: #15803d;
-  }
-
-  &.is-cancel:hover {
-    background-color: rgba(148, 163, 184, .18);
-    color: var(--text-color);
-  }
-}
-
-.message-context-menu__divider {
-  height: 1px;
-  margin: 4px 6px;
-  background-color: var(--border-color);
-}

package/src/components/chat/messages/MessageContextMenu.tsx

@@ -1,110 +0,0 @@
-import './MessageContextMenu.scss'
-
-import { App, Dropdown } from 'antd'
-import type { ReactElement } from 'react'
-import { useState } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import type { ChatMessage } from '@vibe-forge/core'
-
-import { MessageContextMenuContent } from './MessageContextMenuContent'
-import { buildMessageContextMenuEntries } from './build-message-context-menu-entries'
-
-interface MessageContextMenuProps {
-  anchorId: string
-  canEdit: boolean
-  canFork: boolean
-  canRecall: boolean
-  children: ReactElement
-  copyableText?: string
-  isDebugMode: boolean
-  isEditing: boolean
-  message: ChatMessage
-  sessionId?: string
-  trigger?: ('click' | 'contextMenu')[]
-  onFork: () => void
-  onRecall: () => void
-  onStartEditing: () => void
-}
-
-type PendingMessageMenuAction = 'fork' | 'recall' | null
-
-export function MessageContextMenu({
-  anchorId,
-  canEdit,
-  canFork,
-  canRecall,
-  children,
-  copyableText,
-  isDebugMode,
-  isEditing,
-  message: sourceMessage,
-  sessionId,
-  trigger = ['contextMenu'],
-  onFork,
-  onRecall,
-  onStartEditing
-}: MessageContextMenuProps) {
-  const { t } = useTranslation()
-  const { message } = App.useApp()
-  const [open, setOpen] = useState(false)
-  const [pendingAction, setPendingAction] = useState<PendingMessageMenuAction>(null)
-
-  const closeMenu = () => {
-    setOpen(false)
-    setPendingAction(null)
-  }
-
-  const handleConfirmableActionClick = (action: Exclude<PendingMessageMenuAction, null>) => {
-    if (pendingAction === action) {
-      closeMenu()
-      if (action === 'recall') {
-        void onRecall()
-        return
-      }
-      void onFork()
-      return
-    }
-
-    setPendingAction(action)
-  }
-
-  const entries = buildMessageContextMenuEntries({
-    anchorId,
-    canEdit,
-    canFork,
-    canRecall,
-    copyableText,
-    isDebugMode,
-    isEditing,
-    messageApi: message,
-    onCloseMenu: closeMenu,
-    onConfirmableActionClick: handleConfirmableActionClick,
-    onStartEditing,
-    sessionId,
-    sourceMessage,
-    t
-  })
-
-  return (
-    <Dropdown
-      trigger={trigger}
-      open={open}
-      onOpenChange={(nextOpen) => {
-        setOpen(nextOpen)
-        if (!nextOpen) {
-          setPendingAction(null)
-        }
-      }}
-      dropdownRender={() => (
-        <MessageContextMenuContent
-          entries={entries}
-          pendingAction={pendingAction}
-          onCancelConfirm={() => setPendingAction(null)}
-        />
-      )}
-    >
-      {children}
-    </Dropdown>
-  )
-}

package/src/components/chat/messages/MessageContextMenuContent.tsx

@@ -1,87 +0,0 @@
-export interface MessageContextMenuEntry {
-  confirmLabel?: string
-  danger?: boolean
-  icon: string
-  key: string
-  label: string
-  onClick: () => void
-  type?: 'divider'
-}
-
-export function MessageContextMenuContent({
-  entries,
-  pendingAction,
-  onCancelConfirm
-}: {
-  entries: MessageContextMenuEntry[]
-  pendingAction: string | null
-  onCancelConfirm: () => void
-}) {
-  return (
-    <div className='message-context-menu' onContextMenu={(event) => event.preventDefault()}>
-      {entries.map((entry) => {
-        if (entry.type === 'divider') {
-          return <div key={entry.key} className='message-context-menu__divider' />
-        }
-
-        const isConfirming = pendingAction === entry.key
-        return (
-          <div
-            key={entry.key}
-            role='button'
-            tabIndex={0}
-            className={`message-context-menu__item message-context-menu__item--${entry.key} ${
-              entry.danger ? 'is-danger' : ''
-            } ${isConfirming ? 'is-confirming' : ''}`}
-            onClick={(event) => {
-              event.preventDefault()
-              event.stopPropagation()
-              entry.onClick()
-            }}
-            onKeyDown={(event) => {
-              if (event.key === 'Enter' || event.key === ' ') {
-                event.preventDefault()
-                entry.onClick()
-              }
-            }}
-          >
-            <div className='message-context-menu__meta'>
-              <span className='material-symbols-rounded message-context-menu__icon'>
-                {entry.icon}
-              </span>
-              <span className='message-context-menu__label'>
-                {isConfirming ? (entry.confirmLabel ?? entry.label) : entry.label}
-              </span>
-            </div>
-            {isConfirming && (
-              <div className='message-context-menu__confirm-actions'>
-                <button
-                  type='button'
-                  className='message-context-menu__confirm-btn is-accept'
-                  onClick={(event) => {
-                    event.preventDefault()
-                    event.stopPropagation()
-                    entry.onClick()
-                  }}
-                >
-                  <span className='material-symbols-rounded'>check</span>
-                </button>
-                <button
-                  type='button'
-                  className='message-context-menu__confirm-btn is-cancel'
-                  onClick={(event) => {
-                    event.preventDefault()
-                    event.stopPropagation()
-                    onCancelConfirm()
-                  }}
-                >
-                  <span className='material-symbols-rounded'>close</span>
-                </button>
-              </div>
-            )}
-          </div>
-        )
-      })}
-    </div>
-  )
-}