git sync: Update Your Branch from main in One Command

#!/usr/bin/env bash
# Bring the current branch up to date in one step: fetch, fast-forward the
# default branch, then rebase (or merge) the current branch onto it.
#
# Usage: git sync [-m] [base]    (see -h)
set -euo pipefail

usage() {
  cat <<'EOF'
Usage: git sync [options] [base]

Fetch, fast-forward the local <base> branch, then rebase the current branch
onto it. <base> defaults to the remote's default branch (else main or master).

Options:
  -m, --merge    Merge <base> into the current branch instead of rebasing
  -h             Show this help (git sync --help opens Git's man page instead)
EOF
}

die() {
  printf 'git sync: %s\n' "$*" >&2
  exit 1
}

mode=rebase
base=

while [ $# -gt 0 ]; do
  case $1 in
    -m | --merge) mode=merge ;;
    -h | --help) usage; exit 0 ;;
    -*) die "unknown option '$1' (see -h)" ;;
    *)
      [ -z "$base" ] || die "unexpected argument '$1' (see -h)"
      base=$1
      ;;
  esac
  shift
done

git rev-parse --is-inside-work-tree >/dev/null 2>&1 || die "not inside a Git work tree"

# Checked before the branch: a stopped rebase also detaches HEAD, and that's the real problem.
git_dir=$(git rev-parse --git-dir)
for marker in rebase-merge rebase-apply MERGE_HEAD CHERRY_PICK_HEAD REVERT_HEAD BISECT_LOG; do
  [ ! -e "$git_dir/$marker" ] || die "a rebase, merge, cherry-pick, revert or bisect is in progress; finish it first"
done

branch=$(git symbolic-ref --quiet --short HEAD) || die "HEAD is detached; check out a branch first"

remote=$(git config --get "branch.$branch.remote" || echo origin)
[ "$remote" != . ] || remote=origin
git remote get-url "$remote" >/dev/null 2>&1 || die "no such remote '$remote'"
git fetch --prune --quiet "$remote" || die "fetch from '$remote' failed"

if [ -z "$base" ]; then
  base=$(git symbolic-ref --quiet --short "refs/remotes/$remote/HEAD" 2>/dev/null || true)
  base=${base#"$remote"/}
  if [ -z "$base" ]; then
    for candidate in main master; do
      if git rev-parse --quiet --verify "refs/remotes/$remote/$candidate" >/dev/null; then
        base=$candidate
        break
      fi
    done
  fi
  [ -n "$base" ] ||
    die "can't tell the default branch of '$remote'; run 'git remote set-head $remote --auto' or pass a base"
fi

# In a fork, the base usually tracks another remote (e.g. upstream) — sync against that one.
base_remote=$(git config --get "branch.$base.remote" || echo "$remote")
[ "$base_remote" != . ] || base_remote=$remote
if [ "$base_remote" != "$remote" ]; then
  git remote get-url "$base_remote" >/dev/null 2>&1 || die "no such remote '$base_remote'"
  git fetch --prune --quiet "$base_remote" || die "fetch from '$base_remote' failed"
fi

upstream="refs/remotes/$base_remote/$base"
target="$base_remote/$base"
git rev-parse --quiet --verify "$upstream" >/dev/null || die "no such branch '$target'"

# Fast-forward the local base without checking it out. A non-fast-forward
# means local commits on base that aren't on the remote — never discard those.
if [ "$branch" = "$base" ]; then
  git merge --ff-only --autostash --quiet "$upstream" ||
    die "'$base' has diverged from '$target'; resolve it by hand"
  echo "'$base' is up to date with '$target'."
  exit 0
fi

if git rev-parse --quiet --verify "refs/heads/$base" >/dev/null; then
  if git worktree list --porcelain | grep -qxF "branch refs/heads/$base"; then
    # Moving a branch under another worktree would leave its files stale;
    # rebasing onto the remote-tracking ref below is still correct.
    echo "note: '$base' is checked out in another worktree; not updating it." >&2
  elif git merge-base --is-ancestor "refs/heads/$base" "$upstream"; then
    git update-ref "refs/heads/$base" "$upstream" "$(git rev-parse "refs/heads/$base")"
  else
    echo "warning: local '$base' has commits not on '$target'; leaving it alone." >&2
  fi
fi

before=$(git rev-parse HEAD)
if [ "$mode" = merge ]; then
  git merge --autostash --no-edit "$target" ||
    die "merge stopped on conflicts; fix them and 'git commit', or 'git merge --abort'"
else
  git rebase --autostash "$upstream" ||
    die "rebase stopped on conflicts; fix them and 'git rebase --continue', or 'git rebase --abort'"
fi

if [ "$(git rev-parse HEAD)" = "$before" ]; then
  echo "'$branch' is already up to date with '$target'."
else
  # --keep (not --hard) so the undo never wipes the uncommitted changes autostash put back.
  echo "Synced '$branch' onto '$target'. Undo with: git reset --keep $before"
  if [ "$mode" = rebase ] && git rev-parse --quiet --verify "refs/remotes/$remote/$branch" >/dev/null; then
    echo "History was rewritten — push with 'git push --force-with-lease' (or 'git fix-dates')."
  fi
fi

mkdir -p ~/.local/bin
# Save the script above as ~/.local/bin/git-sync, then:
chmod +x ~/.local/bin/git-sync

# Make sure ~/.local/bin is on your PATH (add this to ~/.bashrc or ~/.zshrc)
export PATH="$HOME/.local/bin:$PATH"

git sync -h

git sync            # Rebase the current branch onto the latest default branch
git sync --merge    # Merge it in instead, for shared branches you mustn't rewrite
git sync develop    # Sync against a branch other than the default

$ git sync
Created autostash: 783582b
Applied autostash.
Successfully rebased and updated refs/heads/feat/search-index.
Synced 'feat/search-index' onto 'origin/main'. Undo with: git reset --keep 03432c8e5b1f9a7d24c6e80b3f15a9d7c2e4b618
History was rewritten — push with 'git push --force-with-lease' (or 'git fix-dates').