Création d’un plug-in pour GitHub Copilot CLI

Créez un plug-in pour partager des personnalisations dans un package facile à installer.

Dans cet article

Les plug-ins sont des packages qui étendent les fonctionnalités de Copilot CLI. Pour obtenir une vue d’ensemble inter-clients, consultez Plug-ins pour GitHub Copilot.

Remarque

Vous trouverez de l’aide sur l’utilisation de plug-ins en entrant copilot plugin [SUBCOMMAND] --help dans le terminal.

Structure du plug-in

Un plug-in se compose d’un répertoire avec une structure spécifique et un plugin.json fichier manifeste. Agent Plugins 1.0 exige que le fichier manifeste se trouve à la racine du plug-in. Les plug-ins hérités prennent en charge des emplacements de manifeste supplémentaires. Un plug-in peut également contenir n’importe quelle combinaison d’agents, de compétences, de hooks et de configurations de serveur MCP.

Agent Plugins 1.0 est un format portable pour les compétences et les serveurs MCP sur des clients compatibles. Copilot CLI prend également en charge un Copilot format hérité.

  • Pour utiliser Agent Plugins 1.0, déclarez l’élément canonique $schema dans plugin.json.
  • Le format hérité prend en charge les composants spécifiques à Copilot et les chemins de composants configurables. Dans Copilot CLI, un manifeste sans les Agent Plugins $schema utilise ce format.

Choisissez Agent Plugins 1.0 lorsque vous souhaitez partager des compétences et des serveurs MCP entre des clients compatibles. Consultez la documentation du client pour confirmer quels autres composants il prend en charge. Choisissez le format hérité lorsque vous avez besoin de chemins de composants configurables dans Copilot CLI ou assurez la maintenance d’un plug-in spécifique à Copilot existant.

Création d’un plug-in

  1. Créez un répertoire pour votre plug-in.

  2. Choisissez un format de plug-in, puis ajoutez un plugin.json fichier manifeste à la racine du répertoire.

    Pour créer un plug-in Agent Plugins 1.0, incluez l’élément canonique $schema :

Exemple de fichier Plug-ins d’agent 1.0 plugin.json

JSON
{
  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
  "name": "my-dev-tools",
  "description": "React development utilities",
  "version": "1.2.0",
  "author": {
    "name": "Jane Doe",
    "email": "jane@example.com"
  },
  "license": "MIT",
  "keywords": ["react", "frontend"]
}

Le schéma autorise uniquement $schema, name``homepage``description``version``repository``license``author``keywordset extensions en tant que champs de niveau supérieur. Copilot CLI signale et ignore les champs de niveau supérieur inconnus. Le champ extensions est une structure de correspondance de données propres au client, indexée par un espace de noms de domaine inversé.

Pour créer un plug-in ancien, omettez Agent Plugins $schema. Vous pouvez utiliser les champs de chemin d’accès du composant dans le manifeste :

Exemple de fichier hérité plugin.json

JSON
{
  "name": "my-dev-tools",
  "description": "React development utilities",
  "agents": "agents/",
  "skills": ["skills/", "extra-skills/"],
  "hooks": "hooks.json",
  "mcpServers": ".mcp.json"
}

Pour plus d’informations sur l’ensemble complet de champs que vous pouvez inclure dans ce fichier, consultez Référence du plug-in CLI GitHub Copilot.

  1. Ajoutez des composants à votre plug-in.

    Dans un plug-in Agent Plugins 1.0, les compétences doivent être des sous-répertoires immédiats de skills/, et chaque compétence doit contenir un SKILL.md fichier. La configuration MCP doit se trouver dans mcp.json, à la racine du plug-in. Vous ne pouvez pas remplacer ces emplacements dans plugin.json. Copilot composants spécifiques vont dans le répertoire com.github.copilot, comme com.github.copilot/agents/ pour les agents personnalisés et com.github.copilot/hooks/hooks.json pour les hooks.

    Dans un plug-in hérité, utilisez les emplacements de composant par défaut ou les chemins d’accès des composants configurés dans plugin.json.

    Par exemple:

    1. Ajoutez un agent en créant un NAME.agent.md fichier dans un agents sous-répertoire. Dans un plug-in Agent Plugins 1.0, créez le fichier dans com.github.copilot/agents/. Dans un ancien plug-in, créez-le dans agents/.

      Markdown
      ---
