# Find the merge commit
git log --oneline --merges -5
# a1b2c3d  Merge branch 'feature/broken' into main
# ...
 
# Revert the merge commit
git revert -m 1 a1b2c3d

git revert -m 1 a1b2c3d
git push origin main    # Safe — no force push needed

# 1. The merge was reverted
git revert -m 1 a1b2c3d    # Commit R
 
# 2. Fix the feature branch
git checkout feature/broken
# ... make fixes ...
git commit -m "fix: resolve the bugs"
 
# 3. Revert the revert (re-introduces the original changes)
git checkout main
git revert <hash-of-R>
 
# 4. Now merge the fixes
git merge feature/broken

git checkout feature/broken
git rebase main
# Now the commits have new hashes — Git treats them as new work
git checkout main
git merge feature/broken

# Move main back to before the merge
git checkout main
git reset --hard HEAD~1      # or: git reset --hard <commit-before-merge>
 
# Force push to rewrite the remote
git push --force-with-lease origin main

# Undo the most recent commit
git revert HEAD
git push origin main
 
# Undo a specific older commit
git revert abc1234
git push origin main
 
# Undo multiple consecutive commits (oldest to newest order)
git revert --no-commit abc1234..def5678
git commit -m "revert: undo commits abc1234 through def5678"
git push origin main

# Remove the last commit from history
git reset --hard HEAD~1
git push --force-with-lease origin main
 
# Remove the last 3 commits
git reset --hard HEAD~3
git push --force-with-lease origin main

# Using git-filter-repo (recommended over filter-branch)
pip install git-filter-repo
 
# Remove a specific file from all history
git filter-repo --invert-paths --path secrets.env
 
# Remove a specific string from all files in history
git filter-repo --replace-text <(echo 'my-api-key==>REDACTED')

# View the reflog
git reflog
# abc1234 HEAD@{0}: reset: moving to HEAD~3        ← you reset
# def5678 HEAD@{1}: commit: feat: add dashboard     ← lost commit 3
# 789abcd HEAD@{2}: commit: feat: add sidebar       ← lost commit 2
# 012efgh HEAD@{3}: commit: feat: add header        ← lost commit 1
# 345ijkl HEAD@{4}: checkout: moving from feature to main

# Oops! You reset too far
git reset --hard HEAD~3    # Lost 3 commits!
 
# Find them in the reflog
git reflog
# Current HEAD is 345ijkl
# HEAD@{1} was def5678 (the commit before the reset)
 
# Recover by resetting back
git reset --hard def5678
 
# Or create a new branch from the lost commit
git branch recovered-work def5678

# Delete a branch by accident
git branch -D feature/important-work
# Deleted branch feature/important-work (was abc1234).
 
# Git helpfully tells you the commit hash!
# But if you missed it, use reflog:
git reflog
# abc1234 HEAD@{5}: commit: last commit on feature/important-work
 
# Recreate the branch
git branch feature/important-work abc1234

# You accidentally dropped a stash
git stash drop stash@{0}
 
# Stash entries create commits too — find them
git fsck --unreachable | grep commit
# unreachable commit abc1234def5678...
 
# Inspect each unreachable commit to find your stash
git show abc1234
 
# If that's the one, apply it
git stash apply abc1234

# Rebase went wrong
git rebase main    # Conflicts everywhere, wrong result
 
# ORIG_HEAD saves you — Git sets it before dangerous operations
git reset --hard ORIG_HEAD
 
# Or use the reflog to find the pre-rebase state
git reflog
# Find the entry just before "rebase: ..."
git reset --hard HEAD@{N}

# Default expiration: 90 days for reachable, 30 days for unreachable
git config gc.reflogExpire            # default: 90 days
git config gc.reflogExpireUnreachable  # default: 30 days
 
# Extend for extra safety
git config --global gc.reflogExpire 180.days
git config --global gc.reflogExpireUnreachable 90.days
 
# View reflog with timestamps
git reflog --date=iso

# Checking out a specific commit
git checkout abc1234
 
# Checking out a tag
git checkout v1.0.0
 
