Technische Samenvatting: REFINE – Een Multi-Agent LLM-aanpak voor Bewijsgestuurde Code-refactoring

Probleemstelling

Hoewel Large Language Models (LLM's) sterke capaciteiten vertonen in codegeneratie en -transformatie, staat hun toepassing op software-refactoring voor aanzienlijke uitdagingen. Effectieve refactoring vereist niet alleen het wijzigen van code om kwaliteitsissues (code smells) te verminderen, maar ook het waarborgen dat wijzigingen geen nieuwe defecten introduceren, de externe gedragingen niet veranderen of kritieke structurele elementen (bijv. publieke API's, assertions) verwijderen.

Huidige LLM-ondersteunde refactoring-benaderingen missen vaak een rigoureuze verificatie, wat leidt tot risico's zoals gehallucineerde suggesties, inconsistente transformaties en het verwijderen van gedragsrelevante codestructuren. Er is behoefte aan een systematische aanpak die:

1. LLM's begeleidt met bewijs uit statische analyse.
2. Een multi-agent workflow orkestreert om wijzigingen te plannen, te genereren en te verifiëren.
3. Verifieerbaar bewijs levert van wat er is gewijzigd, welke risico's blijven bestaan en of de output een levensvatbare refactoring-kandidaat is in plaats van een automatisch geaccepteerde oplossing.

Methodologie: De REFINE Workflow

De auteurs introduceren REFINE (Refactoring with Evidence-aware Flow for Integrated ageNtic Execution), een tool-agnostische, bewijsbewuste multi-agent framework ontworpen voor Java file-level refactoring. Het systeem is geïmplementeerd als een research-prototype met een Next.js interface, een Java Spring Boot backend (voor statische analyse via PMD 7.x), en een Python agent service (gebruikmakend van LangGraph v1.1) voor orchestratie.

De workflow werkt via drie primaire stadia:

1. Taakkarakterisering

• Input: Een enkel Java-bestand uit een open-source project.
• Bewijsverzameling: Statische analyse (PMD) identificeert file-level code smells en regel-specifiek bewijs.
• Contextualisering: Het systeem extraheert publieke API-signatures, werkruimtecontext en prioriteert gedetecteerde smells om een begrensde refactoring-taak te vormen.

2. Refactoring Orchestratie

De workflow coördineert elf verschillende rollen (agents) om het proces te beheren:

