stage-tui 1.0.7

package/src/git.ts

@@ -0,0 +1,298 @@
+import { runGitRaw, type GitCommandResult } from "./git-process"
+import { normalizeBranchName } from "./git-branch-name"
+import { parseBranchLine, parseChangedFiles } from "./git-status-parser"
+export type ChangedFile = {
+  path: string
+  indexStatus: string
+  worktreeStatus: string
+  staged: boolean
+  unstaged: boolean
+  untracked: boolean
+  statusLabel: string
+}
+
+export type RepoSnapshot = {
+  root: string
+  branch: string
+  upstream: string | null
+  ahead: number
+  behind: number
+  branches: string[]
+  files: ChangedFile[]
+}
+
+export type CommitHistoryEntry = {
+  hash: string
+  shortHash: string
+  subject: string
+  relativeDate: string
+  author: string
+}
+export type GitClientOptions = {
+  hideWhitespaceChanges: boolean
+  historyLimit: number
+  autoStageOnCommit: boolean
+}
+const DEFAULT_GIT_CLIENT_OPTIONS: GitClientOptions = {
+  hideWhitespaceChanges: true,
+  historyLimit: 200,
+  autoStageOnCommit: true,
+}
+
+export class GitClient {
+  private constructor(
+    private readonly root: string,
+    private readonly options: GitClientOptions,
+  ) {}
+
+  static async create(cwd: string, options?: Partial<GitClientOptions>): Promise<GitClient> {
+    const rootResult = await runGitRaw(cwd, ["rev-parse", "--show-toplevel"])
+    if (rootResult.code !== 0) {
+      throw new Error(rootResult.stderr || "Current directory is not a git repository.")
+    }
+    const root = rootResult.stdout.trim()
+    if (!root) {
+      throw new Error("Failed to resolve git repository root.")
+    }
+    return new GitClient(root, {
+      hideWhitespaceChanges: options?.hideWhitespaceChanges ?? DEFAULT_GIT_CLIENT_OPTIONS.hideWhitespaceChanges,
+      historyLimit: options?.historyLimit ?? DEFAULT_GIT_CLIENT_OPTIONS.historyLimit,
+      autoStageOnCommit: options?.autoStageOnCommit ?? DEFAULT_GIT_CLIENT_OPTIONS.autoStageOnCommit,
+    })
+  }
+  async snapshot(): Promise<RepoSnapshot> {
+    const [statusResult, branchesResult] = await Promise.all([
+      this.runGit(["status", "--porcelain=v1", "--branch", "--untracked-files=all"]),
+      this.runGit(["for-each-ref", "--format=%(refname:short)", "refs/heads"]),
+    ])
+
+    const statusLines = statusResult.stdout.split("\n").filter(Boolean)
+    const branchInfo = parseBranchLine(statusLines[0] ?? "")
+    const files = parseChangedFiles(statusLines.slice(1))
+    const branches = branchesResult.stdout
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+
+    return {
+      root: this.root,
+      branch: branchInfo.branch,
+      upstream: branchInfo.upstream,
+      ahead: branchInfo.ahead,
+      behind: branchInfo.behind,
+      branches,
+      files,
+    }
+  }
+
+  async diffForFile(path: string): Promise<string> {
+    const whitespaceArgs = this.options.hideWhitespaceChanges ? ["-w"] : []
+    const [unstaged, staged] = await Promise.all([
+      this.runGit(["diff", ...whitespaceArgs, "--", path], true),
+      this.runGit(["diff", "--cached", ...whitespaceArgs, "--", path], true),
+    ])
+
+    const sections: string[] = []
+    if (staged.stdout.trim()) {
+      sections.push(`# Staged\n${staged.stdout.trimEnd()}`)
+    }
+    if (unstaged.stdout.trim()) {
+      sections.push(`# Unstaged\n${unstaged.stdout.trimEnd()}`)
+    }
+
+    if (sections.length > 0) {
+      return sections.join("\n\n")
+    }
+
+    const untracked = await this.runGit(["diff", "--no-index", ...whitespaceArgs, "--", "/dev/null", path], true)
+    if (untracked.stdout.trim()) {
+      return `# Untracked\n${untracked.stdout.trimEnd()}`
+    }
+
+    return ""
+  }
+
+  async fetch(): Promise<void> {
+    await this.runGit(["fetch", "--prune"])
+  }
+
+  async pull(): Promise<void> {
+    await this.runGit(["pull", "--ff-only"])
+  }
+
+  async push(): Promise<void> {
+    const hasHeadCommit = await this.runGit(["rev-parse", "--verify", "HEAD"], true)
+    if (hasHeadCommit.code !== 0) {
+      throw new Error("No commits yet. Create a commit before pushing.")
+    }
+
+    const branchResult = await this.runGit(["rev-parse", "--abbrev-ref", "HEAD"])
+    const branch = branchResult.stdout.trim()
+    if (!branch || branch === "HEAD") {
+      throw new Error("Cannot push from detached HEAD.")
+    }
+
+    const upstreamResult = await this.runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], true)
+    if (upstreamResult.code === 0) {
+      await this.runGit(["push"])
+      return
+    }
+
+    const remoteResult = await this.runGit(["remote"], true)
+    const remotes = remoteResult.stdout
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+
+    if (!remotes.includes("origin")) {
+      throw new Error("No upstream configured and remote 'origin' was not found.")
+    }
+
+    await this.runGit(["push", "--set-upstream", "origin", branch])
+  }
+
+  async listCommits(limit = this.options.historyLimit): Promise<CommitHistoryEntry[]> {
+    const result = await this.runGit([
+      "log",
+      `--max-count=${Math.max(limit, 1)}`,
+      "--date=relative",
+      "--pretty=format:%H%x1f%h%x1f%s%x1f%ar%x1f%an",
+    ], true)
+
+    if (result.code !== 0) {
+      const details = result.stderr || result.stdout
+      throw new Error(details || "Failed to load commit history.")
+    }
+    if (!result.stdout.trim()) return []
+
+    return result.stdout
+      .split("\n")
+      .map((line) => line.split("\u001f"))
+      .map(([hash, shortHash, subject, relativeDate, author]) => ({
+        hash: hash ?? "",
+        shortHash: shortHash ?? "",
+        subject: subject ?? "(no subject)",
+        relativeDate: relativeDate ?? "",
+        author: author ?? "",
+      }))
+      .filter((entry) => entry.hash.length > 0)
+  }
+
+  async checkout(branch: string): Promise<void> {
+    if (!branch.trim()) {
+      throw new Error("Branch name is required.")
+    }
+    await this.runGit(["checkout", branch])
+  }
+
+  async checkoutLeavingChanges(branch: string): Promise<void> {
+    await this.runWithStashedChanges(() => this.checkout(branch))
+  }
+
+  async checkoutCommit(commitHash: string): Promise<void> {
+    const hash = commitHash.trim()
+    if (!hash) throw new Error("Commit hash is required.")
+    await this.runGit(["checkout", hash])
+  }
+
+  async createAndCheckoutBranch(branchName: string): Promise<void> {
+    const name = normalizeBranchName(branchName)
+    if (!name) {
+      throw new Error("Branch name is required.")
+    }
+
+    const validation = await this.runGit(["check-ref-format", "--branch", name], true)
+    if (validation.code !== 0) {
+      throw new Error(`Invalid branch name: ${name}`)
+    }
+
+    await this.runGit(["checkout", "-b", name])
+  }
+
+  async createAndCheckoutBranchLeavingChanges(branchName: string): Promise<void> {
+    await this.runWithStashedChanges(() => this.createAndCheckoutBranch(branchName))
+  }
+
+  async revertCommit(commitHash: string): Promise<void> {
+    const hash = commitHash.trim()
+    if (!hash) throw new Error("Commit hash is required.")
+    await this.runGit(["revert", "--no-edit", hash])
+  }
+
+  async commit(summary: string, description: string, excludedPaths: string[] = [], includedPaths: string[] = []): Promise<void> {
+    const title = summary.trim()
+    if (!title) {
+      throw new Error("Commit summary is required.")
+    }
+
+    const selectedPaths = includedPaths.map((path) => path.trim()).filter(Boolean)
+    if (selectedPaths.length === 0) {
+      throw new Error("No files selected for commit.")
+    }
+
+    if (this.options.autoStageOnCommit) {
+      await this.runGit(["add", "-A"])
+    } else {
+      await this.runGit(["add", "-A", "--", ...selectedPaths])
+    }
+
+    const excluded = excludedPaths.map((path) => path.trim()).filter(Boolean)
+    if (excluded.length > 0) {
+      const stagedExcluded = await this.runGit(["diff", "--name-only", "--cached", "--", ...excluded], true)
+      const stagedExcludedPaths = stagedExcluded.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+      if (stagedExcludedPaths.length > 0) {
+        await this.runGit(["reset", "--", ...stagedExcludedPaths])
+      }
+    }
+
+    const hasStagedChanges = await this.runGit(["diff", "--cached", "--quiet"], true)
+    if (hasStagedChanges.code === 0) {
+      throw new Error("No files selected for commit.")
+    }
+
+    const args = ["commit", "-m", title]
+    if (description.trim()) {
+      args.push("-m", description.trim())
+    }
+    await this.runGit(args)
+  }
+
+  private async runGit(args: string[], allowFailure = false): Promise<GitCommandResult> {
+    const result = await runGitRaw(this.root, args)
+    if (result.code !== 0 && !allowFailure) {
+      const details = result.stderr || result.stdout
+      throw new Error(details || `git ${args.join(" ")} failed with code ${result.code}.`)
+    }
+    return result
+  }
+
+  private async runWithStashedChanges(task: () => Promise<void>): Promise<void> {
+    const marker = `stage-tui-leave-${Date.now()}`
+    const stashResult = await this.runGit(["stash", "push", "-u", "-m", marker], true)
+    if (stashResult.code !== 0) {
+      const details = stashResult.stderr || stashResult.stdout
+      throw new Error(details || "Failed to stash working changes.")
+    }
+
+    const output = `${stashResult.stdout}\n${stashResult.stderr}`.toLowerCase()
+    const stashed = output.includes("saved working directory") || output.includes("saved index state")
+    if (!stashed) {
+      await task()
+      return
+    }
+
+    try {
+      await task()
+    } catch (error) {
+      const restoreResult = await this.runGit(["stash", "pop"], true)
+      if (restoreResult.code !== 0) {
+        const message = error instanceof Error ? error.message : String(error)
+        throw new Error(`${message} Also failed to restore stashed changes automatically.`)
+      }
+      throw error
+    }
+  }
+}

