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

package/src/components/chat/messages/message-utils.ts

@@ -1,189 +0,0 @@
-import type { ChatMessage, ChatMessageContent } from '@vibe-forge/core'
-
-import { getMessageAnchorId } from '#~/utils/chat-links.js'
-
-export interface ToolGroupItem {
-  anchorId: string
-  originalMessage: ChatMessage
-  type: 'tool-group'
-  id: string
-  items: {
-    item: Extract<ChatMessageContent, { type: 'tool_use' }>
-    resultItem?: Extract<ChatMessageContent, { type: 'tool_result' }>
-  }[]
-  footer?: {
-    model?: string
-    usage?: ChatMessage['usage']
-    createdAt: number
-    originalMessage: ChatMessage
-  }
-}
-
-export interface MessageRenderItem {
-  anchorId: string
-  originalMessage: ChatMessage
-  type: 'message'
-  message: ChatMessage
-  isFirstInGroup: boolean
-}
-
-export type ChatRenderItem = MessageRenderItem | ToolGroupItem
-
-export function processMessages(messages: ChatMessage[]): ChatRenderItem[] {
-  const result: ChatRenderItem[] = []
-
-  const findResult = (
-    toolId: string,
-    startIndex: number,
-    allMsgs: ChatMessage[]
-  ): Extract<ChatMessageContent, { type: 'tool_result' }> | undefined => {
-    for (let i = startIndex; i < allMsgs.length; i++) {
-      const msg = allMsgs[i]
-      if (Array.isArray(msg.content)) {
-        const found = msg.content.find(
-          (c: ChatMessageContent) => c.type === 'tool_result' && c.tool_use_id === toolId
-        )
-        if (found) {
-          return found as Extract<ChatMessageContent, { type: 'tool_result' }>
-        }
-      }
-    }
-    return undefined
-  }
-
-  let i = 0
-  while (i < messages.length) {
-    const msg = messages[i]
-    if (!msg || !msg.content) {
-      // If content is null/empty but legacy toolCall exists, we should render it
-      if (msg && msg.toolCall) {
-        result.push({
-          anchorId: getMessageAnchorId(msg.id),
-          originalMessage: msg,
-          type: 'message',
-          message: msg,
-          isFirstInGroup: i === 0 || (i > 0 && messages[i - 1]?.role !== msg.role)
-        })
-      }
-      i++
-      continue
-    }
-
-    const prevMsg = i > 0 ? messages[i - 1] : null
-    const isFirstInGroup = i === 0 || (prevMsg != null && prevMsg.role !== msg.role)
-
-    if (typeof msg.content === 'string') {
-      result.push({
-        anchorId: getMessageAnchorId(msg.id),
-        originalMessage: msg,
-        type: 'message',
-        message: msg,
-        isFirstInGroup
-      })
-      i++
-      continue
-    }
-
-    if (Array.isArray(msg.content)) {
-      const content = msg.content
-      const textParts: ChatMessageContent[] = []
-      let currentToolGroup: {
-        item: Extract<ChatMessageContent, { type: 'tool_use' }>
-        resultItem?: Extract<ChatMessageContent, { type: 'tool_result' }>
-      }[] = []
-
-      let producedCount = 0
-
-      const flushTools = () => {
-        if (currentToolGroup.length > 0) {
-          result.push({
-            anchorId: getMessageAnchorId(msg.id, `tool-${producedCount}`),
-            originalMessage: msg,
-            type: 'tool-group',
-            id: `group-${msg.id}-${producedCount}`,
-            items: [...currentToolGroup],
-            footer: undefined
-          })
-          currentToolGroup = []
-          producedCount++
-        }
-      }
-
-      const flushText = () => {
-        if (textParts.length > 0) {
-          result.push({
-            anchorId: getMessageAnchorId(msg.id, `text-${producedCount}`),
-            originalMessage: msg,
-            type: 'message',
-            message: {
-              ...msg,
-              id: `${msg.id}-text-${producedCount}`,
-              content: [...textParts]
-            },
-            isFirstInGroup: isFirstInGroup && producedCount === 0
-          })
-          textParts.length = 0
-          producedCount++
-        }
-      }
-
-      for (const item of content) {
-        if (item.type === 'text' || item.type === 'image' || item.type === 'file') {
-          flushTools()
-          textParts.push(item)
-        } else if (item.type === 'tool_use') {
-          flushText()
-          const resultItem = findResult(item.id, i, messages)
-          currentToolGroup.push({ item, resultItem })
-        }
-      }
-
-      flushText()
-      flushTools()
-
-      // Handle legacy toolCall if no other content was produced
-      if (producedCount === 0 && msg.toolCall) {
-        result.push({
-          anchorId: getMessageAnchorId(msg.id),
-          originalMessage: msg,
-          type: 'message',
-          message: msg,
-          isFirstInGroup
-        })
-        producedCount++
-      }
-
-      if (producedCount > 0) {
-        const lastItem = result[result.length - 1]
-        if (lastItem.type === 'tool-group') {
-          lastItem.footer = {
-            model: msg.model,
-            usage: msg.usage,
-            createdAt: msg.createdAt,
-            originalMessage: msg
-          }
-        }
-      }
-    }
-    i++
-  }
-
-  const mergedResult: ChatRenderItem[] = []
-  for (const item of result) {
-    if (item.type === 'tool-group') {
-      const prev = mergedResult[mergedResult.length - 1]
-      if (prev && prev.type === 'tool-group') {
-        prev.items.push(...item.items)
-        prev.originalMessage = item.originalMessage
-        prev.anchorId = item.anchorId
-        if (item.footer) {
-          prev.footer = item.footer
-        }
-        continue
-      }
-    }
-    mergedResult.push(item)
-  }
-
-  return mergedResult
-}

