💻 computer science

Rover: Context-aware Conflict Resolution with LLM

Rover is een nieuw systeem voor conflictoplossing dat grote taalmodellen verbetert door programmeeranalyse en een Multi-layer Code Property Graph te integreren om contextbewuste prompts te genereren, waardoor het bestaande hulpmiddelen overtreft in het nauwkeurig oplossen van complexe code-mergeconflicten.

Oorspronkelijke auteurs: Qingyu Zhang, Junzhe Li, Jiayi Lin, Changhua Luo, Chenxiong Qian

Gepubliceerd 2026-05-19

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Qingyu Zhang, Junzhe Li, Jiayi Lin, Changhua Luo, Chenxiong Qian

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat jij en een vriend tegelijkertijd hetzelfde receptenboek bewerken. Jij besluit een snufje zout aan de soep toe te voegen, terwijl je vriend besluit een kop suiker toe te voegen. Als je probeert je twee versies te combineren, raakt het boek in de war: "Voegen we zout toe? Suiker? Beide? Geen van beide?" Dit is een samenvoegconflict.

In de wereld van software doen miljoenen ontwikkelaars dit elke dag. Meestal proberen computers deze conflicten automatisch op te lossen, maar ze gaan er vaak naast zitten omdat ze alleen naar de directe regels tekst kijken en het grotere plaatje missen. Als je een variabelenaam in één bestand verandert, kan dat een functie in een compleet ander bestand kapotmaken. Standaardtools "zien" die connectie niet.

Maak kennis met Rover, een nieuw hulpmiddel dat is ontworpen als de ultieme "super-editor" voor deze conflicten. Hier is hoe het werkt, met eenvoudige analogieën:

1. Het Probleem: De "Blinde" Editor

Stel je een robot voor die probeert een typefout in een roman te herstellen. Als de robot alleen naar de zin met de typefout kijkt, kan hij de spelling misschien wel verbeteren, maar per ongeluk de betekenis van de hele alinea verstoren omdat hij niet wist wat het personage drie hoofdstukken eerder zou moeten doen.

Huidige tools zijn als deze robot. Ze kijken naar de conflicterende regels en de paar regels direct ernaast. Ze missen de "langeafstands"-connecties, zoals een functie die in Bestand A is gedefinieerd maar in Bestand B wordt gebruikt.

2. De Oplossing: Rover's "Super-kaart" (MtCPG)

Rover leest niet alleen de tekst; het bouwt een Multi-layer Code Property Graph (MtCPG).

Denk hierbij aan een enorme, interactieve metrokaart van het hele softwareproject.

Standaardtools kijken alleen naar de straat waar het ongeval heeft plaatsgevonden.
Rover's Kaart toont elk station, elk spoor en elke verbinding tussen verschillende lijnen, zelfs als ze in verschillende steden (bestanden) liggen.

Deze kaart houdt bij:

Wie met wie praat: Als een functie in één bestand een variabele in een ander bestand aanroept, tekent de kaart een lijn tussen hen.
De hiërarchie: Het weet dat een specifieke regel code behoort tot een specifieke functie, die op zijn beurt behoort tot een specifieke klasse.
Het "Waarom": Het begrijpt dat als je een definitie verandert, alles wat ermee verbonden is, wordt beïnvloed, zelfs als het 100 regels verderop staat of in een ander bestand.

3. Het Proces: De Juiste Context Vinden

Wanneer een conflict optreedt, pakt Rover niet zomaar de tekst naast de fout. In plaats daarvan gebruikt het zijn Metrokaart om de connecties te traceren.

Locatie van het Conflict: Het vindt de exacte plek waar de twee versies het oneens zijn.
Traceer de Lijnen: Het volgt de "sporen" op zijn kaart om elk stukje code te vinden dat met dat conflict verbonden is. Misschien gaat het conflict over een variabele die in een ander bestand is gedefinieerd? Rover vindt dat bestand en pakt die code ook.
Groeperen van de Aanwijzingen: Het verzamelt al deze verbonden stukjes code in een "contextbundel". Het is alsof je alle getuigen en bewijzen verzamelt die gerelateerd zijn aan een misdaadplek, in plaats van alleen naar de misdaadplek zelf te kijken.

