Règles de curseur géniales que vous pouvez configurer pour votre IDE d'IA de curseur dès maintenant

Le monde du développement logiciel est en constante évolution, et l'une des avancées les plus passionnantes de ces dernières années a été l'essor de la programmation assistée par l'IA. Des outils comme Cursor révolutionnent la façon dont les développeurs écrivent, comprennent et maintiennent le code. Mais pour vraiment exploiter la puissance de ces assistants d'IA, vous devez aller au-delà des paramètres par défaut et les adapter à vos projets spécifiques. C'est là que les fichiers .cursorrules entrent en jeu.

Que sont les Cursorrules et pourquoi devriez-vous vous en soucier ?

À la base, les fichiers .cursorrules sont des fichiers de configuration qui fournissent des instructions et des directives spécifiques au projet à l'IA de Cursor. Considérez-les comme un moyen d'injecter les connaissances collectives et les meilleures pratiques de votre équipe directement dans le processus décisionnel de l'IA. En définissant ces règles, vous pouvez vous assurer que Cursor génère du code qui correspond à l'architecture, au style de codage et à la pile technologique de votre projet.

La solution : des conseils persistants et ciblés avec les règles Cursor modernes

Le système de règles moderne de Cursor résout ce problème en vous permettant d'intégrer des connaissances spécifiques au projet et des préférences personnelles directement dans le contexte de l'IA. Cela garantit que l'IA génère du code cohérent, précis et conforme à vos normes.

Il existe deux principaux types de règles dans le système actuel :

1. Règles de projet : Stockées dans le répertoire .cursor/rules de votre projet, ces règles sont contrôlées par version et limitées au code source. Elles sont parfaites pour encoder des connaissances spécifiques au domaine, normaliser les modèles et automatiser les flux de travail du projet.
2. Règles utilisateur : Définies globalement dans vos paramètres Cursor, ces règles s'appliquent à tous vos projets. Elles sont idéales pour définir des préférences personnelles telles que le style de réponse ou les bibliothèques couramment utilisées.

