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

package/src/hooks/chat/optimistic-session-creation.ts

@@ -1,189 +0,0 @@
-import { atom } from 'jotai'
-
-import type {
-  ChatMessage,
-  ChatMessageContent,
-  EffortLevel,
-  Session,
-  SessionPermissionMode,
-  SessionPromptType
-} from '@vibe-forge/core'
-import type { GitBranchKind } from '@vibe-forge/types'
-
-export interface OptimisticSessionCreationOptions {
-  start?: boolean
-  parentSessionId?: string
-  id: string
-  promptType?: SessionPromptType
-  promptName?: string
-  effort?: EffortLevel
-  permissionMode?: SessionPermissionMode
-  adapter?: string
-  account?: string
-  workspace?: {
-    createWorktree?: boolean
-    worktreeEnvironment?: string
-    branch?: {
-      name: string
-      kind?: GitBranchKind
-      mode?: 'checkout' | 'create'
-    }
-  }
-}
-
-export interface OptimisticSessionCreationRequest {
-  id: string
-  title?: string
-  initialMessage?: string
-  initialContent?: ChatMessageContent[]
-  model?: string
-  options: OptimisticSessionCreationOptions
-}
-
-export interface OptimisticSessionCreation {
-  errorMessage?: string
-  message: ChatMessage
-  request: OptimisticSessionCreationRequest
-  session: Session
-  status: 'creating' | 'failed'
-}
-
-export type OptimisticSessionCreationMap = Record<string, OptimisticSessionCreation>
-
-export const optimisticSessionCreationsAtom = atom<OptimisticSessionCreationMap>({})
-
-const discardedOptimisticSessionIds = new Set<string>()
-
-export const markOptimisticSessionDiscarded = (id: string) => {
-  discardedOptimisticSessionIds.add(id)
-}
-
-export const clearOptimisticSessionDiscarded = (id: string) => {
-  discardedOptimisticSessionIds.delete(id)
-}
-
-export const isOptimisticSessionDiscarded = (id: string) => {
-  return discardedOptimisticSessionIds.has(id)
-}
-
-export const createOptimisticSessionId = () => {
-  return globalThis.crypto?.randomUUID != null
-    ? globalThis.crypto.randomUUID()
-    : `local-session-${Date.now()}-${Math.random().toString(16).slice(2)}`
-}
-
-const getContentPreview = (content?: string | ChatMessageContent[]) => {
-  if (typeof content === 'string') {
-    return content.trim()
-  }
-
-  const textItem = content?.find(
-    (item): item is Extract<ChatMessageContent, { type: 'text' }> => item.type === 'text' && item.text.trim() !== ''
-  )
-  if (textItem != null) {
-    return textItem.text.trim()
-  }
-
-  const fileItem = content?.find(
-    (item): item is Extract<ChatMessageContent, { type: 'file' }> => item.type === 'file' && item.path.trim() !== ''
-  )
-  if (fileItem != null) {
-    return fileItem.path.trim()
-  }
-
-  const imageItem = content?.find((item): item is Extract<ChatMessageContent, { type: 'image' }> =>
-    item.type === 'image'
-  )
-  if (imageItem != null) {
-    return imageItem.name?.trim() ?? ''
-  }
-
-  return ''
-}
-
-const getTitlePreview = (contentPreview: string) => {
-  const firstLine = contentPreview.split('\n')[0]?.trim() ?? ''
-  if (firstLine === '') return undefined
-  return firstLine.length > 50 ? `${firstLine.slice(0, 50)}...` : firstLine
-}
-
-export const createOptimisticSessionCreation = (
-  request: OptimisticSessionCreationRequest,
-  now = Date.now()
-): OptimisticSessionCreation => {
-  const content = request.initialContent ?? request.initialMessage ?? ''
-  const contentPreview = getContentPreview(content)
-  const title = request.title ?? getTitlePreview(contentPreview)
-
-  return {
-    message: {
-      id: `${request.id}:optimistic-user-message`,
-      role: 'user',
-      content,
-      createdAt: now
-    },
-    request,
-    session: {
-      id: request.id,
-      title,
-      createdAt: now,
-      messageCount: 1,
-      lastMessage: contentPreview === '' ? undefined : contentPreview,
-      lastUserMessage: contentPreview === '' ? undefined : contentPreview,
-      isArchived: false,
-      isStarred: false,
-      tags: [],
-      status: 'running',
-      model: request.model,
-      adapter: request.options.adapter,
-      account: request.options.account,
-      permissionMode: request.options.permissionMode,
-      effort: request.options.effort,
-      promptType: request.options.promptType,
-      promptName: request.options.promptName
-    },
-    status: 'creating'
-  }
-}
-
-export const markOptimisticSessionCreationCreating = (
-  creation: OptimisticSessionCreation
-): OptimisticSessionCreation => ({
-  ...creation,
-  errorMessage: undefined,
-  session: {
-    ...creation.session,
-    status: 'running'
-  },
-  status: 'creating'
-})
-
-export const markOptimisticSessionCreationFailed = (
-  creation: OptimisticSessionCreation,
-  errorMessage: string
-): OptimisticSessionCreation => ({
-  ...creation,
-  errorMessage,
-  session: {
-    ...creation.session,
-    status: 'failed'
-  },
-  status: 'failed'
-})
-
-export const mergeOptimisticSessions = (
-  sessions: Session[],
-  creations: OptimisticSessionCreationMap
-) => {
-  const existingIds = new Set(sessions.map(session => session.id))
-  const mergedSessions = sessions.map(session => creations[session.id]?.session ?? session)
-  const optimisticSessions = Object.values(creations)
-    .map(creation => creation.session)
-    .filter(session => session.isArchived !== true && !existingIds.has(session.id))
-
-  return [...mergedSessions, ...optimisticSessions]
-}
-
-export const removeSessionFromList = (sessions: Session[], id: string) => {
-  return sessions.filter(session => session.id !== id)
-}

