lucasilverentand/resolving-conflicts

Resolving Conflicts

Resolve merge conflicts intelligently by understanding the intent behind both sides of each conflict.

Current context

• Branch: !git branch --show-current
• Status: !git status --short
• Rebase in progress: !test -d "$(git rev-parse --git-dir)/rebase-merge" -o -d "$(git rev-parse --git-dir)/rebase-apply" && echo "yes" || echo "no"
• Merge in progress: !test -f "$(git rev-parse --git-dir)/MERGE_HEAD" && echo "yes" || echo "no"
• Cherry-pick in progress: !test -f "$(git rev-parse --git-dir)/CHERRY_PICK_HEAD" && echo "yes" || echo "no"

Decision tree

• What's the situation?
  • Conflicts exist right now (rebase/merge/cherry-pick in progress with unresolved conflicts) -> go to "Resolve conflicts"
  • User wants to rebase onto another branch (clean working tree, no operation in progress) -> go to "Start rebase"
  • User wants to merge another branch in -> go to "Start merge"
  • Dirty working tree, wants to rebase -> commit or stash first using the creating-commits skill, then go to "Start rebase"

Start rebase

1. Determine the target

Default target is main (or master if that's what the repo uses). If the user specified a branch, use that.

2. Fetch and rebase

git fetch origin

git rebase origin/<target>

• No conflicts -> rebase completed cleanly. Go to "Finish".
• Conflicts -> go to "Resolve conflicts"

Start merge

git fetch origin

git merge origin/<target>

• No conflicts -> merge completed cleanly. Go to "Finish".
• Conflicts -> go to "Resolve conflicts"

Resolve conflicts

1. Inventory conflicted files

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

List all conflicted files. Process them one at a time.

2. For each conflicted file

a. Read the conflict

Read the file to see the conflict markers (<<<<<<<, =======, >>>>>>>). Understand what each side changed.

b. Understand intent

For each conflict, gather context:

• git log --oneline -5 -- <file> on the current branch — what recent changes were made and why
• git log --oneline -5 REBASE_HEAD -- <file> (or MERGE_HEAD / CHERRY_PICK_HEAD) — what the incoming side changed and why
• Read surrounding code for context about what the conflicting section does

c. Classify the conflict

• Clear-cut: one side only added — the other side didn't touch those lines. Take the addition.
• Clear-cut: one side deleted, other unchanged — the deletion wins (it was intentional).
• Clear-cut: non-overlapping edits — both sides changed different things in the same region. Combine them.
• Clear-cut: identical changes — both sides made the same change. Take either (they're the same).
• Clear-cut: import/dependency ordering — both sides added imports or dependencies. Combine and sort.
• Ambiguous: both sides made substantive, different changes to the same lines — needs human judgment.

d. Resolve

For clear-cut conflicts:

• Edit the file to remove conflict markers and apply the resolution
• Stage the file: git add <file>
• Move to the next conflicted file

For ambiguous conflicts:

• Prepare your best resolution based on understanding both sides' intent
• Show the user:
  • What each side was trying to do (with commit context)
  • Your proposed resolution
  • Why you chose this resolution
• Use AskUserQuestion with options:
  • Accept resolution — use the proposed resolution
  • Take ours — keep the current branch's version
  • Take theirs — keep the incoming branch's version
• Apply the chosen resolution, edit the file, and stage it

3. Continue the operation

After all conflicts in the current round are resolved:

git rebase --continue

(Or git merge --continue / git cherry-pick --continue depending on the operation.)

If this produces more conflicts (common during rebase when replaying multiple commits), loop back to step 1 of "Resolve conflicts". Each round may have different files conflicting.

If git rebase --continue needs a commit message, use the original commit message — don't modify it unless the resolution changed the commit's intent.

4. Repeat until done

Keep resolving and continuing until the operation completes. Track progress:

Resolving commit 3/7: fix(auth): handle token expiry

Finish

Show the result

git log --oneline -10

Show what the branch looks like after the operation. Summarize:

• How many conflicts were resolved (and how many were auto-resolved vs. asked about)
• Which commits were replayed (for rebase)

Offer to push

If the branch has a remote tracking branch and this was a rebase (which rewrites history):

Use AskUserQuestion:

• Force-push — run git push --force-with-lease to update the remote branch
• Don't push — leave the changes local for now

Always use --force-with-lease over --force — it's safer because it fails if someone else pushed to the branch in the meantime.

For merges (which don't rewrite history), offer a regular git push instead.

Aborting

If the user wants to stop mid-resolution, or if the conflicts are too complex:

git rebase --abort

(Or git merge --abort / git cherry-pick --abort.)

This restores the branch to its state before the operation started. Always mention this option if the user seems unsure about a resolution.