# Your commit history during development:
abc1234 Add user authentication feature
def5678 Fix typo in auth function  # Oops, should be part of abc1234
ghi9012 Add tests for authentication
jkl3456 Fix missing error handling  # Should be part of abc1234
mno7890 Update documentation

git rebase -i HEAD~5

# Interactive todo list appears:
pick abc1234 Add user authentication feature
pick def5678 Fix typo in auth function
pick ghi9012 Add tests for authentication
pick jkl3456 Fix missing error handling
pick mno7890 Update documentation

# Must manually reorder and change commands:
pick abc1234 Add user authentication feature
fixup def5678 Fix typo in auth function
fixup jkl3456 Fix missing error handling
pick ghi9012 Add tests for authentication
pick mno7890 Update documentation

# During development, commit with special prefixes:
git commit -m "Add user authentication feature"  # abc1234
git commit --fixup abc1234  # Automatically creates: "fixup! Add user authentication feature"
git commit -m "Add tests for authentication"
git commit --fixup abc1234  # Another fixup for abc1234
git commit -m "Update documentation"

# When ready to clean up:
git rebase -i --autosquash HEAD~5

# Git automatically generates todo list:
pick abc1234 Add user authentication feature
fixup def5678 fixup! Add user authentication feature
fixup jkl3456 fixup! Add user authentication feature
pick ghi9012 Add tests for authentication
pick mno7890 Update documentation

# Start feature work
git commit -m "Implement user login validation"  # abc1234

# Continue development...
git commit -m "Add password strength checker"    # def5678

# Realize you need to fix something in the login validation
# Make the fix, then:
git add login.py
git commit --fixup abc1234

# Git automatically creates commit with message:
# "fixup! Implement user login validation"

# Continue work...
git commit -m "Add session management"

# Another fix for the original login commit:
git add login.py
git commit --fixup abc1234

# Fixup the previous commit (HEAD~1)
git commit --fixup HEAD~1

# Fixup using commit SHA
git commit --fixup abc1234

# Fixup using relative reference
git commit --fixup HEAD~3

# Fixup using search string (Git 2.35+)
git commit --fixup :/authentication
# Finds most recent commit with "authentication" in message

# Original commit
git commit -m "Add email notification system"  # abc1234

# Later, add significant functionality
git add email_templates.py
git commit --squash abc1234
# Git creates: "squash! Add email notification system"
# Opens editor for you to add description of new changes

# During rebase, you'll be prompted to edit the combined message

# Standard autosquash rebase
git rebase -i --autosquash HEAD~10

# Shorter with config (see Configuration section)
git rebase -i HEAD~10  # If rebase.autosquash is enabled

# Autosquash with specific base
git rebase -i --autosquash main

# Autosquash onto upstream branch
git rebase -i --autosquash origin/main

# Original feature commit
git commit -m "Add API endpoint"  # abc1234

# First fix
git commit --fixup abc1234  # def5678: "fixup! Add API endpoint"

# Later, fix the fix (fixup of a fixup)
git commit --fixup def5678  # ghi9012: "fixup! fixup! Add API endpoint"

# During autosquash rebase:
pick abc1234 Add API endpoint
fixup def5678 fixup! Add API endpoint
fixup ghi9012 fixup! fixup! Add API endpoint
# All three get consolidated into abc1234

# Commit history:
# A - B - C - D - E
# Want to fixup only C, leaving others for manual handling

# Create fixup for C
git commit --fixup <commit-C-sha>

# During rebase, autosquash handles C fixup automatically
# Other commits available for manual reordering/editing
git rebase -i --autosquash HEAD~5

# Show recent commits and create fixup interactively
git commit --fixup=reword:HEAD~3
# Opens editor to reword the target commit message

# Create fixup with message editing (Git 2.32+)
git commit --fixup=reword:<commit-sha>

# Amend the target commit message during fixup
git commit --fixup=amend:<commit-sha>
# Combines changes AND lets you edit target's commit message

# Enable autosquash globally
git config --global rebase.autosquash true

# Now these are equivalent:
git rebase -i HEAD~10
git rebase -i --autosquash HEAD~10

# Disable for specific rebase if needed:
git rebase -i --no-autosquash HEAD~10

