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

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

@@ -1,69 +0,0 @@
-import type { GitRepositoryState } from '@vibe-forge/types'
-
-import { pushSessionGitBranch } from '#~/api'
-
-export const runGitControlMutation = async <TAction extends string>(options: {
-  action: TAction
-  notifyError: (error: unknown) => void
-  notifySuccess: (message: string) => void
-  onSuccess?: () => void
-  refreshGitState: (nextRepo?: GitRepositoryState) => Promise<void>
-  setPendingAction: (action: TAction | null) => void
-  successMessage: string
-  task: () => Promise<{ repo: GitRepositoryState }>
-}) => {
-  const {
-    action,
-    notifyError,
-    notifySuccess,
-    onSuccess,
-    refreshGitState,
-    setPendingAction,
-    successMessage,
-    task
-  } = options
-
-  setPendingAction(action)
-  try {
-    const result = await task()
-    await refreshGitState(result.repo)
-    onSuccess?.()
-    notifySuccess(successMessage)
-  } catch (error) {
-    notifyError(error)
-  } finally {
-    setPendingAction(null)
-  }
-}
-
-export const runSessionGitPush = async (options: {
-  blockedMessage: string
-  blockedReason: string | null
-  force: boolean
-  notifyBlocked: (message: string) => void
-  onSuccess?: () => void
-  repoState: GitRepositoryState | undefined
-  runMutation: (
-    action: 'push',
-    task: () => Promise<{ repo: GitRepositoryState }>,
-    successMessage: string,
-    onSuccess?: () => void
-  ) => Promise<void>
-  sessionId: string
-  successMessage: string
-}) => {
-  if (options.repoState?.available !== true) {
-    return
-  }
-  if (options.blockedReason != null) {
-    options.notifyBlocked(options.blockedMessage)
-    return
-  }
-
-  await options.runMutation(
-    'push',
-    () => pushSessionGitBranch(options.sessionId, { force: options.force }),
-    options.successMessage,
-    options.onSuccess
-  )
-}

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

@@ -1,98 +0,0 @@
-import type { GitRepositoryState } from '@vibe-forge/types'
-
-export type GitOperationKind = 'commit' | 'push' | 'sync'
-export type GitPushBlockedReason = 'behind-upstream' | 'push-unavailable' | null
-
-const hasUpstream = (repoState: GitRepositoryState) => repoState.upstream != null && repoState.upstream.trim() !== ''
-
-const hasRemote = (repoState: GitRepositoryState) => hasUpstream(repoState) || (repoState.remotes?.length ?? 0) > 0
-
-const hasBranch = (repoState: GitRepositoryState) =>
-  repoState.currentBranch != null && repoState.currentBranch.trim() !== ''
-
-export const isGitOperationDisabled = (
-  repoState: GitRepositoryState,
-  kind: GitOperationKind
-) => {
-  switch (kind) {
-    case 'commit':
-      return repoState.hasChanges !== true
-    case 'push':
-    case 'sync':
-      return !hasBranch(repoState) || !hasRemote(repoState)
-  }
-}
-
-export const getGitPushBlockedReason = (
-  repoState: GitRepositoryState,
-  forcePush: boolean
-): GitPushBlockedReason => {
-  if (isGitOperationDisabled(repoState, 'push')) {
-    return 'push-unavailable'
-  }
-
-  if ((repoState.behind ?? 0) > 0 && !forcePush) {
-    return 'behind-upstream'
-  }
-
-  return null
-}
-
-export const getGitControlState = (
-  repoState: GitRepositoryState | undefined,
-  forcePush: boolean,
-  labels: {
-    detachedHead: string
-    pushNeedsSyncOrForce: string
-    pushUnavailable: string
-  }
-) => {
-  const currentBranchName = repoState?.available === true
-    ? repoState.currentBranch?.trim() ?? ''
-    : ''
-  const currentBranchLabel = currentBranchName !== ''
-    ? currentBranchName
-    : labels.detachedHead
-  const pushBlockedReason = repoState?.available === true
-    ? getGitPushBlockedReason(repoState, forcePush)
-    : 'push-unavailable'
-
-  return {
-    currentBranchLabel,
-    pushBlockedReason,
-    pushBlockedMessage: pushBlockedReason === 'behind-upstream'
-      ? labels.pushNeedsSyncOrForce
-      : pushBlockedReason == null
-      ? ''
-      : labels.pushUnavailable
-  }
-}
-
-export const getPrimaryGitOperationKind = (
-  repoState: GitRepositoryState
-): GitOperationKind | null => {
-  if (repoState.hasChanges === true) {
-    return 'commit'
-  }
-
-  if ((repoState.behind ?? 0) > 0 && !isGitOperationDisabled(repoState, 'sync')) {
-    return 'sync'
-  }
-
-  if (
-    ((repoState.ahead ?? 0) > 0 || !hasUpstream(repoState)) &&
-    !isGitOperationDisabled(repoState, 'push')
-  ) {
-    return 'push'
-  }
-
-  if (!isGitOperationDisabled(repoState, 'sync')) {
-    return 'sync'
-  }
-
-  if (!isGitOperationDisabled(repoState, 'push')) {
-    return 'push'
-  }
-
-  return null
-}

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