package/src/hooks/use-branch-dialog-controller.ts

@@ -0,0 +1,188 @@
+import type { InputRenderable, SelectOption } from "@opentui/core"
+import { useCallback, useMemo, useState, type Dispatch, type RefObject, type SetStateAction } from "react"
+
+import type { GitClient, RepoSnapshot } from "../git"
+import type { FocusTarget } from "../ui/types"
+
+type BranchDialogMode = "select" | "create" | "confirm"
+type BranchChangeStrategy = "bring" | "leave"
+type PendingBranchAction =
+  | { kind: "checkout"; branch: string }
+  | { kind: "create"; branchName: string }
+
+type RunTask = (label: string, task: () => Promise<void>) => Promise<boolean>
+
+type UseBranchDialogControllerParams = {
+  git: GitClient | null
+  snapshot: RepoSnapshot | null
+  refreshSnapshot: () => Promise<void>
+  runTask: RunTask
+  setFocus: Dispatch<SetStateAction<FocusTarget>>
+  branchNameRef: RefObject<InputRenderable | null>
+}
+
+const CREATE_BRANCH_VALUE = "__create_branch__"
+const BRANCH_STRATEGY_OPTIONS: SelectOption[] = [
+  { name: "bring working changes", description: "Carry local changes onto the new branch", value: "bring" },
+  { name: "leave changes on current branch", description: "Stash changes and switch cleanly", value: "leave" },
+]
+
+export function useBranchDialogController({
+  git,
+  snapshot,
+  refreshSnapshot,
+  runTask,
+  setFocus,
+  branchNameRef,
+}: UseBranchDialogControllerParams) {
+  const [branchDialogOpen, setBranchDialogOpen] = useState(false)
+  const [branchDialogMode, setBranchDialogMode] = useState<BranchDialogMode>("select")
+  const [branchIndex, setBranchIndex] = useState(0)
+  const [branchStrategyIndex, setBranchStrategyIndex] = useState(0)
+  const [pendingBranchAction, setPendingBranchAction] = useState<PendingBranchAction | null>(null)
+  const [newBranchName, setNewBranchName] = useState("")
+
+  const branchOptions = useMemo<SelectOption[]>(
+    () => [
+      ...(snapshot?.branches ?? []).map((branch) => ({
+        name: branch,
+        description: branch === snapshot?.branch ? "Current branch" : "Checkout branch",
+        value: branch,
+      })),
+      { name: "+ create new branch...", description: "Create and checkout", value: CREATE_BRANCH_VALUE },
+    ],
+    [snapshot],
+  )
+
+  const branchOptionsKey = useMemo(
+    () => branchOptions.map((option) => String(option.value)).join("|"),
+    [branchOptions],
+  )
+
+  const openBranchDialog = useCallback(() => {
+    setBranchDialogOpen(true)
+    setBranchDialogMode("select")
+    setPendingBranchAction(null)
+    setNewBranchName("")
+    setBranchStrategyIndex(0)
+    setFocus("branch-dialog-list")
+
+    const currentBranchIndex = snapshot?.branches.findIndex((branch) => branch === snapshot.branch) ?? -1
+    setBranchIndex(currentBranchIndex >= 0 ? currentBranchIndex : 0)
+  }, [setFocus, snapshot])
+
+  const closeBranchDialog = useCallback(() => {
+    setBranchDialogOpen(false)
+    setBranchDialogMode("select")
+    setPendingBranchAction(null)
+    setBranchStrategyIndex(0)
+    setNewBranchName("")
+    setFocus("files")
+  }, [setFocus])
+
+  const showBranchCreateInput = useCallback(() => {
+    setBranchDialogMode("create")
+    setPendingBranchAction(null)
+    setBranchStrategyIndex(0)
+    setNewBranchName("")
+    setFocus("branch-create")
+  }, [setFocus])
+
+  const showBranchDialogList = useCallback(() => {
+    setBranchDialogMode("select")
+    setPendingBranchAction(null)
+    setBranchStrategyIndex(0)
+    setFocus("branch-dialog-list")
+    setNewBranchName("")
+  }, [setFocus])
+
+  const performBranchTransition = useCallback(
+    async (action: PendingBranchAction, strategy: BranchChangeStrategy): Promise<void> => {
+      if (!git) return
+      const labelTarget = action.kind === "checkout" ? action.branch : action.branchName
+      const label = `${action.kind === "checkout" ? "CHECKOUT" : "CREATE BRANCH"} ${labelTarget} (${strategy})`
+      const succeeded = await runTask(label, async () => {
+        if (action.kind === "checkout") {
+          if (strategy === "leave") {
+            await git.checkoutLeavingChanges(action.branch)
+          } else {
+            await git.checkout(action.branch)
+          }
+        } else if (strategy === "leave") {
+          await git.createAndCheckoutBranchLeavingChanges(action.branchName)
+        } else {
+          await git.createAndCheckoutBranch(action.branchName)
+        }
+        await refreshSnapshot()
+      })
+
+      if (succeeded) {
+        closeBranchDialog()
+      }
+    },
+    [closeBranchDialog, git, refreshSnapshot, runTask],
+  )
+
+  const requestBranchTransition = useCallback(
+    async (action: PendingBranchAction): Promise<void> => {
+      if ((snapshot?.files.length ?? 0) > 0) {
+        setPendingBranchAction(action)
+        setBranchStrategyIndex(0)
+        setBranchDialogMode("confirm")
+        setFocus("branch-dialog-list")
+        return
+      }
+      await performBranchTransition(action, "bring")
+    },
+    [performBranchTransition, setFocus, snapshot],
+  )
+
+  const submitBranchSelection = useCallback(async (): Promise<void> => {
+    if (!snapshot) return
+    const selected = branchOptions[branchIndex]
+    const optionValue = typeof selected?.value === "string" ? selected.value : selected?.name
+    if (!optionValue) return
+
+    if (optionValue === CREATE_BRANCH_VALUE) {
+      showBranchCreateInput()
+      return
+    }
+    if (optionValue === snapshot.branch) {
+      closeBranchDialog()
+      return
+    }
+    await requestBranchTransition({ kind: "checkout", branch: optionValue })
+  }, [branchIndex, branchOptions, closeBranchDialog, requestBranchTransition, showBranchCreateInput, snapshot])
+
+  const createBranchAndCheckout = useCallback(async (): Promise<void> => {
+    const branchName = branchNameRef.current?.value ?? newBranchName
+    await requestBranchTransition({ kind: "create", branchName })
+  }, [branchNameRef, newBranchName, requestBranchTransition])
+
+  const submitBranchStrategy = useCallback(async (): Promise<void> => {
+    if (!pendingBranchAction) return
+    const selectedOption = BRANCH_STRATEGY_OPTIONS[branchStrategyIndex]
+    const selectedValue = selectedOption?.value === "leave" ? "leave" : "bring"
+    await performBranchTransition(pendingBranchAction, selectedValue)
+  }, [branchStrategyIndex, pendingBranchAction, performBranchTransition])
+
+  return {
+    branchDialogOpen,
+    branchDialogMode,
+    branchOptions,
+    branchOptionsKey,
+    branchIndex,
+    branchStrategyOptions: BRANCH_STRATEGY_OPTIONS,
+    branchStrategyIndex,
+    newBranchName,
+    openBranchDialog,
+    closeBranchDialog,
+    showBranchDialogList,
+    submitBranchSelection,
+    submitBranchStrategy,
+    createBranchAndCheckout,
+    onBranchDialogChange: setBranchIndex,
+    onBranchStrategyChange: setBranchStrategyIndex,
+    onBranchNameInput: setNewBranchName,
+  }
+}

