Echo: Graph-Enhanced Retrieval and Execution Feedback for Issue Reproduction Test Generation

O artigo apresenta o Echo, um agente inovador que utiliza recuperação aprimorada por grafos de código e feedback de execução automática para gerar casos de teste de reprodução de bugs com alta eficiência, estabelecendo um novo estado da arte com uma taxa de sucesso de 66,28% no conjunto de dados SWT-Bench Verified.

O essencial

Imagine que você é um detetive tentando resolver um crime em uma cidade gigante e cheia de documentos (o código do software). O "crime" é um bug (um erro) que um usuário relatou, dizendo algo como: "Quando tento fazer X, o sistema trava".

O problema é que o usuário não deixou nenhuma prova concreta (um teste que reproduz o erro). Ele só deixou uma descrição vaga. Para consertar o crime, você precisa criar um "cenário de teste" que force o sistema a falhar exatamente daquela maneira, para que os programadores possam ver o problema e consertá-lo.

Fazer isso manualmente é como procurar uma agulha em um palheiro, de olhos vendados, e ainda ter que escrever um roteiro de filme para reencenar o crime. É demorado e difícil.

É aqui que entra o Echo, o novo "detetive robô" criado pelos autores deste artigo.

O que é o Echo?

O Echo é um agente inteligente (baseado em Inteligência Artificial) que tenta criar sozinho esse "cenário de teste" perfeito. Ele faz três coisas principais que o tornam muito melhor do que os detetives anteriores:

1. O Mapa do Tesouro (Retrieval Aprimorado)

Antes, os robôs tentavam encontrar as informações certas apenas lendo títulos de arquivos, como alguém tentando achar um livro apenas olhando para a lombada. Muitas vezes, eles pegavam o livro errado ou perdiam detalhes importantes.

O Echo usa um Mapa de Conexões (Grafo de Código). Imagine que o código do software não é uma pilha de papéis, mas sim uma teia de aranha gigante onde cada fio conecta uma função a outra. O Echo navega por essa teia.

• A Analogia: Em vez de apenas perguntar "Onde está o arquivo de login?", o Echo pergunta: "Quem conversa com o arquivo de login? Quem usa o que ele cria? Onde estão os testes antigos que falharam de jeito parecido?".
• O Truque: Ele também é esperto o suficiente para perceber quando a pergunta inicial é ruim. Se ele não acha o que precisa, ele refina a pergunta sozinho (como um detetive que muda de ideia e pergunta a outra pessoa) até encontrar as peças exatas do quebra-cabeça.

2. O Laboratório de Testes (Execução Automática)

Muitos robôs geram o teste e dizem: "Aqui está, deve funcionar!". Mas eles nunca realmente testam. O Echo é diferente: ele executa o teste.

• A Analogia: É como se o Echo não apenas escrevesse a receita de um bolo, mas fosse até a cozinha, ligasse o forno, misturasse os ingredientes e comesse o bolo para ver se está gostoso.
• O Desafio: Fazer um robô entrar na cozinha sem queimar a casa ou usar o forno errado é difícil. O Echo aprendeu a seguir regras estritas para não bagunçar o projeto, mas ainda assim conseguir rodar o teste e ver o resultado.

3. O Espelho Mágico (Feedback de Execução e Correção)

Aqui está a parte mais genial. O Echo não apenas testa; ele tenta adivinhar como consertar o bug.

• O Processo:
  1. Ele cria o teste.
  2. Ele tenta "consertar" o código (cria um "patch" ou remédio).
  3. Ele roda o teste no código original (deve falhar) e no código consertado (deve passar).
• O Espelho: Se o teste falhar no código original, mas também falhar no código consertado, o Echo sabe que algo está errado. Ele olha para o "espelho" (o log de erro) e pensa: "Ei, esse teste não está capturando o problema certo!". Então, ele reescreve o teste baseado no erro que viu, tentando novamente.
• A Diferença: Outros robôs geram 100 testes e escolhem o melhor. O Echo é mais eficiente: ele gera um teste, refina-o até ficar perfeito e para. É como um escultor que esculpe uma única estátua com precisão, em vez de fazer 100 estátuas ruins e escolher a menos feia.