# Checking out a remote branch directly
git checkout origin/main
 
# During an interactive rebase (temporary — normal)
git rebase -i HEAD~3

# Simply go back to a branch
git checkout main
# or
git switch main

# Option 1: Create a branch right where you are
git checkout -b my-new-branch
# You're now on a proper branch with your commits
 
# Option 2: If you already switched away and need to recover
git reflog
# Find the detached commit
git branch recovered-work abc1234

# Just switch to any branch — the detached commits will eventually be garbage collected
git checkout main

git switch main                  # safe — switches branches
git switch --detach v1.0.0       # explicit — you know what you're doing
git switch --detach abc1234      # explicit
 
git checkout abc1234             # silently detaches HEAD (confusing)

git pull origin main
# Git creates a merge commit combining both sides
 
#               D ── E ─╲
#              ╱          M   (merge commit)
# A ── B ── C           ╱
#              ╲        ╱
#               F ── G ── H

git pull --rebase origin main
# Your commits are replayed on top of the remote's commits
 
# A ── B ── C ── F ── G ── H ── D'── E'
#                                (your commits reapplied)

# If YOUR version is correct and the remote is wrong
git push --force-with-lease origin main

# If the REMOTE version is correct and your local is wrong
git reset --hard origin/main

# See what you have that the remote doesn't
git log --oneline origin/main..HEAD
# D: feat: add search
# E: feat: add filters
 
# See what the remote has that you don't
git log --oneline HEAD..origin/main
# F: fix: login bug
# G: refactor: database layer
# H: feat: add caching
 
# Visual comparison
git log --oneline --left-right --graph HEAD...origin/main
# < D feat: add search
# < E feat: add filters
# > F fix: login bug
# > G refactor: database layer
# > H feat: add caching

# Dry run — show what WOULD be deleted (ALWAYS do this first)
git clean -n
# Would remove build/
# Would remove temp.log
# Would remove .DS_Store
 
# Actually delete untracked files
git clean -f
 
# Delete untracked files AND directories
git clean -fd
 
# Delete untracked AND ignored files (nuclear option)
git clean -fdx
 
# Delete only ignored files (clean build artifacts, keep new files)
git clean -fdX

git clean -i
# Would remove the following items:
#   build/    temp.log    .DS_Store
#
# *** Commands ***
#     1: clean    2: filter by pattern    3: select by numbers
#     4: ask each    5: quit    6: help
# What now>

# Clean everything except specific patterns
git clean -fd --exclude="*.log"
 
# Clean only within a specific directory
git clean -fd -- build/
 
# The safest workflow:
git clean -n              # 1. Preview
git clean -i              # 2. Interactive (or -f if preview looks right)

# Create a worktree for a hotfix (new directory, existing branch)
git worktree add ../project-hotfix main
 
# Create a worktree with a new branch
git worktree add ../project-experiment -b experiment/new-idea
 
# Create a worktree for a specific commit or tag
git worktree add ../project-v1 v1.0.0
 
# List all worktrees
git worktree list
# /Users/you/code/project            abc1234 [feature/search]
# /Users/you/code/project-hotfix     def5678 [main]
# /Users/you/code/project-experiment 789abcd [experiment/new-idea]

# You're working on a feature
cd ~/code/project
# ... lots of uncommitted work in progress ...
 
# Urgent bug! Create a worktree for the fix (no stashing needed)
git worktree add ../project-hotfix main
cd ../project-hotfix
 
# Fix the bug on main
echo "fix applied" >> bugfix.js
git add . && git commit -m "fix: critical login bug"
git push origin main
 
# Go back to your feature work (exactly as you left it)
cd ../project
# ... continue where you left off ...
 
# Clean up the worktree when done
git worktree remove ../project-hotfix

# List worktrees
git worktree list
 
# Remove a worktree (deletes the directory)
git worktree remove ../project-hotfix
 
# If the directory was already deleted manually
git worktree prune
 
# Move a worktree to a different directory
git worktree move ../project-hotfix ../hotfix-workspace
 
