Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

10.0 KB
Raw Blame
import { useCallback, useEffect, useMemo, useReducer, useRef, useState } from 'react'
import { translate } from '../i18n/mobile-i18n'
import { useMobileTranslation } from '../i18n/use-mobile-translation'
import { useMobileSourceControlSettings } from '../source-control/mobile-source-control-settings'
import type { FlatList } from 'react-native'
import type { DiffComment } from '../../../src/shared/diff-comment-types'
import type { ConnectionState } from '../transport/types'
import type { RpcClient } from '../transport/rpc-client'
import { getWorktreeLabel } from './worktree-label'
import { getUnsentMobileDiffComments } from './mobile-diff-comment-edit'
import {
  buildMobileDiffReviewQueue,
  filterMobileDiffReviewQueue,
  mobileDiffReviewCommentMatchesItem,
  summarizeMobileDiffReviewQueue,
  type MobileDiffReviewQueueFilter
} from './mobile-diff-review-queue'
import {
  findMobileDiffReviewInitialIndex,
  type MobileDiffReviewInitialTarget
} from './mobile-diff-review-positioning'
import { loadMobileDiffReviewSnapshot } from './mobile-diff-review-loaders'
import { useMobileDiffReviewDiffLoading } from './use-mobile-diff-review-diff-loading'
import { canOpenMobileBranchCompareDiff } from '../source-control/mobile-branch-compare'
import type { ReviewDiffLine, ReviewScreenState } from './mobile-diff-review-screen-model'
import {
  NO_REVIEW_SHEETS,
  reduceReviewSheets,
  reviewComposer,
  reviewSheetIntents
} from './mobile-diff-review-sheets'
import { useMobileDiffReviewInteractions } from './use-mobile-diff-review-interactions'
import { resolveMobileAgentLaunchAvailability } from './mobile-agent-launch-availability'
import { useMobilePrSidebarController } from './use-mobile-pr-sidebar-controller'

type ControllerInput = {
  client: RpcClient | null
  connState: ConnectionState
  hostCapabilities: readonly string[]
  hostStatusPending: boolean
  hostStatusReadable: boolean
  hostId: string
  worktreeId: string
  name: string
  initialFilter: MobileDiffReviewQueueFilter
  initialTarget: MobileDiffReviewInitialTarget | null
  onOpenSession: () => void
  /** Null on the page, where the shell owns the connection. */
  onReconnect: ((hostId: string) => void | Promise<void>) | null
}

