How to fix fatal: Not possible to fast-forward, aborting. in Git

First, examine the relationship between your local and remote branches:

# Fetch the latest changes without merging
git fetch origin

# See how your branch differs from the remote
git log --oneline --graph HEAD origin/main

Replace main with your branch name. This shows you:
- Your local commits (on your branch)
- Remote commits (on origin/branch)
- Where they diverged

Example diverged output:

* abc1234 (HEAD -> main) Your local commit
| * def5678 (origin/main) Their remote commit
|/
* 789abcd Common ancestor

If you see a fork like this, your branches have diverged and need to be reconciled.

The cleanest solution is to rebase your local commits on top of the remote changes:

git pull --rebase origin main

Or simply:

git pull --rebase

What this does:
1. Fetches remote changes
2. Temporarily removes your local commits
3. Applies the remote commits
4. Replays your local commits on top

Result: A clean, linear history without merge commits.

If you encounter conflicts during rebase:

# Fix conflicts in the affected files, then:
git add <fixed-files>
git rebase --continue

# Or abort if you want to try a different approach:
git rebase --abort

If you prefer to keep a record of the branch divergence, use a merge:

# Explicitly allow merge commits
git pull --no-ff origin main

Or fetch and merge separately:

git fetch origin
git merge origin/main

What this does:
Creates a merge commit that combines both lines of development.

Pros:
- Preserves the exact history of what happened
- Easier to resolve complex conflicts
- Can be undone with a single git revert

Cons:
- Creates extra merge commits
- History can become harder to read

If you have uncommitted changes preventing the pull:

# Save your uncommitted changes
git stash

# Pull the remote changes
git pull

# Reapply your stashed changes
git stash pop

Note: This only helps with uncommitted changes. If you have local commits, use one of the other approaches.

If you have both uncommitted changes AND local commits:

# Stash uncommitted changes first
git stash

# Then rebase your commits
git pull --rebase

# Finally, restore your uncommitted changes
git stash pop

To avoid this error in the future, configure Git to rebase by default when pulling:

For a specific repository:

git config pull.rebase true

For all repositories (global):

git config --global pull.rebase true

Alternative: Allow merge commits during pull:

# Remove the ff-only restriction
git config pull.ff false

Check your current pull configuration:

git config --get pull.ff
git config --get pull.rebase

Available pull.ff values:
- only - Only fast-forward (causes this error when not possible)
- true - Fast-forward when possible, otherwise merge
- false - Always create a merge commit

Warning: This discards local commit history. Only use if you're sure.

If your local history is very complicated and you want to start fresh:

# Save your current changes to a backup branch
git branch backup-my-work

# Reset your branch to match the remote exactly
git fetch origin
git reset --hard origin/main

# Cherry-pick specific commits from your backup if needed
git cherry-pick <commit-hash>

Or, if you just want to preserve your file changes (not commits):

# Create a patch of your changes
git diff origin/main > my-changes.patch

# Reset to remote
git reset --hard origin/main

# Apply your changes as uncommitted modifications
git apply my-changes.patch

This gives you a clean slate with the remote history while preserving your work.

If someone force-pushed to the remote branch (rewrote history), you need special handling:

Check if the remote was force-pushed:

git fetch origin
git log --oneline origin/main  # Look for unfamiliar commit hashes

If the remote was force-pushed and you have no local changes to keep:

git fetch origin
git reset --hard origin/main

If you have local commits to preserve:

# Create a backup
git branch backup-before-force-push

# Rebase your work onto the new remote history
git fetch origin
git rebase origin/main

# If there are conflicts, resolve them and continue
git rebase --continue

Prevent force-push issues in the future:
- Enable branch protection rules on your repository
- Require pull request reviews before merging
- Avoid using git push --force on shared branches (use --force-with-lease instead)