git-undo-wizard

Git Undo Wizard

Recover from any Git mistake safely.

When to Use

• Accidentally committed to wrong branch
• Need to undo a commit (before or after push)
• Accidentally deleted a branch or file
• Need to recover lost commits
• Want to undo a merge
• Committed sensitive data by mistake

Quick Reference

Situation	Command
Undo last commit, keep changes	git reset --soft HEAD~1
Undo last commit, discard changes	git reset --hard HEAD~1
Undo changes to a file	git checkout -- <file>
Undo staged changes	git reset HEAD <file>
Undo a pushed commit	git revert <commit>
Recover deleted branch	git reflog + git checkout -b <branch> <sha>

Scenarios & Solutions

1. Undo Last Commit (Not Pushed)

Keep the changes (just uncommit):

git reset --soft HEAD~1
# Changes are now staged, ready to recommit

Unstage the changes too:

git reset HEAD~1
# Changes are in working directory, not staged

Discard everything (dangerous):

git reset --hard HEAD~1
# Changes are gone forever

2. Undo Last Commit (Already Pushed)

Safe way (creates a new "undo" commit):

git revert HEAD
git push
# This creates a new commit that undoes the previous one

If you MUST rewrite history (only on your own branch):

git reset --hard HEAD~1
git push --force-with-lease
# Never do this on shared branches!

3. Committed to Wrong Branch

Move commit to correct branch:

# Note the commit hash
git log -1  # Copy the hash

# Go to correct branch
git checkout correct-branch

# Cherry-pick the commit
git cherry-pick <commit-hash>

# Go back and remove from wrong branch
git checkout wrong-branch
git reset --hard HEAD~1

4. Undo Changes to a File

Discard unstaged changes:

git checkout -- <filename>
# Or in newer Git:
git restore <filename>

Unstage a file (keep changes):

git reset HEAD <filename>
# Or in newer Git:
git restore --staged <filename>

Restore file to specific commit:

git checkout <commit-hash> -- <filename>

5. Recover Deleted Branch

# Find the last commit of deleted branch
git reflog

# Look for entries like "checkout: moving from deleted-branch to main"
# Note the SHA before deletion

# Recreate the branch
git checkout -b recovered-branch <sha>

6. Recover Lost Commits

# Git reflog shows ALL recent HEAD movements
git reflog

# Find your lost commit
# Example output:
# abc1234 HEAD@{0}: reset: moving to HEAD~3
# def5678 HEAD@{1}: commit: Important work  <-- This one!

# Recover it
git checkout -b recovery-branch def5678
# Or cherry-pick it
git cherry-pick def5678

7. Undo a Merge

If not pushed:

git reset --hard HEAD~1
# Or to specific commit before merge:
git reset --hard <commit-before-merge>

If already pushed:

git revert -m 1 <merge-commit-hash>
git push

8. Committed Sensitive Data

If not pushed:

# Remove from last commit
git reset --soft HEAD~1
# Remove sensitive file
git rm --cached <sensitive-file>
# Add to .gitignore
echo "sensitive-file" >> .gitignore
# Recommit
git add .
git commit -m "Remove sensitive data"

If already pushed (requires rewriting history):

# Use git-filter-repo (install first)
git filter-repo --path <sensitive-file> --invert-paths

# Force push all branches (coordinate with team!)
git push --force --all

9. Undo Staged Changes

# Unstage everything
git reset

# Unstage specific file
git reset HEAD <file>

# Keep file staged but undo modifications
git checkout HEAD -- <file>

10. Completely Start Over

# Discard ALL local changes and commits
git fetch origin
git reset --hard origin/main

# Or clean untracked files too
git clean -fd

The Reflog Safety Net

Git reflog is your time machine. It tracks every HEAD movement for ~90 days.

# See recent history
git reflog

# See with timestamps
git reflog --date=relative

# Recover ANY previous state
git reset --hard HEAD@{5}  # Go back 5 operations

Best Practices

1. Before dangerous operations:

   git stash  # Save work in progress
   # or
   git branch backup-branch  # Create safety branch
   

2. Use --force-with-lease instead of --force:

   git push --force-with-lease  # Fails if remote changed
   

3. Check before reset:

   git log --oneline -10  # See what you're about to affect
   

Common Mistakes to Avoid

• Using --force on shared branches
• Running reset --hard without checking git stash list
• Forgetting that reflog is local only
• Not making a backup branch before risky operations