git-advanced

SKILL.md

Git Advanced Operations Skill

This skill provides comprehensive guidance on advanced git operations, sophisticated rebase strategies, commit surgery techniques, and complex history manipulation for experienced git users.

When to Use

Activate this skill when:

Performing complex interactive rebases

Rewriting commit history

Splitting or combining commits

Advanced merge strategies

Cherry-picking across branches

Commit message editing in history

Author information changes

Complex conflict resolution

Interactive Rebase Strategies

Basic Interactive Rebase
# Rebase last 5 commits
git rebase -i HEAD~5

# Rebase from specific commit
git rebase -i abc123^

# Rebase entire branch
git rebase -i main

Rebase Commands

# Interactive rebase editor commands:
# p, pick = use commit
# r, reword = use commit, but edit commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like squash, but discard commit message
# x, exec = run command (the rest of the line) using shell
# d, drop = remove commit

Squashing Commits

# Example: Squash last 3 commits
git rebase -i HEAD~3

# In editor:
pick abc123 feat: add user authentication
squash def456 fix: resolve login bug
squash ghi789 style: format code

# Squash all commits in feature branch
git rebase -i main
# Mark all except first as 'squash'

Fixup Workflow

# Create fixup commit automatically
git commit --fixup=abc123

# Autosquash during rebase
git rebase -i --autosquash main

# Set autosquash as default
git config --global rebase.autosquash true

# Example workflow:
git log --oneline -5
# abc123 feat: add authentication
# def456 feat: add authorization
git commit --fixup=abc123
git rebase -i --autosquash HEAD~3

Reordering Commits

# Interactive rebase
git rebase -i HEAD~5

# In editor, change order:
pick def456 feat: add database migration
pick abc123 feat: add user model
pick ghi789 feat: add API endpoints

# Reorder by moving lines:
pick abc123 feat: add user model
pick def456 feat: add database migration
pick ghi789 feat: add API endpoints

Splitting Commits

# Start interactive rebase
git rebase -i HEAD~3

# Mark commit to split with 'edit'
edit abc123 feat: add user and role features

# When rebase stops:
git reset HEAD^

# Stage and commit parts separately
git add user.go
git commit -m "feat: add user management"

git add role.go
git commit -m "feat: add role management"

# Continue rebase
git rebase --continue

Editing Old Commits

# Start interactive rebase
git rebase -i HEAD~5

# Mark commit with 'edit'
edit abc123 feat: add authentication

# When rebase stops, make changes
git add modified-file.go
git commit --amend --no-edit

# Or change commit message
git commit --amend

# Continue rebase
git rebase --continue

Commit Surgery

Amending Commits

# Amend last commit (add changes)
git add forgotten-file.go
git commit --amend --no-edit

# Amend commit message
git commit --amend -m "fix: correct typo in feature"

# Amend author information
git commit --amend --author="John Doe <john@example.com>"

# Amend date
git commit --amend --date="2024-03-15 10:30:00"

Changing Commit Messages

# Change last commit message
git commit --amend

# Change older commit messages
git rebase -i HEAD~5
# Mark commits with 'reword'

# Change commit message without opening editor
git commit --amend -m "new message" --no-edit

Changing Multiple Authors

# Filter-branch (legacy method, use filter-repo instead)
git filter-branch --env-filter '
if [ "$GIT_COMMITTER_EMAIL" = "old@example.com" ]; then
    export GIT_COMMITTER_NAME="New Name"
    export GIT_COMMITTER_EMAIL="new@example.com"
fi
if [ "$GIT_AUTHOR_EMAIL" = "old@example.com" ]; then
    export GIT_AUTHOR_NAME="New Name"
    export GIT_AUTHOR_EMAIL="new@example.com"
fi
' --tag-name-filter cat -- --branches --tags

# Modern method with git-filter-repo
git filter-repo --email-callback '
    return email.replace(b"old@example.com", b"new@example.com")
'

Removing Files from History

# Remove file from all history
git filter-branch --tree-filter 'rm -f passwords.txt' HEAD

# Better performance with index-filter
git filter-branch --index-filter 'git rm --cached --ignore-unmatch passwords.txt' HEAD

# Modern method with git-filter-repo (recommended)
git filter-repo --path passwords.txt --invert-paths

# Remove large files
git filter-repo --strip-blobs-bigger-than 10M

BFG Repo-Cleaner

# Install BFG
# brew install bfg (macOS)
# apt-get install bfg (Ubuntu)

# Remove files by name
bfg --delete-files passwords.txt

# Remove large files
bfg --strip-blobs-bigger-than 50M

# Replace passwords in history
bfg --replace-text passwords.txt

# After BFG cleanup
git reflog expire --expire=now --all
git gc --prune=now --aggressive

