git-advanced

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

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

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

# Accept theirs (incoming branch)

git checkout --theirs

# List conflicted files

git diff --name-only --diff-filter=U

# Mark as resolved

git add

```

Git Bisect

```bash

# Start bisect session

git bisect start

git bisect bad

git bisect good

# 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

# Cherry-pick without committing

git cherry-pick -n

# 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

# Reset to previous state

git reset --hard HEAD@{2}

```

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 # Edit between markers

git add

# Strategy B: Accept one side

git checkout --ours # Keep yours

git checkout --theirs # Keep theirs

git add

# 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

# Show what THEY changed

git diff --theirs

# Show common ancestor

git diff --base

```

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

```

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

```

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

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.

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.

Rebase Conflicts

```bash

# If conflicts are too complex

git rebase --abort

# Start over with different approach

git merge --no-ff

```

Lost Commits

```bash

# Always check reflog first

git reflog

# Find and recover

git checkout -b recovery

```

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.

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

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

git checkout --theirs

# 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.