git-absorb

Automatically create git commit --fixup commits for your staged changes. git-absorb identifies which existing commit owns each changed line and generates the fixup — then git rebase --autosquash folds them in for a perfectly clean history.

What is git-absorb?

git-absorb is a Git extension written in Rust that automates the tedious part of maintaining a clean feature branch: correctly attributing review fixes to the right original commit. When a code reviewer asks for changes, you typically make those changes and then need to figure out which commit introduced the affected code, create a fixup commit targeting that commit, then rebase to clean up.

git-absorb does the attribution automatically. It runs git blame on your staged changes, identifies which commits in your branch introduced those lines, and creates git commit --fixup commits pointing to them. Run git rebase --autosquash afterward and your history is clean.

Key Features

• Automatic fixup targeting — uses git blame to identify which commit owns each staged hunk
• Safe — never wrong — if git-absorb is uncertain, it leaves changes unstaged rather than creating an incorrect fixup
• Multiple fixups at once — stages across multiple files create multiple fixup commits targeting the correct parents in one pass
• Works with autosquash — pairs directly with git rebase -i --autosquash for one-command cleanup
• Configurable range — controls how many commits back git-absorb looks for fixup targets
• Written in Rust — fast, dependency-free binary available on all major platforms

Installation

# macOS (Homebrew)
brew install git-absorb

# Rust / Cargo (any platform)
cargo install git-absorb

# Nix
nix-env -iA nixpkgs.gitAndTools.git-absorb

# Arch Linux (AUR)
yay -S git-absorb

After installation, git absorb is available as a git subcommand in any repository.

Complete Workflow Example

# 1. You have a feature branch with several commits:
#    c1: Add user model
#    c2: Add auth middleware
#    c3: Add login endpoint

# 2. Your reviewer asks for a small fix in the user model.
#    Make the fix, then stage the changes:
git add src/models/user.ts

# 3. Run git absorb — it figures out which prior commit owns this code:
git absorb
# Output: absorbed 1 hunk into fixup! Add user model

# 4. Autosquash to merge the fixup into the original commit:
git rebase --autosquash origin/main
# Result: a clean history with the fix baked into "Add user model"

# 5. Force-push the cleaned-up branch:
git push --force-with-lease

git-absorb vs Manual Fixup Commits

Use Cases

• Incorporating code review feedback into the correct original commit without polluting history
• Cleaning up a feature branch before merging with a squash-friendly team workflow
• Fixing typos or minor errors from commits made earlier in the same branch
• Maintaining atomic, reviewable commits when a PR spans many logical changes
• Pairing with lazygit or other TUIs that support autosquash-based rebase workflows

Pros and Cons