@@ -1,49 +0,0 @@
-import type { GitWorktreeSummary } from '@vibe-forge/types'
-
-const sortGitWorktrees = (worktrees: GitWorktreeSummary[]) => {
-  return [...worktrees].sort((left, right) => {
-    if (left.isCurrent !== right.isCurrent) {
-      return left.isCurrent ? -1 : 1
-    }
-
-    return left.path.localeCompare(right.path)
-  })
-}
-
-const getCurrentWorktreeFallback = (repositoryRoot?: string, currentBranch?: string | null): GitWorktreeSummary[] => {
-  const path = repositoryRoot?.trim() ?? ''
-  if (path === '') {
-    return []
-  }
-
-  const branchName = currentBranch?.trim() || null
-  return [{
-    path,
-    branchName,
-    isCurrent: true,
-    isDetached: branchName == null
-  }]
-}
-
-export const getGitWorktreeViewState = (input: {
-  currentBranch?: string | null
-  enabled: boolean
-  repositoryRoot?: string
-  worktrees?: GitWorktreeSummary[]
-}) => {
-  if (!input.enabled) {
-    return {
-      showWorktreeButton: false,
-      worktrees: []
-    }
-  }
-
-  const worktrees = input.worktrees != null && input.worktrees.length > 0
-    ? sortGitWorktrees(input.worktrees)
-    : getCurrentWorktreeFallback(input.repositoryRoot, input.currentBranch)
-
-  return {
-    showWorktreeButton: true,
-    worktrees
-  }
-}

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

@@ -1,168 +0,0 @@
-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
-  }
-}

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