export function useMobileDiffReviewController(input: ControllerInput) {
  useMobileTranslation()
  const {
    client,
    connState,
    hostCapabilities,
    hostStatusPending,
    hostStatusReadable,
    hostId,
    worktreeId,
    name,
    initialFilter,
    initialTarget,
    onOpenSession,
    onReconnect
  } = input
  const listRef = useRef<FlatList<ReviewDiffLine> | null>(null)
  const loadGenerationRef = useRef(0)
  const seededInitialTargetRef = useRef(false)
  const initialTargetKey = initialTarget ? `${initialTarget.area}\0${initialTarget.filePath}` : ''
  const [screenState, setScreenState] = useState<ReviewScreenState>({ kind: 'loading' })
  const [filter, setFilter] = useState<MobileDiffReviewQueueFilter>(initialFilter)
  const [currentIndex, setCurrentIndex] = useState(0)
  const [activeHunkIndex, setActiveHunkIndex] = useState<number | null>(null)
  const [sheets, dispatchSheets] = useReducer(reduceReviewSheets, NO_REVIEW_SHEETS)
  const sheetIntents = useMemo(() => reviewSheetIntents(dispatchSheets), [])
  const composer = reviewComposer(sheets)
  const [composerBody, setComposerBody] = useState('')
  const [actionError, setActionError] = useState<string | null>(null)
  const [busyAction, setBusyAction] = useState<string | null>(null)
  const worktreeLabel = getWorktreeLabel(name, worktreeId)
  const { compareAgainstUpstream } = useMobileSourceControlSettings(client, connState).settings

  const loadReviewData = useCallback(async () => {
    const generation = loadGenerationRef.current + 1
    loadGenerationRef.current = generation
    const isCurrent = () => generation === loadGenerationRef.current
    if (!worktreeId) {
      setScreenState({
        kind: 'error',
        message: translate('session.useDiffReviewController.missingWorktree', 'Missing worktree')
      })
      return
    }
    // Keep an existing review through disconnects; only empty screens need the waiting state.
    const keepReady = (fallback: ReviewScreenState) => (prev: ReviewScreenState) =>
      prev.kind === 'ready' ? prev : fallback
    if (!client || connState !== 'connected') {
      setScreenState(
        keepReady({
          kind: 'error',
          message: translate(
            'session.useDiffReviewController.waitingForDesktop',
            'Waiting for desktop...'
          )
        })
      )
      return
    }
    setScreenState(keepReady({ kind: 'loading' }))
    try {
      const nextState = await loadMobileDiffReviewSnapshot(
        client,
        worktreeId,
        compareAgainstUpstream
      )
      if (!isCurrent()) {
        return
      }
      setScreenState(nextState)
      setActionError(nextState.kind === 'ready' ? (nextState.branchError ?? null) : null)
    } catch (err) {
      if (isCurrent()) {
        // Failed reconnect reads must not destroy an already loaded review.
        setScreenState(
          keepReady({
            kind: 'error',
            message:
              err instanceof Error
                ? err.message
                : translate('session.useDiffReviewController.loadFailed', 'Unable to load review')
          })
        )
      }
    }
  }, [client, compareAgainstUpstream, connState, worktreeId])

  useEffect(() => {
    void loadReviewData()
  }, [loadReviewData])

  const queue = useMemo(() => {
    if (screenState.kind !== 'ready') {
      return []
    }
    const branchEntries =
      screenState.branchCompare && canOpenMobileBranchCompareDiff(screenState.branchCompare.summary)
        ? (screenState.branchCompare.entries ?? [])
        : []
    return buildMobileDiffReviewQueue({
      worktreeId,
      statusEntries: screenState.status.entries,
      branchEntries,
      branchHeadOid: screenState.branchCompare?.summary.headOid,
      branchMergeBase: screenState.branchCompare?.summary.mergeBase,
      comments: screenState.comments,
      reviewState: screenState.reviewState
    })
  }, [screenState, worktreeId])

  const filteredQueue = useMemo(() => filterMobileDiffReviewQueue(queue, filter), [filter, queue])
  const currentItem = filteredQueue[currentIndex] ?? null
  const { reviewedCount, reviewedUnstagedCount } = useMemo(
    () => summarizeMobileDiffReviewQueue(queue),
    [queue]
  )
  const unsentComments =
    screenState.kind === 'ready' ? getUnsentMobileDiffComments(screenState.comments) : []

  useEffect(() => {
    seededInitialTargetRef.current = false
  }, [initialTargetKey])

  useEffect(() => {
    if (seededInitialTargetRef.current || filteredQueue.length === 0) {
      return
    }
    seededInitialTargetRef.current = true
    // Seed the tapped file only once the queue exists or clamping would reset its selection.
    setCurrentIndex(findMobileDiffReviewInitialIndex(filteredQueue, initialTarget))
  }, [filteredQueue, initialTarget])

  useEffect(() => {
    if (filteredQueue.length === 0) {
      setCurrentIndex(0)
      return
    }
    if (currentIndex >= filteredQueue.length) {
      setCurrentIndex(filteredQueue.length - 1)
    }
  }, [currentIndex, filteredQueue.length])

  const diffState = useMobileDiffReviewDiffLoading({
    client,
    connState,
    worktreeId,
    currentItem,
    screenState,
    setActiveHunkIndex
  })

  const commentsForCurrentItem = useMemo(() => {
    if (!currentItem || screenState.kind !== 'ready') {
      return []
    }
    return screenState.comments.filter((comment) =>
      mobileDiffReviewCommentMatchesItem(comment, currentItem)
    )
  }, [currentItem, screenState])

  const staleCommentIds = useMemo(
    () =>
      new Set(
        commentsForCurrentItem
          .filter(
            (comment) =>
              currentItem &&
              comment.diffIdentity !== undefined &&
              comment.diffIdentity !== currentItem.diffIdentity
          )
          .map((comment) => comment.id)
      ),
    [commentsForCurrentItem, currentItem]
  )

  const commentsByLine = useMemo(() => {
    const map = new Map<number, DiffComment[]>()
    for (const comment of commentsForCurrentItem) {
      const list = map.get(comment.lineNumber) ?? []
      list.push(comment)
      map.set(comment.lineNumber, list)
    }
    return map
  }, [commentsForCurrentItem])

  // Use git.status for PR head identity; branchCompare’s base ref is not the head.
  const prSidebarBranch = screenState.kind === 'ready' ? (screenState.status.branch ?? null) : null
  const prSidebarHeadSha =
    screenState.kind === 'ready'
      ? (screenState.status.head ?? screenState.branchCompare?.summary.headOid ?? null)
      : null
  const prSidebar = useMobilePrSidebarController({
    client,
    connState,
    worktreeId,
    branch: prSidebarBranch,
    headSha: prSidebarHeadSha
  })

  const interactions = useMobileDiffReviewInteractions({
    client,
    connState,
    hostCapabilities,
    hostId,
    worktreeId,
    screenState,
    diffState,
    currentItem,
    queue,
    filteredQueue,
    filter,
    currentIndex,
    activeHunkIndex,
    composer,
    composerBody,
    listRef,
    setScreenState,
    setFilter,
    setCurrentIndex,
    setActiveHunkIndex,
    setComposerBody,
    setActionError,
    setBusyAction,
    sheets: sheetIntents,
    loadReviewData,
    onOpenSession,
    onReconnect
  })

  return {
    ...interactions,
    ...prSidebar,
    ...sheetIntents,
    agentLaunchAvailability: resolveMobileAgentLaunchAvailability({
      hostCapabilities,
      statusPending: hostStatusPending,
      statusReadable: hostStatusReadable
    }),
    client,
    connState,
    worktreeId,
    prSidebarBranch,
    prSidebarHeadSha,
    actionError,
    activeHunkIndex,
    busyAction,
    commentsByLine,
    composer,
    composerBody,
    currentIndex,
    currentItem,
    diffState,
    fileNotes: commentsByLine.get(0) ?? [],
    filter,
    filteredQueue,
    listRef,
    queue,
    reviewedCount,
    reviewedUnstagedCount,
    screenState,
    setComposerBody,
    sheet: sheets.requested,
    staleCommentIds,
    unsentComments,
    worktreeLabel
  }
}