package/src/components/chat/new-session-guide-config.ts

@@ -1,19 +0,0 @@
-export {
-  buildConversationStarterInitialContent,
-  buildConversationStarterTargetDraft,
-  buildConversationStarterWorkspacePatch,
-  normalizeConversationStarterMode
-} from './conversation-starter-apply'
-
-export {
-  buildConversationStarterListItems,
-  getNewSessionGuideData,
-  partitionConversationStarterListItems
-} from './new-session-guide-items'
-
-export type {
-  ConversationStarterCollectionKey,
-  ConversationStarterListItem,
-  NewSessionGuideData,
-  PartitionConversationStarterListItemsResult
-} from './new-session-guide-items'

package/src/components/chat/new-session-guide-items.ts

@@ -1,172 +0,0 @@
-import type { ConfigResponse, ConversationStarterConfig } from '@vibe-forge/types'
-
-import { collectVisibleRecentKeys, filterUniqueStrings, orderItemsByPriorityKeys } from './new-session-guide-list-order'
-
-export interface NewSessionGuideData {
-  announcements: string[]
-  startupPresets: ConversationStarterConfig[]
-  builtinActions: ConversationStarterConfig[]
-}
-
-export type ConversationStarterCollectionKey = 'startupPresets' | 'builtinActions'
-
-export interface ConversationStarterListItem {
-  key: string
-  order: number
-  source: ConversationStarterCollectionKey
-  sourceIndex: number
-  starter: ConversationStarterConfig
-}
-
-export interface PartitionConversationStarterListItemsResult {
-  isSearchMode: boolean
-  favorites: ConversationStarterListItem[]
-  recentKeys: string[]
-  visibleRemaining: ConversationStarterListItem[]
-  totalRemainingCount: number
-  hiddenRemainingCount: number
-}
-
-const trimText = (value: string | undefined) => value?.trim() ?? ''
-
-export const getNewSessionGuideData = (configRes?: ConfigResponse): NewSessionGuideData => {
-  const general = configRes?.sources?.merged?.general
-  const conversation = configRes?.sources?.merged?.conversation
-
-  return {
-    announcements: general?.announcements ?? [],
-    startupPresets: conversation?.startupPresets ?? [],
-    builtinActions: conversation?.builtinActions ?? []
-  }
-}
-
-const buildConversationStarterListItemKey = (
-  starter: ConversationStarterConfig,
-  source: ConversationStarterCollectionKey,
-  sourceIndex: number
-) => {
-  const id = trimText(starter.id)
-  if (id !== '') {
-    return `${source}:${id}`
-  }
-
-  const fingerprint = [
-    trimText(starter.title),
-    trimText(starter.target),
-    trimText(starter.prompt)
-  ].filter(value => value !== '')
-
-  if (fingerprint.length > 0) {
-    return `${source}:${fingerprint.join('|')}`
-  }
-
-  return `${source}:index:${sourceIndex}`
-}
-
-export const buildConversationStarterListItems = (
-  startupPresets: ConversationStarterConfig[],
-  builtinActions: ConversationStarterConfig[]
-): ConversationStarterListItem[] => {
-  let order = 0
-
-  return [
-    ...startupPresets.map((starter, sourceIndex) => ({
-      key: buildConversationStarterListItemKey(starter, 'startupPresets', sourceIndex),
-      order: order++,
-      source: 'startupPresets' as const,
-      sourceIndex,
-      starter
-    })),
-    ...builtinActions.map((starter, sourceIndex) => ({
-      key: buildConversationStarterListItemKey(starter, 'builtinActions', sourceIndex),
-      order: order++,
-      source: 'builtinActions' as const,
-      sourceIndex,
-      starter
-    }))
-  ]
-}
-
-const normalizeSearchQuery = (value: string) => value.trim().toLowerCase()
-
-const buildConversationStarterSearchText = (item: ConversationStarterListItem) => {
-  const { starter } = item
-
-  return [
-    trimText(starter.title),
-    trimText(starter.description),
-    trimText(starter.prompt),
-    trimText(starter.target),
-    trimText(starter.targetLabel),
-    trimText(starter.targetDescription),
-    trimText(starter.model),
-    ...(starter.files?.map(path => trimText(path)) ?? []),
-    ...(starter.rules?.map(rule => trimText(rule)) ?? []),
-    ...(starter.skills?.map(skill => trimText(skill)) ?? [])
-  ]
-    .filter(value => value !== '')
-    .join(' ')
-    .toLowerCase()
-}
-
-export const partitionConversationStarterListItems = ({
-  items,
-  favoriteKeys,
-  recentKeys,
-  query,
-  remainingLimit
-}: {
-  items: ConversationStarterListItem[]
-  favoriteKeys: string[]
-  recentKeys: string[]
-  query: string
-  remainingLimit: number
-}): PartitionConversationStarterListItemsResult => {
-  const normalizedQuery = normalizeSearchQuery(query)
-  if (normalizedQuery !== '') {
-    const searchTerms = normalizedQuery.split(/\s+/).filter(term => term !== '')
-    const matchedItems = items.filter((item) => {
-      const searchText = buildConversationStarterSearchText(item)
-      return searchTerms.every(term => searchText.includes(term))
-    })
-
-    return {
-      isSearchMode: true,
-      favorites: [],
-      recentKeys: [],
-      visibleRemaining: matchedItems,
-      totalRemainingCount: matchedItems.length,
-      hiddenRemainingCount: 0
-    }
-  }
-
-  const favoriteSet = new Set(filterUniqueStrings(favoriteKeys))
-  const itemByKey = new Map(items.map(item => [item.key, item]))
-  const recentKeysByPriority = collectVisibleRecentKeys(recentKeys, new Set(itemByKey.keys()), 3)
-
-  const favorites = orderItemsByPriorityKeys(
-    items.filter(item => favoriteSet.has(item.key)),
-    recentKeysByPriority
-  )
-  const favoriteKeySet = new Set(favorites.map(item => item.key))
-  const recentRemainingKeys = recentKeysByPriority.filter(key => !favoriteKeySet.has(key))
-  const hiddenKeySet = new Set([...favoriteKeySet, ...recentRemainingKeys])
-  const remaining = orderItemsByPriorityKeys(
-    items.filter(item => !hiddenKeySet.has(item.key)),
-    []
-  )
-  const safeLimit = Math.max(0, remainingLimit)
-  const visibleRemaining = [
-    ...recentRemainingKeys.map(key => itemByKey.get(key)).filter(Boolean),
-    ...remaining
-  ] as ConversationStarterListItem[]
-
-  return {
-    isSearchMode: false,
-    favorites,
-    recentKeys: recentKeysByPriority,
-    visibleRemaining: visibleRemaining.slice(0, safeLimit),
-    totalRemainingCount: visibleRemaining.length,
-    hiddenRemainingCount: Math.max(0, visibleRemaining.length - safeLimit)
-  }
-}