Os Resultados (O Veredito)

Os autores testaram o Echo em um banco de dados famoso chamado SWT-Bench, que contém muitos bugs reais de projetos grandes (como o Django, que é usado em sites gigantes).

• O Recorde: O Echo conseguiu resolver 66,28% dos casos, estabelecendo um novo recorde mundial (State-of-the-Art) entre ferramentas de código aberto.
• Comparação: Ele superou outros robôs famosos, mesmo usando modelos de linguagem diferentes.
• Custo: Embora use muita "energia" (tokens de IA) para pensar e ler o código, ele é mais eficiente no geral porque não desperdiça tempo gerando centenas de testes inúteis.

Resumo da Ópera

O Echo é como um detetive super-esperto que:

1. Usa um mapa 3D da cidade para encontrar as pistas certas.
2. Reencena o crime na vida real para ver o que acontece.
3. Tenta consertar o crime e usa esse conserto para verificar se a reencenação estava correta.
4. Se a reencenação falhar, ele ajusta o roteiro e tenta de novo, até acertar.

O resultado? Um sistema que ajuda programadores a encontrar e corrigir bugs muito mais rápido, economizando tempo e evitando que erros estranhos passem despercebidos. E o melhor: eles liberaram o código para que todos possam usar e melhorar essa tecnologia.

Resumo técnico

Título: Echo: Recuperação Aprimorada por Grafos e Feedback de Execução para Geração de Testes de Reprodução de Problemas

1. O Problema

A identificação da causa raiz de um bug é frequentemente difícil para desenvolvedores porque os relatórios de problemas (issues) no GitHub muitas vezes carecem de um caso de teste de reprodução confiável que dispare a falha.

• Desafios Atuais:
  • Recuperação de Contexto: Abordagens existentes dependem de métodos hierárquicos simples baseados em LLMs para localizar arquivos, falhando em capturar relações estruturais profundas e semântica de longo alcance em grandes bases de código, resultando em contexto ruidoso ou incompleto.
  • Configuração de Execução: Muitos sistemas assumem que os comandos de execução e configurações são conhecidos, o que não é verdade em repositórios reais onde esses detalhes estão implícitos e dispersos.
  • Oráculos de Falha: A ausência de um oráculo confiável para verificar se um teste gerado falha pela razão correta. A validação semântica baseada apenas em LLMs é inerentemente não confiável.
  • Ineficiência: Abordagens anteriores frequentemente geram múltiplos candidatos e os ranqueiam, o que é custoso em termos de tokens e tempo.

2. Metodologia: O Sistema Echo

O Echo é um agente autônomo projetado para gerar um único caso de teste de alta qualidade por problema, utilizando um ciclo iterativo de refinamento. O sistema opera em seis fases principais:

1. Recuperação de Contexto Aprimorada por Grafos:

   • O repositório de código é transformado em um grafo heterogêneo (nós de recursos, nós de parse e spans de texto) armazenado no Neo4j.
   • Utiliza um mecanismo de refinamento automático de consultas: Um LLM avalia se a consulta inicial e o contexto recuperado são suficientes. Se não forem, o agente gera uma nova consulta para buscar informações faltantes, garantindo que o contexto seja conciso e acionável.
   • Recupera não apenas o código focal, mas também testes de regressão relevantes e dependências completas.

2. Geração de Patch (Correção):

   • O Echo utiliza uma ferramenta de reparo de programa (no caso, o Prometheus) para gerar um patch candidato.
   • Este patch é usado para criar uma versão "corrigida" do projeto, servindo como um oráculo para validação.

3. Geração do Caso de Teste:

   • Um LLM gera um teste de reprodução autônomo, utilizando o contexto recuperado, a descrição do problema e o patch candidato.
   • O agente atua como um especialista em QA, focando em criar um teste mínimo e focado que siga as convenções do projeto.