Advanced Cherry-Picking

Basic Cherry-Pick

# Cherry-pick single commit
git cherry-pick abc123

# Cherry-pick multiple commits
git cherry-pick abc123 def456 ghi789

# Cherry-pick range of commits
git cherry-pick abc123..ghi789

# Cherry-pick without committing (stage only)
git cherry-pick -n abc123

Cherry-Pick with Conflicts

# When conflicts occur
git cherry-pick abc123
# CONFLICT: resolve conflicts

# After resolving conflicts
git add resolved-file.go
git cherry-pick --continue

# Or abort cherry-pick
git cherry-pick --abort

# Skip current commit
git cherry-pick --skip

Cherry-Pick Options

# Edit commit message during cherry-pick
git cherry-pick -e abc123

# Sign-off cherry-picked commit
git cherry-pick -s abc123

# Keep original author date
git cherry-pick --ff abc123

# Apply changes without commit attribution
git cherry-pick -n abc123
git commit --author="New Author <new@example.com>"

Mainline Selection for Merge Commits

# Cherry-pick merge commit (specify parent)
git cherry-pick -m 1 abc123

# -m 1 = use first parent (main branch)
# -m 2 = use second parent (merged branch)

# Example workflow:
git log --graph --oneline
#   *   abc123 Merge pull request #123
#   |\
#   | * def456 feat: feature commit
#   * | ghi789 fix: main branch commit

# To cherry-pick the merge keeping main branch changes:
git cherry-pick -m 1 abc123

Advanced Merging

Merge Strategies

# Recursive merge (default)
git merge -s recursive branch-name

# Ours (keep our changes on conflict)
git merge -s ours branch-name

# Theirs (keep their changes on conflict)
git merge -s theirs branch-name

# Octopus (merge 3+ branches)
git merge -s octopus branch1 branch2 branch3

# Subtree merge
git merge -s subtree branch-name

Merge Strategy Options

# Ours (resolve conflicts with our version)
git merge -X ours branch-name

# Theirs (resolve conflicts with their version)
git merge -X theirs branch-name

# Ignore whitespace
git merge -X ignore-space-change branch-name
git merge -X ignore-all-space branch-name

# Patience algorithm (better conflict detection)
git merge -X patience branch-name

# Renormalize line endings
git merge -X renormalize branch-name

Three-Way Merge

# Standard three-way merge
git merge feature-branch

# With custom merge message
git merge feature-branch -m "Merge feature: add authentication"

# No fast-forward (always create merge commit)
git merge --no-ff feature-branch

# Fast-forward only (fail if merge commit needed)
git merge --ff-only feature-branch

# Squash merge (combine all commits)
git merge --squash feature-branch
git commit -m "feat: add complete authentication system"

Advanced Conflict Resolution

Understanding Conflict Markers

<<<<<<< HEAD (Current Change)
int result = add(a, b);
=======
int sum = calculate(a, b);
>>>>>>> feature-branch (Incoming Change)

Conflict Resolution Tools

# Use mergetool
git mergetool

# Specify merge tool
git mergetool --tool=vimdiff
git mergetool --tool=meld
git mergetool --tool=kdiff3

# Configure default merge tool
git config --global merge.tool vimdiff
git config --global mergetool.vimdiff.cmd 'vimdiff "$LOCAL" "$MERGED" "$REMOTE"'

# Check out specific version
git checkout --ours file.go    # Keep our version
git checkout --theirs file.go  # Keep their version
git checkout --merge file.go   # Recreate conflict markers

Rerere (Reuse Recorded Resolution)

# Enable rerere
git config --global rerere.enabled true

# Rerere will automatically resolve previously seen conflicts
git merge feature-branch
# Conflict occurs and is resolved
git add file.go
git commit

# Later, same conflict:
git merge another-branch
# Rerere automatically applies previous resolution

# View rerere cache
git rerere status
git rerere diff

# Clear rerere cache
git rerere forget file.go
git rerere clear

Interactive Staging

Partial File Staging

# Interactive staging
git add -p file.go

# Patch commands:
# y - stage this hunk
# n - do not stage this hunk
# q - quit (do not stage this and remaining hunks)
# a - stage this and all remaining hunks
# d - do not stage this and all remaining hunks
# s - split the current hunk into smaller hunks
# e - manually edit the current hunk

Interactive Add

# Interactive mode
git add -i

# Commands:
# 1: status       - show paths with changes
# 2: update       - stage paths
# 3: revert       - unstage paths
# 4: add untracked - stage untracked files
# 5: patch        - partial staging
# 6: diff         - show staged changes
# 7: quit         - exit

Partial Commits

# Stage part of file interactively
git add -p file.go

# Create commit with partial changes
git commit -m "feat: add validation logic"

