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

package/src/components/workspace/project-file-tree/use-project-file-tree-data.ts

@@ -1,197 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
-
-import { listSessionWorkspaceTree, listWorkspaceTree } from '#~/api'
-
-import {
-  collectProjectFileTreeDirectoryPaths,
-  getProjectFileTreeAncestorDirectoryPaths,
-  loadProjectFileTreeDirectoryRecursive,
-  replaceProjectFileTreeNodeChildren,
-  toProjectFileTreeNodes
-} from './project-file-tree-helpers'
-import type { ProjectFileTreeCommand, ProjectFileTreeNode } from './project-file-tree-types'
-
-export const useProjectFileTreeData = ({
-  command,
-  refreshKey,
-  sessionId
-}: {
-  command?: ProjectFileTreeCommand | null
-  refreshKey: number
-  sessionId?: string
-}) => {
-  const [treeData, setTreeData] = useState<ProjectFileTreeNode[]>([])
-  const [expandedPaths, setExpandedPaths] = useState<Set<string>>(new Set())
-  const [loadingPaths, setLoadingPaths] = useState<Set<string>>(new Set())
-  const [hasLoadedTree, setHasLoadedTree] = useState(false)
-  const [hasTreeError, setHasTreeError] = useState(false)
-  const [isRootLoading, setIsRootLoading] = useState(false)
-  const treeContainerRef = useRef<HTMLDivElement | null>(null)
-  const treeDataRef = useRef(treeData)
-  const treeOperationIdRef = useRef(0)
-
-  const loadWorkspaceTree = useCallback(async (path?: string) => {
-    if (sessionId != null && sessionId !== '') {
-      return await listSessionWorkspaceTree(sessionId, path)
-    }
-    return await listWorkspaceTree(path)
-  }, [sessionId])
-
-  const scrollTreePathIntoView = useCallback((path?: string) => {
-    if (path == null || path === '') {
-      return
-    }
-
-    window.requestAnimationFrame(() => {
-      window.requestAnimationFrame(() => {
-        const rows = treeContainerRef.current?.querySelectorAll<HTMLElement>('[data-workspace-tree-path]') ?? []
-        const target = Array.from(rows).find(row => row.dataset.workspaceTreePath === path)
-        target?.scrollIntoView({ block: 'center', inline: 'nearest' })
-      })
-    })
-  }, [])
-
-  const loadRootTree = useCallback(async () => {
-    const operationId = treeOperationIdRef.current + 1
-    treeOperationIdRef.current = operationId
-    setHasTreeError(false)
-    setExpandedPaths(new Set())
-    setIsRootLoading(true)
-    try {
-      const result = await loadWorkspaceTree()
-      if (treeOperationIdRef.current !== operationId) {
-        return
-      }
-      setTreeData(toProjectFileTreeNodes(result.entries))
-      setHasLoadedTree(true)
-    } catch {
-      if (treeOperationIdRef.current === operationId) {
-        setTreeData([])
-        setHasLoadedTree(true)
-        setHasTreeError(true)
-      }
-    } finally {
-      if (treeOperationIdRef.current === operationId) {
-        setIsRootLoading(false)
-      }
-    }
-  }, [loadWorkspaceTree])
-
-  useEffect(() => {
-    treeDataRef.current = treeData
-  }, [treeData])
-
-  useEffect(() => {
-    void loadRootTree()
-  }, [loadRootTree, refreshKey])
-
-  useEffect(() => {
-    if (command == null) {
-      return
-    }
-
-    if (command.action === 'collapse') {
-      treeOperationIdRef.current += 1
-      setExpandedPaths(new Set())
-      return
-    }
-
-    let isCancelled = false
-    const isCurrentOperation = (operationId: number) => !isCancelled && treeOperationIdRef.current === operationId
-    const runLocateFile = async () => {
-      if (command.path == null || command.path === '') {
-        return
-      }
-      const ancestorPaths = getProjectFileTreeAncestorDirectoryPaths(command.path)
-      const operationId = treeOperationIdRef.current + 1
-      treeOperationIdRef.current = operationId
-      setHasTreeError(false)
-      try {
-        let nextTreeData = treeDataRef.current
-        if (nextTreeData.length === 0) {
-          nextTreeData = toProjectFileTreeNodes((await loadWorkspaceTree()).entries)
-        }
-        for (const path of ancestorPaths) {
-          const result = await loadWorkspaceTree(path)
-          nextTreeData = replaceProjectFileTreeNodeChildren(
-            nextTreeData,
-            path,
-            toProjectFileTreeNodes(result.entries)
-          )
-        }
-        if (!isCurrentOperation(operationId)) {
-          return
-        }
-        setTreeData(nextTreeData)
-        setHasLoadedTree(true)
-        setExpandedPaths(prev => new Set([...prev, ...ancestorPaths]))
-        scrollTreePathIntoView(command.path)
-      } catch {
-        if (isCurrentOperation(operationId)) {
-          setHasLoadedTree(true)
-          setHasTreeError(true)
-        }
-      }
-    }
-    const runExpandAll = async () => {
-      const operationId = treeOperationIdRef.current + 1
-      treeOperationIdRef.current = operationId
-      setHasTreeError(false)
-      try {
-        const nextTreeData = await Promise.all(
-          treeDataRef.current.map(node => loadProjectFileTreeDirectoryRecursive(node, loadWorkspaceTree))
-        )
-        if (!isCurrentOperation(operationId)) {
-          return
-        }
-        setTreeData(nextTreeData)
-        setHasLoadedTree(true)
-        setExpandedPaths(new Set(collectProjectFileTreeDirectoryPaths(nextTreeData)))
-      } catch {
-        if (isCurrentOperation(operationId)) {
-          setHasLoadedTree(true)
-          setHasTreeError(true)
-        }
-      }
-    }
-
-    void (command.action === 'locate' ? runLocateFile() : runExpandAll())
-
-    return () => {
-      isCancelled = true
-    }
-  }, [command, loadWorkspaceTree, scrollTreePathIntoView])
-
-  const handleToggleDirectory = useCallback(async (node: ProjectFileTreeNode) => {
-    if (expandedPaths.has(node.path)) {
-      setExpandedPaths(prev => new Set(Array.from(prev).filter(path => path !== node.path)))
-      return
-    }
-
-    setExpandedPaths(prev => new Set(prev).add(node.path))
-    if (node.children != null) {
-      return
-    }
-
-    setLoadingPaths(prev => new Set(prev).add(node.path))
-    try {
-      const result = await loadWorkspaceTree(node.path)
-      setTreeData(prev => replaceProjectFileTreeNodeChildren(prev, node.path, toProjectFileTreeNodes(result.entries)))
-    } catch {
-      setHasTreeError(true)
-    } finally {
-      setLoadingPaths(prev => new Set(Array.from(prev).filter(path => path !== node.path)))
-    }
-  }, [expandedPaths, loadWorkspaceTree])
-
-  return {
-    expandedPaths,
-    handleToggleDirectory,
-    hasLoadedTree,
-    hasTreeError,
-    isRootLoading,
-    loadingPaths,
-    treeContainerRef,
-    treeData
-  }
-}