# Enable both features
git config --global rebase.autosquash true
git config --global rebase.autostash true

# Now you can rebase with uncommitted changes:
# Git automatically stashes, rebases with autosquash, then pops stash
git rebase -i HEAD~10

# Add to ~/.gitconfig:
[alias]
    fixup = commit --fixup
    squash = commit --squash
    ri = rebase -i --autosquash

# Usage:
git fixup HEAD~2
git squash abc1234
git ri HEAD~10

# Add to ~/.gitconfig:
[alias]
    fixup = "!f() { \
        TARGET=$(git log --oneline -n 20 | fzf | awk '{print $1}'); \
        git commit --fixup=$TARGET; \
    }; f"

# Requires fzf (fuzzy finder)
# Usage: git fixup
# Presents last 20 commits interactively for selection

# Start feature
git checkout -b feature/user-profiles
git commit -m "Add user profile model"        # Commit A

# Add more functionality
git commit -m "Add profile view template"     # Commit B
git commit -m "Add profile edit endpoint"     # Commit C

# Discovered issues in earlier commits during testing
git add models/user_profile.py
git commit --fixup A  # Fix for profile model

git add views/profile.py
git commit --fixup B  # Fix for view template

# More feature work
git commit -m "Add profile image upload"      # Commit D

# Another fix for the model
git add models/user_profile.py
git commit --fixup A

# Ready to merge - clean up history
git rebase -i --autosquash main

# Result: Clean history with fixes incorporated:
# - Add user profile model (with both fixes)
# - Add profile view template (with fix)
# - Add profile edit endpoint
# - Add profile image upload

# Initial feature commits pushed for review
git push origin feature/api-refactor

# Reviewer comments on specific commits
# "Commit abc1234 has a typo in function name"
# "Commit def5678 missing error handling"

# Address feedback with fixup commits
git commit --fixup abc1234 -m "fixup! Fix function name typo"
git commit --fixup def5678 -m "fixup! Add error handling"

# Push fixup commits for reviewer to see incremental changes
git push origin feature/api-refactor

# Before final merge, consolidate with autosquash
git rebase -i --autosquash main
git push origin feature/api-refactor --force-with-lease

# Final history shows polished, logical commits

# Create several logical commits for a feature
git commit -m "Add authentication service"     # A
git commit -m "Add authorization middleware"   # B
git commit -m "Add user session management"    # C

# While testing, find issues in all three areas
# Fix them incrementally as you discover them
git commit --fixup A
git commit --fixup C
git commit --fixup B
git commit --fixup A  # Another fix for A

# Autosquash automatically organizes:
git rebase -i --autosquash HEAD~7

# Result: All fixes properly incorporated into their target commits

# Suboptimal: Rebase entire branch history
git rebase -i --autosquash origin/main  # May scan hundreds of commits

# Optimized: Rebase only recent development
git rebase -i --autosquash HEAD~20     # Scan only last 20 commits

# Ambiguous scenario:
git commit -m "Add user authentication"        # A
git commit -m "Add user authorization"         # B
git commit --fixup :/authentication            # Intended for A

# Problem: "authentication" substring might partially match both
# Git uses most recent match (B) if ambiguous

# Solution: Use explicit commit SHA
git commit --fixup A  # Unambiguous

# Verify todo list before executing
git rebase -i --autosquash HEAD~10
# Review the generated todo list carefully
# Exit editor without saving if organization looks wrong

# Use --edit-todo to modify mid-rebase
git rebase --edit-todo

# Dangerous: Fixup commits that exist on remote
git commit --fixup abc1234  # abc1234 already pushed
git rebase -i --autosquash
git push --force  # Rewrites public history!

# Solution: Only fixup unpushed commits
# Or coordinate with team before force-pushing

# Problem: Commit message changed after creating fixup
git commit -m "Add feature X"           # Original: abc1234
git commit --fixup abc1234              # Creates "fixup! Add feature X"
git commit --amend -m "Implement feature X"  # Changes abc1234's message
git rebase -i --autosquash
# Fixup no longer matches - won't be automatic

# Solution: Use SHA-based fixup, not message-based
git commit --fixup abc1234  # Matches by SHA

