Resumen Técnico: Rover: Resolución de Conflictos Consciente del Contexto con LLM

1. Declaración del Problema

La fusión de código en proyectos de software a gran escala es un cuello de botella significativo, que a menudo requiere una intervención manual extensa para resolver conflictos de fusión. Las soluciones existentes enfrentan limitaciones críticas:

• Fusión Textual y Estructural: Las herramientas tradicionales (por ejemplo, Git, herramientas de fusión estructural) a menudo carecen de la capacidad de inferir la intención del desarrollador o manejar dependencias semánticas complejas, lo que lleva a fusiones incorrectas o conflictos sin resolver que requieren corrección manual.
• Enfoques de Aprendizaje Automático: Los modelos de ML anteriores (por ejemplo, MergeGen) a menudo se limitan a lenguajes específicos o patrones de conflicto y requieren preentrenamiento específico para la tarea.
• Enfoques Basados en LLM: Aunque los Modelos de Lenguaje Grandes (LLM) muestran promesa, luchan con conflictos que involucran dependencias de código complejas que se extienden más allá de la vecindad inmediata del conflicto. Los métodos existentes suelen depender de bloques de código adyacentes como contexto, lo que a menudo es insuficiente para capturar dependencias semánticas reales (por ejemplo, definiciones de variables, interacciones entre archivos).
• Enfoques Basados en Agentes: Aunque los agentes pueden explorar repositorios para encontrar contexto, sufren de no determinismo, alta sobrecarga computacional y dificultad para atribuir fallos a la falta de contexto frente a errores de razonamiento.

El desafío central es que los LLM carecen de conciencia contextual respecto a las dependencias de código que abarcan múltiples archivos o niveles de abstracción, y las herramientas existentes de análisis de dependencias o no son agnósticas al lenguaje o fallan al capturar dependencias a través de múltiples versiones de código.

2. Metodología: El Sistema Rover

Rover es un sistema novedoso de resolución automática de conflictos que integra análisis de programas con Modelos de Lenguaje Grandes (LLM). Su diseño se guía por la idea de que una resolución efectiva requiere una noción de contexto principista y analizable derivada del análisis de dependencias, en lugar de una exploración heurística o ventanas de código adyacentes simples.

2.1 Grafo de Propiedades de Código de Múltiples Capas (MtCPG)

Para abordar la falta de un análisis de dependencias integral, Rover introduce MtCPG, un nuevo esquema de representación construido sobre el marco del Grafo de Propiedades de Código (CPG) (específicamente utilizando Joern).

• Arquitectura: MtCPG extiende el CPG estándar introduciendo una estructura jerárquica con nodos de capa alta (por ejemplo, TypeDef, MethodDef, GlobalVarDef, ImportDef) y nodos de capa baja (por ejemplo, MemberDef, MethodStmt, MethodVarDef).
• Tipos de Aristas:
  • Aristas intercapa: Conectan definiciones de capa alta con sus componentes internos de capa baja, permitiendo un razonamiento fino.
  • Aristas interarchivo: Modelan explícitamente las dependencias entre nodos en diferentes archivos fuente a través de nodos ImportDef, permitiendo un análisis de dependencias entre archivos sin aplanar los archivos fuente.
• Ventajas: A diferencia de los CPG estándar, MtCPG captura dependencias entre archivos y abstracciones a nivel de definición, que son cruciales para entender conflictos que abarcan múltiples archivos o involucran definiciones de tipo ubicadas en otro lugar.

2.2 Generación de Contexto mediante Alineación Grafo-Texto

Rover alinea la representación textual de los cambios de código (de los resultados de fusión de Git) con la estructura MtCPG para generar contextos semánticamente significativos.

• Alineación Grafo-Texto: Un mecanismo de "coloreado" mapea los bloques de cambios de código (diffs) a nodos específicos en el MtCPG utilizando un árbol de segmentos basado en números de línea.
• Agrupación de Contexto: Rover emplea un algoritmo de Búsqueda en Amplitud de Múltiples Fuentes (MS-BFS) en el MtCPG comenzando desde los nodos de conflicto. Explora dependencias hasta una profundidad configurable $k$ para agrupar bloques de código relacionados en "contextos".
• Integración Inter-versiones: Los contextos se generan independientemente para ambas versiones que se fusionan y luego se combinan utilizando un enfoque de unión de conjuntos disjuntos para asegurar que se capturen todas las dependencias relevantes a través de ambas versiones.

2.3 Generación de Resolución

La resolución final es generada por un LLM (por ejemplo, Qwen3-30B-A3B) guiado por un prompt estructurado que contiene:

1. Definición de Tarea: Instrucciones claras sobre el rol y el objetivo.
2. Cadena de Pensamiento (CoT): Un proceso de razonamiento de tres pasos que requiere que el LLM analice la causa raíz, infiera la lógica pretendida para ambas versiones y determine la mejor estrategia de fusión.
3. Formato de Entrada/Salida: Utiliza el formato "diff" para un procesamiento optimizado.
4. Entrada Contextual: El código conflictivo combinado con el contexto semánticamente relevante recuperado del MtCPG.

3. Contribuciones Clave

El artículo afirma las siguientes contribuciones:

1. MtCPG: Un esquema de representación novedoso que captura dependencias integrales para todos los componentes de código, incluidas relaciones interarchivo e intercapa, superando las limitaciones de los CPG estándar.
2. Metodología de Clasificación de Contexto: Un enfoque principista para clasificar bloques de código basándose en la conectividad MtCPG, generando contextos más adecuados para evaluar la dependencia del código que las ventanas de código adyacentes simples.
3. Sistema Rover: Una implementación de una herramienta de resolución de conflictos basada en LLM que integra MtCPG. Se evalúa en el conjunto de datos ConGra y se demuestra que supera a los LLM independientes y a las herramientas de referencia.

4. Resultados Experimentales

Los autores evaluaron a Rover utilizando el conjunto de datos ConGra (excluyendo C++ debido a la madurez de la herramienta) y un subconjunto del conjunto de datos de WizardMerge (basado en C). Las métricas incluyeron Distancia de Edición (ED), Similitud Winnowing (WS) y Similitud Coseno (CS).

• MtCPG vs. CPG: MtCPG aumentó el número de nodos del grafo en ~3.4% y las aristas en ~25% en comparación con el CPG estándar, capturando información de dependencias significativamente más rica.
• Rendimiento frente a Líneas Base:
  • LLM Independiente: Rover superó a un LLM independiente (Qwen3-30B-A3B) en un 13.29% (WS), 10.46% (ED) y 9.79% (CS).
  • Línea Base de Aprendizaje Automático: En comparación con MergeGen, Rover logró mejoras del 17.72% (WS), 15.90% (ED) y 9.10% (CS).
  • LLM Asistido por Herramientas: Rover superó la combinación de LLM con WizardMerge en un 3.82% (WS), 1.85% (ED) y 4.07% (CS).
• Sensibilidad al Contexto: El estudio encontró que aumentar el tamaño del contexto (ya sea líneas adyacentes o profundidad del grafo $k$) no mejora linealmente el rendimiento. Existe un $k$ óptimo (por ejemplo, $k=4$); más allá de esto, dependencias irrelevantes y distantes degradan el rendimiento al distraer al modelo.
• Cobertura: Rover logró una tasa de cobertura de conflictos del 98.83% en el conjunto de datos de WizardMerge, significativamente mayor que el 90.67% de WizardMerge, principalmente porque Rover opera sobre código fuente sin requerir la compilación completa del proyecto.
• Dependencia del Modelo: La efectividad de Rover varió según el LLM. Mejoró el rendimiento en modelos más grandes (gpt-oss-20b) pero degradó el rendimiento en modelos más pequeños (Llama-3.1-8B), lo que sugiere un "cuello de botella de razonamiento" donde los modelos más pequeños luchan por interpretar contextos largos y complejos.

5. Significado y Afirmaciones

El artículo posiciona a Rover como un paso significativo hacia la resolución de conflictos totalmente automatizada y consciente del contexto.

• Contexto Determinista: A diferencia de los sistemas basados en agentes, Rover proporciona una base determinista y analizable para la selección de contexto, evitando el no determinismo de la exploración impulsada por LLM.
• Cerrando la Brecha: Conecta exitosamente la brecha entre el análisis de programas (que entiende dependencias pero carece de capacidad generativa) y los LLM (que pueden generar código pero carecen de una conciencia contextual profunda).
• Practicidad: Al operar a nivel de código fuente y no requerir la compilación completa del proyecto, Rover es más robusto y aplicable a escenarios de fusión del mundo real que las herramientas que dependen de análisis basados en compiladores (como WizardMerge).
• Limitaciones Modestas: Los autores reconocen que MtCPG actualmente tiene limitaciones con ciertas características específicas del lenguaje (por ejemplo, ensamblador en línea en C, manejo de excepciones complejo) y que las métricas basadas en cadenas no garantizan completamente la corrección funcional, aunque la validación mediante muestreo manual mostró una fuerte correlación positiva entre las puntuaciones de las métricas y la aceptación de la resolución.

Los autores concluyen que la información contextual adecuada, derivada de un análisis de dependencias principista, es esencial para mejorar la resolución de conflictos basada en LLM, y Rover demuestra este potencial de manera efectiva.