name: my-agent
description: Helps with specific tasks
tools: ["bash", "edit", "view"]
---

You are a specialized assistant that...

    2. Ajoutez une compétence en créant un skills/NAME sous-répertoire de votre répertoire de plug-in, où NAME est le nom de votre compétence. Ensuite, dans ce sous-répertoire, créez un SKILL.md fichier qui définit la compétence.

      Par exemple, pour créer une compétence « déployer », créez skills/deploy/SKILL.md:

      Markdown
      ---
name: deploy
description: Deploy the current project to...
---

Instructions for the skill...

    3. Pour un plug-in Agent Plugins 1.0, ajoutez des serveurs MCP dans un fichier racine mcp.json . La configuration MCP utilise son propre schéma de plug-ins Agent :

      JSON
      {
 "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
 "mcpServers": {
   "deployment-api": {
     "type": "streamable-http",
     "url": "https://deploy.example.com/mcp"
   },
   "local-validator": {
     "type": "stdio",
     "command": "node",
     "args": ["${PLUGIN_ROOT}/server/index.js"],
     "cwd": "${PLUGIN_ROOT}",
     "env": {
       "DATA_DIR": "${PLUGIN_DATA}/validator"
     }
   }
 }
}

      Le nom de streamable-http transport est accepté pour les serveurs HTTP Streamable. Pour les serveurs stdio, Copilot CLI fournit des variables d’environnement PLUGIN_DATA et PLUGIN_ROOT, et développe ${PLUGIN_DATA} et ${PLUGIN_ROOT} dans args, les valeurs env et cwd.

Testez votre plug-in avec GitHub Copilot CLI

Les commandes suivantes testent un plug-in dans Copilot CLI.

  1. Installez votre plug-in localement pour pouvoir le tester lors de son développement.

    Par exemple, où ./my-plugin est le chemin d’accès à votre répertoire de plug-in, entrez :

    Shell
    copilot plugin install ./my-plugin

  2. Vérifiez que le plug-in a été chargé correctement en consultant votre liste de plug-ins installés :

    Shell
    copilot plugin list

    Vous pouvez également démarrer une nouvelle session interactive et entrer :

    Copilot prompt
    /plugin list

  3. Vérifiez que les agents, compétences, hooks et configurations de serveur MCP que vous avez définies sont correctement chargés.

    Par exemple, dans une session interactive, pour vérifier que les agents personnalisés définis dans le plug-in ont été chargés, entrez :

    Copilot prompt
    /agent

    Pour vérifier que les compétences définies dans le plug-in ont été chargées, entrez :

    Copilot prompt
    /skills list

  4. Utilisez les fonctionnalités fournies par les composants de votre plug-in pour vérifier que chaque composant fonctionne comme prévu.

  5. Itérer sur votre développement de plug-in, selon les besoins.

    Important

    Lorsque vous installez un plug-in, ses composants sont mis en cache et Copilot CLI les lit à partir du cache pour les sessions suivantes. Pour récupérer les modifications apportées à un plug-in local, installez-le à nouveau :

    Shell
    copilot plugin install ./my-plugin

  6. Une fois le test terminé, vous pouvez désinstaller la version locale de votre plug-in en entrant :

    Shell
    copilot plugin uninstall NAME

    Utilisez la valeur du champ name dans le manifeste plugin.json du plug-in pour NAME, et non le chemin d’accès au répertoire du plug-in.

Ajouter des évaluations pour votre plug-in

Traitez le contexte du plug-in en tant qu’infrastructure agentique. Ajoutez des évaluations pour les comportements que votre plug-in est destiné à prendre en charge, et exécutez-les lorsque vous modifiez ses instructions, outils ou autres composants.

Distribuez votre plug-in

Pour partager votre plug-in avec d’autres personnes, ajoutez-le à une marketplace. Consultez Création et partage d’une place de marché de plug-in sur GitHub.

Les valeurs par défaut du dépôt peuvent activer votre plug-in pour un projet. Les membres peuvent remplacer ces valeurs par défaut localement, mais les paramètres gérés par l’entreprise peuvent exiger ou bloquer le plug-in et ont toujours la priorité.

Lectures complémentaires