package/src/components/workspace/project-file-tree/use-project-file-tree-selection.ts

@@ -1,144 +0,0 @@
-import type { MouseEvent } from 'react'
-import { useCallback, useMemo, useRef, useState } from 'react'
-
-import { canSelectProjectFileTreeNode } from './project-file-tree-helpers'
-import type {
-  ProjectFileTreeNode,
-  ProjectFileTreeSelectableTypes,
-  ProjectFileTreeSelection,
-  ProjectFileTreeSelectionMode
-} from './project-file-tree-types'
-
-const uniqueNodes = (nodes: ProjectFileTreeNode[]) => {
-  const seen = new Set<string>()
-  const result: ProjectFileTreeNode[] = []
-  for (const node of nodes) {
-    if (seen.has(node.path)) {
-      continue
-    }
-    seen.add(node.path)
-    result.push(node)
-  }
-  return result
-}
-
-const getNodesByPaths = (paths: string[], visibleNodes: ProjectFileTreeNode[]) => {
-  const nodeByPath = new Map(visibleNodes.map(node => [node.path, node]))
-  return paths
-    .map(path => nodeByPath.get(path))
-    .filter((node): node is ProjectFileTreeNode => node != null)
-}
-
-export const useProjectFileTreeSelection = ({
-  activePath,
-  onSelectionChange,
-  selectableTypes,
-  selectedPaths,
-  selectionMode,
-  visibleNodes
-}: {
-  activePath?: string | null
-  onSelectionChange?: (selection: ProjectFileTreeSelection) => void
-  selectableTypes: ProjectFileTreeSelectableTypes
-  selectedPaths?: string[]
-  selectionMode: ProjectFileTreeSelectionMode
-  visibleNodes: ProjectFileTreeNode[]
-}) => {
-  const [internalSelectedPaths, setInternalSelectedPaths] = useState<string[]>([])
-  const selectionAnchorPathRef = useRef<string | null>(null)
-  const resolvedSelectedPaths = selectedPaths ?? internalSelectedPaths
-  const selectedNodes = useMemo(
-    () => getNodesByPaths(resolvedSelectedPaths, visibleNodes),
-    [resolvedSelectedPaths, visibleNodes]
-  )
-  const selectedPathSet = useMemo(() => {
-    const paths = new Set(resolvedSelectedPaths)
-    if (activePath != null && activePath !== '') {
-      paths.add(activePath)
-    }
-    return paths
-  }, [activePath, resolvedSelectedPaths])
-
-  const emitSelectionChange = useCallback((
-    nextNodes: ProjectFileTreeNode[]
-  ) => {
-    const normalizedNodes = uniqueNodes(nextNodes.filter(node => canSelectProjectFileTreeNode(node, selectableTypes)))
-    const nextPaths = normalizedNodes.map(node => node.path)
-    if (selectedPaths == null) {
-      setInternalSelectedPaths(nextPaths)
-    }
-    onSelectionChange?.({ nodes: normalizedNodes, paths: nextPaths })
-  }, [onSelectionChange, selectableTypes, selectedPaths])
-
-  const handleContextSelect = useCallback((node: ProjectFileTreeNode) => {
-    if (selectionMode === 'none' || selectedPathSet.has(node.path)) {
-      return
-    }
-    selectionAnchorPathRef.current = node.path
-    emitSelectionChange([node])
-  }, [emitSelectionChange, selectedPathSet, selectionMode])
-
-  const handleSelectNode = useCallback((node: ProjectFileTreeNode, event: MouseEvent<HTMLButtonElement>) => {
-    if (selectionMode === 'none' || !canSelectProjectFileTreeNode(node, selectableTypes)) {
-      return false
-    }
-
-    const isRangeSelection = event.shiftKey
-    const isToggleSelection = event.metaKey || event.ctrlKey
-    if (!isRangeSelection && !isToggleSelection) {
-      selectionAnchorPathRef.current = node.path
-      emitSelectionChange([node])
-      return false
-    }
-
-    event.preventDefault()
-    event.stopPropagation()
-
-    const selectableVisibleNodes = visibleNodes.filter(item => canSelectProjectFileTreeNode(item, selectableTypes))
-    if (selectableVisibleNodes.length === 0) {
-      return true
-    }
-
-    if (isRangeSelection) {
-      const anchorPath = selectionAnchorPathRef.current ?? resolvedSelectedPaths.at(-1) ?? node.path
-      const anchorIndex = selectableVisibleNodes.findIndex(item => item.path === anchorPath)
-      const targetIndex = selectableVisibleNodes.findIndex(item => item.path === node.path)
-      if (targetIndex < 0) {
-        return true
-      }
-      if (anchorIndex < 0) {
-        emitSelectionChange([node])
-        selectionAnchorPathRef.current = node.path
-        return true
-      }
-
-      const start = Math.min(anchorIndex, targetIndex)
-      const end = Math.max(anchorIndex, targetIndex)
-      emitSelectionChange(selectableVisibleNodes.slice(start, end + 1))
-      return true
-    }
-
-    selectionAnchorPathRef.current = node.path
-    if (selectedPathSet.has(node.path)) {
-      emitSelectionChange(selectedNodes.filter(item => item.path !== node.path))
-    } else {
-      emitSelectionChange([...selectedNodes, node])
-    }
-    return true
-  }, [
-    emitSelectionChange,
-    resolvedSelectedPaths,
-    selectableTypes,
-    selectedNodes,
-    selectedPathSet,
-    selectionMode,
-    visibleNodes
-  ])
-
-  return {
-    handleContextSelect,
-    handleSelectNode,
-    selectedNodes,
-    selectedPathSet
-  }
-}

