Git Commands Cheatsheet

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

git config --global core.editor "vim"
git config --global core.editor "code --wait"  # VS Code

git config --list
git config --global --list
git config --local --list
git config user.name  # Get specific value

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'

git config --global core.autocrlf input   # Linux/Mac
git config --global core.autocrlf true    # Windows

git config --global init.defaultBranch main

git init
git init my-project
git init --bare  # Create bare repository for remote

git clone https://github.com/user/repo.git
git clone git@github.com:user/repo.git  # SSH
git clone https://github.com/user/repo.git my-folder
git clone --depth 1 https://github.com/user/repo.git  # Shallow clone
git clone --branch develop https://github.com/user/repo.git

git status
git status -s   # Short format
git status -sb  # Short format with branch

git remote add origin https://github.com/user/repo.git
git remote add upstream https://github.com/original/repo.git
git remote -v  # View remotes
git remote show origin  # Detailed info

git remote set-url origin https://github.com/user/new-repo.git
git remote set-url origin git@github.com:user/repo.git  # Switch to SSH

git remote remove origin
git remote rm upstream

git branch              # Local branches
git branch -r           # Remote branches
git branch -a           # All branches
git branch -v           # With last commit
git branch -vv          # With tracking info

git branch feature-name
git branch feature-name commit-hash  # From specific commit

git checkout branch-name
git switch branch-name  # Git 2.23+

git checkout -b feature-name
git switch -c feature-name  # Git 2.23+
git checkout -b feature-name origin/feature-name  # Track remote

git branch -d feature-name   # Safe delete (merged only)
git branch -D feature-name   # Force delete
git push origin --delete feature-name  # Delete remote branch

git branch -m old-name new-name
git branch -m new-name  # Rename current branch

git branch --set-upstream-to=origin/main main
git branch -u origin/main  # Short form

git add file.txt
git add .               # All files in current directory
git add -A              # All files in repository
git add *.js            # Pattern matching
git add -p              # Interactive staging (patch mode)

git reset HEAD file.txt
git restore --staged file.txt  # Git 2.23+
git reset HEAD .               # Unstage all

git commit -m "Commit message"
git commit -am "Message"  # Add and commit tracked files
git commit --amend        # Amend last commit
git commit --amend --no-edit  # Amend without changing message

git commit --allow-empty -m "Trigger CI"

git commit -S -m "Signed commit"
git config --global commit.gpgsign true  # Always sign

git fetch
git fetch origin
git fetch --all           # All remotes
git fetch --prune         # Remove deleted remote branches
git fetch origin branch-name

git pull
git pull origin main
git pull --rebase         # Rebase instead of merge
git pull --ff-only        # Fast-forward only

git push
git push origin main
git push -u origin feature-name  # Set upstream and push
git push --force          # Force push (dangerous!)
git push --force-with-lease  # Safer force push
git push --all            # Push all branches
git push --tags           # Push all tags

git remote set-url --add --push origin https://github.com/user/repo1.git
git remote set-url --add --push origin https://github.com/user/repo2.git

git log
git log --oneline
git log --oneline --graph
git log --oneline --graph --all
git log --oneline --decorate

git log -p              # Show patches/diffs
git log -p -2           # Last 2 commits
git log --stat          # Show file statistics
git log --shortstat     # Abbreviated stats

git log --since="2 weeks ago"
git log --until="2024-01-01"
git log --author="John"
git log --grep="fix"    # Search commit messages
git log -S "function_name"  # Search code changes (pickaxe)
git log -- file.txt     # Commits affecting specific file

git log --pretty=format:"%h - %an, %ar : %s"
git log --pretty=format:"%h %s" --graph
git log --oneline --graph --all --decorate

git show commit-hash
git show HEAD
git show HEAD~3         # 3 commits before HEAD
git show branch-name:file.txt  # File from specific branch

git diff                # Unstaged changes
git diff --staged       # Staged changes
git diff HEAD           # All changes
git diff branch1 branch2
git diff commit1 commit2
git diff --stat         # Summary only

git blame file.txt
git blame -L 10,20 file.txt  # Specific lines
git blame -C file.txt        # Detect moved/copied lines

git checkout -- file.txt
git restore file.txt    # Git 2.23+
git checkout .          # Discard all changes