package/src/components/chat/new-session-guide-list-order.ts

@@ -1,58 +0,0 @@
-interface KeyedOrderedItem {
-  key: string
-  order: number
-}
-
-export const filterUniqueStrings = (values: string[]) => Array.from(new Set(values))
-
-export const collectVisibleRecentKeys = (
-  recentKeys: string[],
-  validKeys: Set<string>,
-  limit: number
-) => {
-  const visibleKeys: string[] = []
-
-  for (const key of filterUniqueStrings(recentKeys)) {
-    if (!validKeys.has(key)) {
-      continue
-    }
-
-    visibleKeys.push(key)
-
-    if (visibleKeys.length >= limit) {
-      break
-    }
-  }
-
-  return visibleKeys
-}
-
-export const orderItemsByPriorityKeys = <T extends KeyedOrderedItem>(
-  items: T[],
-  priorityKeys: string[]
-) => {
-  if (priorityKeys.length === 0) {
-    return items
-  }
-
-  const priorityMap = new Map(priorityKeys.map((key, index) => [key, index]))
-
-  return [...items].sort((left, right) => {
-    const leftPriority = priorityMap.get(left.key)
-    const rightPriority = priorityMap.get(right.key)
-
-    if (leftPriority != null && rightPriority != null) {
-      return leftPriority - rightPriority
-    }
-
-    if (leftPriority != null) {
-      return -1
-    }
-
-    if (rightPriority != null) {
-      return 1
-    }
-
-    return left.order - right.order
-  })
-}

