stage-tui 1.0.7

package/src/hooks/use-git-tui-controller.ts

@@ -0,0 +1,310 @@
+import type { InputRenderable, TextareaRenderable } from "@opentui/core"
+import { useCallback, useMemo, useRef, useState } from "react"
+
+import { generateAiCommitSummary } from "../ai-commit"
+import type { StageConfig } from "../config"
+import { GitClient, type RepoSnapshot } from "../git"
+import { type FocusTarget, type TopAction } from "../ui/types"
+import { buildFileRow, inferFiletype } from "../ui/utils"
+import { useBranchDialogController } from "./use-branch-dialog-controller"
+import { useCommitHistoryController } from "./use-commit-history-controller"
+import {
+  useFileDiffLoader,
+  useGitInitialization,
+  useGitSnapshotPolling,
+  useSnapshotSelectionSync,
+} from "./use-git-tui-effects"
+import { useGitTuiKeyboard } from "./use-git-tui-keyboard"
+type RendererLike = {
+  destroy: () => void
+}
+
+export function useGitTuiController(renderer: RendererLike, config: StageConfig) {
+  const branchNameRef = useRef<InputRenderable>(null)
+  const summaryRef = useRef<InputRenderable>(null)
+  const descriptionRef = useRef<TextareaRenderable>(null)
+
+  const [git, setGit] = useState<GitClient | null>(null)
+  const [snapshot, setSnapshot] = useState<RepoSnapshot | null>(null)
+  const [fatalError, setFatalError] = useState<string | null>(null)
+
+  const [focus, setFocus] = useState<FocusTarget>("files")
+  const [fileIndex, setFileIndex] = useState(0)
+  const [excludedPaths, setExcludedPaths] = useState<Set<string>>(new Set())
+
+  const [summary, setSummary] = useState("")
+  const [descriptionRenderKey, setDescriptionRenderKey] = useState(0)
+  const [diffText, setDiffText] = useState("")
+  const [diffMessage, setDiffMessage] = useState<string | null>("No file selected")
+
+  const [commitDialogOpen, setCommitDialogOpen] = useState(false)
+  const [shortcutsDialogOpen, setShortcutsDialogOpen] = useState(false)
+  const [busy, setBusy] = useState<string | null>(null)
+  const [statusMessage, setStatusMessage] = useState("Initializing...")
+
+  const isBusy = busy !== null
+  const selectedFile = snapshot?.files[fileIndex] ?? null
+  const selectedFilePath = selectedFile?.path ?? null
+  const diffFiletype = inferFiletype(selectedFile?.path)
+
+  const fileRows = useMemo(
+    () => (snapshot?.files ?? []).map((file) => buildFileRow(file, excludedPaths)),
+    [excludedPaths, snapshot],
+  )
+  const gitOptions = useMemo(
+    () => ({
+      hideWhitespaceChanges: config.ui.hideWhitespaceChanges,
+      historyLimit: config.history.limit,
+      autoStageOnCommit: config.git.autoStageOnCommit,
+    }),
+    [config.git.autoStageOnCommit, config.history.limit, config.ui.hideWhitespaceChanges],
+  )
+
+  const refreshSnapshot = useCallback(async (): Promise<void> => {
+    if (!git) return
+    const next = await git.snapshot()
+    setSnapshot(next)
+  }, [git])
+
+  const getIncludedPaths = useCallback(
+    () =>
+      (snapshot?.files ?? [])
+        .map((file) => file.path)
+        .filter((path) => !excludedPaths.has(path)),
+    [excludedPaths, snapshot],
+  )
+
+  const runTask = useCallback(
+    async (label: string, task: () => Promise<void>): Promise<boolean> => {
+      if (isBusy) return false
+      setBusy(label)
+      setStatusMessage(`${label}...`)
+      try {
+        await task()
+        setStatusMessage(`${label} complete`)
+        return true
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        setStatusMessage(`Error: ${message}`)
+        return false
+      } finally {
+        setBusy(null)
+      }
+    },
+    [isBusy],
+  )
+
+  const openCommitDialog = useCallback(() => {
+    if (!git) {
+      setStatusMessage("Repository not ready.")
+      return
+    }
+    if ((snapshot?.files.length ?? 0) === 0) {
+      setStatusMessage("No working changes to commit.")
+      return
+    }
+    if (config.ai.enabled) {
+      const includedPaths = getIncludedPaths()
+      if (includedPaths.length === 0) {
+        setStatusMessage("No files selected for commit.")
+        return
+      }
+
+      void (async () => {
+        const succeeded = await runTask("AI COMMIT", async () => {
+          const summary = await generateAiCommitSummary({
+            git,
+            files: snapshot?.files ?? [],
+            selectedPaths: includedPaths,
+            aiConfig: config.ai,
+          })
+          await git.commit(summary, "", Array.from(excludedPaths), includedPaths)
+          setStatusMessage(`Committed: ${summary}`)
+          setSummary("")
+          setDescriptionRenderKey((value) => value + 1)
+          setCommitDialogOpen(false)
+          setFocus("files")
+          setExcludedPaths(new Set())
+          await refreshSnapshot()
+        })
+
+        if (!succeeded) {
+          setCommitDialogOpen(true)
+          setFocus("commit-summary")
+        }
+      })()
+      return
+    }
+    setCommitDialogOpen(true)
+    setFocus("commit-summary")
+  }, [config.ai, excludedPaths, getIncludedPaths, git, refreshSnapshot, runTask, snapshot])
+
+  const runTopAction = useCallback(
+    async (action: TopAction): Promise<void> => {
+      if (!git) return
+
+      if (action === "commit") {
+        openCommitDialog()
+        return
+      }
+
+      await runTask(action.toUpperCase(), async () => {
+        if (action === "refresh") {
+          await refreshSnapshot()
+          return
+        }
+        if (action === "fetch") {
+          await git.fetch()
+          await refreshSnapshot()
+          return
+        }
+        if (action === "pull") {
+          await git.pull()
+          await refreshSnapshot()
+          return
+        }
+        await git.push()
+        await refreshSnapshot()
+      })
+    },
+    [git, openCommitDialog, refreshSnapshot, runTask],
+  )
+
+  const commitChanges = useCallback(async (): Promise<void> => {
+    if (!git) return
+    const effectiveSummary = summaryRef.current?.value ?? summary
+    const description = descriptionRef.current?.plainText ?? ""
+    const includedPaths = getIncludedPaths()
+
+    await runTask("COMMIT", async () => {
+      await git.commit(effectiveSummary, description, Array.from(excludedPaths), includedPaths)
+      setSummary("")
+      setDescriptionRenderKey((value) => value + 1)
+      setCommitDialogOpen(false)
+      setFocus("files")
+      setExcludedPaths(new Set())
+      await refreshSnapshot()
+    })
+  }, [excludedPaths, getIncludedPaths, git, refreshSnapshot, runTask, summary])
+
+  const branchDialog = useBranchDialogController({
+    git,
+    snapshot,
+    refreshSnapshot,
+    runTask,
+    setFocus,
+    branchNameRef,
+  })
+  const commitHistory = useCommitHistoryController({
+    git,
+    refreshSnapshot,
+    runTask,
+    setFocus,
+  })
+
+  useGitInitialization({ setGit, setFatalError, setStatusMessage, gitOptions })
+  useGitSnapshotPolling({ git, refreshSnapshot, setStatusMessage })
+  useSnapshotSelectionSync({
+    snapshot,
+    fileIndex,
+    setFileIndex,
+    setExcludedPaths,
+    autoStageOnCommit: config.git.autoStageOnCommit,
+  })
+  useFileDiffLoader({ git, selectedFile, setDiffText, setDiffMessage })
+
+  const toggleSelectedFileInCommit = useCallback(() => {
+    if (!selectedFilePath) return
+    setExcludedPaths((current) => {
+      const next = new Set(current)
+      if (next.has(selectedFilePath)) {
+        next.delete(selectedFilePath)
+      } else {
+        next.add(selectedFilePath)
+      }
+      return next
+    })
+  }, [selectedFilePath])
+
+  useGitTuiKeyboard({
+    renderer,
+    commitDialogOpen,
+    branchDialogOpen: branchDialog.branchDialogOpen,
+    branchDialogMode: branchDialog.branchDialogMode,
+    historyDialogOpen: commitHistory.historyDialogOpen,
+    historyDialogMode: commitHistory.historyMode,
+    shortcutsDialogOpen,
+    setCommitDialogOpen,
+    setFocus,
+    focus,
+    fileCount: snapshot?.files.length ?? 0,
+    moveToPreviousFile: () => setFileIndex((current) => getPreviousIndex(current, snapshot?.files.length ?? 0)),
+    moveToNextFile: () => setFileIndex((current) => getNextIndex(current, snapshot?.files.length ?? 0)),
+    openBranchDialog: branchDialog.openBranchDialog,
+    closeBranchDialog: branchDialog.closeBranchDialog,
+    showBranchDialogList: branchDialog.showBranchDialogList,
+    submitBranchSelection: branchDialog.submitBranchSelection,
+    submitBranchStrategy: branchDialog.submitBranchStrategy,
+    openHistoryDialog: commitHistory.openHistoryDialog,
+    closeHistoryDialog: commitHistory.closeHistoryDialog,
+    backToHistoryCommitList: commitHistory.backToCommitList,
+    submitHistoryCommitSelection: commitHistory.submitHistoryCommitSelection,
+    submitHistoryAction: commitHistory.submitHistoryAction,
+    commitChanges,
+    createBranchAndCheckout: branchDialog.createBranchAndCheckout,
+    openCommitDialog,
+    openShortcutsDialog: () => setShortcutsDialogOpen(true),
+    closeShortcutsDialog: () => setShortcutsDialogOpen(false),
+    runTopAction,
+    toggleSelectedFileInCommit,
+  })
+
+  const tracking = snapshot
+    ? {
+        loading: false,
+        upstream: snapshot.upstream,
+        ahead: snapshot.ahead,
+        behind: snapshot.behind,
+      }
+    : {
+        loading: true,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+      }
+
+  return {
+    summaryRef,
+    descriptionRef,
+    focus,
+    currentBranch: snapshot?.branch ?? "...",
+    branchNameRef,
+    ...branchDialog,
+    ...commitHistory,
+    fileRows,
+    fileIndex,
+    selectedFilePath,
+    diffText,
+    diffMessage,
+    diffFiletype,
+    commitDialogOpen,
+    shortcutsDialogOpen,
+    summary,
+    descriptionRenderKey,
+    statusMessage,
+    fatalError,
+    isBusy,
+    tracking,
+    onSummaryInput: setSummary,
+  }
+}
+
+function getNextIndex(current: number, total: number): number {
+  if (total <= 0) return 0
+  return (current + 1) % total
+}
+
+function getPreviousIndex(current: number, total: number): number {
+  if (total <= 0) return 0
+  return (current - 1 + total) % total
+}

