Git Command Reference

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config list --show-origin          # all settings and where each comes from (2.46+; older: --list)
git config get user.email              # read one value (2.46+; older: git config user.email)
git config --global --edit             # open ~/.gitconfig in the editor
git config --global alias.lg "log --oneline --graph --decorate --all"

git init                                   # new repository in the current directory
git init --object-format=sha256 <dir>      # SHA-256 object IDs (not interoperable with SHA-1 remotes)
git clone <url>                            # full clone into ./<repo-name>
git clone <url> <dir>                      # into a chosen directory
git clone --branch <branch> <url>          # check out a specific branch or tag
git clone --recurse-submodules <url>       # include submodules

git status                     # working tree and index status
git status -s                  # short format
git add <path>                 # stage a file or directory
git add -A                     # stage everything, including deletions, in the whole tree
git add -p                     # choose hunks interactively
git add -u                     # stage modifications and deletions of tracked files only
git rm <file>                  # delete and stage the deletion
git rm --cached <file>         # stop tracking but keep the file on disk
git mv <old> <new>             # rename and stage

git commit -m "Message"        # commit the index
git commit                     # write the message in the editor
git commit -am "Message"       # stage all tracked modifications, then commit (skips untracked files)
git commit --amend             # replace the last commit with index + new message
git commit --amend --no-edit   # add staged changes to the last commit, keep its message
git commit --fixup=<commit>    # record a fix to be squashed into <commit> by rebase --autosquash
git commit -S -m "Message"     # sign the commit

git diff                       # working tree vs index (unstaged changes)
git diff --staged              # index vs HEAD (what will be committed)
git diff HEAD                  # working tree vs HEAD (everything uncommitted)
git diff main...feature        # changes on feature since it diverged from main
git diff --stat                # per-file summary
git diff --name-status         # file names with A/M/D status
git diff --word-diff           # word-level changes (prose, long lines)
git diff --check               # whitespace errors and leftover conflict markers
git range-diff main old-feature new-feature   # compare two versions of a rebased branch

git log --oneline --graph --decorate --all
git log -p <path>                         # patches touching a path
git log --follow -p <file>                # continue across renames
git log --stat -5                         # last five commits with file statistics
git log --author="Ada" --since="2 weeks ago"
git log --grep="timeout" -i               # search commit messages
git log -S "parse_config"                 # commits that add or remove this string ("pickaxe")
git log -G "retr(y|ies)"                  # commits whose diff matches a regex
git log -L :parse_config:src/config.py    # history of one function
git log main..feature                     # commits on feature not yet on main
git log --format="%h %an %ar %s"          # custom format

git show <commit>                  # message and diff
git show <commit>:<path>           # file contents at that commit
git blame <file>                   # last commit to touch each line
git blame -w -C <file>             # ignore whitespace; detect lines moved from other files
git shortlog -sn                   # commit counts per author
git describe --tags                # nearest tag, e.g. v2.3.0-14-g1a2b3c4
git grep -n "TODO"                 # search tracked files (fast, respects .gitignore)
git last-modified                  # last commit to touch each path (2.52+)
git repo info                      # repository properties such as object format (2.52+)

git branch                         # local branches (* marks the current one)
git branch -a                      # include remote-tracking branches
git branch -vv                     # with upstream and ahead/behind counts
git branch --merged main           # branches already merged into main
git branch <name> [<start>]        # create without switching
git branch -m <old> <new>          # rename
git branch -d <name>               # delete if merged
git branch -D <name>               # delete regardless

git switch <branch>                # change branch
git switch -c <branch> [<start>]   # create and switch
git switch -                       # previous branch
git switch --detach <commit>       # inspect an arbitrary commit
git checkout <branch>              # pre-2.23 equivalent of switch
git checkout -b <branch>           # pre-2.23 equivalent of switch -c

git merge <branch>                 # merge into the current branch
git merge --no-ff <branch>         # always create a merge commit
git merge --ff-only <branch>       # succeed only if no merge commit is needed
git merge --squash <branch>        # stage the branch's combined changes; you then commit
git merge --abort                  # abandon a conflicted merge
git mergetool                      # open the configured merge tool on conflicts

git rebase <upstream>              # replay current branch's commits onto <upstream>
git rebase --onto <new> <old> <b>  # move commits after <old> on <b> onto <new>
git rebase -i HEAD~5               # edit the last five commits interactively
git rebase -i --autosquash main    # apply --fixup commits automatically
git rebase --update-refs main      # also move branches stacked on this one (2.38+)
git rebase --rebase-merges main    # preserve merge commits in the rebased range
git rebase --continue              # after resolving a conflict
git rebase --skip                  # drop the conflicting commit
git rebase --abort                 # return to the pre-rebase state

