AgentSZZ: Teaching the LLM Agent to Play Detective with Bug-Inducing Commits

1. O Problema

O algoritmo SZZ é a técnica dominante para identificar commits que induzem bugs (Bug-Inducing Commits - BICs), servindo de base para tarefas críticas de engenharia de software, como previsão de defeitos e análise de vulnerabilidades. No entanto, o desempenho atual, mesmo com variantes baseadas em Grandes Modelos de Linguagem (LLMs), permanece limitado em conjuntos de dados anotados por desenvolvedores (ex: recall de apenas 0,552 no kernel do Linux).

As principais limitações identificadas são:

• Dependência do git blame: Os métodos tradicionais rastreiam mudanças linha a linha dentro do mesmo arquivo. Isso falha em cenários comuns onde o bug foi introduzido em um arquivo diferente (casos cross-file) ou quando o commit de correção não contém linhas deletadas ou modificadas (commits fantasma ou ghost commits). Estudos indicam que quase 25% dos commits indutores de bugs são intrinsecamente não rastreáveis por métodos baseados em blame.
• Pipelines Fixos: Abordagens atuais seguem fluxos de trabalho rígidos que não permitem raciocínio iterativo ou exploração, diferentemente dos desenvolvedores humanos que utilizam múltiplas ferramentas e um processo de "forrageamento de informação" interativo para investigar bugs.

2. Metodologia: AgentSZZ

Os autores propõem o AgentSZZ, um framework baseado em agentes que utiliza LLMs para interagir dinamicamente com repositórios de código, simulando um detetive investigativo.

Arquitetura e Fluxo de Trabalho

O sistema opera em três fases principais, seguindo o paradigma ReAct (Reason + Act):

1. Pré-processamento: Extrai informações do commit de correção (BFC), filtra ruído e define uma data limite temporal para evitar vazamento de informações.
2. Loop de Investigação ReAct: O agente executa um ciclo iterativo (máximo de 15 voltas) onde:
   • Observa: Recebe o contexto atual.
   • Raciocina: Planeja a próxima ação baseada em conhecimento de domínio.
   • Age: Invoca ferramentas específicas para explorar o repositório.
   • Comprime: O output das ferramentas é processado por um módulo de compressão estruturada para reduzir tokens e ruído.
3. Saída: Gera o hash do commit indutor de bug (BIC) com nível de confiança e justificativa.

Componentes Chave

• Ferramentas Específicas para a Tarefa: Em vez de expor o comando git bruto, o agente possui 5 ferramentas abstratas e otimizadas:
  • git_blame: Rastreia a propriedade de linhas específicas.
  • git_show: Recupera mensagens e diffs para classificação semântica.
  • git_log_s: Busca commits que adicionaram/removeram strings específicas (busca pickaxe).
  • git_log_func: Rastreia o histórico de mudanças em nível de função.
  • git_grep: Pesquisa definições e chamadas em todo o repositório em um snapshot específico.
• Conhecimento de Domínio (Domain Knowledge): Um prompt estruturado que guia o agente com heurísticas, como:
  • Começar com blame no commit pai.
  • Se encontrar refatoração, penetrar no commit anterior (ignorar mudanças cosméticas).
  • Alternar para ferramentas de busca global (grep, log_s) quando o rastreamento local falha (casos cross-file).
  • Validar se a mudança introduziu lógica defeituosa, e não apenas expôs um bug existente.
• Compressão de Contexto Estruturada: Um módulo que reduz o consumo de tokens (>30%) ao:
  • Remover metadados irrelevantes (ex: Signed-off-by).
  • Deduplicar resultados de cache.
  • Aplicar truncamento inteligente (manter cabeçalhos e finais, removendo contexto de diff repetitivo).

3. Contribuições Principais

1. Framework AgentSZZ: Uma nova abordagem baseada em agentes que supera as limitações de rastreamento estático, permitindo investigação causal e adaptativa.
2. Design de Ferramentas e Conhecimento: Criação de cinco ferramentas de interface específica e a codificação de heurísticas de engenharia de software para guiar a exploração do agente.
3. Validação Empírica: Extensa avaliação em três conjuntos de dados amplamente utilizados (Linux, GitHub, Apache), demonstrando superioridade sobre o estado da arte.
4. Eficiência: Demonstração de que a compressão de contexto e o uso de ferramentas estruturadas reduzem drasticamente o custo computacional sem sacrificar a precisão.

4. Resultados Experimentais

Os experimentos foram realizados em três conjuntos de dados (DS_LINUX, DS_GITHUB, DS_APACHE) cobrindo C e Java, comparando o AgentSZZ com 11 baselines (incluindo SZZ clássicos, Neural-SZZ e LLM4SZZ).

• Desempenho Geral: O AgentSZZ superou consistentemente todos os baselines.
  • Melhoria no F1-score: Até 27,2% em relação ao estado da arte anterior (LLM4SZZ).
  • Precisão e Recall: Alcançou recall de 0,711 no Linux (vs. 0,552 do LLM4SZZ) e precisão superior a 0,78 em todos os datasets.
• Cenários Desafiadores:
  • Commits Cross-File: Melhoria no recall de até 300% (ex: de 6,06% para 24,24% no GitHub).
  • Commits Fantasma (Ghost): Melhoria no recall de até 60%.
• Eficiência:
  • O agente convergiu em menos voltas (média de 5,7 vs. 11,2 do LLM4SZZ).
  • Redução de 33,6% no consumo de tokens e 35,7% no custo financeiro em comparação com versões sem compressão.
  • Desempenho significativamente superior ao mini-SWE-agent, que falhou devido à exploração desenfreada e alto consumo de tokens.
• Estudo de Ablação:
  • Remover as ferramentas específicas fez o desempenho colapsar (F1 caiu para ~0,15), provando que a interface estruturada é crítica.
  • O conhecimento de domínio foi essencial para melhorar o recall.

5. Significado e Conclusão

O AgentSZZ representa um avanço significativo na identificação de commits indutores de bugs ao mudar o paradigma de "rastreamento estático baseado em linhas" para "investigação interativa baseada em agentes".

• Superando Limitações Fundamentais: O trabalho demonstra que é possível superar as barreiras impostas pelos métodos baseados em git blame, resolvendo casos complexos de refatoração e mudanças entre arquivos que antes eram considerados intratáveis.
• Eficiência Prática: A combinação de ferramentas específicas e compressão de contexto torna viável o uso de agentes LLM em larga escala, equilibrando custo e desempenho.
• Direções Futuras: Os autores sugerem que o próximo passo é melhorar o raciocínio temporal para distinguir melhor entre commits que introduzem bugs e os que apenas os expõem, além de expandir a capacidade de identificar múltiplos commits indutores por correção.

Em resumo, o paper prova que ensinar um agente LLM a agir como um detetive, utilizando ferramentas adequadas e conhecimento de domínio, é a chave para desbloquear a próxima geração de ferramentas de engenharia de software automatizadas.