Resumo Técnico: Rover: Resolução de Conflitos Consciente de Contexto com LLM

1. Declaração do Problema

A mesclagem de código em projetos de software de grande escala é um gargalo significativo, exigindo frequentemente intervenção manual extensa para resolver conflitos de mesclagem. Soluções existentes enfrentam limitações críticas:

• Mesclagem Textual e Estrutural: Ferramentas tradicionais (por exemplo, Git, ferramentas de mesclagem estrutural) frequentemente carecem da capacidade de inferir a intenção do desenvolvedor ou lidar com dependências semânticas complexas, levando a mesclagens incorretas ou conflitos não resolvidos que exigem correção manual.
• Abordagens de Aprendizado de Máquina: Modelos de ML anteriores (por exemplo, MergeGen) são frequentemente limitados a linguagens específicas ou padrões de conflito e exigem pré-treinamento específico para a tarefa.
• Abordagens Baseadas em LLM: Embora os Modelos de Linguagem Grandes (LLMs) mostrem promessa, eles lutam com conflitos envolvendo dependências complexas de código que se estendem além da vizinhança imediata do conflito. Métodos existentes normalmente dependem de blocos de código adjacentes como contexto, o que é frequentemente insuficiente para capturar dependências semânticas reais (por exemplo, definições de variáveis, interações entre arquivos).
• Abordagens Baseadas em Agentes: Embora agentes possam explorar repositórios para encontrar contexto, eles sofrem de não determinismo, alto custo computacional e dificuldade em atribuir falhas à falta de contexto versus erros de raciocínio.

O desafio central é que os LLMs carecem de consciência de contexto em relação a dependências de código que abrangem múltiplos arquivos ou níveis de abstração, e as ferramentas existentes de análise de dependência ou não são agnósticas à linguagem ou falham em capturar dependências através de múltiplas versões de código.

2. Metodologia: O Sistema Rover

O Rover é um novo sistema automatizado de resolução de conflitos que integra análise de programa com Modelos de Linguagem Grandes (LLMs). Seu design é guiado pela percepção de que uma resolução eficaz requer uma noção de contexto principista e analisável derivada da análise de dependências, em vez de exploração heurística ou janelas simples de código adjacente.

2.1 Grafo de Propriedades de Código Multicamada (MtCPG)

Para abordar a falta de análise de dependência abrangente, o Rover introduz o MtCPG, um novo esquema de representação construído sobre a estrutura do Grafo de Propriedades de Código (CPG) (especificamente usando Joern).

• Arquitetura: O MtCPG estende o CPG padrão introduzindo uma estrutura hierárquica com nós de camada superior (por exemplo, TypeDef, MethodDef, GlobalVarDef, ImportDef) e nós de camada inferior (por exemplo, MemberDef, MethodStmt, MethodVarDef).
• Tipos de Arestas:
  • Arestas intercamada: Conectam definições de camada superior aos seus componentes internos de camada inferior, permitindo raciocínio fino.
  • Arestas interarquivo: Modelam explicitamente dependências entre nós em diferentes arquivos fonte através de nós ImportDef, permitindo análise de dependência entre arquivos sem achatar os arquivos fonte.
• Vantagens: Ao contrário dos CPGs padrão, o MtCPG captura dependências interarquivo e abstrações no nível de definição, que são cruciais para entender conflitos que abrangem múltiplos arquivos ou envolvem definições de tipo localizadas em outro lugar.

2.2 Geração de Contexto via Alinhamento Grafo-Texto

O Rover alinha a representação textual das alterações de código (dos resultados de mesclagem do Git) com a estrutura MtCPG para gerar contextos semanticamente significativos.

• Alinhamento Grafo-Texto: Um mecanismo de "coloração" mapeia blocos de alteração de código (diffs) para nós específicos no MtCPG usando uma árvore de segmentos baseada em números de linha.
• Agrupamento de Contexto: O Rover emprega um algoritmo de Busca em Largura de Múltiplas Fontes (MS-BFS) no MtCPG começando a partir dos nós de conflito. Ele explora dependências até uma profundidade configurável $k$ para agrupar blocos de código relacionados em "contextos".
• Integração entre Versões: Os contextos são gerados independentemente para ambas as versões sendo mescladas e depois mesclados usando uma abordagem de união de conjuntos disjuntos para garantir que todas as dependências relevantes em ambas as versões sejam capturadas.

2.3 Geração de Resolução

A resolução final é gerada por um LLM (por exemplo, Qwen3-30B-A3B) guiado por um prompt estruturado contendo:

1. Definição da Tarefa: Instruções claras sobre o papel e o objetivo.
2. Cadeia de Pensamento (CoT): Um processo de raciocínio de três etapas exigindo que o LLM analise a causa raiz, infira a lógica pretendida para ambas as versões e determine a melhor estratégia de mesclagem.
3. Formato de Entrada/Saída: Usa o formato "diff" para processamento simplificado.
4. Entrada Contextual: O código conflitante combinado com o contexto semanticamente relevante recuperado do MtCPG.

3. Contribuições Principais

O artigo afirma as seguintes contribuições:

1. MtCPG: Um esquema de representação inovador que captura dependências abrangentes para todos os componentes de código, incluindo relações interarquivo e intercamada, superando as limitações dos CPGs padrão.
2. Metodologia de Classificação de Contexto: Uma abordagem principista para classificar blocos de código com base na conectividade MtCPG, gerando contextos mais adequados para avaliar a dependência de código do que janelas simples de código adjacente.
3. Sistema Rover: Uma implementação de uma ferramenta de resolução de conflitos baseada em LLM que integra MtCPG. É avaliada no conjunto de dados ConGra e demonstrou superar LLMs autônomos e ferramentas de base.

4. Resultados Experimentais

Os autores avaliaram o Rover usando o conjunto de dados ConGra (excluindo C++ devido à maturidade da ferramenta) e um subconjunto do conjunto de dados do WizardMerge (baseado em C). As métricas incluíram Distância de Edição (ED), Similaridade Winnowing (WS) e Similaridade de Cosseno (CS).

• MtCPG vs. CPG: O MtCPG aumentou o número de nós do grafo em ~3,4% e arestas em ~25% em comparação com o CPG padrão, capturando informações de dependência significativamente mais ricas.
• Desempenho vs. Bases de Comparação:
  • LLM Autônomo: O Rover superou um LLM autônomo (Qwen3-30B-A3B) em 13,29% (WS), 10,46% (ED) e 9,79% (CS).
  • Base de Aprendizado de Máquina: Comparado ao MergeGen, o Rover alcançou melhorias de 17,72% (WS), 15,90% (ED) e 9,10% (CS).
  • LLM Assistido por Ferramenta: O Rover superou a combinação de LLM com WizardMerge em 3,82% (WS), 1,85% (ED) e 4,07% (CS).
• Sensibilidade ao Contexto: O estudo constatou que aumentar o tamanho do contexto (seja linhas adjacentes ou profundidade do grafo $k$) não melhora linearmente o desempenho. Existe um $k$ ótimo (por exemplo, $k=4$); além disso, dependências distantes irrelevantes degradam o desempenho ao distrair o modelo.
• Cobertura: O Rover alcançou uma taxa de cobertura de conflitos de 98,83% no conjunto de dados do WizardMerge, significativamente maior que os 90,67% do WizardMerge, principalmente porque o Rover opera no código fonte sem exigir compilação completa do projeto.
• Dependência do Modelo: A eficácia do Rover variou conforme o LLM. Ela melhorou o desempenho em modelos maiores (gpt-oss-20b) mas degradou o desempenho em modelos menores (Llama-3.1-8B), sugerindo um "gargalo de raciocínio" onde modelos menores lutam para interpretar contextos longos e complexos.

5. Significado e Afirmações

O artigo posiciona o Rover como um passo significativo em direção à resolução de conflitos totalmente automatizada e consciente de contexto.

• Contexto Determinístico: Ao contrário de sistemas baseados em agentes, o Rover fornece uma base determinística e analisável para seleção de contexto, evitando o não determinismo da exploração orientada por LLM.
• Preenchendo a Lacuna: Ele preenche com sucesso a lacuna entre análise de programa (que entende dependências mas carece de capacidade generativa) e LLMs (que podem gerar código mas carecem de consciência contextual profunda).
• Praticidade: Ao operar no nível do código fonte e não exigir compilação completa do projeto, o Rover é mais robusto e aplicável a cenários de mesclagem do mundo real do que ferramentas que dependem de análise baseada em compilador (como WizardMerge).
• Limitações Modestas: Os autores reconhecem que o MtCPG atualmente tem limitações com certos recursos específicos de linguagem (por exemplo, assembly inline em C, tratamento de exceções complexo) e que métricas baseadas em strings não garantem totalmente a correção funcional, embora a validação por amostragem manual tenha mostrado uma forte correlação positiva entre as pontuações das métricas e a aceitação da resolução.

Os autores concluem que informações contextuais adequadas, derivadas de análise de dependência principista, são essenciais para melhorar a resolução de conflitos baseada em LLM, e o Rover demonstra esse potencial de forma eficaz.