Skip to main content

Welcome to a Grasp lesson

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

Lesson 38

Optimiser le Workflow de Revue d'IA pour les PR

Bonjour ! Dans la leçon précédente, nous avons réussi à faire analyser le diff d'une pull request par une IA, qui nous a retourné une analyse structurée sous forme de chaîne de caractères JSON. Nous avons la matière brute, l'intelligence est là. Il est maintenant temps de la rendre utile et visible pour l'équipe de développement.

L'objectif de cette leçon est de finaliser notre boucle d'automatisation. Nous allons prendre la réponse brute de l'IA, la transformer en un commentaire élégant et lisible, et le publier directement sur la pull request GitHub correspondante. À la fin de cette session, notre workflow sera un véritable assistant de revue de code, capable d'interagir de manière autonome sur GitHub.

1. Parser la réponse de l'IA : de la chaîne à l'objet

La première étape consiste à transformer la sortie de l'IA en un format que n8n peut manipuler. Si vous examinez la sortie du nœud OpenAI Chat Model de la leçon précédente, vous verrez que l'analyse de code se trouve dans la propriété choices[0].message.content sous forme d'une unique chaîne de caractères.

"{\n  \"overall_assessment\": \"...\",\n  \"issues\": [...],\n  \"positives\": [...]\n}"

Pour que n8n puisse accéder aux clés overall_assessment ou issues, nous devons d'abord "parser" cette chaîne de caractères pour la convertir en un véritable objet JSON. L'outil parfait pour cela est le nœud Code.

  1. Ajoutez un nœud Code (il se trouve dans la catégorie "Flow") après votre nœud "Analyze Code with AI". Renommez-le "Parse AI Response".

  2. Le nœud Code exécute du code JavaScript. Il est incroyablement puissant pour toutes les transformations de données qui dépassent les simples expressions.

  3. Dans le champ de code, collez le snippet JavaScript suivant :

    // Récupère la chaîne de caractères JSON depuis la sortie du nœud OpenAI
    const aiResponseString = $input.item.json.choices[0].message.content;
    
    // Parse la chaîne en un objet JavaScript
    const reviewData = JSON.parse(aiResponseString);
    
    // Retourne l'objet parsé pour que les nœuds suivants puissent l'utiliser
    return { json: reviewData };
    

    Ce code est simple mais fondamental. La fonction JSON.parse() est une fonction standard en JavaScript qui fait exactement ce dont nous avons besoin. Nous retournons le résultat dans une propriété json pour qu'il soit facilement accessible à l'étape suivante.

  4. Testez cette étape (Test step). La sortie (Output) devrait maintenant être un objet JSON parfaitement structuré, avec les clés overall_assessment, issues et positives directement accessibles. Notre workflow "comprend" désormais la structure de la revue de code.


2. Formater la revue en un commentaire lisible

Maintenant que nous avons des données structurées, nous devons les formater en un commentaire clair et professionnel pour GitHub. Le format idéal pour cela est le Markdown, qui permet d'inclure des titres, des listes, des tableaux et de la mise en forme de code.

Nous allons à nouveau utiliser un nœud Code pour cette tâche, car la construction d'une chaîne de caractères complexe avec des boucles et des conditions est son point fort.

  1. Ajoutez un autre nœud Code après "Parse AI Response". Renommez-le "Format Review as Markdown".

  2. Collez le code JavaScript suivant. Il peut paraître long, mais il est très logique : il construit pas à pas le commentaire en Markdown.

    // Récupère l'objet JSON de la revue depuis le nœud de parsing
    const review = $input.item.json;
    
    // Initialise le commentaire avec un titre principal
    let markdownComment = "## 🤖 AI Code Review\n\n";
    
    // Ajoute le résumé global
    markdownComment += `**Overall Assessment:** ${review.overall_assessment}\n\n`;
    
    // Vérifie s'il y a des problèmes et construit un tableau s'il y en a
    if (review.issues && review.issues.length > 0) {
      markdownComment += "### Issues Found\n\n";
      markdownComment += "| Severity | File | Line | Issue | Suggestion |\n";
      markdownComment += "|:---|:---|:---|:---|:---|\n"; // Alignement du tableau
      for (const issue of review.issues) {
        // Pour chaque problème, ajoute une ligne au tableau
        markdownComment += `| ${issue.severity} | \`${issue.file}\` | ${issue.line || 'N/A'} | ${issue.issue} | ${issue.suggestion} |\n`;
      }
    } else {
      markdownComment += "### ✨ No issues found!\n\n";
    }
    
    // Vérifie s'il y a des points positifs et les ajoute sous forme de liste
    if (review.positives && review.positives.length > 0) {
      markdownComment += "\n### Positive Points\n\n";
      for (const positive of review.positives) {
        markdownComment += `- 👍 ${positive}\n`;
      }
    }
    
    // Retourne le commentaire final dans une propriété nommée "comment_body"
    return { json: { comment_body: markdownComment } };
    