package/src/connectionManager.ts

@@ -1,174 +0,0 @@
-import type { WSEvent } from '@vibe-forge/core'
-import { createSocket } from './ws'
-import type { WSHandlers } from './ws'
-
-class ConnectionManager {
-  private sockets = new Map<string, WebSocket>()
-  private subscribers = new Map<string, Set<WSHandlers>>()
-  private disconnectTimers = new Map<string, NodeJS.Timeout>()
-  private connectionParams = new Map<string, string>()
-
-  // Keep connection alive for 60 seconds after last subscriber leaves
-  // This allows for quick navigation between sessions without reconnecting
-  // and basic background task updates if the user quickly checks back
-  private readonly DISCONNECT_DELAY = 60000
-
-  /**
-   * Connect to a session or reuse existing connection
-   * @param sessionId The session ID to connect to
-   * @param handlers Event handlers for this subscription
-   * @returns A cleanup function to unsubscribe
-   */
-  connect(sessionId: string, handlers: WSHandlers, params?: Record<string, string>): () => void {
-    // 1. Cancel any pending disconnect timer
-    if (this.disconnectTimers.has(sessionId)) {
-      clearTimeout(this.disconnectTimers.get(sessionId)!)
-      this.disconnectTimers.delete(sessionId)
-    }
-
-    // 2. Add subscriber
-    if (!this.subscribers.has(sessionId)) {
-      this.subscribers.set(sessionId, new Set())
-    }
-    this.subscribers.get(sessionId)!.add(handlers)
-
-    // 3. Ensure WebSocket is open
-    const nextParams = this.normalizeParams({ sessionId, ...(params ?? {}) })
-    const paramsKey = this.buildParamsKey(nextParams)
-    const prevParamsKey = this.connectionParams.get(sessionId)
-    let ws = this.sockets.get(sessionId)
-
-    if (prevParamsKey != null && prevParamsKey !== paramsKey && ws) {
-      ws.close()
-      this.sockets.delete(sessionId)
-      ws = undefined
-    }
-
-    // If socket doesn't exist or is closed/closing, create a new one
-    if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
-      this.createConnection(sessionId, nextParams)
-    } else if (ws.readyState === WebSocket.OPEN) {
-      // If already open, trigger onOpen immediately for this new subscriber
-      handlers.onOpen?.()
-    }
-
-    this.connectionParams.set(sessionId, paramsKey)
-    // 4. Return unsubscribe function
-    return () => this.disconnect(sessionId, handlers)
-  }
-
-  private createConnection(sessionId: string, params: Record<string, string>) {
-    const ws = createSocket({
-      onOpen: () => {
-        this.broadcast(sessionId, 'onOpen')
-      },
-      onMessage: (data: WSEvent) => {
-        this.broadcast(sessionId, 'onMessage', data)
-      },
-      onError: (err: Event) => {
-        this.broadcast(sessionId, 'onError', err)
-      },
-      onClose: () => {
-        this.broadcast(sessionId, 'onClose')
-        // Clean up if closed from server side
-        if (this.sockets.get(sessionId) === ws) {
-          this.sockets.delete(sessionId)
-        }
-      }
-    }, params)
-
-    this.sockets.set(sessionId, ws)
-  }
-
-  private disconnect(sessionId: string, handlers: WSHandlers) {
-    const subs = this.subscribers.get(sessionId)
-    if (subs) {
-      subs.delete(handlers)
-
-      // If no more subscribers, schedule disconnect
-      if (subs.size === 0) {
-        this.disconnectTimers.set(
-          sessionId,
-          setTimeout(() => {
-            const ws = this.sockets.get(sessionId)
-            if (ws) {
-              ws.close()
-              this.sockets.delete(sessionId)
-            }
-            this.disconnectTimers.delete(sessionId)
-            this.subscribers.delete(sessionId)
-            this.connectionParams.delete(sessionId)
-          }, this.DISCONNECT_DELAY)
-        )
-      }
-    }
-  }
-
-  private broadcast(sessionId: string, method: keyof WSHandlers, data?: any) {
-    const subs = this.subscribers.get(sessionId)
-    if (subs) {
-      // Create a copy to avoid issues if handlers unsubscribe during execution
-      const handlers = Array.from(subs)
-      handlers.forEach(h => {
-        if (h[method]) {
-          try {
-            // @ts-ignore - Dynamic dispatch
-            h[method](data)
-          } catch (e) {
-            console.error(`Error in ${method} handler for session ${sessionId}:`, e)
-          }
-        }
-      })
-    }
-  }
-
-  /**
-   * Manually close a connection if needed
-   */
-  close(sessionId: string) {
-    const ws = this.sockets.get(sessionId)
-    if (ws) {
-      ws.close()
-      this.sockets.delete(sessionId)
-    }
-    if (this.disconnectTimers.has(sessionId)) {
-      clearTimeout(this.disconnectTimers.get(sessionId)!)
-      this.disconnectTimers.delete(sessionId)
-    }
-    this.subscribers.delete(sessionId)
-    this.connectionParams.delete(sessionId)
-  }
-
-  /**
-   * Send a message to the session
-   */
-  send(sessionId: string, data: any) {
-    const ws = this.sockets.get(sessionId)
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      ws.send(typeof data === 'string' ? data : JSON.stringify(data))
-      return true
-    }
-
-    console.warn(`Cannot send message: Session ${sessionId} not connected or ready`)
-    return false
-  }
-
-  private normalizeParams(params: Record<string, string>) {
-    return Object.entries(params).reduce<Record<string, string>>((acc, [key, value]) => {
-      if (value == null) return acc
-      const trimmed = String(value).trim()
-      if (trimmed === '') return acc
-      acc[key] = trimmed
-      return acc
-    }, {})
-  }
-
-  private buildParamsKey(params: Record<string, string>) {
-    return Object.entries(params)
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([key, value]) => `${key}=${value}`)
-      .join('&')
-  }
-}
-
-export const connectionManager = new ConnectionManager()