git reset --soft HEAD~1   # Keep changes staged
git reset --mixed HEAD~1  # Keep changes unstaged (default)
git reset --hard HEAD~1   # Discard changes (dangerous!)
git reset commit-hash     # Reset to specific commit

git revert commit-hash
git revert HEAD
git revert HEAD~3
git revert --no-commit commit-hash  # Stage revert without committing

git clean -n            # Dry run
git clean -f            # Remove untracked files
git clean -fd           # Remove files and directories
git clean -fX           # Remove ignored files only
git clean -fx           # Remove untracked and ignored files

git checkout commit-hash -- file.txt
git restore --source=commit-hash file.txt

git merge feature-branch
git merge --no-ff feature-branch  # Create merge commit
git merge --squash feature-branch # Squash commits

git merge -s recursive feature-branch
git merge -s ours feature-branch      # Keep our version
git merge -X theirs feature-branch    # Prefer their changes

git merge --abort

git diff
git diff --name-only --diff-filter=U  # List conflicted files
git status

# Edit conflicted files, then:
git add file.txt
git commit
 
# Or use tools:
git mergetool
git checkout --ours file.txt    # Use our version
git checkout --theirs file.txt  # Use their version

git rebase main
git rebase origin/main
git rebase -i HEAD~5    # Interactive rebase last 5 commits

# During interactive rebase:
# pick   = use commit
# reword = use commit, but edit message
# edit   = use commit, but stop for amending
# squash = use commit, but meld into previous
# fixup  = like squash, but discard message
# drop   = remove commit

git rebase --continue
git rebase --skip
git rebase --abort

git rebase --onto new-base old-base feature-branch

git rebase -p main  # Deprecated
git rebase --rebase-merges main  # Git 2.18+

git stash
git stash save "Work in progress"
git stash -u            # Include untracked files
git stash -a            # Include ignored files

git stash list
git stash show          # Show latest stash
git stash show stash@{1}
git stash show -p       # Show diff

git stash apply
git stash apply stash@{1}
git stash pop           # Apply and remove

git stash drop
git stash drop stash@{1}
git stash clear         # Remove all stashes

git stash branch new-branch-name
git stash branch new-branch stash@{1}

git tag v1.0.0
git tag v1.0.0 commit-hash

git tag -a v1.0.0 -m "Release version 1.0.0"
git tag -a v1.0.0 commit-hash -m "Message"

git tag
git tag -l "v1.*"       # Pattern matching
git show v1.0.0         # Show tag details

git push origin v1.0.0
git push origin --tags  # Push all tags
git push --follow-tags  # Push commits and tags

git tag -d v1.0.0
git push origin --delete v1.0.0  # Delete remote tag
git push origin :refs/tags/v1.0.0  # Alternative

# Feature development
git checkout -b feature/new-feature develop
# Work and commit
git checkout develop
git merge --no-ff feature/new-feature
git branch -d feature/new-feature
 
# Release
git checkout -b release/1.0 develop
# Finalize release
git checkout main
git merge --no-ff release/1.0
git tag -a v1.0 -m "Version 1.0"
git checkout develop
git merge --no-ff release/1.0
git branch -d release/1.0
 
# Hotfix
git checkout -b hotfix/critical-bug main
# Fix and commit
git checkout main
git merge --no-ff hotfix/critical-bug
git tag -a v1.0.1
git checkout develop
git merge --no-ff hotfix/critical-bug
git branch -d hotfix/critical-bug

# Always work on main or short-lived feature branches
git checkout -b feature-123
# Small, frequent commits
git push origin feature-123
# Quick merge to main
git checkout main
git merge feature-123
git branch -d feature-123

# Fork repository on GitHub, then:
git clone git@github.com:yourname/repo.git
git remote add upstream git@github.com:original/repo.git
 
# Keep fork updated
git fetch upstream
git checkout main
git merge upstream/main
git push origin main
 
# Create feature branch
git checkout -b feature-name
git push origin feature-name
# Create pull request on GitHub

git cherry-pick commit-hash
git cherry-pick commit1 commit2
git cherry-pick --no-commit commit-hash  # Stage without committing
git cherry-pick --continue
git cherry-pick --abort

git bisect start
git bisect bad          # Current commit is bad
git bisect good v1.0    # Known good commit
# Git checks out middle commit, test it
git bisect good  # or bad
# Repeat until found
git bisect reset

