Améliorer la qualité du code : revue de code assistée par l'IA avec Antigravity CLI et SDK

1. Introduction

Le vibe coding (utilisation d'agents d'IA pour écrire du code à partir de requêtes en langage naturel) fait passer le rôle du développeur de celui d'auteur à celui d'orchestrateur et de réviseur. Nous nous appuyons sur la préparation du contexte parfait et faisons confiance aux agents d'IA pour faire tout à notre place, depuis la création des documents de spécification jusqu'à la vérification que le code répond à toutes les exigences. Le risque : lors de cycles d'itération rapides, le code fonctionnel est approuvé sans examen approfondi de la sécurité. Les agents modernes produisent souvent du code sécurisé par défaut, mais "souvent" n'est pas "toujours", et les failles accumulées échappent à l'examen manuel.

Cet atelier de programmation aborde ces problèmes en vous expliquant deux approches pour utiliser Antigravity comme réviseur : de manière interactive pendant le développement avec la CLI (vous examinez, corrigez, puis envoyez une demande d'extraction) et de manière automatique dans l'intégration continue avec le SDK (l'agent examine chaque demande d'extraction et publie les résultats sous forme de commentaire).

Points abordés

Vous avez codé une application CRM pour les prospects. Un agent d'IA a créé le stack complet pour vous : backend Express, base de données SQLite et frontend React. Ça fonctionne. Vous avez ensuite demandé à l'agent d'ajouter deux nouvelles fonctionnalités : une fonction de recherche de prospects et une fonctionnalité d'importation/exportation groupée avec des statistiques d'administrateur. L'agent a fourni les deux rapidement. Le code s'exécute, les fonctionnalités fonctionnent et les demandes d'extraction sont prêtes.

Mais voici le problème : vous n'avez pas écrit ce code. Vous l'avez approuvée. Comment savoir si le point de terminaison de recherche n'est pas vulnérable à l'injection SQL ? Comment savez-vous que la route d'administration ne comporte pas de mot de passe codé en dur ? Vous n'avez pas besoin de le faire. De plus, lire chaque ligne de code générée par l'IA annule l'avantage de vitesse qui vous a poussé à utiliser le vibe-coding.

Cet atelier de programmation vous propose deux façons de résoudre ce problème :

• Cas d'utilisation 1 : Examen interactif : extrayez une branche de fonctionnalité présentant des failles, utilisez la CLI Antigravity améliorée avec des compétences d'agent pour examiner le diff, corrigez les problèmes et créez une demande d'extraction propre.
• Cas d'utilisation 2 : Examen automatisé : configurez une action GitHub optimisée par le SDK Antigravity qui examine automatiquement les demandes d'extraction, publie les résultats structurés sous forme de commentaires et répond lorsque les développeurs posent des questions complémentaires sur l'examen.

Points abordés

• Comment le codage des ambiances peut créer des risques de sécurité et pourquoi l'examen automatisé détecte ce que l'examen manuel ne voit pas
• Installer et utiliser des compétences d'agent gérées par la communauté pour doter la CLI Antigravity d'une expertise approfondie en matière de sécurité et de revue de code
• Utiliser la CLI de manière interactive pour examiner le diff d'une branche de fonctionnalité, corriger les failles et créer une demande d'extraction propre
• Utiliser le SDK Antigravity pour créer un agent de revue de code en lecture seule avec des règles de sécurité déclaratives et des hooks de cycle de vie
• Déployer l'agent d'examen en tant qu'action GitHub qui examine les demandes d'extraction et publie le résultat sous forme de commentaire

Prérequis

• Un compte Google Cloud
• Un compte GitHub
• Connaissances de base du terminal, du contrôle des versions et de la CI/CD

2. Configuration de l'environnement

Cette étape consiste à forker le dépôt de l'application Leads CRM, à le cloner dans Cloud Shell, à configurer la CLI Antigravity et à s'authentifier.

Dupliquer le dépôt

Vous avez besoin de votre propre copie du dépôt, car vous allez envoyer des commits et créer des demandes d'extraction avec GitHub Actions.

Accédez au dépôt suivant.

Dépôt CRM pour les prospects

Cliquez ensuite sur Fork (Dupliquer). Sur la page de création du fork, décochez la case "Copier uniquement la branche main". Vous avez besoin des autres branches de fonctionnalités (feature/lead-search et feature/bulk-operations) dans votre fork.

Remarques : Assurez-vous que la case Copy the main branch only est décochée.

Ouvrir Cloud Shell

Ouvrez Cloud Shell dans votre navigateur. Cloud Shell fournit un environnement préconfiguré avec tous les outils dont vous avez besoin pour cet atelier de programmation. Cliquez sur Autoriser lorsque vous y êtes invité.

Ouvrir Cloud Shell

Cliquez ensuite sur Afficher > Terminal pour ouvrir le terminal.Votre interface devrait ressembler à ceci :

Ce sera notre interface principale, avec l'IDE en haut et le terminal en bas.

S'authentifier avec GitHub

Par défaut, Cloud Shell ne dispose pas d'identifiants GitHub configurés, mais l'interface de ligne de commande gh est déjà installée. Configurez l'authentification pour pouvoir envoyer des commits et créer des demandes d'extraction ultérieurement :

💻 Copiez et exécutez cette commande dans le terminal.

gh auth login

Sélectionner Github.com

 Sélectionnez HTTPS ( ou choisissez un autre mécanisme si vous le connaissez).

Sélectionnez ensuite Y.

Sélectionnez ensuite Login with a web browser.

**,**Vous serez invité à copier le code à usage unique et à le saisir lorsque vous ouvrirez la page de connexion dans le navigateur. Vous pouvez Ctrl + Click sur l'URL dans le terminal pour ouvrir l'URL https://github.com/login/device. Vous serez invité à sélectionner le compte auquel vous souhaitez vous connecter et à saisir le code.

Ensuite, revenez à la page de la console Cloud Shell. La sortie du terminal devrait ressembler à ceci :

✓ Authentication complete.
- gh config set -h github.com git_protocol https
✓ Configured git protocol
! Authentication credentials saved in plain text
✓ Logged in as alphinside-joonix

Cela signifie que vous avez correctement configuré l'authentification de votre compte GitHub sur Cloud Shell.

Cloner le dépôt dupliqué

Ensuite, clonons votre dépôt dupliqué. Remplacez <YOUR_GITHUB_USERNAME> par votre nom d'utilisateur GitHub :

💻 Copiez et exécutez cette commande dans le terminal.

git clone https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo.git
cloudshell workspace leads-crm-app-demo && cd leads-crm-app-demo

Valider les branches de fonctionnalité

Vérifiez ensuite que les deux branches de fonctionnalités avec des failles prédéfinies sont disponibles dans le dépôt distant :

💻 Copiez et exécutez cette commande dans le terminal.

git branch -a | grep feature/

Vous devriez obtenir le résultat suivant :

remotes/origin/feature/bulk-operations
remotes/origin/feature/bulk-operations-solution
remotes/origin/feature/email-composer
remotes/origin/feature/lead-search

Vérifier la CLI Antigravity

Ensuite, vérifions qu'Antigravity CLI est préinstallé dans Cloud Shell. Vérifiez qu'il est disponible :

💻 Copiez et exécutez cette commande dans le terminal.

agy --version

La version d'Antigravity CLI installée doit s'afficher, par exemple 1.0.13.

Si vous n'avez pas encore authentifié l'interface de ligne de commande Antigravity, vous pouvez consulter cet atelier de programmation pour en savoir plus sur le processus d'authentification.

Authentification de la CLI Antigravity

À ce stade, vous devriez disposer des éléments suivants :

• le dépôt dupliqué est cloné.
• les deux branches de fonctionnalité sont visibles.
• La commande agy est disponible et authentifiée.

3. Le problème : les failles cachées dans les fonctionnalités codées par les utilisateurs

Voici le scénario : un membre de l'équipe a utilisé un agent d'IA pour ajouter deux fonctionnalités à l'application CRM Prospects : une fonction de recherche de prospects et des opérations d'importation/exportation groupées. Les deux fonctionnalités fonctionnent. Les deux ont été expédiés rapidement sans examen de sécurité. Vous allez examiner les deux branches avant leur fusion : l'une de manière interactive avec la CLI et l'autre automatiquement avec une action GitHub.

Examiner la première branche de fonctionnalité

Examinez la différence sur feature/lead-search :

💻 Copiez et exécutez cette commande dans le terminal.

git diff main...origin/feature/lead-search

Cette branche ajoute un point de terminaison de recherche. Analysez le diff. Vous devriez identifier des problèmes tels que la concaténation de chaînes dans les requêtes SQL, l'absence de validation des entrées, la journalisation de débogage qui divulgue les détails des requêtes et les messages d'erreur bruts exposés au client.

+  app.get("/api/leads/search", (req, res) => {
+    const query = req.query.q as string;
+
+    if (!query) {
+      return res.status(400).json({ error: "Search query is required" });
+    }
...

Remarque : Appuyez sur q pour quitter la vue git diff.

Examiner la deuxième branche de fonctionnalité

💻 Copiez et exécutez cette commande dans le terminal.

git diff main...origin/feature/bulk-operations

Cette branche ajoute des points de terminaison d'importation/exportation groupées et un tableau de bord de statistiques d'administration. Les failles incluent des identifiants d'administrateur codés en dur, des points de terminaison d'administrateur non authentifiés, l'absence de validation des entrées lors de l'importation groupée et le risque de traversée de répertoire dans la gestion des noms de fichiers d'exportation.

...
+  const ADMIN_PASSWORD = "admin123";
+
+  app.post("/api/admin/import", (req, res) => {
+    const { password, leads } = req.body;
+
+    if (password !== ADMIN_PASSWORD) {
+      return res.status(401).json({ error: "Invalid admin password" });
+    }
...

Remarque : Appuyez sur q pour quitter la vue git diff.

Les deux branches ajoutent des fonctionnalités. Les deux présentent des problèmes de sécurité. La question est de savoir comment les détecter : manuellement avec la CLI (cas 1) ou automatiquement avec une action GitHub (cas 2).

4. Cas d'utilisation 1 : Examen interactif avec la CLI Antigravity

L'examen interactif de l'interface de ligne de commande est particulièrement utile juste après une session de vibe-coding, pour examiner le code que vous venez d'écrire ou la demande d'extraction de votre coéquipier. Si nous parlons de vibe coding, un agent d'IA a généré rapidement le code de votre fonctionnalité. Toutefois, vous ne comprenez peut-être pas entièrement chaque ligne produite. De plus, l'agent peut être optimisé pour la fonctionnalité, mais pas nécessairement pour la sécurité, en fonction de la configuration du contexte pendant que vous développez la fonctionnalité.

Dans ce scénario, nous disposons de codes présentant des failles de sécurité. Nous allons utiliser la CLI Antigravity et nos compétences en matière de revue de code pour examiner le code de manière interactive. Ce modèle d'agent qui examine un autre agent permet de détecter les failles qui passent inaperçues lorsque le développeur passe de l'écriture de code à l'approbation de code généré par IA. Cela s'applique également lorsque vous examinez votre propre code écrit manuellement ou la branche d'un membre de l'équipe avant qu'elle ne passe par l'intégration continue. Vous contrôlez la conversation : demandez à l'agent de se concentrer sur des fichiers spécifiques, d'approfondir une découverte ou d'appliquer des correctifs immédiatement.

Sans compétences d'agent, l'interface de ligne de commande Antigravity peut toujours examiner le code, mais elle s'appuie sur ses connaissances générales en matière d'entraînement, qui peuvent passer à côté de schémas spécifiques à un domaine ou appliquer des critères d'examen incohérents d'une session à l'autre. Les compétences de l'agent lui fournissent un manuel structuré : examen à cinq axes pour la qualité, étiquetage de la gravité pour la hiérarchisation. L'examen devient répétable et approfondi, quelle que soit la formulation de votre requête.

Cette étape utilise la CLI Antigravity avec les compétences de l'agent pour examiner la branche feature/lead-search, corriger les failles et créer une demande d'extraction propre.

Consulter la branche de fonctionnalité

Commençons par passer à la branche "Case 1" :

💻 Copiez et exécutez cette commande dans le terminal.

git checkout feature/lead-search

Ensuite, mettons à niveau notre interface de ligne de commande Antigravity avec les compétences de l'agent pour effectuer l'examen.

Que sont les compétences agentiques ?

Les compétences sont des fichiers Markdown déclaratifs qui fournissent à l'agent une expertise spécialisée. Une fois installées, elles deviennent des commandes à barre oblique (par exemple, /code-review-and-quality). Elles permettent à un agent à usage général d'accéder au playbook de sécurité d'un ingénieur senior.

Les compétences sont portables entre les agents (Antigravity, Claude Code, Cursor, etc.) et partageables via Git. Pour l'interface de ligne de commande Antigravity, les compétences de l'espace de travail (projet/local) se trouvent dans .agents/skills/ à la racine du projet. Les compétences globales se trouvent dans ~/.gemini/config/skills/. Pour en savoir plus, consultez cette documentation.

Pour illustrer les capacités des compétences de l'agent, cet atelier de programmation utilisera la revue de code de addyosmani/agent-skills :

• code-review-and-quality : examen sur cinq axes (exactitude, lisibilité, architecture, sécurité, performances) avec étiquetage de la gravité.

Remarques : Ces compétences d'agent sont des exemples concrets pour ce tutoriel, mais il existe d'autres options. L'écosystème de compétences de l'agent est ouvert : tout le monde peut créer et partager des compétences sous forme de fichiers Markdown dans un dépôt Git. Le dépôt [ agent-skills] à lui seul contient plus de 20 compétences couvrant les tests, le débogage, la CI/CD et plus encore. Il existe également d'autres collections de compétences gérées par la communauté. Explorez les options disponibles et choisissez celle qui correspond au workflow de votre équipe, ou créez la vôtre.

Installer la compétence de l'agent de revue de code

En utilisant la commande ci-dessous, la compétence sera installée dans .agents/skills/ par défaut dans le répertoire de travail actuel (une installation au niveau de l'espace de travail). Cela signifie qu'ils font partie du dépôt et peuvent être validés avec votre code. Ainsi, chaque développeur (et pipeline CI) du projet bénéficie automatiquement des mêmes compétences d'examen.

💻 Copiez et exécutez cette commande dans le terminal.

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y

Voici la compétence détaillée qui peut être inspectée dans le fichier .agents/skills/code-review-and-quality/SKILL.md :

name: code-review-and-quality
description: Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

Fonctionnalités clés :

• Examens selon cinq axes : exactitude, lisibilité, architecture, sécurité et performances
• Les résultats sont classés par niveau de gravité pour vous permettre de corriger d'abord les problèmes critiques.
• Applique la norme d'approbation : "Approuver si cela améliore définitivement l'état général du code, même s'il n'est pas parfait"

Nous sommes maintenant prêts à exécuter certaines tâches. Vérifions la compétence dans la CLI Antigravity

Lancer AGY et valider les compétences

Exécutons la CLI Antigravity

💻 Copiez et exécutez cette commande dans le terminal.

agy --dangerously-skip-permissions

Important : Cette option est dangereuse, car elle autorise toutes les actions. Pour en savoir plus sur les paramètres de production, consultez cette documentation. Nous n'utiliserons ce tutoriel que pour accélérer la progression de l'atelier.

Exécutez ensuite la commande suivante :

🤖 Copiez et exécutez la commande suivante dans Antigravity

/skills

Les deux compétences doivent s'afficher comme suit sous Workspace skills :

Remarque : Appuyez sur Esc pour quitter la commande /skills.

Exécuter la revue de code des différences de la fonctionnalité

Invoquez la compétence de sécurité et demandez-lui d'examiner votre branche. Saisissez ce prompt :

🤖 Copiez et exécutez la commande suivante dans Antigravity

Review the git diff between main and my current branch. Find any issues based on the agent skills that are appropriate for this. Write the findings and plan to fix them to code_review.md in the current working directory. Do not apply fixes yet.

L'agent détecte la compétence code-review-and-quality pertinente et l'active automatiquement. Il lit le diff, identifie les failles et rédige les résultats avec un plan de correction proposé dans code_review.md.

Une fois l'analyse terminée, un fichier code_review.md doit être créé dans votre répertoire de travail. Vous pouvez l'inspecter dans l'éditeur.

Examinez chaque problème et la correction proposée. Une fois que le plan vous convient, demandez à l'agent de l'appliquer :

🤖 Copiez et exécutez la commande suivante dans Antigravity

Apply the proposed fixes from code_review.md

L'agent lit le plan et applique chaque correction prévue aux fichiers sources.

Si vous le souhaitez, vous pouvez maintenant vérifier si l'application fonctionne correctement après la correction en installant les dépendances et en l'exécutant.

Remarques : Quittez la CLI Antigravity en appuyant deux fois sur Ctrl+D.

💻 Copiez et exécutez cette commande dans le terminal.

npm install
npm run dev

L'application doit s'exécuter correctement. Sinon, vous pouvez itérer et demander à Antigravity CLI de le corriger.

Valider et créer une demande d'extraction

Vous pouvez maintenant transférer les modifications vers votre propre dépôt si vous le souhaitez. Avant de passer au cas suivant, validons d'abord les modifications dans la branche actuelle.

Si vous ne l'avez pas encore fait, vous devez d'abord configurer votre identité Git (remplacez les valeurs par votre nom et votre adresse e-mail) :

💻 Copiez et exécutez cette commande dans le terminal.

git config --global user.email "[e-mail]"
git config --global user.name "Your Name"

Effectuez ensuite un commit sur les modifications.

💻 Copiez et exécutez cette commande dans le terminal.

git add .
git commit -m "fix: address security vulnerabilities in lead search feature"

Vous avez déjà utilisé la CLI Antigravity en tant qu'examinateur interactif. Les compétences lui ont permis d'acquérir une méthodologie structurée : la revue de code sur cinq axes. Cela fonctionne lorsque vous êtes le développeur qui examine le code généré par l'IA, votre propre code ou la contribution d'un membre de votre équipe. Dans la section suivante, nous allons automatiser l'ensemble de ce flux pour en faire un processus automatisé et évolutif dans votre dépôt de code en utilisant GitHub comme exemple.

5. Cas d'utilisation 2 : Examen automatisé avec le SDK Antigravity – Partie 1 ( création de l'agent)

Cette étape consiste à créer un agent d'examen automatisé à l'aide du SDK Antigravity, à le déployer en tant qu'action GitHub et à le tester par rapport à la deuxième branche de fonctionnalité. L'agent examine les demandes d'extraction à la demande et publie ses conclusions sous forme de commentaires.

Pourquoi un examen automatisé ?

L'examen interactif de la CLI (cas 1) fonctionne lorsqu'un développeur l'examine activement. Les équipes ont besoin d'un examen qui s'exécute automatiquement sur chaque demande d'extraction, ce qui permet de détecter les problèmes de n'importe quel contributeur, outil et moment. Le SDK Antigravity (google-antigravity) fournit le même environnement d'exécution d'agent que l'interface CLI, sous la forme d'une bibliothèque Python. Les règles et les hooks sont configurés dans le code.

GitHub Actions est la plate-forme d'intégration continue/de développement continu (CI/CD) intégrée à GitHub. Il exécute des workflows (scripts automatisés définis en YAML) en réponse à des événements de dépôt tels que l'ouverture d'une demande d'extraction, l'envoi d'un commit ou la publication d'un commentaire. Les workflows s'exécutent sur des machines virtuelles hébergées sur GitHub et ont accès au code du dépôt. Dans ce cas, vous utilisez une action GitHub pour exécuter un agent d'examen de sécurité chaque fois qu'une demande d'extraction est créée.

Voici comment fonctionne le processus d'examen automatisé :

Le SDK Antigravity ( google-antigravity) fournit le même environnement d'exécution d'agent que l'interface CLI, sous la forme d'une bibliothèque Python. Vous écrivez un script Python qui configure l'agent avec des règles et des hooks, l'exécutez dans une action GitHub et publiez les résultats sous forme de commentaire de demande d'extraction.

Obtenir une clé API Gemini

Avant de commencer, nous aurons besoin de la clé API Gemini pour qu'elle soit utilisée par le SDK Antigravity. Accédez à Clé API Google AI Studio, puis créez une clé API. Vous pourrez la copier chaque fois que vous en aurez besoin.

IMPORTANT ! La clé API est un secret et doit être protégée avec soin. Ne l'affichez ni ne la partagez avec personne.

Remarque : Si vous êtes redirigé vers Playground, essayez de trouver l'icône en forme de clé 🔑 en bas à gauche, à côté de vos informations de connexion à votre adresse e-mail.

Cette clé sera utilisée lors de l'exécution de l'agent d'examen en local et en tant que secret GitHub Actions ultérieurement.

Partie A : Créer l'agent d'examen

Maintenant, pour le cas 2, passons de votre répertoire de travail actuel à la branche feature/bulk-operations :

Remarques : Si vous êtes dans l'interface de ligne de commande Antigravity, quittez-la en appuyant deux fois sur Ctrl+D.

💻 Copiez et exécutez cette commande dans le terminal.

git checkout feature/bulk-operations

Il s'agit de la deuxième branche de fonctionnalité du scénario. Elle ajoute des points de terminaison d'importation/exportation groupée et un tableau de bord de statistiques d'administration à l'application CRM.

Configurer le projet Python

Le SDK Antigravity n'est actuellement disponible qu'en Python. Nous aurons donc besoin d'un environnement Python pour le développer. Nous utiliserons uv pour notre gestionnaire de projet Python. uv est un gestionnaire de packages et de projets Python rapide écrit en Rust ( documentation). Cet atelier de programmation l'utilise pour des raisons de rapidité et de simplicité. Si vous utilisez Cloud Shell pour ce tutoriel, il est déjà préinstallé dans l'instance. Consultez ce tutoriel si vous souhaitez l'installer pour votre

Initialisez un projet Python pour l'agent d'examen à l'aide de uv :

💻 Copiez et exécutez cette commande dans le terminal.

uv init code_review_agent
uv add --project code_review_agent google-antigravity==0.1.7

Un nouveau répertoire code_review_agent contenant les fichiers nécessaires de l'agent de revue de code sera créé.

Installer les compétences d'examen

L'agent d'examen doit posséder les mêmes compétences en matière de sécurité et de revue de code que dans le cas 1. Installez-les dans code_review_agent/skills/ pour que l'agent SDK les charge au moment de l'exécution :

💻 Copiez et exécutez cette commande dans le terminal.

npx skills add addyosmani/agent-skills --skill code-review-and-quality -y
cp -r .agents/skills code_review_agent/skills

Remarques : Dans la section précédente, la CLI charge les compétences à partir de .agents/skills/. Le SDK les charge via le paramètre skills_paths : mêmes fichiers de compétences, mécanisme de chargement différent. En les installant sous code_review_agent/skills/, les dépendances de l'agent d'examen restent autonomes.

Créer l'agent d'examen

Remarque : Vous pouvez également installer des compétences d'agent Antigravity SDK pour demander à Antigravity CLI de créer l'agent pour vous. Installez la compétence SDK officielle (npx skills add google-antigravity/antigravity-sdk-python), lancez la CLI Antigravity et décrivez les exigences de l'agent. La compétence SDK fournit à AGY des connaissances précises sur l'API google-antigravity afin qu'il génère le code approprié.

Dans ce tutoriel, nous le rendons plus déterministe en fournissant l'implémentation de référence.

Créons maintenant code_review_agent/review_agent.py . Exécutez la commande suivante :

💻 Copiez et exécutez cette commande dans le terminal.

cloudshell edit code_review_agent/review_agent.py

Ensuite, copiez le contenu suivant dans le fichier.

📄 Copiez ce code dans le fichier et enregistrez-le.

#!/usr/bin/env python3
import asyncio
import json
import os
import sys

import pydantic

from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
from google.antigravity.hooks import hooks, policy
from google.antigravity import types


class Finding(pydantic.BaseModel):
    file: str
    line: int
    severity: str
    category: str
    description: str
    proposed_fix: str = ""


class ReviewResult(pydantic.BaseModel):
    findings: list[Finding]


SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_FILE = "code_review.md"
SKILLS_PATHS = [
    os.path.join(SCRIPT_DIR, "skills", "code-review-and-quality"),
]

review_policies = [
    policy.deny_all(),
    policy.allow("view_file"),
    policy.allow("list_directory"),
    policy.allow("search_directory"),
    policy.allow("find_file"),
    policy.allow("run_command"),
    policy.allow("finish"),
]

@hooks.post_tool_call
async def log_tool_results(data: types.ToolResult):
    result_str = str(data.result) if data.result else ""
    preview = result_str[:200] + "..." if len(result_str) > 200 else result_str
    print(f"[audit] tool={data.name} result_len={len(result_str)} error={data.error} preview={preview}", flush=True)

@hooks.pre_tool_call_decide
async def enforce_safe_tools(data: types.ToolCall) -> types.HookResult:
    print(f"[audit] calling tool={data.name} args_keys={list(data.args.keys())}", flush=True)

    if data.name == "run_command":
        cmd = str(data.args.get("CommandLine", ""))
        if not cmd.startswith("git "):
            return types.HookResult(
                allow=False,
                message=f"Only git commands are allowed. Blocked: {cmd}"
            )
    return types.HookResult(allow=True)

async def review_code(target_dir: str) -> dict:
    prompt = f"""Run `git diff main...HEAD -- ':!.github' ':!code_review_agent'` in {target_dir} to get the changes on this branch.
Review ONLY the changed code for security vulnerabilities and code quality issues.
"""

    config_kwargs = dict(
        system_instructions=(
            "You are a code review agent. "
            "You review code diffs for vulnerabilities and quality issues using the loaded skills. "
            "You can run git commands to inspect the diff. "
            "You NEVER modify files."
        ),
        response_schema=ReviewResult,
        skills_paths=SKILLS_PATHS,
        policies=review_policies,
        hooks=[log_tool_results, enforce_safe_tools],
    )

    if os.environ.get("GEMINI_API_KEY"):
        config_kwargs["api_key"] = os.environ["GEMINI_API_KEY"]
    else:
        config_kwargs["vertex"] = True
        config_kwargs["project"] = os.environ.get("GOOGLE_CLOUD_PROJECT")
        config_kwargs["location"] = os.environ.get("GOOGLE_CLOUD_LOCATION", "global")

    config = LocalAgentConfig(**config_kwargs)

    async with Agent(config) as agent:
        response = await agent.chat(prompt)

        last_step = -1
        final_text_chunks = []
        async for chunk in response.chunks:
            if isinstance(chunk, types.ToolCall):
                final_text_chunks.clear()
            if hasattr(chunk, "text") and hasattr(chunk, "step_index"):
                if chunk.step_index != last_step:
                    final_text_chunks.clear()
                    last_step = chunk.step_index
                final_text_chunks.append(chunk.text)

        final_text = "".join(final_text_chunks)
        if final_text:
            print(final_text)

        data = await response.structured_output()

        if data and "findings" in data:
            return {"findings": data["findings"]}

        try:
            parsed = json.loads(final_text)
            if isinstance(parsed, list):
                return {"findings": parsed}
            if isinstance(parsed, dict) and "findings" in parsed:
                return {"findings": parsed["findings"]}
        except json.JSONDecodeError:
            pass

    return {"findings": final_text}


SEVERITY_EMOJI = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵"}

def format_markdown(result: dict) -> str:
    findings = result.get("findings", [])
    if isinstance(findings, str):
        return f"## AI Security Review\n\n{findings}\n"
    if not findings:
        return "## AI Security Review\n\nNo security issues found.\n"
    lines = ["## AI Security Review\n"]
    for f in findings:
        emoji = SEVERITY_EMOJI.get(f.get("severity", "").lower(), "⚪")
        lines.append(f"### {emoji} [{f.get('severity', 'unknown').upper()}] {f.get('category', '')}\n")
        lines.append(f"**{f.get('file', '')}:{f.get('line', '')}**\n")
        lines.append(f"{f.get('description', '')}\n")
        proposed_fix = f.get('proposed_fix', '')
        if proposed_fix:
            lines.append(f"**Proposed fix:** {proposed_fix}\n")
    lines.append("---\n*Powered by Antigravity SDK*")
    return "\n".join(lines)


if __name__ == "__main__":
    target = sys.argv[1] if len(sys.argv) > 1 else "."
    result = asyncio.run(review_code(target))
    markdown = format_markdown(result)
    with open(OUTPUT_FILE, "w") as f:
        f.write(markdown)
    print(f"Review written to {OUTPUT_FILE}")
    print(json.dumps(result, indent=2))

Examinons les principales décisions de conception de cet agent :

• Règles de refus par défaut : policy.deny_all() bloque tout, puis autorise spécifiquement les outils de lecture de fichiers ouverts et run_command (pour git).
• Application à deux niveaux : les règles imposent des restrictions au niveau du framework, et le hook enforce_safe_tools fournit un deuxième niveau, en n'autorisant que les commandes git via run_command .
• Portée du diff Git : l'agent exécute git diff main...HEAD pour n'examiner que le code modifié, et non l'ensemble du codebase.
• Sortie structurée avec solution de repli : response_schema=ReviewResult impose une structure JSON via l'outil de fin du SDK. Si l'analyse échoue, la chaîne de secours tente d'analyser text() en tant que JSON, puis renvoie le texte brut.
• Authentification de secours : utilise GEMINI_API_KEY si disponible, sinon revient à Vertex AI via les identifiants par défaut de l'application.
• Sortie de fichier : écrit les résultats au format Markdown dans code_review.md. L'action GitHub lit ce fichier et le publie ultérieurement en tant que commentaire de demande d'extraction.

Tester l'agent d'examen

Testez à partir de la racine du projet. Le SDK lira GEMINI_API_KEY à partir de l'environnement. Nous allons donc placer la clé dans l'environnement.

💻 Copiez et exécutez cette commande dans le terminal.

Remplacez YOUR_API_KEY par la clé API que vous avez obtenue précédemment à partir de la clé API Google AI Studio.

export GEMINI_API_KEY=YOUR_API_KEY

Exécutez ensuite la commande suivante pour l'exécuter localement.

💻 Copiez et exécutez cette commande dans le terminal.

uv run --project code_review_agent code_review_agent/review_agent.py .

Lors de l'exécution, il affichera une sortie de console expliquant les outils qu'il utilise actuellement. Vous pouvez le remarquer en accédant aux compétences d'agent security-and-hardening et code-review-and-quality.

[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=47 error=None preview=Read security and hardening skill documentation
[audit] calling tool=view_file args_keys=['AbsolutePath', 'IsSkillFile']
[audit] tool=view_file result_len=48 error=None preview=Read code review and quality skill documentation
[audit] calling tool=run_command args_keys=['CommandLine', 'Cwd', 'WaitMsBeforeAsync']
...

L'agent exécute git diff main...HEAD, n'examine que le code modifié, écrit les résultats mis en forme dans code_review.md et affiche le JSON structuré dans la console. Vous pouvez inspecter le code_review.md écrit dans l'éditeur, comme indiqué ci-dessous.

Il fonctionne déjà en local. Passons maintenant à la partie suivante. Créer la configuration GitHub Actions

6. Cas d'utilisation 2 : Examen automatisé avec le SDK Antigravity – Partie 2 ( configuration des actions GitHub)

Avant de commencer, supprimons le fichier code_review.md produit précédemment, s'il existe.

💻 Copiez et exécutez cette commande dans le terminal.

rm -f code_review.md

Nous devons maintenant créer le fichier de configuration YAML GitHub Actions.

💻 Copiez et exécutez cette commande dans le terminal.

mkdir -p .github/workflows
cloudshell edit .github/workflows/code_review.yml

Ajoutez ensuite le contenu suivant au fichier.

📄 Copiez ce code dans le fichier et enregistrez-le.

name: AI Code Security and Quality Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write

    container:
      image: ghcr.io/astral-sh/uv:python3.12-bookworm

    steps:
      - name: Install git
        run: apt-get update && apt-get install -y git
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Run security review
        env:
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: |
          git config --global --add safe.directory $GITHUB_WORKSPACE
          uv run --project code_review_agent code_review_agent/review_agent.py .
      - name: Post findings as PR comment
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const body = fs.readFileSync('code_review.md', 'utf8');
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.payload.pull_request.number,
              body: body
            });

Le workflow se déclenchera automatiquement lorsqu'une demande d'extraction sera ouverte ou mise à jour. Il extrait la branche de la demande d'extraction avec l'historique Git complet (nécessaire pour git diff main...HEAD), exécute l'agent d'examen qui écrit les résultats dans code_review.md et publie le contenu du fichier en tant que commentaire de la demande d'extraction.

Remarque : Vous pouvez également générer ce workflow à l'aide de l'interface de ligne de commande Antigravity. Décrivez les exigences concernant le déclencheur, les étapes et les secrets, et laissez l'agent créer le fichier YAML pour vous.

Maintenant, validons toutes les modifications et transférons-les vers le dépôt distant GitHub. Nous sommes prêts à tester cette intégration.

💻 Copiez et exécutez cette commande dans le terminal.

git add .
git commit -m "Add AI code security-quality review agent and GitHub Action"
git push origin feature/bulk-operations

7. Cas d'utilisation 2 : Examen automatisé avec le SDK Antigravity – Partie 3 (Tester l'examen automatisé du code)

Accédez maintenant à la page Web https://github.com/<YOUR_GITHUB_USERNAME>/leads-crm-app-demo de votre dépôt dupliqué, puis cliquez sur Settings.

Dans le panneau de gauche, recherchez Secrets and variables, puis cliquez dessus et sélectionnez Actions.

Cliquez ensuite sur New repository secret pour configurer le secret GEMINI_API_KEY.

Sélectionnez ensuite Pull Request et créez une demande d'extraction à partir de la branche feature/bulk_operations vers la branche main de votre propre dépôt.

Important : Assurez-vous de sélectionner la bonne cible de base pour la demande d'extraction (votre propre dépôt main). Ne l'envoyez pas au dépôt d'origine alphinside/leads-crm-app-demo.

Une fois la demande d'extraction créée, elle exécute les actions GitHub que vous pouvez inspecter dans le menu Checks ou à proximité du bouton Merge pull request.

Vous pouvez cliquer sur les actions en cours pour afficher les détails. Une fois l'opération terminée, les résultats de l'examen seront publiés en tant que commentaire de demande d'extraction, comme indiqué ci-dessous.

Remarques : Le déclencheur peut être personnalisé. Par exemple, vous pouvez le limiter à des chemins d'accès spécifiques à l'aide du filtre paths ou passer à un déclencheur issue_comment avec une commande /review pour les vérifications à la demande au lieu du déclenchement automatique.

8. Conclusion

Félicitations !

Vous avez créé deux workflows complets de revue de code pour détecter les failles de sécurité dans les fonctionnalités codées avec Vibe :

• Cas 1 (interactif) : la CLI Antigravity avec les compétences de l'agent a examiné un diff de branche de fonctionnalité, identifié l'injection SQL et d'autres failles, les a corrigées en suivant les modèles OWASP et a produit une demande d'extraction propre.
• Cas d'utilisation 2 (automatisé) : le SDK Antigravity a alimenté une action GitHub qui examine automatiquement chaque demande d'extraction et publie les résultats structurés de sécurité sous forme de commentaires.

Connaissances acquises

• Comment le vibe coding crée des risques de sécurité et pourquoi l'examen automatisé détecte ce que l'examen manuel ne voit pas
• Installer et utiliser des compétences d'agent pour fournir une expertise structurée en sécurité à la CLI Antigravity
• Examiner de manière interactive le diff d'une branche de fonctionnalité, corriger les problèmes et créer une demande d'extraction propre
• Créer un agent d'examen en lecture seule avec le SDK Antigravity à l'aide de règles de refus par défaut et de hooks de cycle de vie
• Déployer un pipeline d'examen automatisé en tant que GitHub Action avec une assistance interactive

Nettoyage

Fermer les demandes de modification

Accédez à chaque demande d'extraction de votre fork sur GitHub, puis cliquez sur Fermer la demande d'extraction. Ne fusionnez pas la demande d'extraction feature/bulk-operations, car elle contient toujours le code vulnérable non corrigé.

Supprimer le dépôt dupliqué (facultatif)

Si vous n'avez plus besoin du fork, accédez-y sur GitHub : Settings (Paramètres) > faites défiler la page jusqu'à Danger Zone (Zone de danger) > Delete this repository (Supprimer ce dépôt).

Étape suivante

• Plug-ins et compétences de la CLI Antigravity : créez des compétences et des plug-ins personnalisés.
• Autorisations et bac à sable de l'interface de ligne de commande Antigravity : stratégies d'outils précises et bac à sable au niveau de l'OS
• Hooks et règles du SDK Antigravity : modèles avancés (limitation du débit, récupération des erreurs, middleware)
• Exemples du SDK Antigravity : agent_middleware.py pour les modèles de production