SWE-Adept: An LLM-Based Agentic Framework for Deep Codebase Analysis and Structured Issue Resolution

Le papier présente SWE-Adept, un cadre agentic à deux agents basé sur les LLM qui améliore la localisation et la résolution d'issues dans les bases de code complexes grâce à une recherche en profondeur dirigée par l'agent et une gestion de version Git adaptative, surpassant ainsi les approches existantes sur les benchmarks SWE-Bench.

L'essentiel

Imaginez que vous êtes le chef d'une immense bibliothèque de livres de cuisine (le code source d'un logiciel). Un client vous dit : « Il y a une erreur dans la recette du gâteau au chocolat, il faut la corriger ! ».

Le problème ? La bibliothèque contient des millions de pages, les recettes sont liées entre elles (la recette du gâteau utilise la recette de la crème, qui utilise celle des œufs, etc.), et si vous lisez tout, votre cerveau va exploser.

C'est exactement le défi que les intelligences artificielles (les LLM) rencontrent aujourd'hui pour réparer des logiciels complexes. Elles sont douées pour écrire une petite fonction, mais elles se perdent dans les méandres d'un projet entier.

Voici comment SWE-Adept résout ce problème, expliqué simplement avec des analogies :

1. Le concept : Une équipe de deux experts

Au lieu d'avoir un seul robot qui essaie de tout faire (chercher ET réparer), SWE-Adept utilise deux agents spécialisés qui travaillent en équipe, comme un détective et un mécanicien.

• L'Agent Détective (Localisation) : Son seul but est de trouver où se trouve le problème.
• L'Agent Mécanicien (Résolution) : Une fois le problème localisé, il vient réparer la machine.

---

2. L'Agent Détective : Le chasseur de pistes intelligent

Dans les anciennes méthodes, le détective lisait des livres au hasard ou ouvrait des étagères entières, ce qui le fatiguait et le distrayait.

La nouvelle méthode de SWE-Adept :

• L'arbre généalogique du code : Avant même de commencer, le système crée une carte mentale (un arbre) qui montre qui appelle qui dans le code. C'est comme avoir un arbre généalogique où l'on voit exactement qui est le parent, l'enfant ou le cousin de chaque recette.
• La recherche en profondeur (DFS) : Au lieu de tout lire, le détective choisit une piste et la suit jusqu'au bout (comme un chien de chasse qui suit une odeur). Il ne s'arrête que s'il trouve le coupable ou s'il réalise que la piste est fausse.
• Le filtre en deux étapes :
  1. Il regarde d'abord juste la couverture du livre et le sommaire (le squelette du code) pour voir si ça a l'air pertinent.
  2. Il ne lit le texte complet que s'il est presque sûr de la bonne page.
     Résultat : Il ne perd pas de temps à lire des pages inutiles et trouve l'erreur beaucoup plus vite.

---

3. L'Agent Mécanicien : Le bricoleur avec une boîte à outils magique

Une fois l'erreur trouvée, le mécanicien doit la réparer. Souvent, les robots essaient de réparer, cassent quelque chose d'autre, et ne savent plus comment revenir en arrière. C'est comme essayer de réparer une montre avec un marteau, sans pouvoir remettre les pièces en place.

La nouvelle méthode de SWE-Adept :

• Les "Branches" (Alternatives) : Le mécanicien ne se lance pas tête baissée. Il imagine plusieurs solutions (hypothèses). Pour chaque solution, il ouvre une branche parallèle dans le temps (comme un jeu vidéo où vous sauvegardez avant de faire un saut risqué).
• La boîte à outils "Git" intelligente : Il utilise des commandes spéciales pour gérer ces branches. Si une réparation échoue, il peut dire : « Annuler tout ce que j'ai fait sur cette branche, je reviens à l'étape précédente ».
• La mémoire partagée : Tout ce qu'il fait est noté dans un carnet de bord (mémoire de travail). Il sait exactement où il en est, ce qui a fonctionné et ce qui a échoué.
• Le plan dynamique : Il ne fait pas tout d'un coup. Il se dit : « D'abord je change cette pièce, je teste. Si ça marche, je passe à la suivante. Si ça casse, je reviens en arrière ».

---

4. Le résultat final

À la fin, le système compare toutes les branches qu'il a explorées. Il choisit la meilleure réparation, fusionne les changements dans le code original, et remet le tout au client.

En résumé, SWE-Adept est comme :

• Un détective qui sait exactement où chercher sans se perdre dans la bibliothèque.
• Un mécanicien qui a une machine à remonter le temps pour tester ses idées sans risquer de tout casser.

Grâce à cette approche, l'IA réussit à réparer des bugs complexes dans de vrais logiciels beaucoup plus souvent que les méthodes précédentes, en évitant de se perdre dans le labyrinthe du code.

Résumé technique

1. Problématique et Contexte

Bien que les grands modèles de langage (LLM) excellent dans les tâches de programmation isolées (fonctions ou fichiers uniques), ils peinent à résoudre des problèmes d'ingénierie logicielle (SWE) au niveau d'un dépôt entier (repository-level). Deux défis majeurs limitent leurs performances actuelles :

1. Localisation précise du code : Les dépôts sont vastes (moyenne de 3 000 fichiers dans SWE-Bench) et présentent des dépendances croisées denses. Les LLMs souffrent de la limite de leur fenêtre de contexte : ils ne peuvent pas charger l'intégralité du code. Les approches existantes injectent souvent trop d'informations non pertinentes dans le contexte, dégradant la précision de la localisation de la racine du problème.
2. Résolution systématique des problèmes : Corriger un bug réel nécessite souvent des modifications itératives, une validation par des tests et une gestion d'état complexe. Les méthodes actuelles (comme SWE-agent) fonctionnent souvent dans une boucle "penser-agir" libre, sans planification explicite ni mécanisme de sauvegarde (checkpointing) fiable. Cela rend difficile le retour en arrière après un échec ou l'exploration de solutions alternatives sans perdre l'état du code.