# Problem: Multiple fixups modify same lines
git commit --fixup A  # Modifies line 10 in file.py
git commit --fixup A  # Also modifies line 10 in file.py
git rebase -i --autosquash
# Conflict during rebase!

# Solution: Resolve conflicts during rebase
# Or combine related changes in single fixup commit

# Install: cargo install git-absorb

# Make changes to multiple files
git add -p  # Stage specific changes

# Automatically create fixup commits
git absorb

# Git absorb analyzes staged changes and creates appropriate fixups
# Then run standard autosquash rebase
git rebase -i --autosquash

git checkout feature-branch
# Create fixup commits during development
git commit --fixup abc1234

# Before merging to main:
git rebase -i --autosquash main
git checkout main
git merge feature-branch  # Fast-forward merge with clean history

# Even with merge workflow, clean up feature branch first
git checkout feature-branch
git rebase -i --autosquash HEAD~10  # Clean up feature branch itself

# Then merge to main
git checkout main
git merge --no-ff feature-branch  # Creates merge commit

#!/bin/bash
# .git/hooks/pre-push

# Check if any fixup/squash commits exist
if git log origin/main..HEAD --oneline | grep -E "^[a-f0-9]+ (fixup|squash)!"; then
    echo "ERROR: Fixup/squash commits detected!"
    echo "Run: git rebase -i --autosquash origin/main"
    exit 1
fi

# .github/workflows/validate-commits.yml
name: Validate Commit History

on: [pull_request]

jobs:
  check-fixups:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Check for unsquashed fixup commits
        run: |
          if git log origin/main..HEAD --oneline | grep -E "(fixup|squash)!"; then
            echo "Found fixup/squash commits that need squashing"
            exit 1
          fi

# Verify fixup commit message format
git log --oneline
# Must see: "fixup! Original commit message"

# Check if commit references correct target
git log --all --oneline | grep "Original commit message"

# Solution 1: Verify autosquash is enabled
git config rebase.autosquash
# Should output: true

# Solution 2: Explicitly use --autosquash flag
git rebase -i --autosquash HEAD~10

# Solution 3: Check commit message matching
# Fixup message must exactly match target commit subject line

# Conflict occurs during rebase
git status  # Shows conflicted files

# Resolve conflicts manually
vim conflicted-file.py  # Edit and resolve

# Mark as resolved
git add conflicted-file.py

# Continue rebase
git rebase --continue

# If too complex, abort and retry
git rebase --abort
# Reconsider fixup strategy or resolve conflicts differently

# Use explicit commit SHA instead of message search
git commit --fixup abc1234  # Unambiguous

# Avoid vague commit messages that might match multiple commits
# Bad:  "Fix bug"
# Good: "Fix validation bug in user authentication"

# Good practice: Descriptive, unique commit messages
git commit -m "Implement JWT token validation in AuthService"
git commit -m "Add user role checking to authorization middleware"

# Later fixups are unambiguous:
git commit --fixup :/JWT        # Matches first commit
git commit --fixup :/authorization  # Matches second commit

# Don't accumulate fixes - create fixups immediately when you discover issues
# This maintains context and makes cleanup easier

# Good workflow:
git commit -m "Add feature"     # Commit A
# ... test ...
# Find issue in A
git commit --fixup A            # Immediate fixup

# Poor workflow:
git commit -m "Add feature"     # Commit A
git commit -m "Add another feature"  # Commit B
git commit -m "Add third feature"    # Commit C
# ... much later ...
git commit -m "Fix issue in feature from commit A"  # Hard to identify target

# Always review the generated todo list
git rebase -i --autosquash HEAD~10

# Verify:
# 1. Fixups are positioned correctly
# 2. Commit order makes logical sense
# 3. No unexpected commit combinations

# If organization looks wrong, exit without saving and investigate

# Team Git Workflow Document

## Using Autosquash for Clean History

1. Enable autosquash globally: `git config --global rebase.autosquash true`
2. During feature development, use `git commit --fixup <commit>` for corrections
3. Before creating pull request, run: `git rebase -i --autosquash main`
4. Review generated todo list and verify organization
5. Push cleaned history for review

## When NOT to Use Autosquash

- After pushing commits to shared branches (coordinate force-push)
- When commit organization is ambiguous
- For emergency hotfixes (keep history explicit)