@vibe-forge/client 0.9.0 → 0.10.1

package/src/components/chat/ChatHistoryView.tsx

@@ -1,7 +1,11 @@
-import React, { useEffect, useMemo, useRef } from 'react'
+import { App } from 'antd'
+import React, { useEffect, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
+import { useLocation } from 'react-router-dom'
 
+import type { ChatErrorBannerState } from '#~/hooks/chat/interaction-state'
 import type { ChatEffort } from '#~/hooks/chat/use-chat-effort'
+import type { ModelSelectMenuGroup, ModelSelectOption } from '#~/hooks/chat/use-chat-model-adapter-selection'
 import type { PermissionMode } from '#~/hooks/chat/use-chat-permission-mode'
 import { useChatScroll } from '#~/hooks/chat/use-chat-scroll'
 import { useChatSessionActions } from '#~/hooks/chat/use-chat-session-actions'
@@ -10,35 +14,31 @@ import type { SessionInfo } from '@vibe-forge/types'
 import { CurrentTodoList } from './CurrentTodoList'
 import { NewSessionGuide } from './NewSessionGuide'
 import { MessageItem } from './messages/MessageItem'
+import { buildMessageTurns } from './messages/message-turns'
 import { processMessages } from './messages/message-utils'
 import { Sender } from './sender/Sender'
 import { ToolGroup } from './tools/core/ToolGroup'
 
-interface ModelSelectOption {
-  value: string
-  label: React.ReactNode
-  searchText: string
-  displayLabel: string
-}
-
-interface ModelSelectGroup {
-  label: React.ReactNode
-  options: ModelSelectOption[]
-}
-
 export function ChatHistoryView({
   isReady,
   messages,
   session,
+  targetMessageId,
+  targetToolUseId,
   sessionInfo,
-  connectionError,
+  errorBanner,
   onRetryConnection,
   interactionRequest,
   onInteractionResponse,
   setMessages,
   onClearMessages,
   placeholder,
-  modelOptions,
+  modelMenuGroups,
+  modelSearchOptions,
+  recommendedModelOptions,
+  servicePreviewModelOptions,
+  onToggleRecommendedModel,
+  updatingRecommendedModelValue,
   selectedModel,
   modelForQuery,
   onModelChange,
@@ -57,15 +57,22 @@ export function ChatHistoryView({
   isReady: boolean
   messages: ChatMessage[]
   session?: Session
+  targetMessageId?: string
+  targetToolUseId?: string
   sessionInfo: SessionInfo | null
-  connectionError?: string | null
+  errorBanner?: ChatErrorBannerState | null
   onRetryConnection: () => void
   interactionRequest: { id: string; payload: AskUserQuestionParams } | null
   onInteractionResponse: (id: string, data: string | string[]) => void
   setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>
   onClearMessages: () => void
   placeholder?: string
-  modelOptions: ModelSelectGroup[]
+  modelMenuGroups: ModelSelectMenuGroup[]
+  modelSearchOptions: ModelSelectOption[]
+  recommendedModelOptions: ModelSelectOption[]
+  servicePreviewModelOptions: ModelSelectOption[]
+  onToggleRecommendedModel: (option: ModelSelectOption) => void | Promise<void>
+  updatingRecommendedModelValue?: string
   selectedModel?: string
   modelForQuery?: string
   onModelChange: (model: string) => void
@@ -82,10 +89,21 @@ export function ChatHistoryView({
   hasAvailableModels: boolean
 }) {
   const { t } = useTranslation()
+  const { message } = App.useApp()
+  const location = useLocation()
   const { messagesEndRef, messagesContainerRef, messagesContentRef, showScrollBottom, scrollToBottom } = useChatScroll({
     messagesLength: messages.length
   })
-  const { isCreating, send, sendContent, interrupt, clearMessages } = useChatSessionActions({
+  const {
+    isCreating,
+    send,
+    sendContent,
+    editMessage,
+    forkMessage,
+    interrupt,
+    clearMessages,
+    recallMessage
+  } = useChatSessionActions({
     session,
     modelForQuery,
     hasAvailableModels,
@@ -95,6 +113,10 @@ export function ChatHistoryView({
     onClearMessages
   })
   const initialScrollDoneRef = useRef(false)
+  const handledHashAnchorIdRef = useRef('')
+  const handledTargetScrollKeyRef = useRef('')
+  const [editingMessageId, setEditingMessageId] = useState<string | null>(null)
+  const [expandedTurnIds, setExpandedTurnIds] = useState<Set<string>>(new Set())
   const buildUserMessage = (content: string | ChatMessageContent[]): ChatMessage => {
     const id = globalThis.crypto?.randomUUID
       ? globalThis.crypto.randomUUID()
@@ -141,19 +163,269 @@ export function ChatHistoryView({
   }
   useEffect(() => {
     initialScrollDoneRef.current = false
+    handledHashAnchorIdRef.current = ''
+    handledTargetScrollKeyRef.current = ''
+    setEditingMessageId(null)
+    setExpandedTurnIds(new Set())
   }, [session?.id])
   useEffect(() => {
-    if (!initialScrollDoneRef.current && isReady) {
+    if (!initialScrollDoneRef.current && isReady && location.hash === '') {
       scrollToBottom('auto')
       initialScrollDoneRef.current = true
     }
-  }, [isReady, messages.length, scrollToBottom])
+  }, [isReady, location.hash, messages.length, scrollToBottom])
   useEffect(() => {
-    if (!showScrollBottom) {
+    if (location.hash === '' && !showScrollBottom) {
       scrollToBottom('auto')
     }
-  }, [messages.length, scrollToBottom, showScrollBottom])
+  }, [location.hash, messages.length, scrollToBottom, showScrollBottom])
+  const handleStartEditing = (messageId: string) => {
+    let isBlocked = false
+
+    setEditingMessageId((current) => {
+      if (current != null && current !== messageId) {
+        isBlocked = true
+        return current
+      }
+
+      return messageId
+    })
+
+    if (isBlocked) {
+      void message.warning(t('chat.messageActions.editInProgress'))
+    }
+  }
+  const isInlineEditing = editingMessageId != null
   const renderItems = useMemo(() => processMessages(messages), [messages])
+  const hashAnchorId = useMemo(() => decodeURIComponent(location.hash.replace(/^#/, '')), [location.hash])
+  const targetAnchorId = useMemo(() => {
+    if (targetToolUseId != null && targetToolUseId !== '') {
+      const targetToolGroup = renderItems.find((item) => {
+        return item.type === 'tool-group' && item.items.some(toolItem => toolItem.item.id === targetToolUseId)
+      })
+      return targetToolGroup?.anchorId ?? ''
+    }
+
+    if (targetMessageId != null && targetMessageId !== '') {
+      const targetMessage = renderItems.find((item) => {
+        return item.type === 'message' && item.originalMessage.id === targetMessageId
+      })
+      return targetMessage?.anchorId ?? ''
+    }
+
+    return ''
+  }, [renderItems, targetMessageId, targetToolUseId])
+  const messageTurns = useMemo(() =>
+    buildMessageTurns({
+      renderItems,
+      expandedTurnIds,
+      hashAnchorId: hashAnchorId !== '' ? hashAnchorId : targetAnchorId,
+      keepLastTurnExpanded: isCreating || session?.status === 'running' || session?.status === 'waiting_input'
+    }), [expandedTurnIds, hashAnchorId, isCreating, renderItems, session?.status, targetAnchorId])
+  const lastAssistantActionAnchorId = useMemo(() => {
+    for (let index = renderItems.length - 1; index >= 0; index -= 1) {
+      const item = renderItems[index]
+      if (item == null) continue
+      if (item.type === 'tool-group') continue
+      if (item.message.role === 'user') continue
+      return item.anchorId
+    }
+    return null
+  }, [renderItems])
+
+  useEffect(() => {
+    const hash = hashAnchorId
+    if (hash === '') {
+      handledHashAnchorIdRef.current = ''
+      return
+    }
+
+    if (!isReady || handledHashAnchorIdRef.current === hash) return
+
+    let removeHighlightTimer: ReturnType<typeof setTimeout> | null = null
+    let retryTimer: ReturnType<typeof setTimeout> | null = null
+    let frameId: number | null = null
+
+    const scrollToAnchor = () => {
+      const target = document.getElementById(hash)
+      if (target == null) {
+        return false
+      }
+
+      handledHashAnchorIdRef.current = hash
+      target.scrollIntoView({ block: 'center', behavior: 'auto' })
+      target.classList.add('is-anchor-target')
+      removeHighlightTimer = setTimeout(() => {
+        target.classList.remove('is-anchor-target')
+      }, 1800)
+      return true
+    }
+
+    if (!scrollToAnchor()) {
+      frameId = requestAnimationFrame(() => {
+        if (!scrollToAnchor()) {
+          retryTimer = setTimeout(() => {
+            void scrollToAnchor()
+          }, 120)
+        }
+      })
+    }
+
+    return () => {
+      if (frameId != null) {
+        cancelAnimationFrame(frameId)
+      }
+      if (retryTimer != null) {
+        clearTimeout(retryTimer)
+      }
+      if (removeHighlightTimer != null) {
+        clearTimeout(removeHighlightTimer)
+      }
+    }
+  }, [hashAnchorId, isReady, messageTurns])
+
+  useEffect(() => {
+    const targetAttr = targetToolUseId != null && targetToolUseId !== ''
+      ? { key: 'data-tool-use-id', value: targetToolUseId, targetKey: `tool:${targetToolUseId}` }
+      : targetMessageId != null && targetMessageId !== ''
+        ? { key: 'data-message-id', value: targetMessageId, targetKey: `message:${targetMessageId}` }
+        : undefined
+    if (targetAttr == null) {
+      handledTargetScrollKeyRef.current = ''
+      return
+    }
+
+    if (handledTargetScrollKeyRef.current === targetAttr.targetKey) {
+      return
+    }
+
+    const frame = window.requestAnimationFrame(() => {
+      const container = messagesContentRef.current
+      if (container == null) {
+        return
+      }
+
+      const target = Array.from(container.querySelectorAll<HTMLElement>(`[${targetAttr.key}]`))
+        .find(element => element.getAttribute(targetAttr.key) === targetAttr.value)
+      if (target == null) {
+        return
+      }
+
+      handledTargetScrollKeyRef.current = targetAttr.targetKey
+      target.scrollIntoView({ block: 'center', behavior: 'smooth' })
+    })
+
+    return () => {
+      window.cancelAnimationFrame(frame)
+    }
+  }, [messageTurns, messagesContentRef, targetMessageId, targetToolUseId])
+
+  const toggleTurnCollapsed = (turnId: string) => {
+    setExpandedTurnIds((prev) => {
+      const next = new Set(prev)
+      if (next.has(turnId)) {
+        next.delete(turnId)
+      } else {
+        next.add(turnId)
+      }
+      return next
+    })
+  }
+
+  const formatTurnDuration = (durationMs: number | null) => {
+    if (durationMs == null) return null
+    const totalSeconds = Math.floor(durationMs / 1000)
+    if (totalSeconds <= 0) {
+      return t('chat.turnDurationUnderSecond')
+    }
+
+    const hours = Math.floor(totalSeconds / 3600)
+    const minutes = Math.floor((totalSeconds % 3600) / 60)
+    const seconds = totalSeconds % 60
+
+    if (hours > 0) {
+      return [
+        t('chat.turnDurationHours', { count: hours }),
+        minutes > 0 ? t('chat.turnDurationMinutes', { count: minutes }) : null
+      ].filter(Boolean).join(' ')
+    }
+
+    if (minutes > 0) {
+      return [
+        t('chat.turnDurationMinutes', { count: minutes }),
+        seconds > 0 ? t('chat.turnDurationSeconds', { count: seconds }) : null
+      ].filter(Boolean).join(' ')
+    }
+
+    return t('chat.turnDurationSeconds', { count: seconds })
+  }
+
+  const renderTurnSummary = (turn: (typeof messageTurns)[number]) => (
+    <div className={`chat-turn-summary ${turn.isCollapsed ? 'is-collapsed' : 'is-expanded'}`}>
+      <div className='chat-turn-summary__content'>
+        <div className='chat-turn-summary__meta'>
+          {formatTurnDuration(turn.durationMs) != null && (
+            <span className='chat-turn-summary__time'>
+              {t('chat.turnProcessedDuration', { duration: formatTurnDuration(turn.durationMs) })}
+            </span>
+          )}
+          <span className='chat-turn-summary__count'>
+            {t('chat.turnSummaryCount', { count: turn.hiddenCount })}
+          </span>
+        </div>
+        <button
+          type='button'
+          className='chat-turn-summary__toggle'
+          aria-expanded={!turn.isCollapsed}
+          onClick={() => toggleTurnCollapsed(turn.id)}
+        >
+          <span className='material-symbols-rounded'>
+            chevron_right
+          </span>
+        </button>
+      </div>
+    </div>
+  )
+
+  const renderTurnItem = (item: (typeof renderItems)[number], key?: string) => {
+    if (item.type === 'message') {
+      return (
+        <MessageItem
+          key={key ?? item.anchorId}
+          anchorId={item.anchorId}
+          msg={item.message}
+          isFirstInGroup={item.isFirstInGroup}
+          isTargeted={item.originalMessage.id === targetMessageId}
+          originalMessage={item.originalMessage}
+          sessionInfo={sessionInfo}
+          isEditing={editingMessageId === item.originalMessage.id}
+          isSessionBusy={isCreating || session?.status === 'running' ||
+            session?.status === 'waiting_input'}
+          showAssistantActions={item.anchorId === lastAssistantActionAnchorId}
+          onEditMessage={editMessage}
+          onForkMessage={forkMessage}
+          onRecallMessage={recallMessage}
+          onStartEditing={handleStartEditing}
+          onCancelEditing={(messageId) => {
+            setEditingMessageId((current) => current === messageId ? null : current)
+          }}
+          sessionId={session?.id}
+        />
+      )
+    }
+
+    return (
+      <ToolGroup
+        key={key ?? item.id}
+        anchorId={item.anchorId}
+        items={item.items}
+        originalMessage={item.originalMessage}
+        sessionId={session?.id}
+        targetToolUseId={targetToolUseId}
+        footer={item.footer}
+      />
+    )
+  }
 
   return (
     <>
@@ -165,26 +437,31 @@ export function ChatHistoryView({
               <span>{t('common.creatingChat')}</span>
             </div>
           )}
-          {renderItems.map((item, index) => {
-            if (item.type === 'message') {
-              return (
-                <MessageItem
-                  key={item.message.id || index}
-                  msg={item.message}
-                  isFirstInGroup={item.isFirstInGroup}
-                />
+          {messageTurns.map((turn) => (
+            turn.isExpandable
+              ? (
+                <div key={turn.id} className={`chat-turn ${turn.isCollapsed ? 'is-collapsed' : 'is-expanded'}`}>
+                  {renderTurnItem(turn.items[0]!, `${turn.id}:leading`)}
+                  <div className={`chat-turn__summary-region ${turn.isCollapsed ? 'is-collapsed' : 'is-expanded'}`}>
+                    {renderTurnSummary(turn)}
+                    <div
+                      className={`chat-turn__collapsible ${turn.isCollapsed ? 'is-collapsed' : 'is-expanded'}`}
+                      aria-hidden={turn.isCollapsed}
+                    >
+                      <div className='chat-turn__collapsible-inner'>
+                        {turn.items.slice(1, -1).map((item) => renderTurnItem(item))}
+                      </div>
+                    </div>
+                  </div>
+                  {renderTurnItem(turn.items[turn.items.length - 1]!, `${turn.id}:trailing`)}
+                </div>
               )
-            } else if (item.type === 'tool-group') {
-              return (
-                <ToolGroup
-                  key={item.id || `group-${index}`}
-                  items={item.items}
-                  footer={item.footer}
-                />
+              : (
+                <React.Fragment key={turn.id}>
+                  {turn.items.map((item) => renderTurnItem(item))}
+                </React.Fragment>
               )
-            }
-            return null
-          })}
+          ))}
           <div ref={messagesEndRef} />
         </div>
 
@@ -202,35 +479,42 @@ export function ChatHistoryView({
       )}
 
       <CurrentTodoList messages={messages} />
-      <div className='sender-container'>
-        <Sender
-          onSend={handleSend}
-          onSendContent={handleSendContent}
-          adapterLocked={session?.id != null}
-          sessionStatus={isCreating ? 'running' : session?.status}
-          onInterrupt={interrupt}
-          onClear={clearMessages}
-          sessionInfo={sessionInfo}
-          connectionError={connectionError}
-          onRetryConnection={onRetryConnection}
-          interactionRequest={interactionRequest}
-          onInteractionResponse={onInteractionResponse}
-          placeholder={placeholder}
-          modelOptions={modelOptions}
-          selectedModel={selectedModel}
-          onModelChange={onModelChange}
-          effort={effort}
-          effortOptions={effortOptions}
-          onEffortChange={onEffortChange}
-          permissionMode={permissionMode}
-          permissionModeOptions={permissionModeOptions}
-          onPermissionModeChange={onPermissionModeChange}
-          selectedAdapter={selectedAdapter}
-          adapterOptions={adapterOptions}
-          onAdapterChange={onAdapterChange}
-          modelUnavailable={modelUnavailable}
-        />
-      </div>
+      {!isInlineEditing && (
+        <div className='sender-container'>
+          <Sender
+            onSend={handleSend}
+            onSendContent={handleSendContent}
+            adapterLocked={session?.id != null}
+            sessionStatus={isCreating ? 'running' : session?.status}
+            onInterrupt={interrupt}
+            onClear={clearMessages}
+            sessionInfo={sessionInfo}
+            errorBanner={errorBanner}
+            onRetryConnection={onRetryConnection}
+            interactionRequest={interactionRequest}
+            onInteractionResponse={onInteractionResponse}
+            placeholder={placeholder}
+            modelMenuGroups={modelMenuGroups}
+            modelSearchOptions={modelSearchOptions}
+            recommendedModelOptions={recommendedModelOptions}
+            servicePreviewModelOptions={servicePreviewModelOptions}
+            onToggleRecommendedModel={onToggleRecommendedModel}
+            updatingRecommendedModelValue={updatingRecommendedModelValue}
+            selectedModel={selectedModel}
+            onModelChange={onModelChange}
+            effort={effort}
+            effortOptions={effortOptions}
+            onEffortChange={onEffortChange}
+            permissionMode={permissionMode}
+            permissionModeOptions={permissionModeOptions}
+            onPermissionModeChange={onPermissionModeChange}
+            selectedAdapter={selectedAdapter}
+            adapterOptions={adapterOptions}
+            onAdapterChange={onAdapterChange}
+            modelUnavailable={modelUnavailable}
+          />
+        </div>
+      )}
     </>
   )
 }

package/src/components/chat/ChatSettingsView.tsx

@@ -1,20 +1,22 @@
 import type { Session } from '@vibe-forge/core'
+import type { SessionInfo } from '@vibe-forge/types'
 
 import { SessionSettingsPanel } from './ChatHeader'
 
 export function ChatSettingsView({
   session,
+  sessionInfo,
   onClose
 }: {
   session: Session
+  sessionInfo: SessionInfo | null
   onClose: () => void
 }) {
   return (
     <div className='chat-settings-panel'>
       <SessionSettingsPanel
-        sessionId={session.id}
-        initialTitle={session.title}
-        initialTags={session.tags}
+        session={session}
+        sessionInfo={sessionInfo}
         onClose={onClose}
       />
     </div>

package/src/components/chat/ChatTimelineView.scss

@@ -1,8 +1,9 @@
 .chat-timeline-view {
   display: flex;
   flex-direction: column;
-  height: 100%;
-  padding: 24px;
+  flex: 1;
+  min-height: 0;
+  padding: 6px 12px 12px;
   overflow: auto;
 }
 

package/src/components/chat/{sender/ThinkingStatus.tsx → ThinkingStatus.tsx}

@@ -1,5 +1,5 @@
 import './ThinkingStatus.scss'
-import React from 'react'
+
 import { useTranslation } from 'react-i18next'
 
 export function ThinkingStatus() {