# Stage remaining changes
git add file.go
git commit -m "feat: add error handling"

Advanced Reset Operations

Reset Modes

# Soft reset (keep changes staged)
git reset --soft HEAD~1

# Mixed reset (keep changes unstaged, default)
git reset --mixed HEAD~1
git reset HEAD~1

# Hard reset (discard all changes)
git reset --hard HEAD~1

# Reset to specific commit
git reset --hard abc123

Reset vs Revert

# Reset (rewrites history, use for local changes)
git reset --hard HEAD~3

# Revert (creates new commit, safe for shared history)
git revert HEAD
git revert HEAD~3
git revert abc123..def456

Advanced Branch Operations

Branch from Specific Commit

# Create branch from commit
git branch new-branch abc123
git checkout new-branch

# Or in one command
git checkout -b new-branch abc123

# Create branch from remote commit
git checkout -b local-branch origin/remote-branch

Orphan Branches

# Create orphan branch (no parent)
git checkout --orphan new-root
git rm -rf .

# Useful for gh-pages, documentation, etc.
echo "# Documentation" > README.md
git add README.md
git commit -m "docs: initialize documentation"

Branch Tracking

# Set upstream branch
git branch -u origin/main

# Push and set upstream
git push -u origin feature-branch

# Change upstream
git branch -u origin/develop

# View tracking information
git branch -vv

Advanced Stash Operations

Stash Specific Files

# Stash specific files
git stash push -m "WIP: feature work" file1.go file2.go

# Stash with pathspec
git stash push -p

# Stash untracked files
git stash -u

# Stash including ignored files
git stash -a

Stash to Branch

# Create branch from stash
git stash branch new-branch stash@{0}

# Creates new branch and applies stash
git stash branch feature-work

Partial Stash Application

# Apply specific files from stash
git checkout stash@{0} -- file.go

# Apply stash without dropping
git stash apply stash@{0}

# Apply and drop
git stash pop stash@{0}

Submodule Management

Advanced Submodule Operations

# Update submodule to specific commit
cd submodule-dir
git checkout abc123
cd ..
git add submodule-dir
git commit -m "chore: update submodule to version 1.2.3"

# Update all submodules to latest
git submodule update --remote --merge

# Update specific submodule
git submodule update --remote --merge path/to/submodule

# Run command in all submodules
git submodule foreach 'git checkout main'
git submodule foreach 'git pull'

# Clone with submodules at specific depth
git clone --recurse-submodules --depth 1 repo-url

Submodule to Subtree Migration

# Remove submodule
git submodule deinit path/to/submodule
git rm path/to/submodule
rm -rf .git/modules/path/to/submodule

# Add as subtree
git subtree add --prefix=path/to/submodule \
    https://github.com/user/repo.git main --squash

# Update subtree
git subtree pull --prefix=path/to/submodule \
    https://github.com/user/repo.git main --squash

Advanced Log and History

Custom Log Formatting

# One-line format with custom fields
git log --pretty=format:"%h - %an, %ar : %s"

# Full custom format
git log --pretty=format:"%C(yellow)%h%C(reset) %C(blue)%ad%C(reset) %C(green)%an%C(reset) %s" --date=short

# Aliases for common formats
git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --date=relative"

Finding Lost Commits

# Find commits not in any branch
git log --all --oneline --no-walk --decorate $(git fsck --no-reflog | grep commit | cut -d' ' -f3)

# Find dangling commits
git fsck --lost-found

# Search commit messages
git log --all --grep="search term"

# Find commits by author
git log --author="John Doe"

# Find commits modifying specific code
git log -S "function_name"
git log -G "regex_pattern"

Bisect Automation

# Start bisect
git bisect start
git bisect bad HEAD
git bisect good abc123

# Automate bisect with script
git bisect run ./test.sh

# test.sh example:
#!/bin/bash
make && make test
exit $?

# Bisect will automatically find first bad commit

Best Practices

Backup Before History Rewriting: Create backup branch before complex operations

Never Rewrite Published History: Only rewrite local commits

Communicate Rebases: Inform team when force-pushing

Use Descriptive Commit Messages: Even during interactive rebase

Test After Rebase: Ensure code still works after history changes

Prefer Rebase for Local Branches: Keep history linear

Use Merge for Shared Branches: Preserve complete history

Sign Important Commits: Use GPG signing for releases

Document Complex Operations: Leave comments for future reference

Know When to Stop: Sometimes merge commits are clearer than rebased history

Resources

Additional guides and examples are available in the assets/ directory:

examples/ - Complex rebase and merge scenarios

scripts/ - Automation scripts for common operations

workflows/ - Advanced workflow patterns

See references/ directory for:

Git internals documentation

Advanced rebasing strategies

Filter-branch alternatives

Conflict resolution techniques