Utilisation de Bugbot pour la révision automatisée du code dans Cursor

Bugbot est l'agent de révision automatisée du code intégré à Cursor qui s'intègre directement à vos dépôts GitHub. Lorsque vous ouvrez une pull request, Bugbot analyse le diff, identifie les bugs potentiels, suggère des améliorations et laisse des commentaires inline sur votre PR. Ce guide couvre tout, de la configuration initiale à la configuration avancée, y compris les problèmes de routage PR et d'intégration GitHub Teams que les utilisateurs du forum rencontrent fréquemment.

Ce que fait Bugbot

Bugbot effectue plusieurs couches d'analyse sur chaque pull request :

• Détection de bugs - Identifie les erreurs de logique, les risques de référence null et les cas limites
• Analyse de sécurité - Signale les vulnérabilités potentielles comme les injections SQL ou les secrets codés en dur
• Style et cohérence - Vérifie les écarts par rapport aux modèles de votre codebase
• Astuces de performance - Met en évidence les modèles inefficaces comme les requêtes N+1
• Couverture de tests - Note quand les modifications manquent de tests correspondants

astuce

Bugbot s'exécute entièrement dans le cloud. Vous n'avez pas besoin de garder Cursor ouvert pour que les révisions se fassent. Une fois activé sur un dépôt, Bugbot révisera chaque PR automatiquement, que vous soyez à votre bureau ou non.

Prérequis

Avant de configurer Bugbot, assurez-vous d'avoir :

1. Cursor Pro ou plan Business - Bugbot n'est pas disponible sur l'offre gratuite
2. Un dépôt GitHub avec les workflows de pull request activés
3. Accès administrateur ou mainteneur au dépôt (requis pour l'installation de l'app)
4. GitHub Teams configuré si vous souhaitez le routage PR par équipe

Activation de Bugbot sur un dépôt

Le problème le plus couramment signalé par les utilisateurs du forum est Bugbot disant "disabled for this repository." Cela remonte presque toujours à l'étape d'installation de l'app GitHub qui a été ignorée ou partiellement complétée.

Étape 1 : Installer l'app GitHub de Cursor

Bugbot fonctionne via une GitHub App. Si vous ne l'avez pas installée :

1. Ouvrez Cursor et accédez à Settings > Features > Bugbot
2. Cliquez sur Connect GitHub Account
3. Vous serez redirigé vers GitHub pour autoriser l'application Cursor
4. Choisissez la portée :
   • All repositories - Cursor peut réviser n'importe quel dépôt de votre compte
   • Selected repositories - Choisissez des dépôts spécifiques pour la révision

attention

Si vous avez sélectionné des dépôts spécifiques lors de l'installation et que vous créez ensuite un nouveau dépôt, Bugbot ne fonctionnera pas sur le nouveau dépôt jusqu'à ce que vous l'ajoutiez explicitement. C'est la cause numéro un de l'erreur "disabled for this repository". Pour la corriger, allez sur GitHub > Settings > Integrations > Applications > Cursor > Configure, et ajoutez le nouveau dépôt.

Étape 2 : Activer Bugbot dans les paramètres de Cursor

Une fois l'application GitHub installée :

1. Ouvrez Cursor Settings (Cmd/Ctrl + ,)
2. Accédez à Features > Bugbot
3. Basculez Enable Bugbot sur ON
4. Sélectionnez les dépôts sur lesquels activer Bugbot

Étape 3 : Vérifier la connexion

Créez une pull request de test et vérifiez si Bugbot répond :

# Create a test branch
git checkout -b test-bugbot-connection

# Make a small change
echo "// Bugbot test" >> README.md
git add README.md
git commit -m "test: verify bugbot connection"
git push origin test-bugbot-connection

Ouvrez une PR sur GitHub. Dans les 30 à 60 secondes, Bugbot devrait publier un commentaire. Si ce n'est pas le cas, passez à la section de dépannage ci-dessous.

Routage PR et assignation des réviseurs

Bugbot peut acheminer les pull requests vers des réviseurs spécifiques en fonction des chemins de fichiers, de la propriété du code ou de l'appartenance à une équipe. Les utilisateurs du forum signalent que le routage PR ne fonctionne pas toujours comme prévu, en particulier avec GitHub Teams.

Comprendre le routage PR

Le routage PR détermine qui reçoit la demande de révision lorsque Bugbot analyse une PR. La logique de routage suit cette priorité :