package/src/hooks/chat/session-view-cache.ts

@@ -1,83 +0,0 @@
-import type { ChatMessage, SessionMessageQueueState } from '@vibe-forge/core'
-import type { SessionInfo } from '@vibe-forge/types'
-
-import type { ChatErrorState, InteractionRequestState } from './interaction-state'
-
-export interface ChatSessionViewSnapshot {
-  messages: ChatMessage[]
-  sessionInfo: SessionInfo | null
-  queuedMessages: SessionMessageQueueState
-  errorState: ChatErrorState | null
-  interactionRequest: InteractionRequestState | null
-  isHydrated: boolean
-}
-
-export const MAX_CHAT_SESSION_VIEW_SNAPSHOTS = 20
-
-export const createChatSessionViewSnapshot = (
-  value?: Partial<ChatSessionViewSnapshot>
-): ChatSessionViewSnapshot => ({
-  messages: value?.messages ?? [],
-  sessionInfo: value?.sessionInfo ?? null,
-  queuedMessages: value?.queuedMessages ?? { steer: [], next: [] },
-  errorState: value?.errorState ?? null,
-  interactionRequest: value?.interactionRequest ?? null,
-  isHydrated: value?.isHydrated ?? false
-})
-
-export const mergeChatSessionViewSnapshot = (
-  current: ChatSessionViewSnapshot | undefined,
-  patch: Partial<ChatSessionViewSnapshot>
-): ChatSessionViewSnapshot => {
-  return createChatSessionViewSnapshot({
-    ...createChatSessionViewSnapshot(current),
-    ...patch
-  })
-}
-
-export const restoreChatSessionViewSnapshot = (snapshot?: ChatSessionViewSnapshot) => {
-  const resolved = createChatSessionViewSnapshot(snapshot)
-  const restorable = resolved.isHydrated === true
-    ? resolved
-    : createChatSessionViewSnapshot()
-
-  return {
-    messages: restorable.messages,
-    sessionInfo: restorable.sessionInfo,
-    queuedMessages: restorable.queuedMessages,
-    errorState: restorable.errorState,
-    interactionRequest: restorable.interactionRequest,
-    isReady: restorable.isHydrated
-  }
-}
-
-export const setChatSessionViewSnapshot = (
-  cache: Map<string, ChatSessionViewSnapshot>,
-  sessionId: string,
-  patch: Partial<ChatSessionViewSnapshot>
-) => {
-  const next = mergeChatSessionViewSnapshot(cache.get(sessionId), patch)
-
-  if (cache.has(sessionId)) {
-    cache.delete(sessionId)
-  }
-
-  cache.set(sessionId, next)
-
-  while (cache.size > MAX_CHAT_SESSION_VIEW_SNAPSHOTS) {
-    const oldestSessionId = cache.keys().next().value
-    if (oldestSessionId == null) {
-      break
-    }
-    cache.delete(oldestSessionId)
-  }
-
-  return next
-}
-
-export const deleteChatSessionViewSnapshot = (
-  cache: Map<string, ChatSessionViewSnapshot>,
-  sessionId: string
-) => {
-  cache.delete(sessionId)
-}