git cherry-pick <commit>           # apply one commit's changes onto the current branch
git cherry-pick A^..B              # a range, A through B inclusive
git cherry-pick -x <commit>        # append "(cherry picked from ...)" to the message
git cherry-pick --continue        # after resolving a conflict (or --abort)
git revert <commit>                # new commit that undoes <commit>
git revert -m 1 <merge-commit>     # undo a merge, keeping parent 1 (the branch merged into)
git revert --no-commit A..B        # revert a range as a single commit

git remote -v                      # list remotes with URLs
git remote add <name> <url>
git remote set-url origin <url>    # e.g. switch from HTTPS to SSH
git remote rename <old> <new>
git remote remove <name>

git fetch                          # update remote-tracking branches from the upstream remote
git fetch --all --prune            # every remote; drop branches deleted upstream
git pull                           # fetch, then merge or rebase (see pull.rebase)
git pull --rebase                  # fetch, then rebase
git push                           # push the current branch to its upstream
git push -u origin <branch>        # first push; set upstream
git push origin --delete <branch>  # delete a remote branch
git push --force-with-lease        # overwrite only if the remote is where you last saw it
git push --force-with-lease --force-if-includes   # also require that you have integrated it (2.30+)

git restore <file>                     # discard working-tree changes (2.23+; older: git checkout -- <file>)
git restore --staged <file>            # unstage (2.23+; older: git reset HEAD <file>)
git restore --source=<commit> <file>   # restore a file's content from another commit
git clean -n                           # preview untracked files that would be deleted
git clean -fd                          # delete untracked files and directories
git reset --soft HEAD~1                # undo the last commit, keep changes staged
git reset HEAD~1                       # undo the last commit, keep changes unstaged (--mixed)
git reset --hard HEAD~1                # undo the last commit and discard its changes
git reset --hard @{u}                  # make the branch match its upstream exactly

git stash                          # stash tracked changes (staged and unstaged)
git stash -u                       # include untracked files
git stash push -m "wip: parser" -- src/parser.py   # stash specific paths with a message
git stash list
git stash show -p stash@{1}        # view a stash's diff
git stash pop                      # apply the most recent stash and drop it
git stash apply stash@{1}          # apply without dropping
git stash branch <name> stash@{1}  # new branch from the stash's base, with the stash applied
git stash drop stash@{1}
git stash clear                    # delete all stashes

git tag                            # list
git tag -l "v2.*"                  # list matching a pattern
git tag v2.3.0                     # lightweight tag (a bare pointer)
git tag -a v2.3.0 -m "Release 2.3.0"   # annotated tag (tagger, date, message)
git tag -s v2.3.0 -m "Release 2.3.0"   # signed annotated tag
git push origin v2.3.0             # push one tag
git push --follow-tags             # push annotated tags reachable from pushed commits
git tag -d v2.3.0                  # delete locally
git push origin --delete v2.3.0    # delete on the remote

git bisect start
git bisect bad                     # the current commit is broken
git bisect good v2.2.0             # this one worked
# Git checks out a midpoint; test it, then mark it:
git bisect good                    # or: git bisect bad, or git bisect skip if untestable
git bisect reset                   # finish and return to the original branch

git bisect run ./test.sh           # automate: exit 0 = good, 125 = skip, other non-zero = bad

git worktree add ../hotfix hotfix/login     # check out an existing branch in ../hotfix
git worktree add -b review ../review main   # create a new branch there
git worktree list
git worktree remove ../hotfix
git worktree prune                          # clean up records of deleted directories

# Monorepo: blobless clone limited to two directories
git clone --filter=blob:none --sparse <url>
cd repo
git sparse-checkout set services/api libs/common
git sparse-checkout list
git sparse-checkout add docs
git sparse-checkout disable        # back to a full working tree

# Manual maintenance
git maintenance run                # run the scheduled tasks now
git gc                             # repack and remove unreachable objects past expiry
git fsck                           # verify object integrity

# SSH signing
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true
git config --global tag.gpgsign true

# Local verification needs a list of trusted signers
git config --global gpg.ssh.allowedSignersFile ~/.config/git/allowed_signers
echo "you@example.com $(cat ~/.ssh/id_ed25519.pub)" >> ~/.config/git/allowed_signers

git log --show-signature -1
git verify-commit <commit>
git verify-tag v2.3.0

# git-filter-repo is the tool recommended by the Git project (install via pip or a package manager)
git filter-repo --invert-paths --path config/secrets.yml   # drop a file from all history
git filter-repo --replace-text expressions.txt             # replace strings, e.g. "SECRET==>***"
git push --force --all && git push --force --tags

git config core.hooksPath .githooks          # use hooks committed to the repository

pip install pre-commit                       # or: pipx install pre-commit
pre-commit install                           # install hooks from .pre-commit-config.yaml
pre-commit run --all-files

# VS Code as editor and diff tool
git config --global core.editor "code --wait"
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'

# GitHub CLI
gh repo clone <owner>/<repo>
gh pr create --fill
gh pr checkout <number>
gh pr view --web