💻 computer science

ARISE: A Repository-level Graph Representation and Toolset for Agentic Fault Localization and Program Repair

ARISE est un framework au niveau du dépôt qui améliore les agents basés sur les LLM pour la localisation de défauts et la réparation de programmes en introduisant un graphe de programme multi-granularité avec des arêtes de flux de données intra-procédurales et une API de tranchage interrogeable, réalisant des améliorations significatives de la précision de localisation et des taux de réussite de réparation sur le benchmark SWE-bench Lite.

Auteurs originaux : Shahd Seddik, Fatemeh Fard

Publié 2026-05-06

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Shahd Seddik, Fatemeh Fard

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous êtes un détective tentant de résoudre un crime dans une ville immense et étendue (le dépôt de logiciels). La ville compte des milliers de bâtiments (fichiers), chacun contenant des centaines de pièces (fonctions), et à l'intérieur de ces pièces se trouvent d'innombrables meubles et documents (lignes de code).

Votre tâche consiste à trouver le document spécifique qui contient le mensonge (le bogue) causant la panne du réseau électrique de la ville, puis à réécrire ce document pour le corriger.

Le Problème : Se perdre dans la ville

Par le passé, les détectives (agents d'IA) tentant de résoudre ces affaires rencontraient deux problèmes majeurs :

Ils ne possédaient qu'une carte des bâtiments : Ils savaient quel bâtiment se trouvait à côté de quel autre, et quel bâtiment avait une porte menant à un autre. Mais ils ne savaient pas comment l'information se déplaçait à l'intérieur des pièces.
Ils devaient tout lire : Pour trouver le mensonge, ils devaient souvent lire des livres entiers ou parcourir chaque page d'un bâtiment, espérant tomber sur l'indice par hasard. Cela était lent, coûteux et les menait souvent à la mauvaise pièce.

La Solution : ARISE (La boîte à outils du super-détective)

Les auteurs ont créé un nouveau système appelé ARISE. Imaginez ARISE comme offrant au détective une carte 3D interactive et surpuissante de la ville, qui ne montre pas seulement les bâtiments, mais aussi exactement comment une pièce de preuve spécifique (une variable) se déplace d'un document à un autre à l'intérieur d'une pièce.

Voici comment ARISE fonctionne, décomposé en trois outils simples :

1. La Carte Structurelle (Niveau 1)

C'est la « carte des bâtiments ». Elle indique au détective : « Ce fichier contient cette classe, qui appelle cette fonction. » C'est comme savoir que la Bibliothèque est connectée à l'École. Cela aide le détective à réduire la zone de recherche pour savoir quel bâtiment explorer, mais cela ne lui indique pas quelle page du livre est erronée.

2. L'Outil « Suivez l'Argent » (Niveau 2 - La Grande Innovation)

C'est la partie magique. Autrefois, si un détective trouvait un chiffre suspect dans un document, il devait feuilleter manuellement chaque page avant et après pour voir d'où venait ce chiffre ou où il allait.

ARISE introduit un outil appelé Tranchage de Flux de Données. Imaginez que vous avez une loupe magique. Vous la pointez sur un chiffre spécifique dans un document et vous dites : « Montrez-moi tout ce qui a touché ce chiffre. »

Tranche arrière : La loupe surligne instantanément chaque phrase qui a créé ou modifié ce chiffre.
Tranche avant : Elle surligne chaque phrase qui a utilisé ce chiffre plus tard.

Au lieu de lire 50 pages, le détective obtient une liste unique et surlignée contenant uniquement les 5 ou 6 phrases qui comptent vraiment. C'est comme pouvoir tracer instantanément une goutte d'eau spécifique d'un robinet jusqu'à l'évier, en ignorant le reste de la plomberie.

3. Le Classeur de Preuves (Niveau 3)

Une fois que le détective a trouvé les phrases suspectes, il doit les rassembler dans un rapport pour corriger le bogue. Parfois, le rapport devient trop long et le cerveau du détective (le modèle d'IA) est submergé.
Cet outil agit comme un bibliothécaire intelligent. Il prend toutes les phrases surlignées, les classe par ordre d'importance et les regroupe dans un « Classeur de Preuves » net et concis qui rentre parfaitement dans le sac à dos du détective (la limite de mémoire). Cela garantit que le détective voit les indices les plus importants en premier.

Les Résultats : Est-ce que ça a marché ?

Les chercheurs ont testé ce nouveau système sur 300 « crimes » (bogues) réels issus de projets logiciels populaires. Ils ont comparé ARISE à un détective standard (l'agent SWE) qui ne disposait que des outils de base.

Trouver la scène du crime : Le détective standard pouvait deviner le bon bâtiment (fichier) environ 57 % du temps. ARISE a eu raison 67 % du temps.
Trouver la pièce exacte : Le détective standard devinait la bonne pièce (fonction) 43 % du temps. ARISE a bondi à 60 %.
Trouver la phrase exacte : Le détective standard trouvait la bonne ligne de code 26 % du temps. ARISE a amélioré ce chiffre à 41 %.

Plus important encore, parce que le détective pouvait trouver le problème exact plus rapidement et plus précisément, il a pu corriger le bogue avec succès 22 % du temps, contre seulement 17 % pour le détective standard.

Points Clés du Document

La structure ne suffit pas : Connaître simplement comment les fichiers sont connectés ne suffit pas ; il faut savoir comment les données se déplacent à l'intérieur du code.
La « Loupe Magique » est la clé : La plus grande amélioration provient de l'outil de Tranchage de Flux de Données. Il a permis à l'IA de sauter les suppositions et d'aller directement à la source du problème.
Pas besoin de traducteur : Les chercheurs ont essayé d'ajouter une étape où une petite IA résumerait les données en anglais simple pour le détective principal. Ils ont constaté que cela était inutile. Le détective principal (un grand modèle d'IA) pouvait lire les données brutes et structurées parfaitement bien. Ajouter l'étape de résumé gaspillait simplement du temps et de l'argent.
La Limite : Le système est excellent pour trouver des problèmes à l'intérieur d'une seule pièce. Cependant, si le problème commence dans une pièce, est transmis à la pièce d'un voisin et provoque un crash là-bas, le détective est parfois confus. C'est le seul domaine où les auteurs indiquent qu'il faut travailler davantage à l'avenir.

En bref, ARISE offre aux agents d'IA un moyen de « tracer le fil » d'une variable à travers le code, transformant une recherche d'aiguille dans une botte de foin en un chemin direct vers la solution.

Résumé Technique : ARISE – Une Représentation Graphique au Niveau du Dépôt et un Ensemble d'Outils pour la Localisation de Pannes et la Réparation de Programmes par Agents

Énoncé du Problème

La réparation automatique de programmes (APR) et la localisation de pannes à l'échelle d'un dépôt nécessitent que les agents naviguent dans des bases de code complexes s'étendant sur plusieurs fichiers, modules et packages. Bien que les systèmes d'agents existants (par exemple, SWE-agent) puissent interagir avec les dépôts, ils éprouvent souvent des difficultés avec la localisation fine des pannes (identification de fonctions et de lignes spécifiques) en raison d'un manque de précision sémantique.

Les approches basées sur les graphes actuelles modélisent généralement les relations structurelles (fichiers, classes, fonctions et leurs dépendances d'appel/d'importation) mais échouent à modéliser le flux de données intra-procédural. Par conséquent, les agents manquent de la capacité de retracer comment les valeurs des variables sont définies et propagées au sein d'une procédure. Cette limitation force les agents à s'appuyer sur la similarité lexicale ou sur une traversal structurelle large, ce qui est insuffisant pour identifier exactement les déclarations responsables d'un bug, en particulier lorsque la faute implique une utilisation complexe de variables au sein d'une fonction.

Méthodologie

Les auteurs présentent ARISE (Agentic Repository-level Issue Solving Engine), un système qui enrichit le cadre SWE-agent avec un graphe de programme structuré et interrogeable, ainsi qu'une API d'outils à trois niveaux. L'innovation centrale est l'intégration du tranchage de flux de données (data-flow slicing) en tant que primitive d'agent de premier ordre.

1. Graphe de Programme Multi-Granulaire

ARISE construit un graphe de propriétés orienté et typé ( $G = (V, E)$ ) qui unifie deux couches d'informations :

Relations Structurelles : Les nœuds représentent des répertoires, des modules, des classes, des fonctions, des méthodes et des déclarations. Les arêtes capturent les relations d'inclusion, d'importation, d'héritage et d'appel.
Relations de Flux de Données : Le graphe s'étend au niveau des déclarations. Pour chaque fonction/méthode, le système effectue une analyse intra-procédurale pour identifier les chaînes définition-utilisation (def-use).
- Nœuds : Les nœuds de déclaration correspondent aux déclarations AST de niveau supérieur.
- Arêtes : Les arêtes DataflowDefUse et DataflowUseDef relient les déclarations où une variable est définie aux déclarations où elle est utilisée (et vice versa).
- Portée : Cette analyse respecte la portée lexicale (gérant les déclarations global/nonlocal) et couvre les modèles d'affectation Python courants (affectations, affectations augmentées, cibles de boucles, gestionnaires de contexte et paramètres).

2. API d'Outils à Trois Niveaux

Le graphe est exposé à l'agent LLM via une API modulaire, permettant à l'agent d'interroger les preuves de manière itérative :

Niveau 1 : Récupération Structurelle : Outils pour rechercher des entités, parcourir les graphes d'appel/d'importation et récupérer des segments de code. Cela reproduit les capacités des systèmes de graphes structurels précédents (par exemple, RepoGraph, LocAgent).
Niveau 2 : Tranchage de Flux de Données : La nouveauté centrale. L'outil get_dataflow_slice permet à l'agent de retracer les flux de variables. Étant donné une graine (fichier, ligne, variable) et une direction (arrière, avant ou bidirectionnelle), il renvoie une liste structurée de segments de déclarations qui définissent ou consomment la variable. Cela permet à l'agent de répondre à la question « quelles déclarations affectent cette variable ? » en une seule requête.
Niveau 3 : Regroupement de Contexte : Outils (build_context_bundle, rank_suspect_regions) qui assemblent les preuves récupérées en un paquet de contexte contraint par le budget de tokens. Ils notent les segments de code en fonction de la pertinence TF-IDF, de la proximité structurelle et de l'appartenance au tranchage, garantissant que le code le plus causalement pertinent est présenté au sous-agent de réparation.

3. Boucle d'Agent

ARISE fonctionne sur l'infrastructure SWE-agent. L'agent interagit avec le dépôt via un protocole multi-tours, choisissant d'appeler des outils structurels, des outils de tranchage ou des outils de regroupement selon les besoins. Le système est conçu pour être indépendant du cadre, permettant au constructeur de graphe et à l'API de tranchage d'être intégrés dans n'importe quel agent capable d'utiliser des outils.

Contributions Clés

Graphe de Programme Multi-Granulaire : Un graphe de dépôt qui unifie l'organisation structurelle avec les informations de flux de données intra-procédural au niveau des déclarations, permettant aux agents d'interroger directement la propagation des valeurs.
Tranchage de Flux de Données comme Primitive d'Agent : L'introduction de get_dataflow_slice en tant qu'outil interrogeable. Contrairement au prétraitement statique, cela permet aux agents de retracer dynamiquement les définitions et utilisations de variables pendant le raisonnement, renvoyant une sortie structurée sur laquelle les modèles peuvent raisonner directement.
Ensemble d'Outils Indépendant du Cadre : Une implémentation découplée du constructeur de graphe et de l'API de tranchage, conçue comme un plugin plug-and-play pour les futures recherches en APR sans nécessiter la réimplémentation de la logique d'analyse sous-jacente.

Résultats Expérimentaux

Le système a été évalué sur SWE-bench Lite (300 vrais problèmes GitHub répartis sur 11 dépôts Python) en utilisant Qwen2.5-Coder-32B-Instruct comme colonne vertébrale.

Performance de Localisation

Par rapport à la base SWE-agent non modifiée :

Rappel de Fonction @1 : Amélioration de 17,0 points (passant de 43,0 % à 60,0 %).
Rappel de Ligne @1 : Amélioration de 15,0 points (passant de 26,0 % à 41,0 %).
Rappel de Fichier @1 : Amélioration de 10,0 points.
Insights des Ablations :
- L'ajout du Niveau 1 (Structurel) a fourni une amélioration de base par rapport à SWE-agent.
- L'ajout du Niveau 2 (Tranchage de Flux de Données) a produit le plus grand gain en une seule étape (+7,0 points dans le Rappel de Fonction @1), confirmant que le traçage du flux de données est crucial pour la localisation fine.
- L'ajout du Niveau 3 (Regroupement de Contexte) a fourni des gains incrémentiels supplémentaires.
- ARISE-Coarse (Schéma Niveau 1 + Niveau 2 mais sans arêtes de flux de données) a performé de manière similaire au seul Niveau 1, prouvant que l'amélioration provient des données du graphe elles-mêmes, et non simplement de la présence d'un outil supplémentaire.
- ExplainSlice (ajout de résumés en langage naturel aux tranches) n'a apporté aucune amélioration mesurable, indiquant que les grands modèles de code (échelle 32B) peuvent raisonner directement sur les sorties de tranches structurées sans médiation en langage naturel.

Performance de Réparation

Pass@1 : ARISE-Full a atteint 22,0 % (66/300), soit une amélioration de 4,7 points de pourcentage par rapport à la base SWE-agent (17,3 %).
Corrélation : Il existe une forte augmentation monotone de la corrélation de Spearman entre le Rappel de Fonction @1 et le Pass@1 à mesure que des outils plus précis sont ajoutés (passant de 0,38 dans SWE-agent à 0,53 dans ARISE-Full). Cela confirme que la qualité de la localisation est la contrainte limitante sur le succès de la réparation dans ce contexte.

Signification et Revendications

L'article revendique que le principal goulot d'étranglement dans l'APR au niveau du dépôt n'est pas seulement la capacité de raisonnement du LLM, mais comment le contexte pertinent est localisé et structuré.

Flux de Données comme Primitive de Récupération : Les auteurs soutiennent que l'exposition des tranches def-use intra-procédurales en tant qu'outil de premier ordre est plus efficace que de s'appuyer uniquement sur la topologie structurelle. Cela réduit l'espace de recherche, permettant aux agents de s'engager sur une hypothèse au niveau de la fonction basée sur un seul tranchage arrière plutôt que de parcourir de larges graphes d'appel.
Structuré vs Langage Naturel : Les résultats remettent en question l'hypothèse selon laquelle l'analyse structurée doit être résumée en langage naturel pour les LLM. À l'échelle de 32 milliards de paramètres, les modèles consomment directement les sorties de tranches structurées, rendant les couches de résumé inutiles et coûteuses.
Limites Modestes : Les auteurs reconnaissent que le système actuel est intra-procédural. Il ne peut pas retracer les flux de variables au-delà des limites d'appel (inter-procédural), ce qui explique 45 % des échecs restants (erreurs de mauvais fichier). Ils identifient l'extension au tranchage inter-procédural comme la direction principale pour les travaux futurs. De plus, l'approche est actuellement spécifique à Python en raison de sa dépendance aux types de nœuds AST.

En résumé, ARISE démontre que l'enrichissement des flux de travail d'agents avec des graphes de flux de données précis et interrogeables améliore considérablement la localisation des pannes et, par conséquent, les taux de réussite de la réparation automatique de programmes.