Skip to main content

Welcome to a Grasp lesson

Create a free account to keep studying and create your own study path.

Lesson 30

Détection de bugs par IA : Création d'un workflow d'analyse de code

Recommended resources

Bonjour ! Dans la leçon précédente, nous avons construit un "correcteur de bug" réactif, capable de proposer une solution à partir d'un message d'erreur et du code source. Vous avez vu comment guider une IA pour résoudre un problème déjà survenu. Aujourd'hui, nous allons adopter une approche proactive, digne d'un ingénieur QA ou d'un développeur senior soucieux de la qualité.

L'objectif de cette leçon est de construire un workflow qui analyse un bloc de code pour y identifier les bugs potentiels, les vulnérabilités et les mauvaises pratiques, avant même que le code ne soit exécuté et ne produise une erreur. Nous passons du débogage à la revue de code automatisée. Cet outil agira comme un pair développeur expérimenté qui relit votre travail et vous donne des conseils avisés pour l'améliorer.

1. De la Réaction à la Prévention : La Revue de Code par l'IA

La différence fondamentale avec notre précédent workflow est l'intention.

  • Réactif (Leçon précédente) : Code + Erreur → Correction
  • Proactif (Cette leçon) : Code → Rapport d'analyse

La tâche de l'IA est ici plus subtile. Elle ne se base plus sur un indice clair (un message d'erreur) pour trouver une solution. Elle doit s'appuyer sur sa connaissance approfondie des principes de la programmation, des bonnes pratiques spécifiques à un langage, des failles de sécurité courantes et des "code smells" (des indices dans le code qui suggèrent un problème plus profond).

Pour réussir, notre prompt devra être encore plus sophistiqué. Nous devrons définir une "persona" d'expert pour l'IA, lui donner un cahier des charges d'analyse très précis et, surtout, exiger une réponse structurée pour pouvoir l'exploiter automatiquement.


2. Le Workflow "AI Code Reviewer"

Créons un nouveau workflow que nous nommerons "Revue de Code IA".

Étape 1 : Le Déclencheur

Comme dans la leçon précédente, un déclencheur manuel est parfait pour nos tests.

  1. Ajoutez un nœud Manual Trigger.
  2. Créez deux champs :
    • code (Type: Multi-line String) : Pour coller le code à analyser.
    • language (Type: String) : Pour spécifier le langage de programmation.

Étape 2 : Le Cerveau IA et le Prompt d'Expert

C'est ici que nous allons concevoir l'intelligence de notre outil. Pour vous donner un aperçu d'une implémentation complète et professionnelle, je vous invite à regarder une vidéo qui met en place un système de revue de code de A à Z.

🤖 Créez un Agent IA de Code Review avec n8n (le guide complet)

La vidéo "Créez un Agent IA de Code Review avec n8n" par YoanDev est une excellente démonstration de ce que nous cherchons à accomplir. Elle montre comment construire un workflow complexe qui interagit avec GitHub pour analyser des pull requests.

Regardez la section où l'auteur configure le nœud OpenAI pour la revue de code détaillée (le prompt de revue). Observez la richesse du prompt : il définit un rôle (lead développeur symphonie expérimenté), liste une série de points de contrôle très précis (architecture, nommage, complexité, sécurité, etc.) et spécifie le format de sortie attendu (JSON). C'est un exemple parfait de prompt engineering pour une tâche complexe.

Inspirons-nous de cet exemple pour créer notre propre prompt. Ajoutez un nœud de modèle d'IA (par exemple, OpenAI Chat Model) et connectez-le au déclencheur.

Dans le champ System Prompt (ou équivalent), collez le prompt suivant. Notez sa structure :

  • Persona : Tu es un expert en qualité logicielle...
  • Contexte : Injection du code et du langage.
  • Instructions : Une liste de points à vérifier.
  • Format de sortie : Une exigence stricte pour obtenir du JSON.
Tu es un expert en qualité logicielle et un développeur senior, spécialisé dans le langage {{ $json.language }}.
Ta mission est d'effectuer une revue de code rigoureuse sur le bloc de code suivant.

Code à analyser :

{{ $json.code }}


Tu dois analyser le code selon les critères suivants :
1.  **Bugs potentiels** : Erreurs logiques, "off-by-one errors", conditions de course, gestion incorrecte des valeurs null/undefined.
2.  **Sécurité** : Risques d'injection (SQL, XSS), exposition de données sensibles, gestion des permissions.
3.  **Bonnes pratiques** : Respect des conventions du langage, lisibilité, nommage des variables, utilisation de "magic numbers".
4.  **Performance** : Boucles inefficaces, algorithmes de complexité élevée, requêtes inutiles.
5.  **Robustesse** : Manque de validation des entrées, absence de gestion des erreurs.

Formate ta réponse UNIQUEMENT en JSON, sans aucun texte avant ou après. Le JSON doit avoir la structure suivante :
{
  "issues": [
    {
      "line": <numéro de ligne approximatif du problème>,
      "severity": "<Criticité|Majeur|Mineur>",
      "description": "<Description claire du problème>",
      "suggestion": "<Suggestion concrète pour corriger ou améliorer>"
    }
  ],
  "summary": "<Un résumé global de la qualité du code en une phrase.>"
}
Si aucun problème n'est trouvé, retourne un tableau "issues" vide.