package/src/components/chat/sender/@components/account-select/AccountSelectControl.scss

@@ -1,112 +0,0 @@
-.account-select {
-  min-width: 116px;
-  max-width: 220px;
-
-  .ant-select-selector {
-    position: relative;
-  }
-
-  .ant-select-selector::before {
-    content: 'switch_account';
-    font-family: 'Material Symbols Rounded';
-    font-size: 16px;
-    line-height: 1;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    flex-shrink: 0;
-    color: currentColor;
-    margin-right: 6px;
-  }
-
-  .ant-select-selection-wrap {
-    min-width: 0;
-  }
-
-  .ant-select-selection-item,
-  .ant-select-selection-placeholder {
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    max-width: 100%;
-  }
-}
-
-.account-select--compact {
-  min-width: var(--sender-control-height);
-  max-width: var(--sender-control-height);
-
-  &.ant-select-single .ant-select-selector {
-    position: relative;
-    padding-left: 0 !important;
-    padding-right: 0 !important;
-    padding-inline-start: 0 !important;
-    padding-inline-end: 0 !important;
-    justify-content: center;
-  }
-
-  .ant-select-selector::before {
-    position: absolute;
-    inset: 0;
-    margin: 0;
-    pointer-events: none;
-  }
-
-  .ant-select-selection-wrap,
-  .ant-select-selection-search {
-    display: none !important;
-  }
-
-  &.ant-select-single .ant-select-selector .ant-select-selection-item,
-  &.ant-select-single .ant-select-selector .ant-select-selection-placeholder,
-  .ant-select-selection-item,
-  .ant-select-selection-placeholder {
-    display: none !important;
-    width: 0 !important;
-    min-width: 0 !important;
-    max-width: 0 !important;
-    padding: 0 !important;
-    margin: 0 !important;
-    opacity: 0 !important;
-    overflow: hidden !important;
-  }
-}
-
-.account-select-create-modal {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 10px;
-  padding: 10px 4px 4px;
-  text-align: center;
-}
-
-.account-select-create-modal__icon {
-  width: 36px;
-  height: 36px;
-  border-radius: 999px;
-  background: color-mix(
-    in srgb,
-    var(--primary-soft-bg, #eff6ff) 80%,
-    transparent
-  );
-  color: var(--primary-color, #2563eb);
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 20px;
-  line-height: 1;
-}
-
-.account-select-create-modal__title {
-  font-size: 14px;
-  font-weight: 600;
-  color: var(--text-color);
-}
-
-.account-select-create-modal__description {
-  max-width: 360px;
-  font-size: 12px;
-  line-height: 1.5;
-  color: var(--sub-text-color, #6b7280);
-}