• Planning Agent: Combineert deterministische regelgebaseerde begeleiding met optionele LLM-verfijning om een smell-georiënteerd refactoringplan te creëren.
• Refactoring Agent: Roept een LLM aan om een kandidaat-transformatie te genereren op basis van het plan, de originele broncode en restricties (bijv. het behoud van publieke API's).
• Verification Agent: Analyseert de gegenereerde kandidaat tegen geconfigureerde bewijscontroles voordat deze wordt behouden.

3. Verificatie-trace & Analyse

REFINE behandelt de LLM-output niet als definitief. In plaats daarvan wordt het getransformeerde bestand opnieuw geanalyseerd om te berekenen:

• Smell Reductie: Absolute ($\Delta_{smell} = B - A$) en relatieve verbeteringen in gedetecteerde code smells.
• Statische Preservatie Proxies: Controles op het behoud van publieke API's, exception handling, framework-contracten, conditionele logica en kritieke assert/fail calls.
• Foutdiagnostiek: Registreert specifieke redenen voor afwijzing (bijv. verwijdering van een publieke methode).
• Traceerbaarheid: Slaat de originele bron, de gegenereerde kandidaat, de agent-stappen, metrieken en verificatie-uitkomsten op om elke beslissing te koppelen aan het bewijs.

Experimenteel Ontwerp

• Dataset: 450 Java-bestanden uit 15 open-source systemen (bijv. JHotDraw, Apache Ant, Guava, JabRef), geselecteerd via gestratificeerde steekproeftrekking op basis van het aantal code-smells en Lines of Code (LOC).
• LLM Configuraties: Drie frontier modellen werden geëvalueerd: OpenAI GPT-5.5, Google Gemini 3.1 Pro Preview, en Anthropic Claude Opus 4.8.
• Schaal: Dit resulteerde in 1.350 model-pass outputs.
• Baseline: Een gematchte direct-prompt baseline werd uitgevoerd op een subset van 150 bestanden om de multi-agent workflow te vergelijken met eenvoudige prompting.
• Metrieken: Reductie van code-smells, kwaliteitsindicatoren (Cyclomatic Complexity, Maintainability Index, etc.), structurele wijzigingen en preservatie-risico's.

Belangrijkste Resultaten

1. Code Smell Reductie (RQ1)

REFINE bereikte substantiële reducties in gedetecteerde code smells over alle drie de LLM-configuraties:

• Totale Reductie: 68,26% (GPT-5.5), 72,79% (Gemini 3.1), en 68,49% (Opus 4.8).
• Major Smells: De meest significante verbeteringen waren in major code smells (86,51% tot 91,60% reductie).
• Kwaliteitsindicatoren: Verbeteringen in bredere kwaliteitsmetrieken waren niet uniform. Terwijl Gemini 3.1 significante reducties liet zien in Cyclomatic Complexity en LCOM, vertoonden andere metrieken (Maintainability, Testability, Halstead effort) gemengde of zelfs negatieve veranderingen, afhankelijk van het model.

2. Preservatie en Risico's (RQ2)

• Hoge Pass Rates: De meeste statische preservatie-indicatoren (publieke methode-signatures, exception handling, framework-contracten) slaagden met hoge percentages (81,8% tot 94,2%).
• Kritieke Risico's:
  • Assert/Fail Calls: Slechts 57,1% van de outputs behield kritieke assert/fail calls over alle modellen heen, wat wijst op een systemisch risico.
  • Verwijdering van Publieke Methoden: Dit was de meest concrete diagnostische fout. Gemini 3.1 vertoonde de hoogste mate van publieke methode-verwijdering (71 gevallen), gevolgd door GPT-5.5 (41) en Opus 4.8 (34).

3. Refactoring Gedrag (RQ3)

Verschillende modellen bereikten smell-reductie via verschillende edit-profielen:

• GPT-5.5: Produceerde de meest compacte edities.
• Gemini 3.1: Vertoonde een "deletion-heavy" profiel, waarbij de meeste regels en methoden werden verwijderd.
• Opus 4.8: Toonde een "extraction-heavy" profiel met het hoogste aantal methode-extracties.
• Correlatie: Grotere edit-volumes correleerden met een hogere absolute smell-reductie, maar niet noodzakelijkerwijs met een hogere relatieve reductie.

4. Vergelijking met Direct Prompting

Op de gematchte subset van 150 bestanden presteerde REFINE beter dan direct prompting op het gebied van:

• Smell Reductie: Mediaan totale reductie van 100,0% (REFINE) versus 20,8% (Direct Prompt).
• Edit Footprint: Kleinere mediane churn (14 LOC versus 65 LOC).
• API Veiligheid: Minder verwijderingen van publieke methoden (46 gevallen versus 112).
• Trade-off: Direct prompting behield kritieke assert/fail constructen vaker (100% versus 58%).

Betekenis en Claims

Het artikel positioneert REFINE niet als een vervanging voor gedrag-behoudende refactoring-tools, maar als een traceerbaar, bewijsbewust mechanisme voor het genereren en evalueren van refactoring-kandidaten.

• Bewijsbewustzijn: De primaire bijdrage is het koppelen van gegenereerde code aan het specifieke statische bewijs (smells) dat de wijziging motiveerde en de verificatiecontroles die het heeft doorstaan of gefaald.
• Gecontroleerde Generatie: De multi-agent workflow biedt een meer gecontroleerde kandidaat-generatie dan direct prompting, wat resulteert in kleinere edities en minder accidentele API-verwijderingen, hoewel het alle gedragsrisico's niet elimineert.
• Beperkingen: De auteurs stellen expliciet dat de gegenereerde outputs kandidaten zijn, geen productie-klare refactorings. De statische preservatie-controles zijn proxies en bewijzen geen gedragsgelijkenis.
• Praktische Implicatie: Gegenereerde kandidaten vereisen compilatie, testen, dependency-analyse en menselijke review voordat ze kunnen worden toegepast, vooral in dependency-rijke of systeem-niveau omgevingen.

De studie concludeert dat hoewel bewijsbewuste multi-agent workflows veelbelovend zijn voor gerichte file-level code-smell mitigatie, noch direct prompting, noch de multi-agent aanpak momenteel voldoende bewijs levert van volledige gedragsbehoud om autonoom te opereren in complexe software-ecosystemen.