Merge Conflict Resolver Pro

Stop staring at conflict markers across 8 files for 45 minutes. Get semantic analysis, resolution strategies, and safety verification in one pass.

Free vs Pro

The free resolver handles standard content conflicts with strategy selection. Pro adds the hard cases: rename/delete conflicts across refactors, binary file conflicts, submodule pointer clashes, semantic conflict detection (both sides compile but behavior breaks), and a conflict-history learner that recognizes your repo's recurring merge patterns. Free solves the merge in front of you — Pro prevents the next three.

Upgrade Path

If your team hits conflicts daily or you maintain long-lived branches, Pro's semantic detection and history learning are the upgrade.

The Problem

You've rebased a long-running feature branch and git status shows 6 conflicted files. Some are simple same-line edits, but two involve renamed functions where one branch renamed calculate_total to compute_sum and the other added a new call to calculate_total. You spend 40 minutes reading both sides of each hunk, guessing which intent is correct, resolving the text-level conflicts, then discovering the code compiles but is semantically wrong — the renamed function is only partially updated, leaving an orphaned reference that crashes at runtime.

What You Get

• Conflict landscape assessment — categorizes every conflicted file into same-line, adjacent-line, semantic, structural, or N-way complexity tiers with an automated conflict marker scanner
• Semantic conflict detection — goes beyond text markers to detect function renames, type signature changes, and behavioral modifications that compile but alter semantics incorrectly
• Resolution strategy matrix — prescribes the right approach per conflict type: "Ours" for bug fixes, "Theirs" for feature branches, Smart Merge for coexisting changes, and "Defer to Expert" for domain-specific logic
• Batch conflict resolution script — scripts/apply_resolution.py applies resolution patterns across multiple files with a single command, preserving both sides' intent with proper ordering
• Post-resolution safety verifier — runs conflict marker check, type compilation, and related test suites to confirm the merge is clean and correct before git merge --continue
• Conflict resolution documentation template — logs every resolution decision (strategy chosen, rationale, both intents) for future reference and team knowledge sharing

Why This Beats Prompting It Yourself

When an AI agent encounters a merge conflict, it typically resolves each hunk independently — picking "ours" or "theirs" based on which side is newer — without understanding the semantic relationship between conflicting changes. This results in compiles-but-wrong merges: the text is resolved but the logic is subtly broken. This skill forces a 5-phase workflow: assess scope → analyze each hunk → choose strategy per type → resolve → verify, catching semantic conflicts that text-level resolution misses entirely.

Example Session

You: I have a merge conflict across 4 files after rebasing feature/payment-v2 onto main. Here's the git status output.

Agent: Analyzed 4 conflicted files. File 1 (payment.py): Same-line — both sides changed MAX_RETRIES, feature branch intentionally increased from 3→5. Resolution: keep theirs (feature intent). File 2 (order.py): Semantic — calculate_total renamed to compute_sum on feature branch, but main added a new call to calculate_total. Resolution: use new name compute_sum and verify all references updated. File 3 (utils.py): Adjacent — both added functions to the same module, no overlap. Resolution: merge both with ordering based on dependency graph. File 4 (config.py): Structural — main deleted the config file that feature still imports. Resolution: defer to expert — flagged for human review. Safety check: 0 conflict markers remaining, tsc --noEmit passes, related test suite green.

Use Cases

• Resolving rebase conflicts on a monorepo with 50+ microservices where conflicts span module boundaries
• Handling cherry-pick conflicts when backporting security fixes to older release branches
• Systematically resolving conflicts in a PR with 3+ contributors who edited the same module
• Training junior developers on conflict resolution by showing the analysis and rationale for each choice
• Setting up automated conflict resolution with safety verification in a CI/CD merge queue

Known Limitations

Semantic conflict detection works best in statically-typed languages (TypeScript, Python, Go) where type signatures are explicit. Dynamic languages with duck typing may produce false negatives for semantic conflicts because the type system cannot confirm function compatibility.

Tags: git merge-conflict dev-workflow version-control code-quality

Version: 1.0.0