1. Fichier CODEOWNERS - S'il est présent, les propriétaires des fichiers modifiés deviennent les réviseurs
2. Mapping GitHub Teams - Routage par équipe via la configuration de Bugbot
3. Repli - Tous les mainteneurs reçoivent la demande de révision

Configurer CODEOWNERS

Créez un fichier CODEOWNERS à la racine de votre dépôt (ou .github/CODEOWNERS) :

# Default owners
*                           @team-leads

# Frontend files
src/components/             @frontend-team
src/pages/                  @frontend-team
src/styles/                 @frontend-team

# Backend files
src/api/                    @backend-team
src/models/                 @backend-team
src/middleware/             @backend-team

# Infrastructure
terraform/                  @devops-team
docker/                     @devops-team
.github/workflows/           @devops-team

# Security-sensitive files
src/auth/                   @security-team @team-leads
.env*                       @security-team

Intégration GitHub Teams

Pour le routage par équipe, Bugbot lit l'appartenance à vos GitHub Teams. Pour configurer :

1. Assurez-vous que votre organisation GitHub a des équipes configurées sous Org Settings > Teams
2. Ajoutez des membres à chaque équipe
3. Référencez les noms d'équipe (avec le préfixe @) dans CODEOWNERS
4. Dans Cursor, allez dans Settings > Features > Bugbot > Advanced
5. Activez Use GitHub Teams for routing

astuce

Les noms d'équipe GitHub dans CODEOWNERS doivent correspondre exactement. Une erreur courante consiste à utiliser des noms d'affichage au lieu du slug d'équipe. Par exemple, si votre équipe s'appelle "Frontend Engineers" avec le slug frontend-engineers, l'entrée CODEOWNERS doit être @frontend-engineers, et non @Frontend Engineers.

Problèmes courants de routage PR

Problème : PR acheminée vers la mauvaise équipe

Symptôme : Une PR modifiant des fichiers backend est acheminée vers l'équipe frontend.

Cause : Chevauchement des modèles CODEOWNERS. Le premier modèle correspondant gagne, et les modèles sont évalués de haut en bas.

Solution : Réorganisez votre fichier CODEOWNERS pour que les modèles plus spécifiques viennent avant les généraux :

# Specific first
src/auth/                   @security-team @team-leads
src/api/                    @backend-team

# Then general
src/                        @all-developers
*                           @team-leads

Problème : L'équipe ne reçoit pas les demandes de révision

Symptôme : Bugbot révisé la PR mais aucun membre de l'équipe GitHub n'est ajouté comme réviseur.

Cause : L'équipe GitHub est définie comme "secrète" (non visible) ou n'a aucun membre.