package/src/hooks/chat/chat-session-target.ts

@@ -1,69 +0,0 @@
-import type { Session } from '@vibe-forge/core'
-import type { SessionPromptType } from '@vibe-forge/types'
-
-export type ChatSessionTargetType = 'default' | SessionPromptType
-
-export interface ChatSessionTargetDraft {
-  type: ChatSessionTargetType
-  name?: string
-  label?: string
-  description?: string
-  path?: string
-}
-
-export interface ChatSessionTargetResource {
-  id: string
-  name: string
-  description?: string
-  path?: string
-}
-
-export const DEFAULT_CHAT_SESSION_TARGET_DRAFT: ChatSessionTargetDraft = {
-  type: 'default'
-}
-
-export const isChatSessionTargetReady = (target?: ChatSessionTargetDraft) => (
-  target == null || target.type === 'default' || (target.name?.trim() ?? '') !== ''
-)
-
-export const getChatSessionTargetPrompt = (target?: ChatSessionTargetDraft): {
-  promptType?: SessionPromptType
-  promptName?: string
-} => {
-  if (target == null || target.type === 'default') {
-    return {}
-  }
-
-  const promptName = target.name?.trim()
-  if (promptName == null || promptName === '') {
-    return {}
-  }
-
-  return {
-    promptType: target.type,
-    promptName
-  }
-}
-
-export const createChatSessionTargetDraft = (
-  type: Exclude<ChatSessionTargetType, 'default'>,
-  resource: ChatSessionTargetResource
-): ChatSessionTargetDraft => ({
-  type,
-  name: type === 'workspace' ? resource.id : resource.name,
-  label: resource.name,
-  description: resource.description,
-  path: resource.path
-})
-
-export const getChatSessionTargetDraftFromSession = (session?: Session): ChatSessionTargetDraft => {
-  if (session?.promptType == null) {
-    return DEFAULT_CHAT_SESSION_TARGET_DRAFT
-  }
-
-  return {
-    type: session.promptType,
-    name: session.promptName,
-    label: session.promptName
-  }
-}

