💻 computer science

AgenticSZZ: Temporal Knowledge Graph-Guided Agentic Bug-Inducing Commit Identification

AgenticSZZ é uma abordagem inovadora que alavanca Grafos de Conhecimento Temporais e agentes de LLM para superar as limitações dos métodos tradicionais baseados em git blame, reformulando a identificação de Commits Indutores de Bugs como um problema de busca em grafos, melhorando assim significativamente a precisão da detecção por meio de contexto histórico expandido e raciocínio causal.

Autores originais: Yu Shi, Hao Li, Bram Adams, Ahmed E. Hassan

Publicado 2026-05-12

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Yu Shi, Hao Li, Bram Adams, Ahmed E. Hassan

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

O Novo Mapa do Detetive: Como o AgenticSZZ Encontra Bugs de Software

Imagine que você é um detetive tentando resolver um mistério: Quem quebrou o código? No mundo do software, um "bug" é um erro que faz um programa travar ou agir de forma estranha. Para corrigi-lo, você precisa encontrar o momento exato na história em que um desenvolvedor introduziu acidentalmente esse erro. Esse momento é chamado de Commit Indutor de Bug (BIC).

Por décadas, os detetives usaram uma ferramenta padrão chamada SZZ (nomeada em homenagem aos seus criadores). Pense no SZZ como uma lupa que examina a "cena do crime" (a correção do código) e pergunta: "Quem tocou nesta linha específica de código por último?" Ele usa um comando chamado git blame para apontar o dedo para a pessoa mais recente que alterou aquela linha.

O Problema:
Os autores deste artigo descobriram uma falha grave nesse método antigo. Eles analisaram mais de 2.000 correções de bugs do mundo real e constataram que 40% das vezes, a lupa aponta para a pessoa errada.

Por quê?

A Falsa Pista: Às vezes, a pessoa que tocou na linha por último apenas mudou a cor da fonte ou adicionou um espaço (uma "mudança cosmética"). O verdadeiro bug foi introduzido por outra pessoa meses antes, mas a ferramenta SZZ antiga não consegue ver além da última pessoa.
A Pista Faltante: Às vezes, a correção não tocou em nenhuma linha antiga; ela apenas adicionou novas linhas. Neste caso, a lupa não tem nada para examinar, e a ferramenta desiste completamente.

A Solução: AgenticSZZ

Os autores, Yu Shi e sua equipe da Queen's University, construíram um novo sistema chamado AgenticSZZ. Em vez de olhar apenas para uma linha de código, eles criaram um Mapa Viajante no Tempo (um Grafo de Conhecimento Temporal) e contrataram um Super-Detetive IA (um Agente LLM) para navegá-lo.

Veja como funciona, usando analogias simples:

1. Construindo o Mapa (O Grafo de Conhecimento Temporal)

Imagine a história de um projeto de software não como uma linha reta de texto, mas como uma gigantesca teia de aranha 3D.

Os Nós: Cada vez que um desenvolvedor salva seu trabalho (um "commit"), é um ponto na teia.
Os Fios: A teia conecta esses pontos de duas maneiras:
- Tempo: Quem veio antes de quem?
- Estrutura: Quem alterou os mesmos arquivos ou funções?
A Expansão: Diferente do método antigo, que olha apenas para o bairro imediato, o AgenticSZZ expande o mapa. Ele traça a teia para trás a partir da correção e para trás a partir da "última pessoa que tocou na linha". Isso garante que o mapa inclua as "Falsas Pistas" e as "Pistas Faltantes" que a ferramenta antiga ignorava.

2. O Super-Detetive (O Agente LLM)

Agora que eles têm o mapa, precisam de alguém inteligente o suficiente para lê-lo. Eles não pediram apenas a um computador para escanear a lista; eles contrataram um Agente IA equipado com ferramentas especiais.

Pense neste Agente como um detetive com um kit de ferramentas:

O Criador de Listas: "Mostre-me os principais suspeitos."
O Viajante do Tempo: "Deixe-me caminhar para trás ao longo da teia para ver quem mais tocou neste arquivo."
O Verificador de Fatos: "Leia a mensagem do commit e as alterações no código para ver se essa pessoa realmente quebrou a lógica."
O Cérebro Lógico: "Essa alteração faz sentido como a causa do bug?"

O Agente não apenas adivinha. Ele explora o mapa, verifica as evidências e raciocina através da história para encontrar o verdadeiro culpado, mesmo que essa pessoa esteja muito atrás na linha do tempo ou em um ramo diferente do projeto.

Os Resultados: Um Detetive Melhor

A equipe testou esse novo sistema em três conjuntos de dados massivos (kernel do Linux, projetos Apache e repositórios do GitHub). Eis o que eles encontraram:

Taxa de Sucesso: O AgenticSZZ encontrou o commit indutor de bug correto 16% a 34% mais frequentemente do que os melhores métodos existentes.
Resolvendo o Insolúvel: Ele resolveu com sucesso casos que antes eram impossíveis, como quando a correção adicionou novo código (os casos "Inocentes") ou quando o bug foi introduzido por um commit que ocorreu depois da última pessoa tocar na linha, mas antes da correção.
O "Ponto Ideal" da IA: Os autores testaram diferentes modelos de IA para atuar como o detetive. Eles descobriram que a IA precisa ser "inteligente o suficiente" para fazer o trabalho. Modelos de IA menores e mais baratos tendiam a desistir muito rápido ou pular etapas importantes, falhando em encontrar o bug. Apenas os modelos maiores e mais capazes conseguiam navegar com sucesso na complexa teia da história.

A Conclusão

O artigo argumenta que encontrar bugs de software não é apenas sobre classificar uma lista de suspeitos (o jeito antigo); é sobre explorar uma teia complexa de história (o jeito novo).

Ao combinar um Mapa Viajante no Tempo (que expande o espaço de busca) com um Agente IA Raciocinante (que filtra inteligentemente os suspeitos), o AgenticSZZ resolve um problema que tem deixado detetives de software perplexos por 20 anos. Ele prova que, para encontrar a causa raiz de um bug, às vezes é preciso olhar muito além da pessoa que tocou no código por último.

Resumo Técnico: AgenticSZZ

Declaração do Problema

Identificar o Commit Indutor de Bug (BIC) é uma tarefa fundamental na manutenção de software, permitindo a previsão de defeitos, a correção automática de programas e a análise histórica de bugs. A abordagem dominante por duas décadas tem sido o algoritmo SZZ e suas variantes, que dependem do git blame para rastrear linhas excluídas ou modificadas em um Commit de Correção de Bug (BFC) de volta ao commit que as tocou por último.

No entanto, essa abordagem sofre de limitações fundamentais quanto ao recall. Um estudo preliminar de 2.102 commits de correção de bugs validados pelos autores revela que o git blame sozinho é insuficiente para quase metade de todos os casos:

28% dos BICs exigem a travessia do histórico de commits além dos resultados diretos de blame (seja como ancestrais dos commits de blame ou ancestrais do BFC).
14% dos casos são "sem blame", onde o BFC contém apenas linhas adicionadas, sem linhas excluídas/modificadas para culpar, tornando o SZZ padrão inaplicável.
Mesmo dentro dos 57% dos casos onde os BICs aparecem nos resultados de blame, identificar o BIC correto entre múltiplos candidatos permanece desafiador devido à alta complexidade em alguns projetos.

Melhorias existentes no SZZ focaram em heurísticas de filtragem, detecção de refatoração ou classificação de candidatos de blame usando aprendizado profundo e LLMs, mas permanecem restritas pelo espaço de busca definido estritamente pelo git blame.

Metodologia: AgenticSZZ

Os autores propõem o AgenticSZZ, a primeira abordagem a aplicar Grafos de Conhecimento Temporais (TKGs) à análise da evolução de software. A ideia central é reformular a identificação do BIC de um problema de classificação sobre uma lista estática de candidatos de blame para um problema de busca em grafo sobre o histórico temporal de commits.

A metodologia opera em duas fases distintas:

1. Construção do Grafo de Conhecimento Temporal (TKG)

O sistema constrói um grafo que codifica commits como nós com ordenação temporal e conexões estruturais (arquivos e funções compartilhados). O espaço de busca é expandido além dos resultados diretos de blame através de duas direções de travessia:

Travessia de Ancestrais de Blame: Começando a partir dos commits de blame, o sistema percorre para trás o histórico de arquivos para encontrar commits anteriores que podem ter introduzido a lógica do bug.
Travessia de Ancestrais do BFC: Começando a partir do BFC, o sistema percorre para trás em direção aos commits de blame para identificar commits intermediários que podem ter transformado código correto em código defeituoso.
Expansão de Contexto: Para lidar com casos "sem blame" e melhorar a qualidade das sementes, o sistema aplica uma estratégia de fallback, culpando linhas de contexto (2 linhas antes e depois) que cercam o código adicionado.

O esquema do grafo inclui:

Nós: Commits (rotulados como BFC, blame, blame_ancestor ou bfc_ancestor), Arquivos e Funções.
Arestas: PRECEDES (ordenação temporal), MODIFIES_FILE, MODIFIES_FUNCTION e DEFINED_IN.

2. Busca Agente de BIC

Um agente LLM navega pelo TKG construído usando quatro ferramentas especializadas para raciocinar sobre relações causais:

Enumeração de Candidatos (list_candidates): Recupera os top- $K$ candidatos classificados por uma pontuação de aptidão (priorizando blame > blame_ancestor > bfc_ancestor).
Travessia Estrutural (traverse_graph): Segue arestas para descobrir commits que modificam as mesmas entidades de código.
Consulta de Propriedades (query_node): Inspecta metadados do commit (mensagens, carimbos de data/hora, sobreposições).
Análise Causal (read_node_content): Lê diffs de código para verificar se as alterações de um candidato estão causalmente relacionadas à correção do bug.

O agente investiga candidatos iterativamente, potencialmente sobrescrevendo classificações iniciais com base em raciocínio semântico e verificação causal, até que uma decisão seja alcançada ou um limite de etapas seja esgotado.

Contribuições Principais

Estudo Preliminar (RQ0): Uma caracterização sistemática das localizações de BICs em relação aos commits de blame, quantificando que 28% dos casos exigem travessia de histórico e 14% são sem blame, estabelecendo a necessidade de estratégias de busca expandidas.
Framework AgenticSZZ: A primeira aplicação de TKGs à análise da evolução de software, reformulando a identificação de BICs como um problema de busca em grafo. Isso permite a identificação de BICs fora do conjunto tradicional de candidatos definido pelo blame.
Avaliação Abrangente: Uma avaliação rigorosa em três conjuntos de dados (Linux, Apache, GitHub) comparando o AgenticSZZ com sete variantes do SZZ e o estado da arte LLM4SZZ.
Análise de Sensibilidade a LLM: Uma investigação sobre como diferentes LLMs de pesos abertos afetam o desempenho, identificando um limiar de capacidade para navegação eficaz em TKG.

Resultados

A avaliação em 2.102 pares BFC-BIC validados demonstra que o AgenticSZZ alcança desempenho de última geração:

Desempenho: O AgenticSZZ alcança pontuações F1 variando de 0,47 a 0,79 entre os conjuntos de dados. Ele supera o estado anterior da arte (LLM4SZZ) em 16,0% a 34,2% na pontuação F1.
Significância Estatística: As melhorias são estatisticamente significativas (teste de McNemar, $p < 0,001$ ) em três das quatro divisões de conjunto de dados. Mesmo a execução de pior desempenho do AgenticSZZ supera a melhor execução do LLM4SZZ.
Estudo de Ablação:
- Tanto o TKG quanto o agente LLM são mutuamente essenciais; apenas TKG introduz ruído sem filtragem inteligente, enquanto apenas Agente é limitado pelo espaço de busca de blame limitado.
- A combinação de travessia de TKG e expansão de contexto desbloqueia a categoria "Ancestral", gerando um ganho líquido de 60 verdadeiros positivos entre os conjuntos de dados em comparação com o LLM4SZZ.
- A expansão de contexto troca aproximadamente 48 verdadeiros positivos de "Blame" por 106 verdadeiros positivos adicionais de "Ancestral", resultando em um ganho líquido positivo na maioria dos conjuntos de dados.
Sensibilidade a LLM: Apenas modelos com 37B+ parâmetros ativos (DeepSeek-V3.2 e DeepSeek-V4-Pro) superam consistentemente a linha de base simples de fallback de Blame. Modelos menores falham em realizar verificação suficiente de múltiplos passos (pulando chamadas de query_node e read_node_content), reduzindo-se efetivamente a uma heurística menos confiável.
Amplificação Arquitetural: Uma comparação controlada usando DeepSeek-V4-Pro mostra que a arquitetura TKG amplifica os benefícios de LLMs mais fortes. A lacuna de desempenho entre AgenticSZZ e LLM4SZZ aumenta de 18,8% (com V3.2) para 32,0% (com V4-Pro), enquanto os ganhos do LLM4SZZ estagnam devido ao seu espaço de busca limitado pelo blame.

Significância e Alegações

O artigo alega que o AgenticSZZ abre uma nova direção de pesquisa para raciocínio temporal e causal na análise da evolução de software. Ao transformar a identificação de BICs em um problema de busca em grafo, a abordagem supera as limitações inerentes de recall dos métodos baseados em git blame.

Os autores enfatizam que a melhoria é impulsionada pelo paradigma guiado por TKG e não meramente pela escolha de um LLM mais capaz. O TKG fornece um espaço de raciocínio estruturado que permite que modelos mais fortes naveguem efetivamente por históricos complexos de commits, enquanto abordagens confinadas a listas lineares de blame enfrentam um teto de desempenho independentemente da capacidade subjacente do LLM. O trabalho sugere que avanços futuros na identificação de BICs dependerão da integração de espaços de busca estruturados com raciocínio agente, desde que o LLM possua capacidade suficiente para realizar verificação de múltiplos passos.