(Remarque : l'ancien fichier .cursorrules à la racine du projet est toujours pris en charge, mais déconseillé. Il est recommandé de migrer vers le nouveau système de règles de projet.)

Comment fonctionnent les CursorRules modernes

Contrairement aux interactions de chat standard, les règles fournissent un contexte persistant. Lorsqu'une règle est appliquée (automatiquement ou manuellement), son contenu est ajouté au début de l'invite envoyée au modèle d'IA (Agent ou Cmd-K). Cela garantit que l'IA suit systématiquement les directives spécifiées.

Configuration et utilisation des règles de projet

Les règles de projet offrent un contrôle précis sur le comportement de l'IA au sein d'une base de code spécifique.

1. Emplacement : Créez un répertoire .cursor/rules à la racine de votre projet.

2. Format : Chaque règle réside dans son propre fichier avec l'extension .mdc (Composants Markdown). MDC permet à la fois les métadonnées (frontmatter) et le contenu des règles.

3. Structure des règles : Un fichier de règle .mdc ressemble généralement à ceci :

---
description: Description facultative pour les règles demandées par l'agent.
globs: ["optional/glob/pattern/**", "*.py"] # Pour les règles jointes automatiquement
alwaysApply: false # True pour les règles Always
---

# Le contenu de la règle commence ici
- Utilisez cette bibliothèque/ce modèle spécifique.
- Évitez de faire cette autre chose.
- Référencez des fichiers spécifiques pour le contexte : @path/to/important/file.ts

4. Types de règles (déterminés par les métadonnées) :

5. Création de règles : Vous pouvez créer des fichiers .mdc manuellement ou utiliser la palette de commandes (Cmd+Maj+P ou Ctrl+Maj+P) et rechercher "New Cursor Rule".

6. Génération de règles : Après une conversation de chat au cours de laquelle vous avez affiné le comportement de l'IA, utilisez la commande /Generate Cursor Rules pour créer automatiquement une règle basée sur cette interaction.

Règles utilisateur : vos préférences globales

Les règles utilisateur sont plus simples.

1. Accédez à Cursor Settings > Rules > User Rules.
2. Saisissez des instructions en texte brut (le format MDC n'est pas pris en charge ici).
3. Ces règles sont toujours appliquées à tous vos projets.

Exemple de règle utilisateur :

Toujours importer React explicitement : `import React from 'react';`
Répondre de manière concise. Évitez les phrases de remplissage.
Préférez les composants fonctionnels avec Hooks aux composants de classe.

Meilleures pratiques pour l'écriture de règles

• Soyez précis et exploitable : Les instructions vagues sont moins efficaces. Dites à l'IA exactement ce qu'il faut faire ou éviter.
• Gardez-les concises : Visez la clarté et la concision. Moins de 500 lignes est une bonne ligne directrice.
• Utilisez des exemples : Incluez de courts extraits de code ou des fichiers de référence (@filename.ext) pour illustrer les points.
• Décomposez : Décomposez les normes complexes en règles plus petites et ciblées.
• Utilisez des descriptions : Pour les règles Agent Requested, rédigez des descriptions claires afin que l'IA sache quand les utiliser.
• Itérez : Affinez vos règles en fonction des performances de l'IA.

Exemples de règles impressionnantes (en utilisant le format .mdc)

Voici quelques exemples inspirés des fichiers rules-mdc fournis, démontrant le format moderne :

1. Meilleures pratiques de Django (django.mdc)

---
description: Fournit des conseils sur les meilleures pratiques de Django, les modèles, les vues, les modèles et l'utilisation de l'ORM.
globs: ["*.py"]
alwaysApply: false
---

# Lignes directrices de développement Django

## Général
- Suivez le guide de style Django et PEP 8.
- Utilisez les fonctionnalités intégrées de Django chaque fois que possible (authentification, administration, formulaires).
- Gardez les applications modulaires et réutilisables.

## Modèles (`models.py`)
- Utilisez des noms de modèles et de champs descriptifs.
- Définissez les méthodes `__str__` pour tous les modèles.
- Ajoutez des options `Meta` pour l'ordre, les noms verbeux, etc.
- Utilisez `ForeignKey` avec `on_delete` spécifié de manière appropriée (par exemple, `models.CASCADE`, `models.SET_NULL`).
- Exemple : `author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts')`

## Vues (`views.py`)
- Préférez les vues basées sur les classes (CBV) pour les modèles courants (Liste, Détail, Créer, Mettre à jour, Supprimer).
- Utilisez les vues basées sur les fonctions (FBV) pour une logique simple ou très personnalisée.
- Mettez en œuvre une authentification et des autorisations appropriées (`@login_required`, `PermissionRequiredMixin`).
- Gérez les exceptions avec élégance (par exemple, `try...except ObjectDoesNotExist`).
- Utilisez le raccourci `get_object_or_404`.

## Modèles
- Organisez les modèles dans des répertoires spécifiques à l'application (`templates/<app_name>/`).
- Utilisez l'héritage de modèle (`{% extends 'base.html' %}`).
- Chargez les fichiers statiques en utilisant `{% load static %}` et `{% static 'path/to/file.css' %}`.
- Évitez la logique complexe dans les modèles ; utilisez plutôt des balises ou des filtres de modèle.

## ORM
- Utilisez efficacement le filtrage de requête (`.filter()`, `.exclude()`). Évitez de charger des données inutiles.
- Utilisez `select_related` (pour la clé étrangère/clé étrangère unique) et `prefetch_related` (pour la clé étrangère inverse/clé étrangère plusieurs à plusieurs) pour optimiser les requêtes de base de données.
- Utilisez `.annotate()` pour les agrégations au niveau de la base de données.
- Soyez attentif au chargement paresseux et aux problèmes potentiels de requête N+1.

## Formulaires (`forms.py`)
- Utilisez les formulaires Django pour la validation des données et la génération HTML.
- Préférez `ModelForm` pour les formulaires directement liés aux modèles.
- Définissez des méthodes de validation personnalisées (`clean_<fieldname>()`, `clean()`).

## URLs (`urls.py`)
- Utilisez des noms d'URL descriptifs (`path('articles/<int:pk>/', views.ArticleDetailView.as_view(), name='article-detail')`).
- Incluez des fichiers `urls.py` spécifiques à l'application en utilisant `include()`.

## Paramètres (`settings.py`)
- Utilisez des variables d'environnement pour les données sensibles (SECRET_KEY, informations d'identification de la base de données). Ne validez pas les secrets.
- Configurez correctement `STATIC_URL`, `STATIC_ROOT`, `MEDIA_URL`, `MEDIA_ROOT`.

## Tests
- Écrivez des tests unitaires et des tests d'intégration en utilisant `TestCase` de Django ou `pytest-django`.
- Testez les modèles, les vues, les formulaires et les utilitaires.

2. Meilleures pratiques de Dockerfile (docker.mdc)

---
description: Lignes directrices pour l'écriture de Dockerfiles efficaces et sécurisés.
globs: ["Dockerfile", "*.Dockerfile"]
alwaysApply: false
---

# Meilleures pratiques de Dockerfile

## Image de base
- Utilisez des images de base officielles et minimales (par exemple, `python:3.11-slim`, `node:18-alpine`, `golang:1.20-alpine`).
- Spécifiez les versions exactes ou les condensés pour la reproductibilité (`python:3.11.4-slim-bullseye`).
- Préférez les images Alpine pour la taille, mais soyez conscient des problèmes de compatibilité potentiels de `musl libc` par rapport à `glibc`.

## Minimiser les couches et le contexte de construction
- Enchaînez les commandes associées en utilisant `&&` pour réduire les couches (par exemple, `apt-get update && apt-get install -y --no-install-recommends package && rm -rf /var/lib/apt/lists/*`).
- Utilisez un fichier `.dockerignore` pour exclure les fichiers/répertoires inutiles (par exemple, `.git`, `node_modules`, `.venv`, journaux, configuration locale) du contexte de construction.

## Efficacité de la construction
- Classez les instructions de la moins à la plus fréquemment modifiée (par exemple, installez les dépendances avant de copier le code de l'application).
- Tirez parti efficacement du cache de construction Docker.
- Utilisez des constructions à plusieurs étapes pour maintenir l'image finale petite, en séparant les dépendances de construction des dépendances d'exécution.

## Sécurité
- Exécutez les conteneurs en tant qu'utilisateur non root. Créez un utilisateur/groupe dédié (`RUN groupadd -r appuser && useradd -r -g appuser appuser`) et passez-y (`USER appuser`).
- Évitez de stocker les secrets directement dans le Dockerfile. Utilisez les arguments de construction (`ARG`), les variables d'environnement (`ENV`) ou les outils de gestion des secrets au moment de l'exécution.
- Analysez les images pour détecter les vulnérabilités à l'aide d'outils tels que Trivy ou Docker Scout.
- Minimisez la surface d'attaque : installez uniquement les packages nécessaires (`--no-install-recommends`).

## Instructions
- Utilisez `COPY` au lieu de `ADD` sauf si vous avez spécifiquement besoin des fonctionnalités de `ADD` (comme l'extraction automatique ou l'extraction d'URL).
- Préférez `ENTRYPOINT` pour la commande principale du conteneur et utilisez `CMD` pour les arguments par défaut qui peuvent être remplacés. Utilisez le formulaire de tableau JSON (par exemple, `ENTRYPOINT ["python", "app.py"]`).
- Utilisez `WORKDIR` pour définir le répertoire de travail pour les instructions suivantes (`RUN`, `CMD`, `ENTRYPOINT`, `COPY`, `ADD`).
- Exposez les ports nécessaires en utilisant `EXPOSE`.

## Exemple de construction à plusieurs étapes (Python)
```dockerfile
# Étape de construction
FROM python:3.11-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt
COPY . .

# Étape finale
FROM python:3.11-alpine
WORKDIR /app
# Créer un utilisateur non root
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
# Copier les packages installés et le code de l'application de l'étape de construction
COPY --from=builder /root/.local /usr/local
COPY --from=builder /app .
# Assurez-vous que les scripts sont exécutables si nécessaire
# RUN chmod +x ./entrypoint.sh
USER appuser
EXPOSE 8000
ENTRYPOINT ["python"]
CMD ["manage.py", "runserver", "0.0.0.0:8000"]

**3. Formatage Python Black (`black.mdc`)**

```mdc
---
description: S'assure que le formatage du code Python respecte le guide de style Black.
globs: ["*.py"]
alwaysApply: false
---

# Règles de formatage du code Black pour Python

- Respectez strictement le style de code Black. Black est non négociable et a une configuration minimale.
- La longueur de ligne par défaut est de 88 caractères.
- Utilisez des guillemets doubles (`"`) pour les chaînes de caractères dans la mesure du possible, mais Black gérera la cohérence.
- Black gère automatiquement l'indentation, les espaces blancs, les virgules de fin et les sauts de ligne.
- Assurez-vous que le code passe le contrôle `black .` avant de valider.
- Intégrez Black dans vos hooks de pré-validation ou votre pipeline CI/CD.

## Exemple d'intégration (pré-validation)
```yaml
# .pre-commit-config.yaml
repos:
-   repo: <https://github.com/psf/black>
    rev: 23.3.0 # Utilisez une version stable récente
    hooks:
    -   id: black

Exécution de Black

• Formater des fichiers spécifiques : black my_module.py your_script.py
• Formater l'ensemble du projet (vérification de .gitignore) : black .
• Vérifier les fichiers sans les modifier : black --check .

**4. Meilleures pratiques de React (`react.mdc`)**
(En supposant qu'un fichier nommé `react.mdc` existe avec une structure de contenu similaire)

```mdc
---
description: Lignes directrices pour l'écriture de composants et d'applications React modernes.
globs: ["*.js", "*.jsx", "*.ts", "*.tsx"]
alwaysApply: false
---

# Meilleures pratiques de développement React

## Composants
- Préférez les composants fonctionnels avec Hooks aux composants de classe.
- Utilisez PascalCase pour les noms de composants (`MyComponent`).
- Gardez les composants petits et ciblés (principe de responsabilité unique).
- Utilisez `import React from 'react';` explicite en haut (bien que non strictement nécessaire avec les nouvelles transformations JSX, c'est une bonne pratique pour la clarté).
- Définissez `propTypes` (si vous utilisez JavaScript) ou des interfaces TypeScript pour les props.
- Utilisez la déstructuration pour les props : `function MyComponent({ name, count }) { ... }`

## Gestion de l'état
- Utilisez `useState` pour un état simple local au composant.
- Utilisez `useReducer` pour une logique d'état plus complexe ou lorsque les transitions d'état dépendent de l'état précédent.
- Remontez l'état jusqu'à l'ancêtre commun le plus proche lorsque plusieurs composants ont besoin d'accéder au même état.
- Pour l'état global ou partagé, envisagez l'API Context (`useContext`) pour une complexité modérée ou des bibliothèques de gestion d'état dédiées (Redux, Zustand, Jotai) pour les applications plus volumineuses.

## Hooks
- Appelez uniquement les Hooks au niveau supérieur des composants fonctionnels ou d'autres Hooks personnalisés.
- N'appelez pas les Hooks à l'intérieur des boucles, des conditions ou des fonctions imbriquées.
- Suivez les règles des Hooks. Utilisez les plugins ESLint (`eslint-plugin-react-hooks`) pour les appliquer.
- Utilisez `useEffect` pour les effets secondaires (extraction de données, abonnements, manipulations manuelles du DOM). Incluez un tableau de dépendances pour contrôler le moment où l'effet s'exécute.
- Utilisez `useCallback` et `useMemo` pour mémoriser respectivement les fonctions et les valeurs, en optimisant les performances si nécessaire (souvent lié à `React.memo` ou aux calculs lourds).

## Clés
- Fournissez des props `key` stables et uniques lors du rendu de listes d'éléments (`<li key={item.id}>`). Évitez d'utiliser les indices de tableau comme clés si l'ordre de la liste peut changer ou si des éléments peuvent être insérés/supprimés.

## Structure de fichiers
- Organisez les fichiers par fonctionnalité ou itinéraire (par exemple, `/features/Auth`, `/components/common`).
- Colocalisez les composants, les styles, les tests et les hooks liés à une fonctionnalité spécifique.

## Style
- Choisissez une approche de style cohérente : CSS Modules, Styled Components, Emotion, Tailwind CSS, CSS/SASS simple.
- Évitez les styles en ligne pour tout ce qui dépasse les ajustements dynamiques simples.

## Performances
- Utilisez `React.memo` pour mémoriser les composants et éviter les re-rendus inutiles.
- Analysez les performances avec React DevTools Profiler.
- Envisagez de diviser le code (par exemple, `React.lazy` et `Suspense`) pour réduire la taille du bundle initial.

## Accessibilité (a11y)
- Utilisez des éléments HTML sémantiques (`<button>`, `<nav>`, `<main>`).
- Assurez-vous que les attributs ARIA appropriés sont utilisés lorsque cela est nécessaire.
- Testez avec la navigation au clavier et les lecteurs d'écran.

Conclusion : Adoptez l'assistance IA de précision

Les règles Cursor modernes (.cursor/rules et les règles utilisateur) sont essentielles pour exploiter toute la puissance du développement assisté par l'IA. En investissant peu de temps dans la définition des normes de projet et des préférences personnelles, vous permettez à Cursor d'agir comme un véritable programmeur en binôme conscient du contexte. Cela conduit à une qualité de code supérieure, à une productivité accrue, à une meilleure collaboration d'équipe et à une réduction de la dette technique. Arrêtez de modifier les suggestions d'IA génériques et commencez à guider Cursor avec précision en utilisant les règles.