4. Execução Autônoma de Testes:

   • O Echo infere automaticamente o comando de execução correto a partir do contexto do repositório (README, configurações) e executa o teste em um container.
   • Restrições de Segurança: O agente é estritamente limitado a não modificar arquivos, não instalar pacotes e não rodar toda a suíte de testes, focando apenas no arquivo de teste gerado.

5. Verificação e Validação (Dual-Version Check):

   • O sistema verifica o critério Fail-to-Pass: O teste deve falhar na versão original (buggy) e passar na versão corrigida (patched).
   • Diferente de métodos anteriores que usam apenas LLMs para julgar a falha, o Echo aplica o patch e executa o teste na versão corrigida para uma verificação baseada em regras.

6. Refinamento Iterativo:

   • Se o teste falhar na validação (ex: não passa na versão corrigida ou falha por motivo errado), os logs de execução são enviados de volta ao gerador para refinar o teste.
   • O processo repete-se até que o critério seja atendido ou o limite de tentativas seja atingido.

3. Contribuições Principais

1. Abordagem Baseada em Grafos: Introdução de um grafo de código e um mecanismo de refinamento de consultas para superar as limitações da recuperação de contexto baseada apenas em texto ou hierarquia simples.
2. Execução e Feedback Automáticos: É a primeira ferramenta a integrar automaticamente a execução de testes e o uso de feedback de execução (logs de falha e sucesso na versão corrigida) para refinar a geração de testes em um fluxo de trabalho prático.
3. Eficiência (Um Teste por Problema): Ao contrário de métodos que geram pools de candidatos, o Echo foca em gerar e refinar um único teste de alta qualidade, oferecendo um melhor trade-off entre custo e desempenho.
4. Open Source: O código, logs de execução e resultados completos são disponibilizados publicamente.

4. Resultados Experimentais

Os experimentos foram conduzidos no conjunto de dados SWT-Bench Verified (433 instâncias reais de problemas de software).

• Estado da Arte (SOTA): O Echo alcançou uma taxa de sucesso de 66,28%, estabelecendo um novo recorde entre abordagens de código aberto, superando ferramentas como OpenHands (62,4%), e-Otter++ (62,1%) e Amazon Q Developer Agent (51,0%).
• Cobertura: Entre os testes bem-sucedidos, a cobertura de código alterado (Coverage Delta Resolved) atingiu 76,50%.
• Análise de Refinamento: A comparação com uma versão do Echo sem o componente de refinamento (sem verificação dual-version) mostrou que o refinamento aumentou a taxa de sucesso de 59,12% para 66,28%, demonstrando a eficácia do feedback de execução.
• Custo: O custo médio por instância foi de $1,54, o que é competitivo em relação a outras abordagens de agentes complexos (como e-Otter++ com Claude 3.7 Sonnet a $2,75), mantendo desempenho superior.
• Análise de Erros: A maioria das falhas (30,4%) deveu-se a AssertionError (o teste não reproduziu o comportamento relatado corretamente), seguida por erros de importação e módulo não encontrado, indicando desafios na adaptação ao ambiente de execução.

5. Significado e Impacto

O Echo representa um avanço significativo na automação de testes de software e na resolução de bugs:

• Confiabilidade: Ao utilizar a versão corrigida do código como oráculo, o sistema reduz a dependência de julgamentos semânticos subjetivos de LLMs sobre o que constitui uma falha.
• Praticidade: A capacidade de inferir e executar comandos de teste em repositórios reais, sem configuração manual prévia, torna a ferramenta aplicável em cenários industriais.
• Eficiência de Recursos: A estratégia de gerar um único teste refinado iterativamente prova ser mais eficiente em termos de tokens e custo do que a geração massiva de candidatos.
• Futuro: O trabalho aponta para a necessidade de otimizar a seleção de contexto (para reduzir custos de tokens) e desenvolver oráculos mais robustos para validar comportamentos de falha complexos.

Em resumo, o Echo demonstra que a combinação de recuperação estruturada (grafos), execução autônoma e validação baseada em patches é uma estratégia superior para automatizar a reprodução de bugs em projetos de software complexos.