Advanced Git Operations

Overview

Master advanced Git workflows for complex version control scenarios. This skill covers sophisticated operations beyond basic commits and merges, including interactive rebasing, advanced conflict resolution, history manipulation, and strategic branch management.

Use this skill when you need to:

• Clean up messy commit history before code review
• Resolve complex merge conflicts strategically
• Hunt down bugs with binary search (bisect)
• Recover lost commits or undo mistakes
• Implement team branching strategies
• Rewrite history safely

Core Capabilities

Interactive Rebasing

• Reorder commits for logical history
• Squash multiple commits into one
• Edit commit messages retroactively
• Split commits into smaller pieces
• Remove unwanted commits from history

Conflict Resolution

• Strategic merge conflict handling
• Three-way merge understanding
• Ours vs theirs strategy selection
• Conflict marker interpretation
• Partial file staging during conflicts

Git Bisect

• Binary search for bug introduction
• Automated bisect with scripts
• Good/bad commit identification
• Efficient debugging of regressions

History Manipulation

• Amend commits safely
• Filter-branch operations
• BFG Repo-Cleaner for large files
• Rewrite history with caution
• Preserve attribution and dates

Branch Strategies

• Git Flow workflow
• Trunk-based development
• Feature branch workflows
• Release branch management
• Hotfix procedures

Quick Command Reference

Interactive Rebase

bash
# Rebase last 5 commits interactively
git rebase -i HEAD~5

# Rebase onto main branch
git rebase -i main

# Continue after resolving conflicts
git rebase --continue

# Abort and return to original state
git rebase --abort

Conflict Resolution

bash
# Accept ours (current branch)
git checkout --ours <file>

# Accept theirs (incoming branch)
git checkout --theirs <file>

# List conflicted files
git diff --name-only --diff-filter=U

# Mark as resolved
git add <file>

Git Bisect

bash
# Start bisect session
git bisect start
git bisect bad
git bisect good <commit-hash>

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

# End bisect session
git bisect reset

Cherry-Pick

bash
# Apply specific commit
git cherry-pick <commit-hash>

# Cherry-pick without committing
git cherry-pick -n <commit-hash>

# Cherry-pick range of commits
git cherry-pick A^..B

Reflog Recovery

bash
# View reflog history
git reflog

# Recover lost commit
git checkout -b recovery <commit-hash>

# Reset to previous state
git reset --hard HEAD@{2}

Core Workflows

1. Interactive Rebase Workflow

When to Use:

• Clean up messy commit history before pushing
• Combine "WIP" or "fix typo" commits
• Reorder commits for logical progression
• Split large commits into focused changes

Steps:

bash
# 1. Start interactive rebase for last N commits
git rebase -i HEAD~5

# Interactive editor opens with commit list
# Modify commands to reorganize history

Rebase Commands:

• pick (p): Keep commit as-is
• reword (r): Keep commit, edit message
• edit (e): Keep commit, stop to amend
• squash (s): Combine with previous commit, keep message
• fixup (f): Combine with previous commit, discard message
• drop (d): Remove commit entirely

Example:

bash
# Before
pick abc1234 Add feature X
pick def5678 Fix typo
pick ghi9012 WIP commit
pick jkl3456 Update documentation

# After cleanup
pick abc1234 Add feature X
fixup def5678 Fix typo
drop ghi9012 WIP commit
reword jkl3456 Update documentation

Safety Tips:

• Never rebase commits already pushed to shared branches
• Create backup branch: git branch backup
• Use git reflog if something goes wrong
• Force push carefully: git push --force-with-lease

For detailed examples and advanced techniques, see examples/interactive_rebase.md.

2. Conflict Resolution Workflow

Understanding Conflict Markers:

<<<<<<< HEAD (Current Change)
Your code from current branch
=======
Their code from merging branch
>>>>>>> branch-name (Incoming Change)

Resolution Process:

bash
# 1. Identify conflicts
git status

# 2. Choose resolution strategy:

# Strategy A: Manual resolution
vim <file>  # Edit between markers
git add <file>

# Strategy B: Accept one side
git checkout --ours <file>    # Keep yours
git checkout --theirs <file>  # Keep theirs
git add <file>

# Strategy C: Use merge tool
git mergetool

# 3. Continue operation
git merge --continue
# or
git rebase --continue

Three-Way Diff:

bash
# Show what YOU changed
git diff --ours <file>

# Show what THEY changed
git diff --theirs <file>

# Show common ancestor
git diff --base <file>

For common conflict patterns and solutions, see examples/conflict_resolution.md.

3. Git Bisect for Bug Hunting

Scenario: Bug exists in current version, find which commit introduced it.

Manual Bisect:

bash
# 1. Start bisect
git bisect start

# 2. Mark current state as bad
git bisect bad

# 3. Mark known good commit
git bisect good v1.0.0

# 4. Test the code (Git checks out middle commit)
# Run app, check if bug exists

# 5. Mark result
git bisect bad   # If bug exists
git bisect good  # If bug doesn't exist

# Repeat until Git finds first bad commit

# 6. End bisect
git bisect reset

Automated Bisect:

bash
# Create test script (test.sh)
#!/bin/bash
npm test
exit $?

# Run automated bisect
git bisect start
git bisect bad
git bisect good v1.0.0
git bisect run ./test.sh

# Git automatically finds bad commit
git bisect reset

4. Branch Management

Quick Cleanup:

bash
# Use helper script
bash scripts/git_helper.sh cleanup-branches

# Or manual cleanup
git branch --merged main | grep -v "\*\|main\|develop" | xargs git branch -d
git fetch --prune

Stale Branch Detection:

bash
# Show branches with last commit date
for branch in $(git branch -r | grep -v HEAD); do
    echo -e "$(git show --format="%ci %cr" $branch | head -n 1)\t$branch"
done | sort -r

For detailed branch management strategies, see references/branch-management.md.

5. Reflog Recovery

Recover Deleted Branch:

bash
# View reflog
git reflog

# Find commit where branch was deleted
# Restore branch
git checkout -b feature-x <commit-hash>

Undo Bad Reset:

bash
# Accidentally ran: git reset --hard HEAD~5

# View reflog
git reflog

# Restore previous state
git reset --hard HEAD@{1}

Recover Lost Commits:

bash
# Find dangling commits
git fsck --lost-found

# Cherry-pick recovered commit
git cherry-pick <lost-commit-hash>

For comprehensive recovery techniques, see references/reflog-recovery.md.

Branch Strategy Implementation

This skill supports implementing various branching strategies. Choose based on your team's needs:

Git Flow

Best for: Projects with scheduled releases, multiple production versions

Branch Types:

• main: Production-ready code
• develop: Integration branch
• feature/*: New features
• release/*: Release preparation
• hotfix/*: Production fixes

Quick Start:

bash
# Feature development
git checkout develop
git checkout -b feature/user-auth
# Work on feature
git checkout develop
git merge --no-ff feature/user-auth

Trunk-Based Development

Best for: Continuous deployment, fast-moving teams

Principles:

• Single main branch
• Short-lived feature branches (< 1 day)
• Frequent integration
• Feature flags for incomplete work

Quick Start:

bash
# Create short-lived branch
git checkout main
git checkout -b feature/quick-fix
# Work and merge same day
git checkout main
git merge feature/quick-fix

For complete branch strategy workflows, see examples/branch_strategies.md.

Best Practices

Before Rebase

• Create backup branch: git branch backup
• Ensure working directory is clean: git status
• Know your commit history: git log --oneline
• Never rebase public/shared branches

During Conflicts

• Understand both sides of the conflict
• Test thoroughly after resolution
• Use meaningful merge commit messages
• Document complex resolutions

Branch Management

• Delete merged branches promptly
• Use descriptive branch names: feature/user-login
• Keep branches focused and short-lived
• Sync with main branch regularly

History Hygiene

• Squash "fixup" commits before pushing
• Write clear, descriptive commit messages
• Keep commits atomic (one logical change)
• Use conventional commit format when possible

For comprehensive best practices, see references/best-practices.md.

Troubleshooting

Rebase Conflicts

bash
# If conflicts are too complex
git rebase --abort

# Start over with different approach
git merge --no-ff <branch>

Lost Commits

bash
# Always check reflog first
git reflog

# Find and recover
git checkout -b recovery <commit-hash>

Detached HEAD State

bash
# Create branch from detached HEAD
git checkout -b new-branch-name

# Or go back to branch
git checkout main

Failed Push After Rebase

bash
# Only if you're certain and branch is not shared
git push --force-with-lease

# Safer: Create new branch
git checkout -b feature-v2
git push origin feature-v2

For detailed troubleshooting, see references/troubleshooting.md.

Additional Resources

Detailed Guides

• examples/interactive_rebase.md: Step-by-step rebase examples with scenarios
• examples/conflict_resolution.md: Common conflict patterns and solutions
• examples/branch_strategies.md: Complete Git Flow and trunk-based workflows

Reference Documentation

• references/branch-management.md: Branch cleanup automation and strategies
• references/reflog-recovery.md: Recovery techniques and history rewriting
• references/best-practices.md: Comprehensive best practices and quality standards
• references/troubleshooting.md: Common issues and emergency recovery

Helper Scripts

• scripts/git_helper.sh: Branch cleanup and conflict resolution utilities

Quick Reference Commands

Must-Know Commands

bash
# Interactive rebase
git rebase -i HEAD~N

# Abort operations
git rebase --abort
git merge --abort
git cherry-pick --abort

# View history
git log --oneline --graph --all
git reflog

# Conflict resolution
git checkout --ours <file>
git checkout --theirs <file>

# Recovery
git fsck --lost-found
git reflog

# Cleanup
git branch --merged | xargs git branch -d
git fetch --prune

Safety First

1. Always backup before history rewrite: git branch backup
2. Never force push to shared branches: Use --force-with-lease
3. Test after conflicts: Don't assume resolution is correct
4. Document complex operations: Leave comments in merge commits
5. Use reflog: It's your safety net for 30+ days

Master these advanced Git operations to maintain clean history, resolve conflicts efficiently, and manage complex development workflows with confidence.