package/src/hooks/chat/chat-session-workspace-draft.ts

@@ -1,32 +0,0 @@
-import type { ConfigResponse, GitBranchKind } from '@vibe-forge/types'
-
-export interface ChatSessionWorkspaceDraftBranch {
-  name: string
-  kind?: GitBranchKind
-  mode: 'checkout' | 'create'
-}
-
-export interface ChatSessionWorkspaceDraft {
-  createWorktree: boolean
-  worktreeEnvironment?: string
-  branch?: ChatSessionWorkspaceDraftBranch
-}
-
-export const buildChatSessionWorkspaceDraft = (
-  createWorktree = true,
-  worktreeEnvironment?: string
-): ChatSessionWorkspaceDraft => ({
-  createWorktree,
-  ...(worktreeEnvironment != null && worktreeEnvironment.trim() !== ''
-    ? { worktreeEnvironment: worktreeEnvironment.trim() }
-    : {})
-})
-
-export const getChatSessionWorkspaceDraftFromConfig = (
-  configRes?: ConfigResponse
-): ChatSessionWorkspaceDraft => {
-  const conversation = configRes?.sources?.merged?.conversation
-  return buildChatSessionWorkspaceDraft(conversation?.createSessionWorktree ?? true, conversation?.worktreeEnvironment)
-}
-
-export const DEFAULT_CHAT_SESSION_WORKSPACE_DRAFT: ChatSessionWorkspaceDraft = buildChatSessionWorkspaceDraft()