4. De Oplossing: De Slimme AI

Zodra Rover deze rijke "contextbundel" heeft, geeft hij deze door aan een Large Language Model (LLM) – een zeer slimme AI die weet hoe je code schrijft.

Zonder Rover: De AI krijgt een klein stukje code en moet de rest raden. Het raadt vaak verkeerd omdat het context mist.
Met Rover: De AI krijgt het conflict plus de volledige "Metrokaart" van gerelateerde code. Het kan het hele plaatje zien. Het begrijpt: "Ah, deze variabele wordt hier gebruikt, en die functie verwacht dit type data."

De AI schrijft vervolgens de perfecte oplossing die aan beide versies van de code voldoet, waarbij de intentie van beide ontwikkelaars behouden blijft.

5. De Resultaten: Waarom Het Belangrijk Is

De onderzoekers hebben Rover getest tegen:

Standaard AI: Gewoon de AI die kijkt naar nabijgelegen tekst.
Oude Machine Learning-tools: Tools die zijn getraind op specifieke patronen.
Andere "Hulp"-tools: Tools die proberen gerelateerde code te vinden, maar vaak de diepe connecties missen.

Het Resultaat:
Rover was aanzienlijk beter in het oplossen van conflicten.

Het produceerde oplossingen die meer leken op wat menselijke ontwikkelaars zouden hebben geschreven.
Het hanteerde complexe situaties waarbij code in één bestand afhankelijk was van code in een ander bestand, wat andere tools niet konden oplossen.
Het werkte over verschillende programmeertalen (C, Java, Python) zonder dat het voor elk opnieuw getraind hoefde te worden.

Samenvatting

Denk aan Rover als een detective die niet alleen naar de misdaadplek (het conflict) kijkt, maar ook elke getuige interviewt en elke alibi (de code-afhankelijkheden) controleert voordat hij de zaak oplost. Door de AI een complete kaart van de relaties in de software te geven, zorgt Rover ervoor dat de uiteindelijke samengevoegde code correct, veilig is en daadwerkelijk werkt.

Technische Samenvatting: Rover: Contextbewuste Conflictoplossing met LLM

1. Probleemstelling

Het samenvoegen van code in grootschalige softwareprojecten is een aanzienlijke knelpunt, waarbij vaak uitgebreide handmatige ingrepen nodig zijn om samenvoegingsconflicten op te lossen. Bestaande oplossingen staan voor kritieke beperkingen:

Tekstuele en Structurele Samenvoeging: Traditionele tools (bijv. Git, structurele samenvoegtools) missen vaak het vermogen om de intentie van de ontwikkelaar af te leiden of complexe semantische afhankelijkheden te verwerken, wat leidt tot onjuiste samenvoegingen of onopgeloste conflicten die handmatige correctie vereisen.
Machine Learning-benaderingen: Eerdere ML-modellen (bijv. MergeGen) zijn vaak beperkt tot specifieke talen of conflictpatronen en vereisen taakspecifiek vooraf trainen.
LLM-gebaseerde benaderingen: Hoewel Large Language Models (LLM's) veelbelovend zijn, worstelen ze met conflicten die complexe code-afhankelijkheden omvatten die verder reiken dan de directe omgeving van het conflict. Bestaande methoden vertrouwen doorgaans op aangrenzende codeblokken als context, wat vaak ontoereikend is voor het vastleggen van ware semantische afhankelijkheden (bijv. variabele definities, interacties tussen bestanden).
Agent-gebaseerde benaderingen: Hoewel agenten repositories kunnen verkennen om context te vinden, lijden ze onder niet-determinisme, hoge rekenkundige overhead en moeilijkheden bij het toeschrijven van fouten aan ontbrekende context versus redeneerfouten.

De kernuitdaging is dat LLM's geen contextbewustzijn hebben met betrekking tot code-afhankelijkheden die zich over meerdere bestanden of abstractieniveaus uitstrekken, en bestaande afhankelijkheidsanalyse-tools zijn óf niet taalagnostisch óf slagen er niet in om afhankelijkheden over meerdere versies van code vast te leggen.

2. Methodologie: Het Rover-systeem

Rover is een nieuw geautomatiseerd systeem voor conflictoplossing dat programma-analyse integreert met Large Language Models (LLM's). Het ontwerp wordt geleid door het inzicht dat effectieve oplossing een principieel, analyseerbaar begrip van context vereist dat is afgeleid van afhankelijkheidsanalyse, in plaats van heuristische exploratie of eenvoudige vensters met aangrenzende code.

2.1 Multi-layer Code Property Graph (MtCPG)

Om het gebrek aan uitgebreide afhankelijkheidsanalyse aan te pakken, introduceert Rover MtCPG, een nieuw representatieschema gebaseerd op het Code Property Graph (CPG)-raamwerk (specifiek met Joern).

Architectuur: MtCPG breidt de standaard CPG uit door een hiërarchische structuur in te voeren met hoge-laag knopen (bijv. TypeDef, MethodDef, GlobalVarDef, ImportDef) en lage-laag knopen (bijv. MemberDef, MethodStmt, MethodVarDef).
Edge-types:
- Cross-layer edges: Verbinden hoge-laag definities met hun interne lage-laag componenten, wat fijnmazig redeneren mogelijk maakt.
- Inter-file edges: Modelleren expliciet afhankelijkheden tussen knopen in verschillende bronbestanden via ImportDef-knopen, waardoor afhankelijkheidsanalyse tussen bestanden mogelijk is zonder bronbestanden te flattten.
Voordelen: In tegenstelling tot standaard CPG's legt MtCPG afhankelijkheden tussen bestanden en abstracties op definicieniveau vast, wat cruciaal is voor het begrijpen van conflicten die zich over meerdere bestanden uitstrekken of type-definities omvatten die elders zijn geplaatst.

2.2 Contextgeneratie via Graph-Text Alignment

Rover aligneert de tekstuele representatie van codewijzigingen (van Git-samenvoegresultaten) met de MtCPG-structuur om semantisch betekenisvolle contexten te genereren.

Graph-Text Alignment: Een "kleurmechanisme" (coloring mechanism) kopt code-wijzigingsblokken (diffs) toe aan specifieke knopen in de MtCPG met behulp van een segmentboom gebaseerd op regelnummers.
Contextclustering: Rover maakt gebruik van een Multi-Source Breadth-First Search (MS-BFS)-algoritme op de MtCPG, startend bij conflictknopen. Het verkent afhankelijkheden tot een configureerbare diepte $k$ om gerelateerde codeblokken te groeperen in "contexten".
Cross-versie integratie: Contexten worden onafhankelijk gegenereerd voor beide versies die worden samengevoegd en vervolgens samengevoegd met behulp van een disjoint-set union-benadering om ervoor te zorgen dat alle relevante afhankelijkheden over beide versies worden vastgelegd.

2.3 Generatie van Oplossing

De uiteindelijke oplossing wordt gegenereerd door een LLM (bijv. Qwen3-30B-A3B) die wordt geleid door een gestructureerde prompt met:

Taakdefinitie: Duidelijke instructies over de rol en het doel.
Chain-of-Thought (CoT): Een redeneerproces in drie stappen waarbij de LLM moet analyseren wat de oorzaak is, de beoogde logica voor beide versies moet afleiden en de beste samenvoegstrategie moet bepalen.
Invoer/Outputformaat: Gebruikt het "diff"-formaat voor gestroomlijnde verwerking.
Contextuele invoer: De conflicterende code gecombineerd met de semantisch relevante context die is opgehaald uit de MtCPG.

3. Belangrijkste Bijdragen

Het artikel claimt de volgende bijdragen:

MtCPG: Een nieuw representatieschema dat uitgebreide afhankelijkheden voor alle codecomponenten vastlegt, inclusief relaties tussen bestanden en tussen lagen, en zo de beperkingen van standaard CPG's overwint.
Methodologie voor Contextclassificatie: Een principieel aanpak om codeblokken te classificeren op basis van MtCPG-connectiviteit, waardoor contexten worden gegenereerd die beter geschikt zijn voor het beoordelen van code-afhankelijkheid dan eenvoudige vensters met aangrenzende code.
Rover-systeem: Een implementatie van een LLM-gebaseerd hulpmiddel voor conflictoplossing dat MtCPG integreert. Het wordt geëvalueerd op het ConGra-dataset en blijkt te presteren bovenop standalone LLM's en basistools.

4. Experimentele Resultaten

De auteurs hebben Rover geëvalueerd met behulp van het ConGra-dataset (met uitzondering van C++ vanwege de volwassenheid van de tool) en een subset van het dataset van WizardMerge (op C gebaseerd). De metrieken omvatten Edit Distance (ED), Winnowing Similarity (WS) en Cosine Similarity (CS).

MtCPG vs. CPG: MtCPG verhoogde het aantal grafknopen met ongeveer 3,4% en het aantal edges met ongeveer 25% in vergelijking met de standaard CPG, waardoor aanzienlijk rijker informatie over afhankelijkheden wordt vastgelegd.
Prestaties ten opzichte van Baselines:
- Standalone LLM: Rover presteerde 13,29% (WS), 10,46% (ED) en 9,79% (CS) beter dan een standalone LLM (Qwen3-30B-A3B).
- Machine Learning-baseline: In vergelijking met MergeGen boekte Rover verbeteringen van 17,72% (WS), 15,90% (ED) en 9,10% (CS).
- Tool-ondersteunde LLM: Rover overtrof de combinatie van LLM met WizardMerge met 3,82% (WS), 1,85% (ED) en 4,07% (CS).
Contextgevoeligheid: De studie vond uit dat het vergroten van de contextgrootte (zij het aangrenzende regels of grafdiepte $k$ ) de prestaties niet lineair verbetert. Er bestaat een optimale $k$ (bijv. $k=4$ ); daarbuiten verslechteren irrelevante, verre afhankelijkheden de prestaties door het model af te leiden.
Dekking: Rover behaalde een conflictdekkingspercentage van 98,83% op het dataset van WizardMerge, aanzienlijk hoger dan de 90,67% van WizardMerge, voornamelijk omdat Rover werkt op broncode zonder volledige projectcompilatie te vereisen.
Modelafhankelijkheid: De effectiviteit van Rover varieerde per LLM. Het verbeterde de prestaties op grotere modellen (gpt-oss-20b) maar verslechterde de prestaties op kleinere modellen (Llama-3.1-8B), wat wijst op een "redeneerknelpunt" waarbij kleinere modellen moeite hebben om lange, complexe contexten te interpreteren.

5. Betekenis en Claims

Het artikel positioneert Rover als een belangrijke stap richting volledig geautomatiseerde, contextbewuste conflictoplossing.

Deterministische Context: In tegenstelling tot agent-gebaseerde systemen biedt Rover een deterministische en analyseerbare basis voor contextselectie, waardoor het niet-determinisme van door LLM's gedreven exploratie wordt vermeden.
Overbrugging van de Kloof: Het slaagt erin de kloof te overbruggen tussen programma-analyse (die afhankelijkheden begrijpt maar geen generatieve capaciteit heeft) en LLM's (die code kunnen genereren maar geen diep contextbewustzijn hebben).
Praktijktoepasbaarheid: Door te werken op het niveau van broncode en geen volledige projectcompilatie te vereisen, is Rover robuuster en toepasbaarder in real-world samenvoegscenario's dan tools die vertrouwen op compiler-gebaseerde analyse (zoals WizardMerge).
Beperkte Beperkingen: De auteurs erkennen dat MtCPG momenteel beperkingen heeft met bepaalde taal-specifieke functies (bijv. inline assembly in C, complexe uitzonderingsbehandeling) en dat op tekenreeksen gebaseerde metrieken geen volledige functionele correctheid garanderen, hoewel handmatige steekproefvalidatie een sterke positieve correlatie liet zien tussen metriekscores en acceptatie van de oplossing.

De auteurs concluderen dat juiste contextuele informatie, afgeleid van principieel afhankelijkheidsanalyse, essentieel is voor het verbeteren van LLM-gebaseerde conflictoplossing, en dat Rover dit potentieel effectief demonstreert.