package/src/hooks/use-commit-history-controller.ts

@@ -0,0 +1,130 @@
+import type { SelectOption } from "@opentui/core"
+import { useCallback, useMemo, useState, type Dispatch, type SetStateAction } from "react"
+
+import type { CommitHistoryEntry, GitClient } from "../git"
+import type { FocusTarget } from "../ui/types"
+
+type CommitHistoryMode = "list" | "action"
+type RunTask = (label: string, task: () => Promise<void>) => Promise<boolean>
+
+type UseCommitHistoryControllerParams = {
+  git: GitClient | null
+  refreshSnapshot: () => Promise<void>
+  runTask: RunTask
+  setFocus: Dispatch<SetStateAction<FocusTarget>>
+}
+
+const ACTION_OPTIONS: SelectOption[] = [
+  { name: "revert commit", description: "Create a new commit that reverts this one", value: "revert" },
+  { name: "checkout commit", description: "Move HEAD to this commit (detached)", value: "checkout" },
+]
+
+export function useCommitHistoryController({
+  git,
+  refreshSnapshot,
+  runTask,
+  setFocus,
+}: UseCommitHistoryControllerParams) {
+  const [historyDialogOpen, setHistoryDialogOpen] = useState(false)
+  const [historyMode, setHistoryMode] = useState<CommitHistoryMode>("list")
+  const [commitOptions, setCommitOptions] = useState<SelectOption[]>([])
+  const [selectedCommit, setSelectedCommit] = useState<CommitHistoryEntry | null>(null)
+  const [commitIndex, setCommitIndex] = useState(0)
+  const [actionIndex, setActionIndex] = useState(0)
+
+  const selectedCommitTitle = useMemo(() => {
+    if (!selectedCommit) return ""
+    return `${selectedCommit.shortHash} ${selectedCommit.subject}`
+  }, [selectedCommit])
+
+  const openHistoryDialog = useCallback(async (): Promise<void> => {
+    if (!git) return
+
+    const succeeded = await runTask("LOAD HISTORY", async () => {
+      const commits = await git.listCommits()
+      if (commits.length === 0) {
+        throw new Error("No commits found in this repository.")
+      }
+
+      const options = commits.map((commit) => ({
+        name: `${commit.shortHash} ${commit.subject}`,
+        description: `${commit.relativeDate} by ${commit.author}`,
+        value: commit,
+      }))
+
+      setCommitOptions(options)
+      setCommitIndex(0)
+      setSelectedCommit(commits[0] ?? null)
+      setActionIndex(0)
+      setHistoryMode("list")
+      setHistoryDialogOpen(true)
+      setFocus("history-commits")
+    })
+
+    if (!succeeded) {
+      setHistoryDialogOpen(false)
+    }
+  }, [git, runTask, setFocus])
+
+  const closeHistoryDialog = useCallback(() => {
+    setHistoryDialogOpen(false)
+    setHistoryMode("list")
+    setSelectedCommit(null)
+    setActionIndex(0)
+    setFocus("files")
+  }, [setFocus])
+
+  const backToCommitList = useCallback(() => {
+    setHistoryMode("list")
+    setFocus("history-commits")
+  }, [setFocus])
+
+  const submitHistoryCommitSelection = useCallback(async (): Promise<void> => {
+    const selectedOption = commitOptions[commitIndex]
+    const commit = selectedOption?.value as CommitHistoryEntry | undefined
+    if (!commit) return
+
+    setSelectedCommit(commit)
+    setActionIndex(0)
+    setHistoryMode("action")
+    setFocus("history-actions")
+  }, [commitIndex, commitOptions, setFocus])
+
+  const submitHistoryAction = useCallback(async (): Promise<void> => {
+    if (!git || !selectedCommit) return
+
+    const selectedAction = ACTION_OPTIONS[actionIndex]
+    const action = selectedAction?.value === "checkout" ? "checkout" : "revert"
+    const label = `${action.toUpperCase()} ${selectedCommit.shortHash}`
+
+    const succeeded = await runTask(label, async () => {
+      if (action === "revert") {
+        await git.revertCommit(selectedCommit.hash)
+      } else {
+        await git.checkoutCommit(selectedCommit.hash)
+      }
+      await refreshSnapshot()
+    })
+
+    if (succeeded) {
+      closeHistoryDialog()
+    }
+  }, [actionIndex, closeHistoryDialog, git, refreshSnapshot, runTask, selectedCommit])
+
+  return {
+    historyDialogOpen,
+    historyMode,
+    commitOptions,
+    commitIndex,
+    actionOptions: ACTION_OPTIONS,
+    actionIndex,
+    selectedCommitTitle,
+    openHistoryDialog,
+    closeHistoryDialog,
+    backToCommitList,
+    submitHistoryCommitSelection,
+    submitHistoryAction,
+    onCommitIndexChange: setCommitIndex,
+    onActionIndexChange: setActionIndex,
+  }
+}