@@ -1,185 +0,0 @@
-import { App } from 'antd'
-import { useEffect, useMemo, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import type { GitRepositoryState } from '@vibe-forge/types'
-
-import { commitSessionGitChanges, getApiErrorMessage, pushSessionGitBranch } from '#~/api'
-
-import type { GitCommitNextStep } from './git-commit-utils'
-import {
-  canGitCommitAndPush,
-  canSubmitGitCommit,
-  getGitCommitBlockedReason,
-  getGitCommitSummary,
-  isGitCommitMessageRequired
-} from './git-commit-utils'
-import { getGitPushBlockedReason } from './git-operation-utils'
-
-export function useChatGitCommit({
-  closeOperationsMenu,
-  refreshGitState,
-  repoState,
-  sessionId,
-  setPendingAction
-}: {
-  closeOperationsMenu: () => void
-  refreshGitState: (nextRepo?: GitRepositoryState) => Promise<void>
-  repoState: GitRepositoryState | undefined
-  sessionId: string
-  setPendingAction: (action: 'commit' | 'commit-and-push' | null) => void
-}) {
-  const { t } = useTranslation()
-  const { message } = App.useApp()
-  const [commitModalOpen, setCommitModalOpen] = useState(false)
-  const [commitMessage, setCommitMessage] = useState('')
-  const [commitMessageError, setCommitMessageError] = useState('')
-  const [commitIncludeUnstagedChanges, setCommitIncludeUnstagedChanges] = useState(true)
-  const [commitSkipHooks, setCommitSkipHooks] = useState(false)
-  const [commitAmend, setCommitAmend] = useState(false)
-  const [commitForcePush, setCommitForcePush] = useState(false)
-  const [commitNextStep, setCommitNextStep] = useState<GitCommitNextStep>('commit')
-
-  const resetCommitState = () => {
-    setCommitModalOpen(false)
-    setCommitMessage('')
-    setCommitMessageError('')
-    setCommitIncludeUnstagedChanges(true)
-    setCommitSkipHooks(false)
-    setCommitAmend(false)
-    setCommitForcePush(false)
-    setCommitNextStep('commit')
-  }
-
-  useEffect(() => {
-    resetCommitState()
-  }, [sessionId])
-
-  const commitSummary = useMemo(() => {
-    if (repoState?.available !== true) {
-      return null
-    }
-
-    return getGitCommitSummary(repoState, commitIncludeUnstagedChanges)
-  }, [commitIncludeUnstagedChanges, repoState])
-
-  const canCommitAndPush = repoState?.available === true && canGitCommitAndPush(repoState)
-  const baseCommitBlockedReason = repoState?.available === true
-    ? getGitCommitBlockedReason(repoState, {
-      includeUnstagedChanges: commitIncludeUnstagedChanges,
-      amend: commitAmend,
-      commitMessage
-    })
-    : null
-  const commitPushBlockedReason = repoState?.available === true && commitNextStep === 'commit-and-push'
-    ? getGitPushBlockedReason(repoState, commitForcePush)
-    : null
-  const canSubmitCommit = repoState?.available === true && canSubmitGitCommit(repoState, {
-    includeUnstagedChanges: commitIncludeUnstagedChanges,
-    amend: commitAmend,
-    commitMessage
-  }) && commitPushBlockedReason == null
-  const commitBlockedReason = baseCommitBlockedReason ?? commitPushBlockedReason
-  const commitBlockedMessage = commitBlockedReason == null
-    ? ''
-    : commitBlockedReason === 'amend-unavailable'
-    ? t('chat.gitAmendUnavailable')
-    : commitBlockedReason === 'message-required'
-    ? t('chat.gitCommitMessageRequired')
-    : commitBlockedReason === 'behind-upstream'
-    ? t('chat.gitPushNeedsSyncOrForce')
-    : commitIncludeUnstagedChanges
-    ? t('chat.gitCommitNoChanges')
-    : t('chat.gitCommitNoStagedChanges')
-
-  useEffect(() => {
-    if (commitNextStep === 'commit-and-push' && !canCommitAndPush) {
-      setCommitNextStep('commit')
-    }
-  }, [canCommitAndPush, commitNextStep])
-
-  const handleCommit = () => {
-    if (repoState?.available !== true) {
-      return
-    }
-
-    const trimmedMessage = commitMessage.trim()
-    if (trimmedMessage === '' && isGitCommitMessageRequired(commitAmend)) {
-      setCommitMessageError(t('chat.gitCommitMessageRequired'))
-      return
-    }
-
-    if (!canSubmitCommit) {
-      void message.error(commitBlockedMessage === '' ? t('common.operationFailed') : commitBlockedMessage)
-      return
-    }
-
-    const action = commitNextStep === 'commit-and-push' ? 'commit-and-push' : 'commit'
-
-    void (async () => {
-      setPendingAction(action)
-      try {
-        const commitResult = await commitSessionGitChanges(sessionId, {
-          message: trimmedMessage === '' ? undefined : trimmedMessage,
-          includeUnstagedChanges: commitIncludeUnstagedChanges,
-          amend: commitAmend,
-          skipHooks: commitSkipHooks
-        })
-
-        if (commitNextStep === 'commit-and-push') {
-          try {
-            const pushResult = await pushSessionGitBranch(sessionId, {
-              force: commitForcePush
-            })
-            await refreshGitState(pushResult.repo)
-            resetCommitState()
-            closeOperationsMenu()
-            void message.success(commitAmend ? t('chat.gitAmendAndPushSuccess') : t('chat.gitCommitAndPushSuccess'))
-          } catch (error) {
-            await refreshGitState()
-            resetCommitState()
-            closeOperationsMenu()
-            void message.error(t('chat.gitCommitPushFailedAfterCommit', {
-              error: getApiErrorMessage(error, t('common.operationFailed'))
-            }))
-          }
-          return
-        }
-
-        await refreshGitState(commitResult.repo)
-        resetCommitState()
-        closeOperationsMenu()
-        void message.success(commitAmend ? t('chat.gitAmendSuccess') : t('chat.gitCommitSuccess'))
-      } catch (error) {
-        void message.error(getApiErrorMessage(error, t('common.operationFailed')))
-      } finally {
-        setPendingAction(null)
-      }
-    })()
-  }
-
-  return {
-    canCommitAndPush,
-    canSubmitCommit,
-    commitAmend,
-    commitBlockedMessage,
-    commitForcePush,
-    commitIncludeUnstagedChanges,
-    commitMessage,
-    commitMessageError,
-    commitModalOpen,
-    commitNextStep,
-    commitSkipHooks,
-    commitSummary,
-    handleCommit,
-    resetCommitState,
-    setCommitAmend,
-    setCommitForcePush,
-    setCommitIncludeUnstagedChanges,
-    setCommitMessage,
-    setCommitMessageError,
-    setCommitModalOpen,
-    setCommitNextStep,
-    setCommitSkipHooks
-  }
-}