---
name: git-advanced
description: "Advanced Git operations and workflows including interactive rebasing, conflict resolution, history manipulation, bisecting for bugs, cherry-picking, reflog recovery, and branch management strategies. Use for: (1) Interactive rebasing and commit cleanup, (2) Complex merge conflict resolution, (3) Git bisect for bug hunting, (4) History rewriting and cleanup, (5) Branch strategy implementation (Git Flow, trunk-based), (6) Recovering lost commits with reflog"
---

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