package/src/hooks/use-git-tui-effects.ts

@@ -0,0 +1,168 @@
+import { useEffect, useRef, type Dispatch, type SetStateAction } from "react"
+
+import { GitClient, type ChangedFile, type GitClientOptions, type RepoSnapshot } from "../git"
+
+type SetGit = Dispatch<SetStateAction<GitClient | null>>
+type SetString = Dispatch<SetStateAction<string>>
+type SetNullableString = Dispatch<SetStateAction<string | null>>
+type SetNumber = Dispatch<SetStateAction<number>>
+type SetExcludedPaths = Dispatch<SetStateAction<Set<string>>>
+
+type UseGitInitializationParams = {
+  setGit: SetGit
+  setFatalError: SetNullableString
+  setStatusMessage: SetString
+  gitOptions: GitClientOptions
+}
+
+export function useGitInitialization({ setGit, setFatalError, setStatusMessage, gitOptions }: UseGitInitializationParams) {
+  useEffect(() => {
+    let cancelled = false
+
+    async function init(): Promise<void> {
+      try {
+        const client = await GitClient.create(process.cwd(), gitOptions)
+        if (cancelled) return
+        setGit(client)
+        setFatalError(null)
+        setStatusMessage("Ready")
+      } catch (error) {
+        if (cancelled) return
+        const message = error instanceof Error ? error.message : String(error)
+        setFatalError(message)
+        setStatusMessage(`Error: ${message}`)
+      }
+    }
+
+    void init()
+    return () => {
+      cancelled = true
+    }
+  }, [gitOptions, setFatalError, setGit, setStatusMessage])
+}
+
+type UseGitSnapshotPollingParams = {
+  git: GitClient | null
+  refreshSnapshot: () => Promise<void>
+  setStatusMessage: SetString
+}
+
+export function useGitSnapshotPolling({ git, refreshSnapshot, setStatusMessage }: UseGitSnapshotPollingParams) {
+  useEffect(() => {
+    if (!git) return
+    let active = true
+
+    const sync = async () => {
+      if (!active) return
+      try {
+        await refreshSnapshot()
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        setStatusMessage(`Error: ${message}`)
+      }
+    }
+
+    void sync()
+    const timer = setInterval(() => void sync(), 4000)
+    return () => {
+      active = false
+      clearInterval(timer)
+    }
+  }, [git, refreshSnapshot, setStatusMessage])
+}
+
+type UseSnapshotSelectionSyncParams = {
+  snapshot: RepoSnapshot | null
+  fileIndex: number
+  setFileIndex: SetNumber
+  setExcludedPaths: SetExcludedPaths
+  autoStageOnCommit: boolean
+}
+
+export function useSnapshotSelectionSync({
+  snapshot,
+  fileIndex,
+  setFileIndex,
+  setExcludedPaths,
+  autoStageOnCommit,
+}: UseSnapshotSelectionSyncParams) {
+  const previousPathsRef = useRef<Set<string>>(new Set())
+
+  useEffect(() => {
+    if (!snapshot) return
+
+    const knownPaths = new Set(snapshot.files.map((file) => file.path))
+    const previousPaths = previousPathsRef.current
+    setExcludedPaths((current) => {
+      const next = new Set(Array.from(current).filter((path) => knownPaths.has(path)))
+
+      if (!autoStageOnCommit) {
+        for (const path of knownPaths) {
+          if (!previousPaths.has(path)) {
+            next.add(path)
+          }
+        }
+      }
+
+      if (next.size === current.size && Array.from(next).every((path) => current.has(path))) {
+        return current
+      }
+      return next
+    })
+
+    const nextFileIndex = Math.min(fileIndex, Math.max(snapshot.files.length - 1, 0))
+    if (nextFileIndex !== fileIndex) setFileIndex(nextFileIndex)
+    previousPathsRef.current = knownPaths
+  }, [autoStageOnCommit, fileIndex, setExcludedPaths, setFileIndex, snapshot])
+}
+
+type UseFileDiffLoaderParams = {
+  git: GitClient | null
+  selectedFile: ChangedFile | null
+  setDiffText: SetString
+  setDiffMessage: SetNullableString
+}
+
+export function useFileDiffLoader({ git, selectedFile, setDiffText, setDiffMessage }: UseFileDiffLoaderParams) {
+  const previousSelectedPathRef = useRef<string | null>(null)
+
+  useEffect(() => {
+    if (!git || !selectedFile) {
+      previousSelectedPathRef.current = null
+      setDiffText("")
+      setDiffMessage("No file selected")
+      return
+    }
+
+    const selectedPath = selectedFile.path
+    const pathChanged = previousSelectedPathRef.current !== selectedPath
+    previousSelectedPathRef.current = selectedPath
+
+    let cancelled = false
+    if (pathChanged) {
+      setDiffText("")
+      setDiffMessage(`Loading diff: ${selectedPath}`)
+    }
+
+    const loadDiff = async () => {
+      try {
+        const nextDiff = await git.diffForFile(selectedPath)
+        if (cancelled) return
+        setDiffText(nextDiff)
+        setDiffMessage(nextDiff.trim() ? null : `No diff output for ${selectedPath}`)
+      } catch (error) {
+        if (cancelled) return
+        const message = error instanceof Error ? error.message : String(error)
+        if (pathChanged) {
+          setDiffText("")
+        }
+        setDiffMessage(`Failed to load diff: ${message}`)
+      }
+    }
+
+    void loadDiff()
+    return () => {
+      cancelled = true
+    }
+  }, [git, selectedFile, setDiffMessage, setDiffText])
+}