---
# System prepended metadata

title: 'Guide Débutant : Les Plugins dans Claude Code'

---

# 🔌 Guide Débutant : Les Plugins dans Claude Code

> **Guide pédagogique pour comprendre et créer vos propres plugins Claude Code**
> Aucune connaissance technique avancée requise !

---

## 📚 Table des matières

1. [Qu'est-ce qu'un Plugin ?](#1-quest-ce-quun-plugin-)
2. [Différence entre Skills et Plugins](#2-différence-entre-skills-et-plugins)
3. [Comment fonctionnent les Plugins ?](#3-comment-fonctionnent-les-plugins-)
4. [Installer des Plugins existants](#4-installer-des-plugins-existants)
5. [Créer votre premier Plugin (simple)](#5-créer-votre-premier-plugin-simple)
6. [Structure complète d'un Plugin](#6-structure-complète-dun-plugin)
7. [Exemples de Plugins complets](#7-exemples-de-plugins-complets)
8. [Partager vos Plugins](#8-partager-vos-plugins)
9. [Dépannage et erreurs courantes](#9-dépannage-et-erreurs-courantes)
10. [Idées de Plugins à créer](#10-idées-de-plugins-à-créer)

---

## 1. Qu'est-ce qu'un Plugin ?

### 🤔 Analogie simple

Pensez à votre smartphone :
- **Le téléphone de base** = Claude Code
- **Les applications que vous installez** = Les Plugins

Les plugins sont des **extensions** qui ajoutent des fonctionnalités à Claude Code.

### 🎯 Définition simple

Un **plugin** est :
- Un dossier contenant plusieurs fichiers
- Qui ajoute des fonctionnalités à Claude Code
- Réutilisable et partageable
- Plus puissant qu'une skill simple

### ✨ Ce qu'un Plugin PEUT contenir

Un plugin peut inclure plusieurs éléments :

| Élément | Description | Quantité |
|---------|-------------|----------|
| **Skills** | Commandes personnalisées (/) | Plusieurs |
| **Agents** | Sous-agents spécialisés | Plusieurs |
| **Configurations** | Paramètres prédéfinis | 1 fichier |
| **Documentation** | README, guides | Plusieurs |
| **Scripts** | Outils auxiliaires | Plusieurs |

### 💡 Exemples concrets

**Plugin "Code Quality"**
- Skill : `/reviser-code`
- Skill : `/generer-tests`
- Skill : `/documenter`
- Agent : `code-reviewer`
- Agent : `test-generator`
- Config : Règles de qualité

**Plugin "DevOps Tools"**
- Skill : `/deployer`
- Skill : `/creer-dockerfile`
- Skill : `/configurer-ci`
- Agent : `deploy-assistant`
- Config : Configurations Docker/K8s

---

## 2. Différence entre Skills et Plugins

### 📊 Comparaison

| Aspect | Skill | Plugin |
|--------|-------|--------|
| **Complexité** | Simple | Plus complexe |
| **Contenu** | 1 commande | Plusieurs fonctionnalités |
| **Structure** | 1 fichier | Dossier avec sous-dossiers |
| **Scope** | Une tâche spécifique | Suite de fonctionnalités |
| **Partage** | Fichier individuel | Package complet |

### 🎯 Quand utiliser quoi ?

#### Utilisez une **Skill** quand :
- ✅ Vous avez besoin d'une seule commande
- ✅ La tâche est simple et bien définie
- ✅ Pas besoin d'agents ou de config complexe
- ✅ Débutant en personnalisation

**Exemple :**
```
~/.claude/skills/commit-message/
  SKILL.md
```

#### Utilisez un **Plugin** quand :
- ✅ Vous avez plusieurs fonctionnalités liées
- ✅ Vous voulez combiner skills + agents + config
- ✅ Vous voulez partager un ensemble cohérent
- ✅ Vous créez un "toolkit" complet

**Exemple :**
```
~/.claude/plugins/my-devops-toolkit/
  plugin.json
  skills/
    deploy/
    docker/
    ci-cd/
  agents/
    deploy-helper/
  settings.json
  README.md
```

### 🔄 Relation

```
Plugin (Package)
  └─ Contient plusieurs Skills
  └─ Contient plusieurs Agents
  └─ Contient une Configuration
  └─ Contient de la Documentation
```

**Pensez-y comme :**
- **Skill** = Une application mobile
- **Plugin** = Une suite d'applications (Microsoft Office = Word + Excel + PowerPoint)

---

## 3. Comment fonctionnent les Plugins ?

### 📁 Emplacement des plugins

```
~/.claude/plugins/
  mon-plugin-1/
    plugin.json
    skills/
    agents/
    ...
  mon-plugin-2/
    plugin.json
    ...
```

### 🔍 Découverte automatique

Quand vous démarrez Claude Code :

1. **Scan** : Claude scanne `~/.claude/plugins/`
2. **Lecture** : Lit chaque `plugin.json`
3. **Chargement** : Charge les skills et agents
4. **Disponibilité** : Tout est disponible via `/help`

### 🎛️ Activation/Désactivation

Les plugins sont **automatiquement activés** s'ils sont dans le dossier `plugins/`.

**Pour désactiver un plugin temporairement :**
```bash
# Renommer le dossier
mv ~/.claude/plugins/mon-plugin ~/.claude/plugins/mon-plugin.disabled
```

**Pour réactiver :**
```bash
mv ~/.claude/plugins/mon-plugin.disabled ~/.claude/plugins/mon-plugin
```

### 🔧 Charger un plugin pour une session uniquement

```bash
claude --plugin-dir ~/mes-plugins/plugin-temporaire
```

**Exemple d'utilisation :**
```bash
# Pour un projet spécifique
cd mon-projet
claude --plugin-dir ./plugins/projet-specifique
```

---

## 4. Installer des Plugins existants

### 📥 Méthode 1 : Installation depuis GitHub (recommandée)

**Étape par étape :**

1. **Trouver un plugin** sur GitHub (ex: `username/claude-plugin-name`)

2. **Cloner dans le dossier plugins :**
   ```bash
   cd ~/.claude/plugins
   git clone https://github.com/username/claude-plugin-name.git
   ```

3. **Vérifier l'installation :**
   ```bash
   ls ~/.claude/plugins/claude-plugin-name
   ```

4. **Redémarrer Claude Code :**
   ```bash
   claude
   ```

5. **Vérifier que le plugin est chargé :**
   ```bash
   /help
   ```
   Les commandes du plugin devraient apparaître.

**Exemple concret :**
```bash
# Installer un plugin fictif "devops-toolkit"
cd ~/.claude/plugins
git clone https://github.com/awesome/devops-toolkit.git

# Vérifier
ls devops-toolkit/
# Devrait afficher : plugin.json, skills/, agents/, README.md, etc.

# Lancer Claude
claude

# Tester
/help
# Les commandes du plugin devraient être listées
```

### 📥 Méthode 2 : Installation manuelle (téléchargement ZIP)

1. **Télécharger** le ZIP du plugin depuis GitHub ou ailleurs

2. **Décompresser** dans `~/.claude/plugins/` :
   ```bash
   unzip plugin-name.zip -d ~/.claude/plugins/
   ```

3. **Renommer** si nécessaire (retirer `-main` ou `-master`) :
   ```bash
   mv ~/.claude/plugins/plugin-name-main ~/.claude/plugins/plugin-name
   ```

4. **Vérifier** la structure :
   ```bash
   ls ~/.claude/plugins/plugin-name/
   # Doit contenir plugin.json
   ```

### 📥 Méthode 3 : Via gestionnaire de plugins (si disponible)

```bash
claude plugin install username/plugin-name
```

**Note :** Cette fonctionnalité pourrait ne pas être disponible dans toutes les versions.

### 🔍 Lister les plugins installés

```bash
# Via commande CLI
claude plugin list

# Ou manuellement
ls -la ~/.claude/plugins/
```

### ❌ Désinstaller un plugin

```bash
# Méthode 1 : Supprimer le dossier
rm -rf ~/.claude/plugins/nom-du-plugin

# Méthode 2 : Via commande (si disponible)
claude plugin remove nom-du-plugin
```

---

## 5. Créer votre premier Plugin (simple)

### 🎬 Tutoriel pas-à-pas

Nous allons créer un plugin appelé "My First Plugin" contenant deux skills simples.

#### Étape 1 : Créer la structure du plugin

```bash
# Créer le dossier principal
mkdir -p ~/.claude/plugins/my-first-plugin

# Créer les sous-dossiers
mkdir -p ~/.claude/plugins/my-first-plugin/skills
mkdir -p ~/.claude/plugins/my-first-plugin/agents
```

**Structure créée :**
```
~/.claude/plugins/my-first-plugin/
  skills/
  agents/
```

#### Étape 2 : Créer le fichier plugin.json

C'est le **certificat d'identité** de votre plugin.

**Créer le fichier :**
```bash
touch ~/.claude/plugins/my-first-plugin/plugin.json
```

**Contenu à copier-coller :**
```json
{
  "name": "my-first-plugin",
  "version": "1.0.0",
  "description": "Mon premier plugin pour Claude Code",
  "author": "Votre Nom",
  "skills": [
    "skills/hello",
    "skills/goodbye"
  ],
  "agents": []
}
```

**Explication de chaque champ :**
- `name` : Identifiant unique du plugin (minuscules, tirets)
- `version` : Version du plugin (format: X.Y.Z)
- `description` : Description courte et claire
- `author` : Votre nom ou pseudo
- `skills` : Liste des chemins vers vos skills
- `agents` : Liste des chemins vers vos agents (vide pour l'instant)

#### Étape 3 : Créer la première skill

**Créer le dossier :**
```bash
mkdir -p ~/.claude/plugins/my-first-plugin/skills/hello
```

**Créer le fichier SKILL.md :**
```bash
touch ~/.claude/plugins/my-first-plugin/skills/hello/SKILL.md
```

**Contenu :**
```markdown
---
name: hello
description: Dit bonjour de manière amicale
---

# Skill Hello

Salue l'utilisateur de manière chaleureuse.

## Instructions

1. Salue l'utilisateur en français
2. Souhaite une excellente journée
3. Propose ton aide

## Ton

Amical, chaleureux et encourageant.
```

#### Étape 4 : Créer la deuxième skill

**Créer le dossier :**
```bash
mkdir -p ~/.claude/plugins/my-first-plugin/skills/goodbye
```

**Créer le fichier SKILL.md :**
```bash
touch ~/.claude/plugins/my-first-plugin/skills/goodbye/SKILL.md
```

**Contenu :**
```markdown
---
name: goodbye
description: Dit au revoir de manière sympathique
---

# Skill Goodbye

Salue l'utilisateur pour lui dire au revoir.

## Instructions

1. Remercie l'utilisateur pour la session
2. Souhaite une bonne continuation
3. Propose de revenir quand il veut

## Ton

Professionnel mais chaleureux.
```

#### Étape 5 : Créer un README

**Créer le fichier :**
```bash
touch ~/.claude/plugins/my-first-plugin/README.md
```

**Contenu :**
```markdown
# My First Plugin

Mon premier plugin pour Claude Code.

## Description

Un plugin simple avec deux commandes :
- `/hello` : Dit bonjour
- `/goodbye` : Dit au revoir

## Installation

```bash
cd ~/.claude/plugins
git clone [url-de-votre-repo] my-first-plugin
```

## Usage

### Commande Hello
```
/hello
```

### Commande Goodbye
```
/goodbye
```

## Version

1.0.0

## Auteur

Votre Nom
```

#### Étape 6 : Vérifier la structure

```bash
ls -R ~/.claude/plugins/my-first-plugin/
```

**Devrait afficher :**
```
my-first-plugin/:
plugin.json
README.md
skills/
agents/

my-first-plugin/skills:
hello/
goodbye/

my-first-plugin/skills/hello:
SKILL.md

my-first-plugin/skills/goodbye:
SKILL.md

my-first-plugin/agents:
[vide pour l'instant]
```

#### Étape 7 : Tester votre plugin

1. **Lancer Claude Code :**
   ```bash
   claude
   ```

2. **Vérifier que les commandes sont disponibles :**
   ```bash
   /help
   ```
   Vous devriez voir `/hello` et `/goodbye` dans la liste.

3. **Tester les commandes :**
   ```bash
   /hello
   ```
   Claude devrait vous saluer chaleureusement.

   ```bash
   /goodbye
   ```
   Claude devrait vous dire au revoir.

#### 🎉 Félicitations !

Vous venez de créer votre premier plugin ! 🚀

---

## 6. Structure complète d'un Plugin

### 📂 Structure recommandée

```
mon-plugin/
├── plugin.json                 # OBLIGATOIRE - Métadonnées
├── README.md                   # RECOMMANDÉ - Documentation
├── LICENSE                     # RECOMMANDÉ - Licence
├── CHANGELOG.md                # OPTIONNEL - Historique des versions
├── .gitignore                  # OPTIONNEL - Pour Git
│
├── skills/                     # Skills du plugin
│   ├── skill-1/
│   │   ├── SKILL.md           # Définition de la skill
│   │   └── README.md          # Doc de la skill
│   ├── skill-2/
│   │   └── SKILL.md
│   └── skill-3/
│       └── SKILL.md
│
├── agents/                     # Agents du plugin
│   ├── agent-1/
│   │   ├── AGENT.md           # Définition de l'agent
│   │   └── README.md          # Doc de l'agent
│   └── agent-2/
│       └── AGENT.md
│
├── settings.json               # OPTIONNEL - Config par défaut
│
├── scripts/                    # OPTIONNEL - Scripts utilitaires
│   ├── setup.sh
│   └── test.sh
│
├── examples/                   # OPTIONNEL - Exemples d'usage
│   ├── example-1.md
│   └── example-2.md
│
└── docs/                       # OPTIONNEL - Documentation étendue
    ├── getting-started.md
    ├── advanced-usage.md
    └── troubleshooting.md
```

### 📄 Fichier plugin.json complet

```json
{
  "name": "mon-plugin-complet",
  "version": "2.1.0",
  "description": "Description détaillée de ce que fait le plugin",
  "author": "Votre Nom <email@example.com>",
  "license": "MIT",
  "homepage": "https://github.com/username/mon-plugin",
  "repository": {
    "type": "git",
    "url": "https://github.com/username/mon-plugin.git"
  },
  "keywords": [
    "claude",
    "plugin",
    "development",
    "code-quality"
  ],
  "skills": [
    "skills/reviser-code",
    "skills/generer-tests",
    "skills/documenter"
  ],
  "agents": [
    "agents/code-reviewer",
    "agents/test-generator"
  ],
  "dependencies": {
    "claude-code": ">=2.0.0"
  },
  "settings": {
    "defaultModel": "sonnet",
    "autoActivate": true
  }
}
```

**Explication des champs :**

| Champ | Obligatoire | Description |
|-------|-------------|-------------|
| `name` | ✅ Oui | Nom unique du plugin |
| `version` | ✅ Oui | Version (semver: X.Y.Z) |
| `description` | ✅ Oui | Description courte |
| `author` | ⚠️ Recommandé | Auteur(s) |
| `license` | ⚠️ Recommandé | Type de licence |
| `homepage` | ❌ Optionnel | Site web du plugin |
| `repository` | ❌ Optionnel | Dépôt Git |
| `keywords` | ❌ Optionnel | Mots-clés pour recherche |
| `skills` | ⚠️ Recommandé | Chemins vers les skills |
| `agents` | ❌ Optionnel | Chemins vers les agents |
| `dependencies` | ❌ Optionnel | Dépendances |
| `settings` | ❌ Optionnel | Configuration par défaut |

### 📝 README.md complet

```markdown
# Nom du Plugin

> Description en une ligne

## 📋 Description

Description détaillée du plugin, ce qu'il fait, pourquoi l'utiliser.

## ✨ Fonctionnalités

- ✅ Fonctionnalité 1
- ✅ Fonctionnalité 2
- ✅ Fonctionnalité 3

## 🚀 Installation

### Via Git (recommandé)

```bash
cd ~/.claude/plugins
git clone https://github.com/username/plugin-name.git
```

### Via téléchargement manuel

1. Téléchargez le [dernier release](https://github.com/username/plugin-name/releases)
2. Décompressez dans `~/.claude/plugins/`
3. Redémarrez Claude Code

## 📖 Usage

### Commande 1 : `/commande-1`

Description de la commande.

**Exemple :**
```
/commande-1 @./fichier.js
```

**Résultat :**
```
[Description du résultat attendu]
```

### Commande 2 : `/commande-2`

[Même structure...]

## ⚙️ Configuration

Configuration optionnelle dans `.claude/settings.json` :

```json
{
  "plugins": {
    "mon-plugin": {
      "option1": "valeur1",
      "option2": "valeur2"
    }
  }
}
```

## 📚 Documentation

- [Guide de démarrage](docs/getting-started.md)
- [Usage avancé](docs/advanced-usage.md)
- [Dépannage](docs/troubleshooting.md)

## 🤝 Contribution

Les contributions sont bienvenues ! Voir [CONTRIBUTING.md](CONTRIBUTING.md).

## 📝 Changelog

Voir [CHANGELOG.md](CHANGELOG.md) pour l'historique des versions.

## 📄 Licence

[MIT](LICENSE) © Votre Nom

## 🙏 Remerciements

- Remerciement 1
- Remerciement 2

## 🔗 Liens utiles

- [Documentation Claude Code](https://code.claude.com/docs)
- [Autre lien pertinent]
```

---

## 7. Exemples de Plugins complets

### 🎨 Exemple 1 : Plugin "Code Quality Suite"

Un plugin complet pour la qualité de code.

#### Structure

```
code-quality-suite/
├── plugin.json
├── README.md
├── LICENSE
├── skills/
│   ├── reviser-code/
│   │   └── SKILL.md
│   ├── generer-tests/
│   │   └── SKILL.md
│   ├── calculer-couverture/
│   │   └── SKILL.md
│   └── refactoriser/
│       └── SKILL.md
├── agents/
│   ├── code-reviewer/
│   │   └── AGENT.md
│   └── refactoring-expert/
│       └── AGENT.md
└── settings.json
```

#### plugin.json

```json
{
  "name": "code-quality-suite",
  "version": "1.5.0",
  "description": "Suite complète d'outils pour la qualité de code",
  "author": "Code Quality Team",
  "license": "MIT",
  "homepage": "https://github.com/example/code-quality-suite",
  "keywords": [
    "code-quality",
    "testing",
    "review",
    "refactoring"
  ],
  "skills": [
    "skills/reviser-code",
    "skills/generer-tests",
    "skills/calculer-couverture",
    "skills/refactoriser"
  ],
  "agents": [
    "agents/code-reviewer",
    "agents/refactoring-expert"
  ],
  "dependencies": {
    "claude-code": ">=2.0.0"
  },
  "settings": {
    "defaultModel": "sonnet",
    "strictMode": true
  }
}
```

#### Skill : reviser-code/SKILL.md

```markdown
---
name: reviser-code
description: Révision complète du code (sécurité, performance, qualité)
---

# Révision de Code Complète

[Contenu détaillé comme dans le guide des skills...]

## Integration avec le plugin

Cette skill fait partie de la suite "Code Quality".
Elle utilise l'agent `code-reviewer` pour les analyses approfondies.

Pour une révision approfondie, utilisez :
```
/reviser-code --mode=deep
```
```

#### Agent : code-reviewer/AGENT.md

```markdown
---
name: code-reviewer
description: Agent expert en révision de code
model: opus
tools: [Read, Grep, Glob, Bash]
---

# Agent Code Reviewer

Expert en révision de code avec 15+ ans d'expérience.

## Spécialités

- Analyse de sécurité (OWASP)
- Optimisation de performance
- Détection de code smells
- Suggestions d'architecture

## Processus

1. Analyse statique du code
2. Identification des problèmes
3. Priorisation par sévérité
4. Propositions de solutions
5. Génération de rapport détaillé

## Format de sortie

[Format structuré du rapport...]
```

#### settings.json

```json
{
  "permissions": {
    "allow": [
      "Read(**/*)",
      "Grep(*)",
      "Glob(*)"
    ],
    "deny": [
      "Bash(rm:*)",
      "Edit(**/*)"
    ]
  },
  "hooks": {
    "PostEditWrite": [
      {
        "name": "Auto-review on save",
        "matcher": "*.{js,ts,py,java}",
        "type": "Bash",
        "command": "echo '💡 N'oublie pas de lancer /reviser-code !'"
      }
    ]
  }
}
```

---

### 🚀 Exemple 2 : Plugin "DevOps Toolkit"

Plugin pour les tâches DevOps courantes.

#### Structure

```
devops-toolkit/
├── plugin.json
├── README.md
├── skills/
│   ├── deployer/
│   ├── creer-dockerfile/
│   ├── configurer-ci/
│   └── monitorer/
├── agents/
│   ├── deploy-assistant/
│   └── docker-expert/
├── scripts/
│   ├── deploy.sh
│   └── docker-build.sh
└── examples/
    ├── deployment-example.md
    └── dockerfile-example.md
```

#### plugin.json

```json
{
  "name": "devops-toolkit",
  "version": "2.0.0",
  "description": "Toolkit complet pour les opérations DevOps",
  "author": "DevOps Team",
  "license": "Apache-2.0",
  "keywords": [
    "devops",
    "docker",
    "kubernetes",
    "ci-cd",
    "deployment"
  ],
  "skills": [
    "skills/deployer",
    "skills/creer-dockerfile",
    "skills/configurer-ci",
    "skills/monitorer"
  ],
  "agents": [
    "agents/deploy-assistant",
    "agents/docker-expert"
  ]
}
```

#### Skill : deployer/SKILL.md

```markdown
---
name: deployer
description: Assistant de déploiement avec vérifications de sécurité
---

# Assistant de Déploiement

Guide l'utilisateur à travers un déploiement sécurisé.

## Checklist pré-déploiement

Avant tout déploiement, vérifie :

- [ ] Tests unitaires passent
- [ ] Tests d'intégration passent
- [ ] Build réussit
- [ ] Variables d'environnement configurées
- [ ] Backup de la version actuelle
- [ ] Plan de rollback préparé

## Processus de déploiement

### Étape 1 : Vérification

Pose ces questions :
1. Environnement cible ? (dev/staging/prod)
2. Version à déployer ?
3. Stratégie ? (blue-green/canary/rolling)

### Étape 2 : Validation

- Vérifie que tous les tests passent
- Confirme les variables d'env
- Valide la configuration

### Étape 3 : Exécution

[Guide le déploiement étape par étape]

### Étape 4 : Vérification post-déploiement

- Health checks
- Smoke tests
- Monitoring

## Rollback

En cas de problème, guide le rollback immédiat.
```

---

### 📚 Exemple 3 : Plugin "Documentation Generator"

Plugin spécialisé dans la génération de documentation.

#### Structure minimale

```
doc-generator/
├── plugin.json
├── README.md
└── skills/
    ├── generer-readme/
    ├── generer-api-doc/
    ├── generer-changelog/
    └── generer-contributing/
```

#### plugin.json

```json
{
  "name": "doc-generator",
  "version": "1.0.0",
  "description": "Générateur automatique de documentation",
  "author": "Doc Team",
  "keywords": ["documentation", "readme", "api-doc"],
  "skills": [
    "skills/generer-readme",
    "skills/generer-api-doc",
    "skills/generer-changelog",
    "skills/generer-contributing"
  ]
}
```

---

## 8. Partager vos Plugins

### 📤 Publier sur GitHub

#### Étape 1 : Préparer le plugin

1. **Créer un dépôt Git local**
   ```bash
   cd ~/.claude/plugins/mon-plugin
   git init
   ```

2. **Créer un .gitignore**
   ```bash
   cat > .gitignore << EOL
   # macOS
   .DS_Store

   # Logs
   *.log

   # Fichiers temporaires
   *.tmp
   .cache/

   # Configuration locale
   settings.local.json
   EOL
   ```

3. **Commit initial**
   ```bash
   git add .
   git commit -m "Initial commit"
   ```

#### Étape 2 : Créer le dépôt GitHub

1. Allez sur [GitHub](https://github.com)
2. Cliquez sur "New repository"
3. Nommez-le (ex: `claude-plugin-mon-plugin`)
4. **Ne pas** initialiser avec README (vous en avez déjà un)
5. Créez le dépôt

#### Étape 3 : Pousser le code

```bash
git remote add origin https://github.com/username/claude-plugin-mon-plugin.git
git branch -M main
git push -u origin main
```

#### Étape 4 : Créer un release

1. Sur GitHub, allez dans "Releases"
2. Cliquez "Create a new release"
3. Tag : `v1.0.0`
4. Titre : `Version 1.0.0`
5. Description : Décrivez les fonctionnalités
6. Publiez

### 📋 Template de README pour partage

```markdown
# Claude Plugin: [Nom du Plugin]

> Tagline : Description en une ligne

[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/username/plugin/releases)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

## 📋 Description

Description détaillée...

## ✨ Fonctionnalités

- Fonctionnalité 1
- Fonctionnalité 2

## 🚀 Installation rapide

```bash
cd ~/.claude/plugins
git clone https://github.com/username/claude-plugin-name.git
```

## 📖 Documentation complète

Voir [la documentation](docs/README.md) pour :
- Guide de démarrage
- Exemples d'utilisation
- Configuration avancée
- Dépannage

## 🤝 Contribution

Les contributions sont bienvenues ! Voir [CONTRIBUTING.md](CONTRIBUTING.md).

## 📝 Licence

[MIT](LICENSE)

## 🌟 Star le projet !

Si ce plugin vous est utile, n'hésitez pas à lui donner une étoile ⭐
```

### 🌍 Partager dans la communauté

#### Lieux de partage

1. **GitHub Discussions** de Claude Code
   - https://github.com/anthropics/claude-code/discussions

2. **Discord Anthropic**
   - Canal #claude-code

3. **Reddit**
   - r/ClaudeAI
   - r/LocalLLaMA

4. **Collections communautaires**
   - [awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)
   - Soumettre une PR pour ajouter votre plugin

#### Template d'annonce

```markdown
# 🎉 Nouveau plugin : [Nom]

Salut ! Je viens de publier un nouveau plugin pour Claude Code : **[Nom]**

## 🎯 Ce qu'il fait
[Description courte]

## ✨ Fonctionnalités principales
- Fonctionnalité 1
- Fonctionnalité 2

## 📦 Installation
```bash
cd ~/.claude/plugins
git clone https://github.com/username/plugin-name.git
```

## 🔗 Liens
- Repo: [lien]
- Documentation: [lien]
- Démo: [lien si vidéo]

Feedback bienvenu ! 🙏
```

---

## 9. Dépannage et erreurs courantes

### ❌ Problème 1 : Plugin non détecté

**Symptômes :**
- Les commandes n'apparaissent pas dans `/help`
- Le plugin ne se charge pas

**Causes possibles et solutions :**

#### 1. Fichier plugin.json manquant ou mal placé

```bash
# Vérifier que le fichier existe
ls ~/.claude/plugins/mon-plugin/plugin.json

# Si absent, le créer
cat > ~/.claude/plugins/mon-plugin/plugin.json << EOL
{
  "name": "mon-plugin",
  "version": "1.0.0",
  "description": "Mon plugin",
  "skills": []
}
EOL
```

#### 2. JSON invalide

**Vérifier la syntaxe JSON :**
```bash
# Sur macOS/Linux
cat ~/.claude/plugins/mon-plugin/plugin.json | python3 -m json.tool

# Si erreur, corrigez la syntaxe
```

**Erreurs JSON courantes :**
```json
❌ Virgule en trop :
{
  "name": "test",
  "version": "1.0.0",  <-- Virgule avant }
}

✅ Correct :
{
  "name": "test",
  "version": "1.0.0"
}
```

#### 3. Mauvais nom de dossier

```bash
# Le nom du dossier DOIT correspondre au "name" dans plugin.json
# Renommer si nécessaire
mv ~/.claude/plugins/ancien-nom ~/.claude/plugins/nouveau-nom
```

### ❌ Problème 2 : Skills du plugin non trouvées

**Symptômes :**
- Plugin détecté mais commandes manquantes

**Solution :**

1. **Vérifier les chemins dans plugin.json :**
   ```json
   {
     "skills": [
       "skills/ma-skill"  // ✅ Correct
       // PAS "skills/ma-skill/SKILL.md"
       // PAS "./skills/ma-skill"
     ]
   }
   ```

2. **Vérifier la structure :**
   ```bash
   ls -R ~/.claude/plugins/mon-plugin/skills/

   # Devrait afficher :
   # skills/ma-skill/SKILL.md
   ```

3. **Vérifier le contenu du SKILL.md :**
   ```bash
   cat ~/.claude/plugins/mon-plugin/skills/ma-skill/SKILL.md

   # Doit commencer par :
   # ---
   # name: ma-skill
   # ---
   ```

### ❌ Problème 3 : Conflit entre plugins

**Symptômes :**
- Deux plugins ont des skills avec le même nom
- Comportement inattendu

**Solution :**

```bash
# 1. Identifier le conflit
/help | grep "nom-skill"

# 2. Renommer une des skills
# Dans plugin A : /skill-nom-a
# Dans plugin B : /skill-nom-b

# 3. Ou désactiver un plugin
mv ~/.claude/plugins/plugin-conflit ~/.claude/plugins/plugin-conflit.disabled
```

### ❌ Problème 4 : Erreur de permissions

**Symptômes :**
- "Permission denied" lors du chargement

**Solution :**

```bash
# Corriger les permissions
chmod -R 755 ~/.claude/plugins/mon-plugin
chmod 644 ~/.claude/plugins/mon-plugin/plugin.json
chmod 644 ~/.claude/plugins/mon-plugin/skills/*/SKILL.md
```

### ❌ Problème 5 : Plugin obsolète

**Symptômes :**
- Plugin ne fonctionne plus après mise à jour de Claude Code

**Solution :**

1. **Vérifier la compatibilité :**
   ```json
   {
     "dependencies": {
       "claude-code": ">=2.0.0"  // Version minimale requise
     }
   }
   ```

2. **Mettre à jour le plugin :**
   ```bash
   cd ~/.claude/plugins/mon-plugin
   git pull origin main
   ```

3. **Vérifier les changelog :**
   - Lire CHANGELOG.md du plugin
   - Lire les notes de version de Claude Code

### 🔍 Diagnostic complet

Script de diagnostic :

```bash
#!/bin/bash
# diagnostic-plugin.sh

PLUGIN_NAME="mon-plugin"
PLUGIN_PATH=~/.claude/plugins/$PLUGIN_NAME

echo "🔍 Diagnostic du plugin: $PLUGIN_NAME"
echo "=================================="

# 1. Vérifier l'existence
if [ ! -d "$PLUGIN_PATH" ]; then
  echo "❌ Le dossier du plugin n'existe pas"
  exit 1
fi
echo "✅ Dossier du plugin trouvé"

# 2. Vérifier plugin.json
if [ ! -f "$PLUGIN_PATH/plugin.json" ]; then
  echo "❌ Fichier plugin.json manquant"
  exit 1
fi
echo "✅ plugin.json trouvé"

# 3. Valider JSON
if ! cat "$PLUGIN_PATH/plugin.json" | python3 -m json.tool > /dev/null 2>&1; then
  echo "❌ plugin.json contient des erreurs de syntaxe"
  exit 1
fi
echo "✅ plugin.json valide"

# 4. Vérifier les skills
if [ -d "$PLUGIN_PATH/skills" ]; then
  SKILL_COUNT=$(find "$PLUGIN_PATH/skills" -name "SKILL.md" | wc -l)
  echo "✅ $SKILL_COUNT skill(s) trouvée(s)"
else
  echo "⚠️  Dossier skills/ absent"
fi

# 5. Vérifier les permissions
if [ ! -r "$PLUGIN_PATH/plugin.json" ]; then
  echo "❌ Problème de permissions de lecture"
  exit 1
fi
echo "✅ Permissions OK"

echo "=================================="
echo "🎉 Diagnostic terminé"
```

**Utilisation :**
```bash
chmod +x diagnostic-plugin.sh
./diagnostic-plugin.sh
```

---

## 10. Idées de Plugins à créer

### 💼 Plugins professionnels

#### 1. **Full-Stack Dev Suite**
- Skills : `/api-endpoint`, `/react-component`, `/database-migration`
- Agents : `backend-expert`, `frontend-expert`, `database-expert`
- Config : Standards de code, conventions API

#### 2. **Security Audit Toolkit**
- Skills : `/audit-securite`, `/scan-vulnerabilites`, `/generer-rapport-sec`
- Agents : `security-auditor`, `penetration-tester`
- Scripts : Scripts de scan automatisés

#### 3. **Testing Master**
- Skills : `/generer-tests-unitaires`, `/generer-tests-e2e`, `/mutation-testing`
- Agents : `test-architect`, `qa-expert`
- Exemples : Templates de tests

#### 4. **Documentation Pro**
- Skills : `/api-docs`, `/readme-generator`, `/architecture-diagram`
- Agents : `technical-writer`
- Templates : Templates de documentation

#### 5. **CI/CD Builder**
- Skills : `/github-actions`, `/gitlab-ci`, `/jenkins-pipeline`
- Agents : `devops-engineer`
- Exemples : Pipelines types

### 🎨 Plugins par technologies

#### Frontend

**React Toolkit**
- `/create-component` - Scaffold composant React
- `/optimize-performance` - Optimisations React
- `/accessibility-check` - Vérification a11y

**Vue Toolkit**
- `/create-vue-component`
- `/vuex-store`
- `/vue-router-setup`

#### Backend

**Node.js Toolkit**
- `/express-route` - Créer une route Express
- `/mongodb-model` - Modèle Mongoose
- `/jwt-auth` - Setup authentification JWT

**Python Toolkit**
- `/flask-route`
- `/django-model`
- `/fastapi-endpoint`

#### Database

**SQL Master**
- `/generer-migration`
- `/optimiser-requete`
- `/conception-schema`

**NoSQL Toolkit**
- `/mongodb-query`
- `/redis-cache`
- `/elasticsearch-mapping`

### 🏢 Plugins par domaine

#### E-commerce
- `/creer-product-model`
- `/panier-implementation`
- `/payment-integration`

#### Finance
- `/audit-calculs`
- `/generer-rapport-financier`
- `/validation-transactions`

#### Santé
- `/hipaa-compliance-check`
- `/donnees-sensibles-audit`
- `/generer-consentement`

### 🎓 Plugins éducatifs

#### Learn to Code
- `/expliquer-concept` - Explique un concept
- `/generer-exercice` - Crée des exercices
- `/corriger-code` - Corrige avec explications

#### Interview Prep
- `/question-algorithmique`
- `/revue-solution`
- `/generer-probleme-systeme`

### 🔧 Plugins utilitaires

#### Project Bootstrap
- `/init-projet` - Initialise un nouveau projet
- `/setup-git` - Configure Git
- `/setup-eslint` - Configure ESLint/Prettier

#### Code Migration
- `/migrer-javascript-typescript`
- `/migrer-vue2-vue3`
- `/migrer-python2-python3`

#### Performance
- `/profiler-performance`
- `/analyser-bundle`
- `/optimiser-images`

---

## 🎓 Exercices pratiques

### Exercice 1 : Plugin simple (débutant)

**Objectif :** Créer un plugin "Quick Notes" avec des skills pour prendre des notes.

**À faire :**
1. Créer la structure du plugin
2. Ajouter skill `/note-rapide`
3. Ajouter skill `/lister-notes`
4. Tester le plugin

**Structure attendue :**
```
quick-notes/
├── plugin.json
├── README.md
└── skills/
    ├── note-rapide/
    │   └── SKILL.md
    └── lister-notes/
        └── SKILL.md
```

### Exercice 2 : Plugin avec agent (intermédiaire)

**Objectif :** Créer "Code Mentor" avec un agent qui explique le code.

**À faire :**
1. Skill `/expliquer-code`
2. Agent `code-mentor` expert pédagogue
3. Documentation complète
4. Exemples d'utilisation

### Exercice 3 : Plugin complet (avancé)

**Objectif :** Créer "Full DevOps Suite" complet.

**À faire :**
1. Au moins 5 skills DevOps
2. 2 agents spécialisés
3. Configuration settings.json
4. Scripts utilitaires
5. Documentation exhaustive
6. Publier sur GitHub

---

## 📚 Checklist de qualité pour plugins

Avant de publier votre plugin :

### Essentiel
- [ ] `plugin.json` valide et complet
- [ ] README.md avec documentation claire
- [ ] LICENSE appropriée
- [ ] Toutes les skills testées
- [ ] Noms descriptifs et cohérents
- [ ] Versioning semver (X.Y.Z)

### Recommandé
- [ ] CHANGELOG.md avec historique
- [ ] Exemples d'utilisation
- [ ] Documentation détaillée
- [ ] .gitignore approprié
- [ ] Tests des skills
- [ ] Gestion d'erreurs

### Bonus
- [ ] CI/CD pour tests automatiques
- [ ] Badges dans README (version, license)
- [ ] Vidéo de démonstration
- [ ] Contributing guidelines
- [ ] Issue templates
- [ ] Code of conduct

---

## 🎯 Meilleures pratiques

### ✅ Do (À faire)

1. **Nommage cohérent**
   ```
   ✅ code-quality-suite
   ✅ devops-toolkit
   ❌ CodQltySte
   ❌ devops_tools
   ```

2. **Documentation complète**
   - README avec exemples
   - Chaque skill documentée
   - Instructions d'installation claires

3. **Versioning sémantique**
   - `1.0.0` : Version initiale
   - `1.1.0` : Nouvelles fonctionnalités
   - `1.1.1` : Corrections de bugs
   - `2.0.0` : Changements cassants

4. **Structure organisée**
   - Dossiers logiques
   - Fichiers bien nommés
   - Hiérarchie claire

5. **Tests réguliers**
   - Tester chaque skill
   - Vérifier les cas limites
   - Tester sur différents projets

### ❌ Don't (À éviter)

1. **Plugins monolithiques**
   - Ne pas mettre 50 skills dans un plugin
   - Diviser en plugins thématiques

2. **Absence de documentation**
   - Toujours documenter
   - Même pour usage personnel

3. **Dépendances non documentées**
   - Spécifier toutes les dépendances
   - Expliquer comment les installer

4. **Noms génériques**
   ```
   ❌ plugin
   ❌ my-plugin
   ❌ test
   ✅ react-optimization-toolkit
   ```

5. **Ignorer les erreurs**
   - Toujours tester
   - Gérer les cas d'erreur
   - Fournir des messages clairs

---

## 🎉 Conclusion

Vous savez maintenant :
- ✅ Ce qu'est un plugin et quand l'utiliser
- ✅ Comment installer des plugins existants
- ✅ Comment créer vos propres plugins
- ✅ Comment structurer un plugin professionnel
- ✅ Comment partager vos plugins
- ✅ Comment résoudre les problèmes courants

**Prochaines étapes :**

1. 🎯 Créez votre premier plugin simple
2. 📚 Explorez les plugins communautaires
3. 🔧 Créez un plugin pour vos besoins
4. 🌟 Partagez-le avec la communauté
5. 🚀 Contribuez aux plugins existants

**N'oubliez pas :**
- Commencez petit
- Testez souvent
- Documentez toujours
- Partagez volontiers

**Bonne création de plugins ! 🚀**

---

## 🔗 Ressources

### Documentation
- [Claude Code Docs](https://code.claude.com/docs)
- [Guide des Skills](~/CLAUDE_STOCK/GUIDE_SKILLS.md)
- [Guide complet](~/CLAUDE_STOCK/GUIDE_COMPLET.md)

### Collections
- [awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)
- [everything-claude-code](https://github.com/affaan-m/everything-claude-code)

### Communauté
- [GitHub Discussions](https://github.com/anthropics/claude-code/discussions)
- [Discord Anthropic](https://discord.gg/anthropic)

---

*Guide créé le 4 février 2026*
*Pour questions ou suggestions : [GitHub Issues](https://github.com/anthropics/claude-code/issues)*