package/src/hooks/chat/use-chat-adapter-account-selection.tsx

@@ -1,156 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import useSWR from 'swr'
-
-import type { AdapterAccountInfo, AdapterAccountQuotaMetric, AdapterAccountsResult } from '@vibe-forge/types'
-
-import { getAdapterAccounts } from '#~/api.js'
-import { normalizeNonEmptyString } from './model-selector'
-
-export interface ChatAdapterAccountOption {
-  value: string
-  label: string
-  hint?: string
-  meta?: string
-}
-
-const ACCOUNT_STORAGE_KEY_PREFIX = 'vf_chat_adapter_account:'
-
-const formatQuotaMetric = (metric: AdapterAccountQuotaMetric) => {
-  const label = normalizeNonEmptyString(metric.label) ??
-    normalizeNonEmptyString(
-      metric.id
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .replace(/[_-]+/g, ' ')
-        .trim()
-        .replace(/\b\w/g, match => match.toUpperCase())
-    )
-  const value = normalizeNonEmptyString(metric.value)
-  if (label != null && value != null) {
-    return `${label}: ${value}`
-  }
-  return value ?? label
-}
-
-const formatQuotaMeta = (quota: AdapterAccountInfo['quota']) => {
-  const metrics = (quota?.metrics ?? [])
-    .slice()
-    .sort((left, right) => Number(right.primary === true) - Number(left.primary === true))
-    .map(formatQuotaMetric)
-    .filter((value): value is string => value != null && value !== '')
-
-  if (metrics.length > 0) {
-    return metrics.slice(0, 2).join(' · ')
-  }
-
-  const summary = normalizeNonEmptyString(quota?.summary)
-  return summary == null ? undefined : `Quota: ${summary}`
-}
-
-const readStoredAccount = (adapter: string | undefined) => {
-  const normalizedAdapter = normalizeNonEmptyString(adapter)
-  if (normalizedAdapter == null) {
-    return undefined
-  }
-
-  try {
-    const raw = localStorage.getItem(`${ACCOUNT_STORAGE_KEY_PREFIX}${normalizedAdapter}`)
-    return raw == null || raw.trim() === '' ? undefined : raw.trim()
-  } catch {
-    return undefined
-  }
-}
-
-export function useChatAdapterAccountSelection({
-  adapter,
-  model
-}: {
-  adapter?: string
-  model?: string
-}) {
-  const normalizedAdapter = normalizeNonEmptyString(adapter)
-  const [selectedAccount, setSelectedAccountState] = useState<string | undefined>(() => readStoredAccount(adapter))
-
-  useEffect(() => {
-    setSelectedAccountState(readStoredAccount(normalizedAdapter))
-  }, [normalizedAdapter])
-
-  const { data } = useSWR<AdapterAccountsResult>(
-    normalizedAdapter == null ? null : ['/api/adapters', normalizedAdapter, model ?? ''],
-    normalizedAdapter == null ? null : () => getAdapterAccounts(normalizedAdapter, { model })
-  )
-
-  const accountOptions = useMemo<ChatAdapterAccountOption[]>(() => {
-    return (data?.accounts ?? [])
-      .filter(account => account.status !== 'missing')
-      .map(account => ({
-        value: account.key,
-        label: account.title,
-        hint: account.description,
-        meta: formatQuotaMeta(account.quota)
-      }))
-  }, [data?.accounts])
-
-  const resolveSelectableAccount = useCallback((value?: string, preserveUnknown = false) => {
-    const normalizedValue = normalizeNonEmptyString(value)
-    const accountValues = new Set(accountOptions.map(option => option.value))
-    if (normalizedValue != null) {
-      if (accountValues.has(normalizedValue)) {
-        return normalizedValue
-      }
-      if (preserveUnknown) {
-        return normalizedValue
-      }
-    }
-
-    const defaultAccount = normalizeNonEmptyString(data?.defaultAccount)
-    if (defaultAccount != null && accountValues.has(defaultAccount)) {
-      return defaultAccount
-    }
-
-    return accountOptions[0]?.value
-  }, [accountOptions, data?.defaultAccount])
-
-  useEffect(() => {
-    if (normalizedAdapter == null) {
-      setSelectedAccountState(undefined)
-      return
-    }
-
-    const nextValue = resolveSelectableAccount(selectedAccount)
-    setSelectedAccountState((prev) => prev === nextValue ? prev : nextValue)
-  }, [normalizedAdapter, resolveSelectableAccount, selectedAccount])
-
-  useEffect(() => {
-    if (normalizedAdapter == null) {
-      return
-    }
-
-    try {
-      const storageKey = `${ACCOUNT_STORAGE_KEY_PREFIX}${normalizedAdapter}`
-      if (selectedAccount == null || selectedAccount.trim() === '') {
-        localStorage.removeItem(storageKey)
-      } else {
-        localStorage.setItem(storageKey, selectedAccount)
-      }
-    } catch {}
-  }, [normalizedAdapter, selectedAccount])
-
-  const applySessionSelection = useCallback((params: { account?: string }) => {
-    const nextAccount = resolveSelectableAccount(params.account, true) ??
-      normalizeNonEmptyString(params.account)
-    setSelectedAccountState((prev) => prev === nextAccount ? prev : nextAccount)
-  }, [resolveSelectableAccount])
-
-  const updateSelectedAccount = useCallback((value?: string) => {
-    const nextAccount = resolveSelectableAccount(value)
-    setSelectedAccountState((prev) => prev === nextAccount ? prev : nextAccount)
-  }, [resolveSelectableAccount])
-
-  return {
-    accountOptions,
-    selectedAccount: resolveSelectableAccount(selectedAccount, true) ?? selectedAccount,
-    setSelectedAccount: updateSelectedAccount,
-    applySessionSelection,
-    showAccountSelector: normalizedAdapter != null && accountOptions.length > 0
-  }
-}