git submodule add https://github.com/user/repo.git path/to/submodule
git submodule init
git submodule update
git submodule update --remote  # Update to latest
git clone --recurse-submodules https://github.com/user/repo.git

git subtree add --prefix=lib/plugin https://github.com/user/repo.git main --squash
git subtree pull --prefix=lib/plugin https://github.com/user/repo.git main --squash
git subtree push --prefix=lib/plugin https://github.com/user/repo.git main

git archive --format=zip --output=project.zip HEAD
git archive --format=tar.gz --output=project.tar.gz HEAD
git archive --format=zip HEAD:path/to/dir > dir.zip

git bundle create repo.bundle --all
git clone repo.bundle my-repo
git bundle create repo.bundle HEAD main

git worktree add ../feature-branch feature-branch
git worktree list
git worktree remove ../feature-branch
git worktree prune

git sparse-checkout init
git sparse-checkout set folder1 folder2
git sparse-checkout add folder3
git sparse-checkout list

# Remove file from all history
git filter-branch --tree-filter 'rm -f passwords.txt' HEAD
 
# Change email in all commits
git filter-branch --commit-filter '
    if [ "$GIT_AUTHOR_EMAIL" = "old@example.com" ]; then
        GIT_AUTHOR_EMAIL="new@example.com"
    fi
    git commit-tree "$@"
' HEAD

git reflog
git reflog show HEAD
git reflog show branch-name
git reset --hard HEAD@{2}  # Restore from reflog

git clone --depth 1 https://github.com/user/repo.git
git fetch --depth=100  # Deepen history
git fetch --unshallow  # Convert to full clone

git lfs install
git lfs track "*.psd"
git add .gitattributes
git lfs ls-files
git lfs migrate import --include="*.zip"

# .git/hooks/pre-commit
#!/bin/bash
npm test
 
# .git/hooks/commit-msg
#!/bin/bash
# Enforce commit message format
grep -E '^(feat|fix|docs|style|refactor|test|chore): .+' "$1"
 
# .git/hooks/pre-push
#!/bin/bash
npm run build

# hooks/pre-receive
#!/bin/bash
# Reject commits with TODO
 
# hooks/update
#!/bin/bash
# Check branch permissions
 
# hooks/post-receive
#!/bin/bash
# Trigger deployment

# Make executable
chmod +x .git/hooks/pre-commit
 
# Share hooks (commit to repo)
mkdir .githooks
git config core.hooksPath .githooks

git branch temp-branch
git checkout main
git merge temp-branch

git reflog
git checkout -b recovered-branch commit-hash

git reflog
git reset --hard commit-hash-before-force-push
git push --force-with-lease

# Committed to main instead of feature branch
git branch feature-branch  # Create branch from current
git reset --hard origin/main  # Reset main
git checkout feature-branch

# Using BFG Repo Cleaner (faster than filter-branch)
java -jar bfg.jar --delete-files passwords.txt
java -jar bfg.jar --replace-text passwords.txt
git reflog expire --expire=now --all
git gc --prune=now --aggressive

git config core.autocrlf true
git rm --cached -r .
git reset --hard

git gc --aggressive --prune=now
git repack -a -d --depth=250 --window=250

git rev-list --objects --all | \
  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | \
  sed -n 's/^blob //p' | \
  sort --numeric-sort --key=2 | \
  tail -n 10

git config --global core.preloadindex true
git config --global core.fscache true
git config --global gc.auto 256
git config --global feature.manyFiles true

# Create branch from current state
git branch feature/my-feature
 
# Reset main to origin
git reset --hard origin/main
 
# Switch to feature branch
git checkout feature/my-feature
 
# Verify changes are there
git log

# Find lost commits
git reflog
 
# Identify the commit hash before reset
# Recover
git reset --hard HEAD@{2}
 
# Or create branch from it
git checkout -b recovery-branch abc123

# Pull latest changes
git pull origin main
 
# Conflict occurs
# CONFLICT (content): Merge conflict in file.txt
 
# View conflicted files
git status
 
# Edit file.txt, look for:
<<<<<<< HEAD
Your changes
=======
Their changes
>>>>>>> branch-name
 
# Keep desired changes, remove markers
 
# Stage resolved file
git add file.txt
 
# Complete merge
git commit
 
# Or use merge tool
git mergetool

# Interactive rebase
git rebase -i HEAD~5
 
