Plugins Claude Code : Créer et Distribuer des Extensions

Que Sont les Plugins ?

Les plugins sont des paquets autonomes qui ajoutent des fonctionnalités à Claude Code :

• →Nouveaux outils : Commandes supplémentaires que Claude peut utiliser
• →Intégrations : Connexions à des services et API
• →Workflows : Modèles d'automatisation préconstruits
• →Extensions d'interface : Visualisations et interfaces personnalisées

Exemple : Sans Plugin

> Analyse cette image pour les problèmes d'accessibilité

Je n'ai pas de capacités d'analyse d'image dans ce contexte.

Exemple : Avec le Plugin Vision

> Analyse cette image pour les problèmes d'accessibilité

[Plugin Vision : Analyse de l'image...]

Problèmes d'Accessibilité Trouvés :
1. Ratio de contraste faible (2.1:1) sur le texte d'en-tête
2. Suggestion de texte alt manquant : "Bannière de présentation produit"
3. Information uniquement par la couleur dans le graphique (nécessite des motifs)

Recommandations :
- Augmenter le contraste du texte à 4.5:1
- Ajouter un texte alt descriptif
- Ajouter des motifs pour distinguer les segments du graphique

Architecture des Plugins

Pile des Plugins (du haut vers le bas) :

1. →Claude Code (application principale)
2. →Couche Plugins → Vision, DB, AWS, Plugins personnalisés
3. →Couche API des Plugins → Interface standardisée
4. →Cœur de Claude Code → Fonctionnalités de base

Les plugins interagissent avec Claude Code via :

• →Enregistrement d'Outils : Déclarent les outils disponibles
• →Intégration de Hooks : S'abonnent aux événements du cycle de vie
• →Extensions MCP : Ajoutent de nouveaux serveurs MCP
• →Configuration : Paramètres et préférences

Gestion des Plugins

Lister les Plugins Installés

> /plugin list

Plugins Installés :

  vision@1.2.0 - Analyse d'images et de vision
  db-explorer@2.0.1 - Outils d'exploration de bases de données
  aws-toolkit@1.5.0 - Intégration des services AWS

Marketplace : https://plugins.claude.ai

Installer un Plugin

> /plugin install vision

Installation de vision@latest...

✓ Téléchargement de vision@1.2.0
✓ Vérification de la signature
✓ Enregistrement de 3 nouveaux outils :
  - analyze_image
  - extract_text
  - describe_scene

Plugin installé avec succès.

Depuis une source spécifique :

# Depuis npm
claude plugin install @anthropic/vision-plugin

# Depuis GitHub
claude plugin install github:username/my-plugin

# Depuis un chemin local
claude plugin install ./my-local-plugin

Mettre à Jour les Plugins

> /plugin update vision

Mise à jour de vision...
1.2.0 → 1.3.0

Changements :
- Ajout de l'analyse d'images vidéo
- Amélioration de la précision d'extraction de texte
- Corrections de bugs

✓ Mis à jour avec succès

Mettre à jour tous les plugins :

> /plugin update --all

Supprimer des Plugins

> /plugin remove vision

Supprimer le plugin vision ? Cela désinscrira ses outils.
[y/n] : y

✓ Plugin supprimé

Configuration des Plugins

Voir les Paramètres d'un Plugin

> /plugin config vision

Paramètres du Plugin Vision :

  model: gpt-4-vision (défaut)
  max_image_size: 4MB
  output_format: markdown
  cache_results: true

[e] Modifier les paramètres  [r] Réinitialiser  [Esc] Quitter

Configurer un Plugin

> /plugin config vision set output_format json

Mis à jour : output_format = json

Fichier de Configuration du Plugin

// ~/.claude/plugins/vision/config.json
{
  "model": "gpt-4-vision",
  "max_image_size": "4MB",
  "output_format": "json",
  "cache_results": true,
  "api_key": "${VISION_API_KEY}"
}

Créer des Plugins

Structure d'un Plugin

Un dossier de plugin contient :

• →package.json - Métadonnées du plugin
• →index.js - Point d'entrée principal
• →tools/my-tool.js - Définitions d'outils
• →tools/another-tool.js - Outils supplémentaires
• →hooks/on-start.js - Hooks du cycle de vie
• →config.schema.json - Schéma de configuration
• →README.md - Documentation

package.json

{
  "name": "@myorg/my-plugin",
  "version": "1.0.0",
  "description": "Mon plugin Claude Code personnalisé",
  "claudeCode": {
    "type": "plugin",
    "displayName": "Mon Plugin",
    "icon": "puzzle",
    "minVersion": "1.0.0"
  },
  "main": "index.js",
  "keywords": ["claude-code-plugin"],
  "author": "Votre Nom",
  "license": "MIT"
}

Point d'Entrée Principal

// index.js
export default {
  name: "my-plugin",
  version: "1.0.0",
  
  // Outils fournis par ce plugin
  tools: [
    require("./tools/my-tool"),
    require("./tools/another-tool")
  ],
  
  // Hooks de cycle de vie
  hooks: {
    onLoad: async (context) => {
      console.log("Plugin chargé");
    },
    onUnload: async (context) => {
      console.log("Plugin déchargé");
    }
  },
  
  // Schéma de configuration
  configSchema: require("./config.schema.json")
};

Définir des Outils

// tools/my-tool.js
export default {
  name: "analyze_complexity",
  description: "Analyser les métriques de complexité du code",
  
  inputSchema: {
    type: "object",
    properties: {
      filePath: {
        type: "string",
        description: "Chemin du fichier à analyser"
      },
      metrics: {
        type: "array",
        items: { type: "string" },
        description: "Métriques à calculer",
        default: ["cyclomatic", "cognitive", "halstead"]
      }
    },
    required: ["filePath"]
  },
  
  async execute(input, context) {
    const { filePath, metrics } = input;
    
    // Lire le fichier via le contexte
    const content = await context.readFile(filePath);
    
    // Calculer les métriques
    const results = calculateMetrics(content, metrics);
    
    return {
      content: [{
        type: "text",
        text: JSON.stringify(results, null, 2)
      }]
    };
  }
};

function calculateMetrics(content, metrics) {
  // Implémentation...
  return {
    cyclomatic: 5,
    cognitive: 8,
    halstead: { difficulty: 12.5 }
  };
}

API des Plugins

Objet Context

Les plugins reçoivent un objet context avec les API de Claude Code :

async execute(input, context) {
  // Opérations sur les fichiers
  const content = await context.readFile(path);
  await context.writeFile(path, content);
  
  // Exécuter des commandes
  const result = await context.runCommand("npm test");
  
  // Accéder à la configuration
  const config = context.getConfig();
  
  // Journalisation
  context.log.info("Traitement...");
  context.log.error("Quelque chose s'est mal passé");
  
  // Interaction utilisateur
  const answer = await context.prompt("Continuer ? [y/n]");
  
  // Rapport de progression
  context.progress.start("Analyse...");
  context.progress.update(50, "À mi-chemin");
  context.progress.complete("Terminé !");
}

Format de Réponse des Outils

return {
  content: [
    {
      type: "text",
      text: "Analyse terminée"
    },
    {
      type: "code",
      language: "json",
      text: JSON.stringify(data)
    }
  ],
  metadata: {
    cached: true,
    duration: 1234
  }
};

Gestion des Erreurs

async execute(input, context) {
  try {
    const result = await riskyOperation();
    return { content: [{ type: "text", text: result }] };
  } catch (error) {
    return {
      error: {
        code: "OPERATION_FAILED",
        message: error.message,
        recoverable: true
      }
    };
  }
}

Types de Plugins

Plugins d'Outils

Ajoutent de nouvelles capacités :

// Plugin d'analyse d'image
export default {
  name: "vision-tools",
  tools: [
    {
      name: "analyze_image",
      description: "Analyser le contenu d'une image",
      async execute({ imagePath }, context) {
        const image = await context.readFile(imagePath, "base64");
        const analysis = await visionAPI.analyze(image);
        return { content: [{ type: "text", text: analysis }] };
      }
    }
  ]
};

Plugins d'Intégration

Connectent à des services externes :

// Plugin d'intégration Jira
export default {
  name: "jira-integration",
  tools: [
    {
      name: "get_jira_issue",
      description: "Récupérer les détails d'un ticket Jira",
      async execute({ issueKey }, context) {
        const config = context.getConfig();
        const jira = new JiraClient(config.apiKey);
        const issue = await jira.getIssue(issueKey);
        return { content: [{ type: "text", text: formatIssue(issue) }] };
      }
    },
    {
      name: "create_jira_issue",
      description: "Créer un nouveau ticket Jira",
      async execute({ summary, description, type }, context) {
        // Implémentation...
      }
    }
  ]
};

Plugins de Workflow

Fournissent des opérations complexes en plusieurs étapes :

// Plugin d'automatisation de release
export default {
  name: "release-automation",
  tools: [
    {
      name: "prepare_release",
      description: "Préparer une nouvelle release",
      async execute({ version, changelog }, context) {
        // 1. Mettre à jour la version
        await context.runCommand(`npm version ${version}`);
        
        // 2. Générer le changelog
        const changes = await generateChangelog();
        await context.writeFile("CHANGELOG.md", changes);
        
        // 3. Créer le commit
        await context.runCommand("git add -A");
        await context.runCommand(`git commit -m "Release ${version}"`);
        
        // 4. Créer le tag
        await context.runCommand(`git tag v${version}`);
        
        return {
          content: [{
            type: "text",
            text: `Release ${version} préparée. Exécutez 'git push --tags' pour publier.`
          }]
        };
      }
    }
  ]
};

Plugins de Hooks

Réagissent aux événements de Claude Code :

// Plugin d'analytics
export default {
  name: "analytics",
  hooks: {
    onToolUse: async (event, context) => {
      await analytics.track("tool_used", {
        tool: event.toolName,
        duration: event.duration
      });
    },
    onSessionStart: async (context) => {
      await analytics.track("session_started");
    },
    onSessionEnd: async (context) => {
      await analytics.track("session_ended", {
        duration: context.sessionDuration
      });
    }
  }
};

Publier des Plugins

Préparer la Publication

1. →Tester minutieusement :

npm test
claude plugin validate ./my-plugin

2. →Ajouter la documentation :

<!-- README.md -->
# Mon Plugin

## Installation
\`\`\`
claude plugin install @myorg/my-plugin
\`\`\`

## Outils

### analyze_complexity
Analyse les métriques de complexité du code.

**Paramètres :**
- `filePath` (requis) : Chemin à analyser
- `metrics` (optionnel) : Tableau de métriques

**Exemple :**
\`\`\`
> Analyser la complexité de src/utils.ts
\`\`\`

3. →Créer le schéma de configuration :

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "threshold": {
      "type": "number",
      "default": 10,
      "description": "Seuil de complexité pour les avertissements"
    }
  }
}

Publier sur npm

npm publish --access public

Publier sur le Plugin Marketplace

claude plugin publish

Publication de @myorg/my-plugin@1.0.0...

✓ Structure du plugin validée
✓ Scan de sécurité effectué
✓ Documentation générée
✓ Soumis pour examen

Votre plugin sera examiné sous 24-48 heures.
Suivre le statut : https://plugins.claude.ai/submissions/abc123

Distribution Privée

Pour les plugins internes :

# Installation depuis npm privé
claude plugin install @internal/my-plugin --registry https://npm.internal.com

# Installation depuis GitHub privé
claude plugin install github:org/private-plugin --token $GITHUB_TOKEN

Sécurité des Plugins

Permissions

Les plugins déclarent les permissions requises :

{
  "claudeCode": {
    "permissions": {
      "filesystem": {
        "read": ["**/*.ts", "**/*.js"],
        "write": ["reports/**"]
      },
      "network": ["api.example.com"],
      "commands": ["npm:*"]
    }
  }
}

Les utilisateurs approuvent les permissions à l'installation :

Installation de my-plugin...

Ce plugin demande :
✓ Lire les fichiers TypeScript/JavaScript
✓ Écrire dans le répertoire reports/
✓ Accès réseau à api.example.com
✓ Exécuter les commandes npm

Installer avec ces permissions ? [y/n]

Sandboxing

Les plugins s'exécutent dans des environnements isolés :

• →Accès limité au système de fichiers
• →Accès réseau contrôlé
• →Pas d'appels système directs
• →Limites de mémoire

Vérification

Les plugins du marketplace sont vérifiés :

• →Revue de code
• →Scan de sécurité
• →Vérification de signature

> /plugin info vision

Plugin Vision
Éditeur : Anthropic (vérifié ✓)
Téléchargements : 45 230
Note : 4.8/5
Sécurité : Scanné ✓
Signature : Valide ✓

Catégories de Plugins Populaires

Outils de Développement

Intégrations

IA/ML

DevOps

Bonnes Pratiques de Développement de Plugins

1. Responsabilité Unique

Chaque outil doit faire une seule chose bien :

// Bien : Outils ciblés
{
  name: "get_user",
  // Ne fait que récupérer l'utilisateur
}
{
  name: "update_user",
  // Ne fait que mettre à jour l'utilisateur
}

// Mauvais : Outil fourre-tout
{
  name: "manage_user",
  // Fait trop de choses
}

2. Descriptions Claires

Aidez Claude à comprendre quand utiliser les outils :

{
  name: "analyze_bundle_size",
  description: "Analyser la taille du bundle JavaScript et identifier les dépendances volumineuses. " +
               "Utiliser pour optimiser la sortie de build ou investiguer les chargements lents de page. " +
               "Retourne une décomposition du contenu du bundle avec la taille en octets."
}

3. Gestion Robuste des Erreurs

async execute(input, context) {
  if (!input.filePath) {
    return {
      error: {
        code: "MISSING_PARAMETER",
        message: "filePath est requis"
      }
    };
  }
  
  try {
    const result = await analyze(input.filePath);
    return { content: [{ type: "text", text: result }] };
  } catch (error) {
    if (error.code === "ENOENT") {
      return {
        error: {
          code: "FILE_NOT_FOUND",
          message: `Fichier non trouvé : ${input.filePath}`
        }
      };
    }
    throw error; // Relancer les erreurs inattendues
  }
}

4. Utilisation Efficace des Ressources

// Mettre en cache les opérations coûteuses
const cache = new Map();

async execute(input, context) {
  const cacheKey = JSON.stringify(input);
  
  if (cache.has(cacheKey)) {
    return cache.get(cacheKey);
  }
  
  const result = await expensiveOperation(input);
  cache.set(cacheKey, result);
  
  return result;
}

5. Compatibilité de Version

{
  "claudeCode": {
    "minVersion": "1.0.0",
    "maxVersion": "2.x"
  }
}

Intégration avec d'Autres Fonctionnalités

Plugins + MCP

Les plugins peuvent s'enregistrer comme serveurs MCP :

export default {
  name: "my-plugin",
  mcp: {
    serverName: "my-mcp-server",
    tools: [/* ... */]
  }
};

Voir Model Context Protocol (MCP) pour Claude Code : Guide Complet.

Plugins + Hooks

Les plugins peuvent définir des hooks :

export default {
  hooks: {
    PreToolUse: async (event, context) => {
      // Valider avant l'exécution de tout outil
    }
  }
};

Voir Claude Code Hooks : Automatisez Votre Workflow de Développement.

Plugins + Commandes Personnalisées

Les commandes peuvent utiliser les outils des plugins :

<!-- .claude/commands/analyze.md -->
Utilise le plugin complexity-analyzer pour analyser cette base de code
et générer un rapport.

Voir Commandes Slash Personnalisées dans Claude Code : Créez les Vôtres.

Points Clés à Retenir

1. →

   Les plugins étendent les capacités : Ajoutent des outils, intégrations et workflows.

2. →

   Installation facile : /plugin install gère tout.

3. →

   La sécurité d'abord : Les plugins déclarent leurs permissions et s'exécutent en sandbox.

4. →

   Partagez avec la communauté : Publiez sur npm ou le marketplace.

5. →

   Créez des solutions personnalisées : Développez des plugins pour les besoins de votre équipe.

Top Plugins du Marketplace Claude Code

Voici les plugins les plus populaires du marketplace en 2026 :

Classement par Installations

Focus : Code Review Plugin

Le plugin Code Review mérite une attention particulière :

• →5 reviewers IA parallèles analysent votre code simultanément
• →Score de confiance 0-100 pour chaque suggestion
• →Seuil configurable (défaut: 80) pour filtrer le bruit
• →Intégration CI/CD via GitHub Actions

👉 Guide dédié : Consultez notre article complet sur Code Review pour un tutoriel détaillé.

Combinaisons de Plugins Recommandées

• →Développement Frontend : Frontend Design + Context7 + Code Review
• →Backend/API : MCP Hub + Code Review + Superpowers
• →Documentation : Context7 + Writing Assistant + Mermaid

Créez des Extensions Prêtes pour la Production

Les plugins sont du code de production. Apprenez les principes de construction de logiciels fiables et maintenables.

Dans notre Module 4 — Génération de Code, vous apprendrez :

• →Écrire du code maintenable
• →Stratégies de test
• →Modèles de gestion d'erreurs
• →Bonnes pratiques de documentation

→ Explorer le Module 4 : Génération de Code