Solution : Allez sur GitHub > Organization > Teams > [Nom de l'équipe] > Settings. Assurez-vous que la visibilité de l'équipe n'est pas définie sur "Secret" si vous souhaitez qu'elle reçoive des demandes de révision. Vérifiez que l'équipe a des membres actifs.

Configuration de Bugbot

Au-delà de l'activation de base, Bugbot offre plusieurs options de configuration pour adapter son comportement.

Sévérité de la révision

Contrôlez le niveau de sévérité de Bugbot dans ses résultats :

{
  "bugbot.severity": "balanced",
  "bugbot.maxComments": 20,
  "bugbot.autoResolve": false
}

Sévérité	Comportement
strict	Signale tous les résultats, y compris les problèmes de style mineurs
balanced	Signale les bugs, les problèmes de sécurité et les problèmes de style significatifs (par défaut)
lenient	Signale uniquement les bugs et les vulnérabilités de sécurité

Exclusions de fichiers

Empêchez Bugbot de réviser les fichiers générés ou vendus :

{
  "bugbot.excludePaths": [
    "**/*.min.js",
    "**/*.min.css",
    "node_modules/**",
    "dist/**",
    "build/**",
    "*.lock",
    "package-lock.json",
    "yarn.lock"
  ]
}

Configuration de l'agent de sécurité

Bugbot inclut un agent de sécurité dédié qui scanne les vulnérabilités. Configurez-le indépendamment :

{
  "bugbot.securityAgent": {
    "enabled": true,
    "sensitivityLevel": "high",
    "scanForSecrets": true,
    "scanForDependencies": true,
    "ignorePatterns": [
      "test/**",
      "__mocks__/**"
    ]
  }
}

attention

L'agent de sécurité scanne les secrets codés en dur (clés API, mots de passe, jetons) dans le diff de votre PR. S'il trouve ce qu'il croit être un secret, il le signalera comme un problème critique. Il s'agit d'une fonctionnalité de sécurité. Ne ignorez jamais ces avertissements sans vérifier que la chaîne signalée n'est pas un vrai secret. Même les fixtures de test qui ressemblent à de vraies clés peuvent être dangereuses si quelqu'un les copie dans du code de production.

Flux d'approbation

Bugbot s'intègre au système d'approbation de révision de GitHub. Vous pouvez configurer si les résultats de Bugbot bloquent la fusion des PR.

Définir les révisions requises

Dans les paramètres de votre dépôt GitHub :

1. Allez dans Settings > Branches > Branch protection rules
2. Modifiez la règle de votre branche principale
3. Sous Require pull request reviews before merging :
   • Définissez le nombre d'approbations requises (par ex. 2)
   • Activez Dismiss stale pull request approvals lorsque de nouveaux commits sont poussés
   • Activez Require review from Code Owners

Bugbot comme réviseur requis

Vous pouvez configurer Bugbot pour qu'il agisse comme un réviseur requis. Lorsqu'il est activé, les PR ne peuvent pas être fusionnées tant que Bugbot n'a pas terminé sa révision et soit approuvé, soit la révision est rejetée.

Dans Cursor :

1. Settings > Features > Bugbot > Workflow
2. Activez Block merge on critical findings
3. Définissez le seuil de sévérité pour le blocage (par défaut : critical et high)

astuce

Utilisez la fonctionnalité de blocage avec discernement. Si vous définissez le seuil trop bas (blocage sur les résultats de faible sévérité), les développeurs peuvent se frustrer lorsque des problèmes de style empêchent la fusion. Commencez par "critical et high" et ajustez en fonction de l'expérience de votre équipe.

Gérer les désaccords avec Bugbot

Parfois Bugbot signale quelque chose que le développeur considère comme un faux positif. Le flux de travail recommandé :

1. Cliquez sur Resolve conversation sur le commentaire de Bugbot dans GitHub
2. Ajoutez un commentaire expliquant pourquoi c'est un faux positif
3. S'il s'agit d'un faux positif récurrent sur le même modèle, ajoutez un commentaire // bugbot-ignore :

# bugbot-ignore: This is intentionally using eval for a DSL interpreter
result = eval(user_expression)

Dépannage de "Disabled for This Repository"

C'est le problème Bugbot le plus signalé. Suivez cet organigramme de diagnostic.

Étape de diagnostic 1 : Vérifier l'installation de l'app GitHub

# Check if the Cursor app has access to your repo
gh api repos/{owner}/{repo}/installation --jq '.id'

Si cela renvoie un 404, l'app GitHub n'est pas installée pour ce dépôt.

Solution : Allez sur GitHub > Settings > Integrations > Applications > Cursor > Configure, et ajoutez le dépôt.

Étape de diagnostic 2 : Vérifier les paramètres du dépôt dans Cursor

1. Ouvrez les paramètres de Cursor
2. Accédez à Features > Bugbot
3. Recherchez votre dépôt dans la liste des dépôts activés
4. S'il n'y est pas, cliquez sur Add Repository et sélectionnez-le

Étape de diagnostic 3 : Vérifier les règles de protection de branche

Bugbot nécessite que votre dépôt autorise l'app GitHub à publier des commentaires de révision. Si vos règles de protection de branche sont trop restrictives :

1. Allez dans GitHub > Settings > Branches
2. Modifiez votre règle de protection de branche
3. Assurez-vous que Allow specified actors to bypass requirements inclut l'application Cursor
4. Assurez-vous que l'application n'est pas bloquée par Restrict who can push to matching branches

Étape de diagnostic 4 : Vérifier les applications conflictuelles

Si vous avez d'autres outils de révision automatisée installés (CodeRabbit, GitHub Copilot, SonarQube), ils peuvent entrer en conflit avec Bugbot.

Solution : Désactivez temporairement les autres bots de révision et vérifiez si Bugbot commence à fonctionner. Si c'est le cas, vous devrez configurer les outils pour qu'ils coexistent, ce qui peut nécessiter d'ajuster les paramètres webhook ou les déclencheurs de révision.

Étape de diagnostic 5 : Vérifier le statut de Bugbot

# Check Cursor service status
curl -s https://status.cursor.sh/api/v2/incidents.json | jq '.incidents[] | select(.status != "resolved")'

S'il y a un incident actif, attendez qu'il soit résolu et réessayez.

attention

Bugbot apparaît parfois comme "disabled" immédiatement après une mise à jour de Cursor. C'est un problème connu où le jeton GitHub doit être ré-authentifié. Allez dans Settings > Features > Bugbot, cliquez sur Disconnect, puis Reconnect votre compte GitHub. Cela actualise le jeton sans perdre votre configuration.

Approfondissement de l'intégration Bugbot et GitHub Teams

Synchronisation de l'appartenance à l'équipe

Bugbot met en cache l'appartenance à l'équipe GitHub pour des raisons de performance. Si vous ajoutez ou supprimez un membre d'équipe, le changement peut ne pas être reflété immédiatement.

Pour forcer une synchronisation :

1. Ouvrez les paramètres de Cursor
2. Allez dans Features > Bugbot > Advanced
3. Cliquez sur Sync GitHub Teams
4. Attendez la fin de la synchronisation (généralement moins de 30 secondes)

Appartenance multi-équipes

Lorsqu'un développeur appartient à plusieurs équipes, Bugbot achemine en fonction de la correspondance CODEOWNERS. Si un fichier appartient à plusieurs équipes et que le développeur est dans les deux, il reçoit une seule demande de révision, pas de doublons.

Politiques de révision par équipe

Vous pouvez configurer différentes exigences de révision par équipe :

{
  "bugbot.teamPolicies": {
    "security-team": {
      "requiredReviews": 2,
      "blockOnHighSeverity": true,
      "additionalScanners": ["dependency-check"]
    },
    "frontend-team": {
      "requiredReviews": 1,
      "blockOnHighSeverity": false
    }
  }
}

Performance et limites de Bugbot

Vitesse de révision

Bugbot termine généralement une révision dans les 30 à 90 secondes après l'ouverture ou la mise à jour d'une PR. Facteurs affectant la vitesse :

Facteur	Impact
Taille de la PR (lignes modifiées)	Les gros diffs prennent plus de temps à analyser
Nombre de fichiers	Chaque fichier nécessite une analyse individuelle
Taille du dépôt	Les grandes bases de code nécessitent plus de collecte de contexte
Charge actuelle	Les heures de pointe peuvent voir des réponses plus lentes

Limite de commentaires

Par défaut, Bugbot publie un maximum de 20 commentaires par révision. Cela empêche de submerger l'auteur de la PR. Vous pouvez ajuster cela :

{
  "bugbot.maxComments": 50
}

astuce

Si Bugbot atteint la limite de commentaires sur chaque PR, envisagez de relever le seuil de sévérité. Atteindre la limite signifie que Bugbot trouve de nombreux problèmes de faible priorité. Les filtrer rendra la révision plus exploitable.

Limites de débit

Bugbot respecte les limites de débit de l'API GitHub. Si votre organisation ouvre de nombreuses PR simultanément, les révisions peuvent être mises en file d'attente. Bugbot les traite dans l'ordre, et toutes les révisions finissent par être complétées.

Bonnes pratiques pour l'adoption de Bugbot

Commencer en mode lecture seule

Lors de la première activation de Bugbot sur un dépôt existant, commencez en mode lecture seule (pas de blocage de fusion). Cela permet à l'équipe de voir ce que Bugbot trouve sans perturber leur flux de travail. Après une ou deux semaines de revue des résultats, ajustez la configuration et activez le blocage de fusion si approprié.

Utiliser les résultats de Bugbot comme outils d'apprentissage

Les résultats de Bugbot ne concernent pas seulement la correction de la PR actuelle. Ce sont des opportunités d'apprentissage :

1. Suivre les types de résultats récurrents (par ex., "risque de référence null" apparaît sur 30% des PR)
2. Créer des entrées .cursor/rules pour prévenir le modèle dans le code futur
3. Partager les résultats intéressants dans les canaux d'équipe

Revue régulière de la configuration

Revoyez votre configuration Bugbot mensuellement :

• Les exclusions de fichiers sont-elles toujours appropriées ?
• Les seuils de sévérité sont-ils correctement calibrés ?
• Y a-t-il de nouveaux modèles de faux positifs à supprimer ?
• La limite de commentaires est-elle appropriée pour la taille actuelle de vos PR ?

Résumé

Bugbot apporte une révision de code automatisée et intelligente à chaque pull request dans vos dépôts GitHub connectés à Cursor. Le problème le plus courant, "disabled for this repository", est presque toujours résolu en vérifiant la portée d'installation de l'app GitHub et en s'assurant que le dépôt est explicitement ajouté. En configurant le routage PR avec CODEOWNERS, en réglant l'agent de sécurité et en adoptant une approche incrémentale du blocage de fusion, votre équipe peut exploiter Bugbot comme une première ligne de défense fiable contre les bugs et les vulnérabilités de sécurité.