# In editor, change all except first to 'squash':
pick abc123 First commit
squash def456 Second commit
squash ghi789 Third commit
squash jkl012 Fourth commit
squash mno345 Fifth commit
 
# Save and edit commit message
git push --force-with-lease

# Revert the commit (creates new commit)
git revert commit-hash
 
# Or revert multiple commits
git revert oldest-hash..newest-hash
 
# Push
git push origin main

# Find commits you want
git log feature-branch
 
# Cherry-pick them
git checkout main
git cherry-pick abc123
git cherry-pick def456
 
# If conflicts, resolve and continue
git add .
git cherry-pick --continue
 
# Push
git push origin main

# Reset to previous commit, keeping changes
git reset HEAD~1
 
# Stage changes incrementally
git add -p  # Interactive staging
 
# Commit first set
git commit -m "First logical change"
 
# Stage and commit second set
git add -p
git commit -m "Second logical change"

# Add upstream remote (once)
git remote add upstream https://github.com/original/repo.git
 
# Fetch upstream changes
git fetch upstream
 
# Merge into your main
git checkout main
git merge upstream/main
 
# Or rebase for cleaner history
git rebase upstream/main
 
# Push to your fork
git push origin main

# Using BFG (recommended)
java -jar bfg.jar --delete-files secrets.txt
git reflog expire --expire=now --all
git gc --prune=now --aggressive
git push --force
 
# Or using filter-branch
git filter-branch --force --index-filter \
  'git rm --cached --ignore-unmatch secrets.txt' \
  --prune-empty --tag-name-filter cat -- --all
 
git push --force --all
git push --force --tags

# Start bisect
git bisect start
 
# Mark current as bad
git bisect bad
 
# Mark known good version
git bisect good v1.0
 
# Git checks out middle commit
# Test the code
npm test
 
# Mark result
git bisect good  # or 'bad'
 
# Repeat until found
# Git will identify the exact commit
 
# Reset
git bisect reset

# Use MERGE when:
# - Preserving complete history is important
# - Working with public/shared branches
# - Want to see when features were integrated
git checkout main
git merge feature-branch
 
# Use REBASE when:
# - Want linear history
# - Working on private feature branches
# - Before creating pull request
git checkout feature-branch
git rebase main
git push --force-with-lease origin feature-branch
 
# Golden rule: Never rebase public history

# Interactive staging
git add -p file.txt
 
# Options:
# y - stage this hunk
# n - don't stage this hunk
# s - split into smaller hunks
# e - manually edit the hunk
# q - quit
 
# Commit staged changes
git commit -m "Partial changes"
 
# Remaining changes stay unstaged

# Add multiple push URLs
git remote set-url --add --push origin https://github.com/user/repo.git
git remote set-url --add --push origin https://gitlab.com/user/repo.git
 
# Verify
git remote -v
 
# Now git push pushes to both
git push

# During development - commit frequently
git add .
git commit -m "WIP: partial implementation"
 
# Before creating PR - clean up commits
git rebase -i origin/main
 
# Squash WIP commits
pick abc123 Feature: Add user authentication
fixup def456 WIP: partial implementation
fixup ghi789 WIP: fixing tests
fixup jkl012 WIP: cleanup
 
# Force push to feature branch
git push --force-with-lease

# Tag with project prefix
git tag -a frontend/v1.0.0 -m "Frontend Release 1.0.0"
git tag -a backend/v2.1.0 -m "Backend Release 2.1.0"
 
# View tags for specific project
git tag -l "frontend/*"
 
# Sparse checkout for CI/CD
git sparse-checkout set frontend/
npm run build
 
# Or use git worktrees for parallel development
git worktree add ../frontend-hotfix frontend/main
git worktree add ../backend-feature backend/develop

# Daily workflow
git pull
git checkout -b feature/xyz
# Make changes
git add .
git commit -m "message"
git push -u origin feature/xyz
 
# Update feature branch
git checkout feature/xyz
git rebase main
git push --force-with-lease
 
# Clean merge
git checkout main
git merge --no-ff feature/xyz
git push
git branch -d feature/xyz

git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
git config --global alias.undo "reset --soft HEAD~1"
git config --global alias.amend "commit --amend --no-edit"
git config --global alias.cleanup "!git branch --merged | grep -v '\\*\\|main\\|develop' | xargs -n 1 git branch -d"