# Lock a worktree (prevent accidental removal)
git worktree lock ../project-hotfix
git worktree unlock ../project-hotfix

# Review a PR
git fetch origin pull/42/head:pr-42
git worktree add ../review-pr-42 pr-42
cd ../review-pr-42
# ... run, test, review ...
cd ../project
git worktree remove ../review-pr-42

# Discard changes in a tracked file (working directory)
git restore app.js
 
# Unstage a file (keep changes in working directory)
git restore --staged app.js
 
# Restore a file to a specific commit's version
git restore --source=HEAD~3 app.js
 
# Restore everything to the last commit
git restore .

# Switch to an existing branch
git switch main
 
# Create and switch to a new branch
git switch -c feature/new
 
# Switch with uncommitted changes (carries them along if no conflicts)
git switch feature/other
 
# Switch to a branch, discarding local changes (dangerous)
git switch -f main

# After a merge
git merge feature
# ORIG_HEAD = where HEAD was before the merge
git reset --hard ORIG_HEAD    # undo the merge
 
# After a rebase
git rebase main
git reset --hard ORIG_HEAD    # undo the rebase
 
# After a reset
git reset --hard HEAD~5
git reset --hard ORIG_HEAD    # undo the reset (go back)

# Find all unreachable objects
git fsck --unreachable
 
# Find dangling commits (commits not referenced by any branch or tag)
git fsck --lost-found
 
# Lost objects are saved to .git/lost-found/
ls .git/lost-found/commit/
# Shows hashes of recoverable commits
 
# Inspect them
git show <hash>
 
# Recover one
git branch recovered <hash>

mkdir recovery-lab && cd recovery-lab
git init
 
# Create some history to work with
echo "line 1" > file.txt
git add . && git commit -m "commit 1"
 
echo "line 2" >> file.txt
git add . && git commit -m "commit 2"
 
echo "line 3" >> file.txt
git add . && git commit -m "commit 3"
 
echo "line 4" >> file.txt
git add . && git commit -m "commit 4"
 
echo "line 5" >> file.txt
git add . && git commit -m "commit 5"
 
git log --oneline
# Should show 5 commits

# 1. Record the current state
git log --oneline
# Save the hash of "commit 5" mentally
 
# 2. "Accidentally" reset to commit 2
git reset --hard HEAD~3
git log --oneline
# Only commits 1 and 2 remain!
 
# 3. Panic! Then remember the reflog
git reflog
# You should see HEAD@{1} pointing to "commit 5"
 
# 4. Recover
git reset --hard HEAD@{1}
git log --oneline
# All 5 commits are back!

# 1. Create a branch with unique work
git checkout -b feature/important
echo "important work" > important.txt
git add . && git commit -m "feat: critical feature"
echo "more important work" >> important.txt
git add . && git commit -m "feat: extend critical feature"
 
# 2. Go back to main and delete the branch
git checkout main
git branch -D feature/important
# Note the hash Git reports!
 
# 3. Try to check it out (fails)
git checkout feature/important
# error: pathspec 'feature/important' did not match any file(s)
 
# 4. Find it in the reflog
git reflog | grep "critical feature"
# You'll see the commit hash
 
# 5. Recreate the branch
git branch feature/important HEAD@{2}   # adjust the reflog index
git checkout feature/important
git log --oneline
# Both commits should be there plus the original 5

# 1. Go to detached HEAD
git checkout main
git log --oneline -3   # note the hash of "commit 3"
git checkout HEAD~2    # detach HEAD at commit 3
 
# 2. Git warns you about detached HEAD — make commits anyway
echo "detached work 1" > detached.txt
git add . && git commit -m "work in detached HEAD 1"
 
echo "detached work 2" >> detached.txt
git add . && git commit -m "work in detached HEAD 2"
 
# 3. Now save this work to a branch BEFORE switching
git checkout -b saved-detached-work
git log --oneline
# Shows commit 1-3 + your two detached commits
 
# 4. Go back to main
git checkout main
git log --oneline
# main still has commits 1-5 (unaffected)
 
# 5. Merge or cherry-pick the detached work if needed
git merge saved-detached-work