N'oubliez pas de cocher l'option pour forcer la sortie en JSON si votre nœud le permet (par exemple, "Response Format: JSON Object" sur le nœud OpenAI).


3. Test avec un Cas Pratique

Mettons notre critique IA à l'épreuve.

  1. Cliquez sur Test workflow.
  2. Dans le formulaire du déclencheur, entrez les informations suivantes :
    • language: JavaScript
    • code:
      // Fonction pour récupérer les données utilisateur et les afficher
      function processUserData(userId) {
        const data = fetch('https://api.example.com/users/' + userId);
        const user = JSON.parse(data);
      
        document.getElementById('welcome').innerHTML = "Bienvenue, " + user.name;
      
        for (let i = 0; i < user.posts; i++) {
          // Simule un traitement lourd
          console.log('Traitement du post ' + i);
        }
      }
      
      processUserData(123);
      
  3. Exécutez le workflow et examinez la sortie du nœud IA.

L'IA devrait identifier plusieurs problèmes dans ce petit bloc de code :

  • Bug potentiel : fetch est asynchrone et retourne une Promise, pas les données directement. JSON.parse(data) échouera.
  • Sécurité : L'utilisation de .innerHTML avec des données externes (user.name) crée une vulnérabilité XSS (Cross-Site Scripting).
  • Bonnes pratiques/Bug potentiel : user.posts est probablement un tableau d'objets, mais il est utilisé comme un nombre dans la boucle for. La boucle devrait itérer sur la longueur du tableau, par exemple user.posts.length.

La sortie JSON de l'IA pourrait ressembler à ceci :

{
  "issues": [
    {
      "line": 4,
      "severity": "Critique",
      "description": "L'appel à `fetch` est asynchrone. Il retourne une Promise, pas les données JSON. Le code devrait utiliser `await` dans une fonction `async` ou des callbacks `.then()`.",
      "suggestion": "Rendre la fonction `processUserData` `async` et utiliser `await fetch(...)` puis `await response.json()`."
    },
    {
      "line": 7,
      "severity": "Majeur",
      "description": "L'utilisation de `innerHTML` avec des données provenant d'une API expose à un risque de faille de sécurité XSS.",
      "suggestion": "Utiliser `textContent` à la place de `innerHTML` pour insérer du texte de manière sécurisée."
    },
    {
      "line": 9,
      "severity": "Majeur",
      "description": "La boucle `for` itère jusqu'à `user.posts`, ce qui est probablement un objet ou un tableau et non un nombre, causant un comportement inattendu ou une erreur.",
      "suggestion": "Si `user.posts` est un tableau, la condition de la boucle devrait être `i < user.posts.length`."
    }
  ],
  "summary": "Le code contient des erreurs critiques de gestion de l'asynchronisme et une faille de sécurité majeure."
}

4. Application dans un Contexte Réel : Le Triage de Bugs

Ce type d'analyse textuelle est extrêmement polyvalent. Le même principe s'applique à d'autres tâches de votre cycle de développement. Par exemple, au lieu d'analyser du code, vous pourriez analyser des descriptions de bugs pour en déduire automatiquement la priorité.

🚀 Automatiser la hiérarchisation des bugs dans Jira avec l'IA et ...

Cet article de Vinodini Visvanathan sur LinkedIn illustre un cas d'usage similaire dans un autre domaine : la gestion de projet.

Lisez la section d'introduction Aperçu pour comprendre le flux. Ensuite, jetez un œil à la structure du workflow et aux tests suggérés. Vous remarquerez que le schéma est le même : un déclencheur (nouveau bug Jira), une extraction de données (titre, description), un appel à l'IA pour analyse, et une action en retour (mise à jour du ticket).

Cela montre que la compétence que vous développez — formuler une requête d'analyse pour une IA et traiter sa réponse — est transférable à de nombreux problèmes d'automatisation.


Conclusion

Félicitations ! Vous avez maintenant un embryon de relecteur de code automatique. Cet outil peut vous faire gagner un temps précieux en attrapant les erreurs courantes avant même la première exécution, améliorant ainsi drastiquement la qualité de vos livrables.

Les points clés de cette leçon sont :

  • Le passage au proactif : L'analyse de code prévient les bugs au lieu de les corriger.
  • L'importance du prompt d'expert : Définir une persona, des règles précises et un format de sortie strict (JSON) est la clé pour obtenir des résultats fiables et exploitables.
  • La polyvalence du modèle : Le même pattern Trigger -> Extract -> Analyze -> Act peut être appliqué à de nombreuses tâches (revue de code, triage de bugs, analyse de logs, etc.).

Dans la prochaine leçon, nous explorerons une autre méthode d'analyse de code. Vous apprendrez à utiliser le nœud Execute Command pour lancer des outils en ligne de commande, comme un linter, directement depuis n8n. Nous verrons ensuite comment combiner la puissance brute de ces outils spécialisés avec l'intelligence de l'IA pour créer des rapports d'analyse encore plus pertinents.