2. Méthodologie : Le Framework SWE-Adept

SWE-Adept est un framework basé sur des agents LLM qui décompose le processus de résolution en deux agents spécialisés, opérant dans des fenêtres de contexte distinctes pour éviter l'accumulation d'informations non pertinentes.

A. Représentation du Codebase et Indexation

Avant l'interaction, le dépôt est indexé au niveau des définitions (classes et fonctions) pour créer des unités de code fines.

• Arbre de structure de code : En utilisant tree-sitter, le système extrait les dépendances (contient, invoque) pour construire un arbre de structure.
• Liste d'adjacence légère : Au lieu d'un graphe global lourd, chaque unité de code stocke une liste d'adjacence de ses unités enfants, permettant une navigation efficace sans surcharge de recherche.

B. Agent de Localisation (Issue Localization Agent)

Cet agent a pour but d'identifier les fichiers et fonctions pertinents pour un bug donné.

• Parcours en profondeur dirigé par l'agent (Agent-Directed DFS) : Contrairement aux recherches en largeur (BFS) aveugles, l'agent effectue une exploration en profondeur sélective. Il utilise les outils de recherche pour obtenir des informations structurelles légères (squelettes de code, métadonnées) sans charger le contenu complet.
• Filtrage en deux étapes :
  1. Filtrage préliminaire : Basé sur les squelettes de code et les métadonnées pour éliminer les chemins non pertinents.
  2. Re-calibrage (Re-ranking) : Le contenu complet n'est chargé que pour les candidats restants afin d'une analyse précise.
• Résultat : Une liste classée de localisations de code pertinentes, minimisant l'usage du contexte.

C. Agent de Résolution (Issue Resolution Agent)

Une fois les localisations identifiées, cet agent implémente et valide les correctifs.

• Planification Adaptative et Hypothèses : L'agent formule des hypothèses de réparation (solutions alternatives). Pour chaque hypothèse, il génère une liste de tâches (to-do list) dynamique qui s'adapte aux retours des tests (ex: ajout de cas limites).
• Gestion de version et Checkpointing (Point clé) :
  • L'agent utilise une interface d'outils CLI (hypothesis_git) qui encapsule les commandes Git complexes.
  • Mémoire de travail partagée : Chaque étape de tâche (to-do) est associée à un point de contrôle (checkpoint) Git. Les métadonnées (hash Git, message de commit) sont stockées dans une mémoire de travail structurée.
  • Opérations de contrôle de version : Cela permet à l'agent de créer des branches pour explorer différentes hypothèses, de revenir en arrière (revert) vers un checkpoint spécifique si une direction échoue, et de fusionner la solution finale. Cela assure une résolution systématique et fiable sur le long terme.

3. Contributions Clés

1. Framework à deux agents : Séparation stricte entre la localisation (recherche) et la résolution (modification), optimisant l'utilisation du contexte.
2. Parcours de code intelligent : Introduction d'une navigation en profondeur guidée par l'agent couplée à un filtrage en deux étapes, permettant une exploration profonde des dépendances sans saturer la fenêtre de contexte.
3. Interface Outil-Mémoire pour le contrôle de version : Conception d'une interface permettant à l'agent de gérer des checkpoints de code via Git de manière autonome et fiable, facilitant le retour en arrière et l'exploration de multiples hypothèses (branching).

4. Résultats Expérimentaux

Les évaluations ont été menées sur les benchmarks SWE-Bench Lite et SWE-Bench Pro en utilisant les modèles GPT-5.2 et Claude-Sonnet-4.5.

• Localisation : SWE-Adept surpasse les approches de base (SWE-agent, RepoGraph, LocAgent) avec une précision accrue.
  • Amélioration de 5,4 % sur la précision de localisation au niveau fonctionnel (Func Acc@5) sur SWE-Bench Lite par rapport au meilleur baseline.
• Résolution (Taux de réussite) :
  • Sur SWE-Bench Lite : Gain de 3,3 % (GPT-5.2) et 2,6 % (Claude).
  • Sur SWE-Bench Pro (plus complexe) : Gain de 4,7 % (GPT-5.2) et 4,0 % (Claude), atteignant un taux de résolution global supérieur.
• Efficacité : Le framework consomme généralement moins de tokens que les approches basées sur des graphes complets grâce à une gestion efficace du contexte.
• Analyse des échecs : L'analyse montre que SWE-Adept réduit significativement les échecs dus à une mauvaise localisation, à des hypothèses incorrectes et à l'incapacité de récupérer après une erreur de modification.

5. Signification et Impact

SWE-Adept démontre que la résolution autonome de problèmes logiciels complexes nécessite plus que de simples capacités de génération de code. Elle exige :

• Une gestion rigoureuse du contexte pour naviguer dans de vastes bases de code.
• Une méthodologie structurée (planification, hypothèses, suivi de l'état) pour gérer la complexité des corrections itératives.

L'approche proposée établit un nouveau standard pour les agents logiciels, prouvant que l'intégration de mécanismes de contrôle de version (Git) gérés par l'agent et d'une mémoire de travail structurée est essentielle pour des tâches d'ingénierie logicielle à long horizon. Cela ouvre la voie à des systèmes capables de gérer des dépôts de production réels avec une fiabilité accrue.