Ce script est un excellent exemple de la manière de transformer des données structurées en une présentation destinée à un humain. Il gère dynamiquement le cas où aucun problème n'est trouvé et met en forme les informations de manière claire et concise.

Testez ce nœud. La sortie devrait être un objet JSON avec une seule clé, comment_body, contenant une longue chaîne de caractères : votre commentaire Markdown, prêt à être publié.


3. Publier le commentaire sur la Pull Request

C'est la dernière étape, celle qui boucle la boucle. Nous allons utiliser le nœud GitHub pour poster le commentaire que nous venons de fabriquer sur la pull request d'origine. C'est une action que nous avons déjà vue dans une leçon précédente, mais nous allons maintenant l'utiliser avec un contenu dynamique.

  1. Ajoutez un nœud GitHub à la fin de votre workflow. Renommez-le "Post Review Comment to PR".
  2. Configurez-le comme suit :
    • Credential for GitHub API : Sélectionnez vos identifiants GitHub.
    • Resource : Issue (Rappelez-vous que pour l'API GitHub, les commentaires sur les PRs sont gérés via la ressource "Issue").
    • Operation : Create Comment.
  3. Remplissez les champs requis avec des expressions dynamiques provenant du GitHub Trigger initial :
    • Owner : {{ $('GitHub Trigger').item.json.repository.owner.login }}
    • Repository : {{ $('GitHub Trigger').item.json.repository.name }}
    • Issue/PR Number : {{ $('GitHub Trigger').item.json.pull_request.number }}
  4. Enfin, pour le champ Body, insérez l'expression qui récupère notre commentaire formaté :
    • Body : {{ $('Format Review as Markdown').item.json.comment_body }}

Votre workflow complet devrait maintenant ressembler à ceci :

Ce schéma montre un workflow similaire au nôtre. Il commence par un trigger de PR, prépare les données, les envoie à un agent IA, puis utilise un "GitHub Robot" pour effectuer une action sur la PR, comme créer une revue ou, dans notre cas, poster un commentaire.

Il est temps de lancer le test final ! Exécutez le workflow depuis le début, ou testez simplement la dernière étape "Post Review Comment to PR" si les données des étapes précédentes sont correctes. Rendez-vous ensuite sur votre pull request sur GitHub. Vous devriez y voir un nouveau commentaire, posté par votre bot, contenant l'analyse complète et formatée de l'IA !


Conclusion

Félicitations ! Vous avez maintenant un workflow de CI/CD entièrement fonctionnel et intelligent. Il ne se contente pas de réagir aux événements ; il analyse, réfléchit, et communique de manière constructive. C'est une application concrète et puissante de l'automatisation et de l'IA dans le cycle de vie du développement logiciel.

Voici les points essentiels de cette leçon :

  • Nous avons utilisé le nœud Code et la fonction JSON.parse() pour transformer une chaîne de caractères en un objet JSON exploitable.
  • Nous avons exploité la puissance du nœud Code pour construire dynamiquement une chaîne de caractères formatée en Markdown à partir de données structurées, en utilisant des boucles et des conditions.
  • Nous avons complété le cycle en postant ce commentaire formaté sur la pull request GitHub d'origine, rendant l'analyse de l'IA accessible à toute l'équipe.

Dans la prochaine leçon, nous explorerons comment ajouter une autre couche de communication à notre système. Nous allons créer un workflow qui déclenche des notifications, par exemple sur Slack, pour informer les développeurs que la revue de l'IA est terminée et qu'une action humaine est peut-être nécessaire.