package/src/hooks/chat/use-chat-adapter.ts

@@ -1,97 +0,0 @@
-import { createElement, useEffect, useMemo, useState } from 'react'
-import type { ReactNode } from 'react'
-import useSWR from 'swr'
-
-import { getConfig } from '#~/api.js'
-import { getAdapterDisplay } from '#~/resources/adapters.js'
-import type { ConfigResponse } from '@vibe-forge/types'
-
-const ADAPTER_STORAGE_KEY = 'vf_chat_adapter'
-
-export function useChatAdapter() {
-  const [selectedAdapter, setSelectedAdapter] = useState<string | undefined>(() => {
-    try {
-      const raw = localStorage.getItem(ADAPTER_STORAGE_KEY)
-      return raw == null || raw.trim() === '' ? undefined : raw
-    } catch {
-      return undefined
-    }
-  })
-
-  const { data: configRes } = useSWR<ConfigResponse>('/api/config', getConfig)
-
-  const mergedAdapters = useMemo(() => {
-    return configRes?.sources?.merged?.adapters ?? {}
-  }, [configRes?.sources?.merged?.adapters])
-
-  const defaultAdapter = configRes?.sources?.merged?.general?.defaultAdapter
-
-  const resolveAdapter = (value?: string) => {
-    const normalizedValue = typeof value === 'string' ? value.trim() : ''
-    const keys = Object.keys(mergedAdapters)
-    if (keys.length === 0) return undefined
-    if (normalizedValue !== '' && keys.includes(normalizedValue)) return normalizedValue
-    if (defaultAdapter && keys.includes(defaultAdapter as string)) return defaultAdapter as string
-    return keys[0]
-  }
-
-  const updateSelectedAdapter = (value?: string) => {
-    setSelectedAdapter((prev) => {
-      const nextValue = resolveAdapter(value)
-      return nextValue === prev ? prev : nextValue
-    })
-  }
-
-  const adapterOptions = useMemo<Array<{ value: string; label: ReactNode }>>(() => {
-    const keys = Object.keys(mergedAdapters)
-    return keys.map((key) => {
-      const display = getAdapterDisplay(key)
-      return {
-        value: key,
-        label: createElement('span', { className: 'adapter-option' }, [
-          display.icon != null
-            ? createElement('img', {
-              key: 'icon',
-              className: 'adapter-option__icon',
-              src: display.icon,
-              alt: '',
-              'aria-hidden': true
-            })
-            : createElement('span', {
-              key: 'fallback-icon',
-              className: 'adapter-option__icon adapter-option__icon--fallback material-symbols-rounded',
-              'aria-hidden': true
-            }, 'deployed_code'),
-          createElement('span', { key: 'text', className: 'adapter-option__text' }, display.title)
-        ])
-      }
-    })
-  }, [mergedAdapters])
-
-  // Auto-select: use stored value if valid, else config default, else first available
-  useEffect(() => {
-    const keys = Object.keys(mergedAdapters)
-    if (keys.length === 0) {
-      setSelectedAdapter(undefined)
-      return
-    }
-    setSelectedAdapter((prev) => resolveAdapter(prev))
-  }, [defaultAdapter, mergedAdapters])
-
-  // Persist to localStorage
-  useEffect(() => {
-    try {
-      if (selectedAdapter == null || selectedAdapter.trim() === '') {
-        localStorage.removeItem(ADAPTER_STORAGE_KEY)
-      } else {
-        localStorage.setItem(ADAPTER_STORAGE_KEY, selectedAdapter)
-      }
-    } catch {}
-  }, [selectedAdapter])
-
-  return {
-    selectedAdapter,
-    setSelectedAdapter: updateSelectedAdapter,
-    adapterOptions
-  }
-}

