Git Update

Overview

Update your current branch with changes from the upstream branch, intelligently resolving conflicts when they occur.

Announce: "Using git:update to sync your branch with upstream..."

Philosophy:

• Merge (not rebase) to preserve history
• Understand intent behind conflicting changes
• Resolve autonomously, present for approval before committing

When to Use

• User says "update", "sync", "pull in latest", "merge main"
• PR has conflicts that need resolving
• Branch is behind upstream and needs updating
• User wants to incorporate recent changes from main/master

Workflow: Detect Upstream

Step 1: Try tracking branch

git rev-parse --abbrev-ref @{upstream} 2>/dev/null

If this succeeds, use the result (e.g., origin/main).

Step 2: Fall back to PR base branch

If no tracking branch:

gh pr view --json baseRefName -q '.baseRefName' 2>/dev/null

If this succeeds, use origin/{result}.

Step 3: Ask user if neither works

If both fail, use AskUserQuestion:

I couldn't detect an upstream branch for this branch.

Which branch should I merge from?
(A) main
(B) master
(C) Other - I'll specify

Workflow: Fetch and Merge

Step 1: Fetch latest

git fetch origin

Step 2: Check if update needed

git rev-list --count HEAD..{upstream}

If count is 0, report "Already up to date with {upstream}" and stop.

Step 3: Attempt merge

git merge {upstream} --no-edit

Step 4: Branch on result

On clean merge:

git push

Report:

## Update Complete

Merged `{upstream}` into `{current-branch}`
{N} commits pulled in
Pushed to origin

Workflow: Conflict Resolution

Step 1: Inventory conflicts

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

Step 2: For each conflicted file, gather context

Read the conflict:

cat {file}  # Shows conflict markers

Understand "ours" (your branch):

git log --oneline -5 HEAD -- {file}
git show HEAD:{file}  # Your version

Understand "theirs" (upstream):

git log --oneline -5 {upstream} -- {file}
git show {upstream}:{file}  # Their version

Get commit messages for context:

# What your commits were doing
git log --format="%s%n%b" HEAD...$(git merge-base HEAD {upstream}) -- {file}

# What upstream commits were doing
git log --format="%s%n%b" {upstream}...$(git merge-base HEAD {upstream}) -- {file}

Step 3: Analyze each conflict

For each conflict, determine the type:

Analysis approach:

1. Read both versions and the conflict markers
2. Use commit messages to understand intent
3. Identify what each side was trying to accomplish
4. Determine if changes can coexist or need reconciliation

Step 4: Resolve conflicts

For independent changes:

• Identify which hunks belong to each side
• Structure the file to include both changes appropriately

For overlapping changes:

• Understand the newer pattern/approach (usually upstream)
• Apply your changes using the newer approach
• Example: If upstream refactored a function, adapt your additions to the new structure

For contradictory changes:

• Do not auto-resolve
• Present both options to user with context

Step 5: Present for approval

After resolving, show summary:

## Conflict Resolution Summary

Merged `main` into `feature/my-branch`

### {filename}

**Your changes:** {1-2 sentence summary of what your commits did}
**Upstream changes:** {1-2 sentence summary of what upstream commits did}
**Resolution:** {1-2 sentence explanation of how resolved}

{Show key parts of the resolution}

---

[Repeat for each file]

---

**Verification:**
- [ ] No conflict markers remain
- [ ] File parses correctly (if applicable)

Does this resolution look correct?
(A) Yes, commit and push
(B) Let me review/adjust manually
(C) Show me more context on a specific file

Use AskUserQuestion with these options.

Workflow: Verification & Completion

Step 1: Verify no conflict markers

grep -rn "^<<<<<<< \|^=======$\|^>>>>>>> " {resolved_files}

If any found, resolution is incomplete - fix before proceeding.

Step 2: Syntax verification (where practical)

Step 3: Commit and push

git add {resolved_files}
git commit -m "Merge {upstream} into {branch}

Resolved conflicts in:
$(for f in {resolved_files}; do echo "- $f"; done)"

git push

Step 4: Report completion

## Update Complete

Merged `{upstream}` into `{branch}`
Resolved {N} conflict(s):
- {file1}
- {file2}

Pushed to origin. PR should now be mergeable.

Edge Cases

Quick Reference

Related Skills

• git:commit - Commit practices (used after resolution)
• git:pull-request - Creating/updating PRs
• git:triage - Overview of work state