Ataraxy-Labs/weave: Entity-level semantic merge driver for Git. Resolves conflicts that git can’t by understanding code structure via tree-sitter. 31/31 clean merges vs git’s 15/31. · GitHub

Resolves merge conflicts that Git can’t by understanding code structure via tree-sitter.

Git merges by comparing lines. When two branches both add code to the same file — even to completely different functions — Git sees overlapping line ranges and declares a conflict:

<<<<<<< HEAD
export function validateToken(token: string): boolean ⚡
=======
export function formatDate(date: Date): string 💬
>>>>>>> feature-branch

These are completely independent changes. There’s no real conflict. But someone has to manually resolve it anyway.

This happens constantly when multiple AI agents work on the same codebase. Agent A adds a function, Agent B adds a different function to the same file, and Git halts everything for a human to intervene.

Weave replaces Git’s line-based merge with entity-level merge. Instead of diffing lines, it:

1. Parses all three versions (base, ours, theirs) into semantic entities — functions, classes, JSON keys, etc. — using tree-sitter
2. Matches entities across versions by identity (name + type + scope)
3. Merges at the entity level:
   • Different entities changed → auto-resolved, no conflict
   • Same entity changed by both → attempts intra-entity merge, conflicts only if truly incompatible
   • One side modifies, other deletes → flags a meaningful conflict

The same scenario above? Weave merges it cleanly with zero conflicts — both functions end up in the output.

The key difference: Git produces false conflicts on independent changes because they happen to be in the same file. Weave only conflicts on actual semantic collisions when two branches change the same entity incompatibly.

Tested on real merge commits from major open-source repositories. For each merge commit, we replay the merge with both Git and Weave, then compare against the human-authored result.

• Wins: Merge commits where Git conflicted but Weave resolved cleanly
• Regressions: Cases where Weave introduced errors (0 across all repos)
• Human Match: How often Weave’s output exactly matches what the human wrote
• Resolution Rate: Percentage of all merge commits Weave resolved vs total attempted

Zero regressions across all repositories. Every “win” is a place where a developer had to manually resolve a false conflict that Weave handles automatically.

When a real conflict occurs, weave gives you context that Git doesn’t:

<<<<<<< ours — function `process` (both modified)
export function process(data: any) {
    return JSON.stringify(data);
}
=======
export function process(data: any) {
    return data.toUpperCase();
}
>>>>>>> theirs — function `process` (both modified)

You immediately know: what entity conflicted, what type it is, and why it conflicted.

TypeScript, JavaScript, Python, Go, Rust, JSON, YAML, TOML, Markdown. Falls back to standard line-level merge for unsupported file types.

# Build
cargo build --release

# In your repo:
./target/release/weave-cli setup

# Or manually:
git config merge.weave.name "Entity-level semantic merge"
git config merge.weave.driver "/path/to/weave-driver %O %A %B %L %P"
echo "*.ts *.tsx *.js *.py *.go *.rs *.json *.yaml *.toml *.md merge=weave" >> .gitattributes

Then use Git normally. git merge will use weave automatically for configured file types.

Dry-run a merge to see what weave would do:

weave-cli preview feature-branch

  src/utils.ts — auto-resolved
    unchanged: 2, added-ours: 1, added-theirs: 1
  src/api.ts — 1 conflict(s)
    ✗ function `process`: both modified

✓ Merge would be clean (1 file(s) auto-resolved by weave)

weave-core       # Library: entity extraction, 3-way merge algorithm, reconstruction
weave-driver     # Git merge driver binary (called by git via %O %A %B %L %P)
weave-cli        # CLI: `weave setup` and `weave preview`

Uses sem-core for entity extraction via tree-sitter grammars.

         base
        /    \
     ours    theirs
        \    /
       weave merge

1. Parse all three versions into semantic entities via tree-sitter
2. Extract regions — alternating entity and interstitial (imports, whitespace) segments
3. Match entities across versions by ID (file:type:name:parent)
4. Resolve each entity: one-side-only changes win, both-changed attempts intra-entity 3-way merge
5. Reconstruct file from merged regions, preserving ours-side ordering
6. Fallback to line-level merge for files >1MB, binary files, or unsupported types