package/src/hooks/chat/use-chat-effort.ts

@@ -1,55 +0,0 @@
-import { useEffect, useMemo, useState } from 'react'
-import type { ReactNode } from 'react'
-
-export type ChatEffort = 'default' | 'low' | 'medium' | 'high' | 'max'
-
-const EFFORT_STORAGE_KEY = 'vf_chat_effort'
-
-export const isChatEffort = (value: string): value is ChatEffort => {
-  return value === 'default' ||
-    value === 'low' ||
-    value === 'medium' ||
-    value === 'high' ||
-    value === 'max'
-}
-
-export function useChatEffort() {
-  const [effort, setEffort] = useState<ChatEffort>('default')
-
-  const updateEffort = (value?: string) => {
-    if (value != null && isChatEffort(value)) {
-      setEffort(value)
-      return
-    }
-    setEffort('default')
-  }
-
-  useEffect(() => {
-    try {
-      const raw = localStorage.getItem(EFFORT_STORAGE_KEY)
-      if (raw && isChatEffort(raw)) {
-        updateEffort(raw)
-      }
-    } catch {}
-  }, [])
-
-  useEffect(() => {
-    try {
-      localStorage.setItem(EFFORT_STORAGE_KEY, effort)
-    } catch {}
-  }, [effort])
-
-  const effortOptions = useMemo<Array<{ value: ChatEffort; label: ReactNode }>>(() => [
-    { value: 'default', label: '默认' },
-    { value: 'low', label: '低' },
-    { value: 'medium', label: '中' },
-    { value: 'high', label: '高' },
-    { value: 'max', label: '最高' }
-  ], [])
-
-  return {
-    effort,
-    setEffort: updateEffort,
-    effortOptions
-  }
-}

package/src/hooks/chat/use-chat-interaction.ts

@@ -1,31 +0,0 @@
-import { useCallback, useState } from 'react'
-
-import { respondSessionInteraction } from '#~/api/sessions'
-import type { AskUserQuestionParams } from '@vibe-forge/core'
-
-export function useChatInteraction({
-  sessionId
-}: {
-  sessionId?: string
-}) {
-  const [interactionRequest, setInteractionRequest] = useState<{ id: string; payload: AskUserQuestionParams } | null>(
-    null
-  )
-
-  const handleInteractionResponse = useCallback((id: string, data: string | string[]) => {
-    if (!sessionId) return
-    void respondSessionInteraction(sessionId, id, data)
-      .then(() => {
-        setInteractionRequest(current => (current?.id === id ? null : current))
-      })
-      .catch((error) => {
-        console.error('Failed to submit interaction response:', error)
-      })
-  }, [sessionId])
-
-  return {
-    interactionRequest,
-    setInteractionRequest,
-    handleInteractionResponse
-  }
-}