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

Présentation

Les plug-ins sont des packages qui étendent les fonctionnalités de Copilot CLI. Consultez À propos des GitHub Copilot plug-ins.

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.

Copilot CLI prend en charge deux formats de plug-in :

  • Agent Plugins 1.0, un format portable pour les compétences et les serveurs MCP. Le fait de déclarer la balise canonique $schema dans plugin.json fait adopter ce format au plugin.
  • Le format hérité Copilot, qui prend en charge des composants spécifiques à Copilot et des chemins de composants configurables. Un manifeste sans les plug-ins $schema de l’agent continue d’utiliser ce format.

Les deux formats sont pris en charge. Choisissez Agent Plugins 1.0 si vous souhaitez rendre les compétences et les serveurs MCP portables entre des clients compatibles. Choisissez le format hérité lorsque vous avez besoin de chemins de composant personnalisés ou si vous assurez la maintenance d’un plug-in spécifique à Copilot existant. Dans Agent Plugins 1.0, les compétences et les serveurs MCP sont portables, et les composants spécifiques à Copilot, tels que les agents, les commandes, les règles, les crochets et les serveurs LSP, proviennent du répertoire com.github.copilot du plugin.

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. Les champs de niveau supérieur inconnus sont signalés et ignorés. 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.

  2. 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

  3. 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

  4. 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

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

  6. 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 l’interface CLI 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

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

    Shell
    copilot plugin uninstall NAME

    Remarque

    Pour désinstaller un plug-in, utilisez le nom du plug-in tel que spécifié dans le name champ du fichier manifeste du plugin.json plug-in, et non le chemin d’accès au répertoire du plug-in.

Distribution de votre plug-in

Pour distribuer votre plug-in, vous pouvez l’ajouter à une place de marché. Consultez Création d’une place de marché de plug-ins pour GitHub Copilot CLI.

Lectures complémentaires