# 1. Create a "broken" feature branch
git checkout main
git checkout -b feature/broken
echo "BROKEN CODE" > broken.txt
git add . && git commit -m "feat: add broken feature"
 
# 2. Merge it into main
git checkout main
git merge --no-ff feature/broken -m "Merge feature/broken into main"
 
# 3. Realize it's broken — revert the merge
git log --oneline -3  # Note the merge commit hash
git revert -m 1 HEAD  # HEAD is the merge commit
 
# 4. Verify
cat broken.txt 2>/dev/null || echo "broken.txt is gone (reverted successfully)"
git log --oneline -3
# Shows: revert commit, merge commit, commit 5

# 1. Create various untracked files and directories
mkdir -p build/output
echo "compiled" > build/output/app.min.js
echo "temporary" > temp.log
echo "notes" > scratch.txt
 
# Also create an ignored file
echo "build/" > .gitignore
echo "*.log" >> .gitignore
git add .gitignore && git commit -m "chore: add gitignore"
 
# 2. See the current state
git status
# Untracked: scratch.txt (temp.log and build/ are ignored)
 
# 3. Dry run — see what clean would delete
git clean -n
# Would remove scratch.txt
 
git clean -dn
# Would remove scratch.txt (directories shown with -d)
 
git clean -dnx
# Would remove build/ scratch.txt temp.log (ignored files too with -x)
 
git clean -dnX
# Would remove build/ temp.log (ONLY ignored files with -X)
 
# 4. Remove only untracked (non-ignored) files
git clean -f
ls scratch.txt 2>/dev/null || echo "scratch.txt removed"
ls temp.log         # still exists (ignored)
ls build/output/    # still exists (ignored)
 
# 5. Remove ignored files
git clean -fdX
ls temp.log 2>/dev/null || echo "temp.log removed"
ls build/ 2>/dev/null || echo "build/ removed"

# 1. Make some uncommitted changes on main (simulating in-progress work)
git checkout main
echo "work in progress" >> file.txt
git status
# modified: file.txt (not committed)
 
# 2. Urgent bug! Create a worktree for the fix
git worktree add ../recovery-lab-hotfix main~1 -b hotfix/urgent
 
# 3. List worktrees
git worktree list
# Shows both the main worktree and the hotfix worktree
 
# 4. Fix the bug in the hotfix worktree
cd ../recovery-lab-hotfix
echo "bug fixed" > bugfix.txt
git add . && git commit -m "fix: urgent production bug"
 
# 5. Go back to main worktree — your changes are still there!
cd ../recovery-lab
git status
# modified: file.txt  (still has your in-progress work!)
 
# 6. Clean up the worktree
git worktree remove ../recovery-lab-hotfix
git worktree list
# Only the main worktree remains

# 1. Set up a "remote" bare repo
git init --bare /tmp/diverge-test.git
git remote add test-remote /tmp/diverge-test.git
git push test-remote main
 
# 2. Create divergence — push from a parallel clone
git clone /tmp/diverge-test.git /tmp/diverge-other
cd /tmp/diverge-other
echo "remote change 1" >> file.txt
git add . && git commit -m "remote: change 1"
echo "remote change 2" >> file.txt
git add . && git commit -m "remote: change 2"
git push origin main
 
# 3. Make local commits in our original repo (without fetching)
cd ~/recovery-lab
echo "local change 1" > local.txt
git add . && git commit -m "local: change 1"
echo "local change 2" > local2.txt
git add . && git commit -m "local: change 2"
 
# 4. Try to push (will fail — diverged!)
git push test-remote main
# ! [rejected] main -> main (fetch first)
 
# 5. Fetch and see the divergence
git fetch test-remote
git status
# Your branch and 'test-remote/main' have diverged
 
# 6. Diagnose
git log --oneline --left-right HEAD...test-remote/main
# < local: change 1
# < local: change 2
# > remote: change 1
# > remote: change 2
 
# 7. Resolve with rebase (linear history)
git rebase test-remote/main
# Resolve any conflicts...
git push test-remote main