Tutoriel sur l'interface CLI de GitHub Copilot : Caractéristiques, installation et cas d'utilisation

GitHub Copilot CLI intègre l'assistance IA directement dans le terminal afin d'aider les développeurs à écrire du code, automatiser des tâches et gérer des flux de travail à l'aide du langage naturel. Il étend les capacités de Copilot au-delà de l'éditeur et transforme la ligne de commande en un espace de travail intelligent et contextuel.

Ce guide vous présente tout ce que vous devez savoir : le fonctionnement de l'interface CLI Copilot, son installation et sa configuration, ainsi que son utilisation dans des scénarios concrets.

Pour utiliser efficacement l'interface CLI Copilot, il est nécessaire d'être à l'aise avec l'interface CLI elle-même. Introduction au cours Introduction à shell permet d'acquérir les connaissances de base que l'interface CLI Copilot vise à automatiser.

Qu'est-ce que GitHub Copilot CLI ?

GitHub Copilot CLI est un outil en ligne de commande qui apporte l'assistance de l'IA directement dans votre terminal. Vous pouvez lui demander des commandes, comprendre des scripts complexes et déboguer des problèmes directement depuis votre shell. Au lieu d'interrompre votre flux de travail pour parcourir la documentation ou mémoriser des indicateurs obscurs, vous pouvez simplement décrire ce que vous souhaitez accomplir.

Vous pouvez également gérer des dépôts distants, ouvrir des tickets, créer des pull requests et utiliser GitHub Actions à l'aide de commandes en langage naturel. Cela réduit considérablement les changements de contexte, vous permettant ainsi de gérer presque toutes les tâches que vous effectuez habituellement sur le site Web GitHub directement depuis l'interface CLI.

Comprendre l'interface CLI de GitHub Copilot

La CLI GitHub Copilot évolue d'un simple assistant en ligne de commande vers un agent plus autonome. Cette section examine cette transition et ses nouvelles possibilités.

Évolution de l'extension CLI vers un agent autonome

La première version de l'assistance IA pour terminal a été intégrée via l'extension gh-copilot. Il fonctionnait comme un module complémentaire à l'interface CLI GitHub. Vous pouvez saisir une invite en langage naturel et recevoir une commande ou un script adapté à la tâche que vous avez décrite. Par exemple :

gh copilot generate "Write a bash script that deletes merged branches"

#!/bin/bash
git branch --merged main | grep -v "main" | xargs git branch -d

Vous pouvez copier le résultat et l'exécuter dans le terminal. Veuillez noter que vous devez toujours le copier et l'exécuter vous-même. Et si l'outil effectuait cette opération de manière autonome ? C'est ce qu'apporte la nouvelle interface CLI GitHub Copilot.

Afin de s'adapter aux avancées actuelles en matière d'IA, GitHub a officiellement abandonné l'ancienne extension le 25 octobre 2025 et a lancé la nouvelle CLI Copilot. Cette version offre une expérience beaucoup plus interactive dans le terminal. Il comprend le contexte, exécute des workflows en plusieurs étapes, applique les modifications de code et facilite le débogage des problèmes directement à partir de la ligne de commande.

Extension Copilot IDE par rapport à Copilot CLI

L'interface CLI Copilot complète l'extension IDE Copilot, et toutes deux utilisent les modèles d'IA de GitHub pour prendre en charge différentes parties du flux de travail de développement. Dans l'éditeur, Copilot vous assiste dans la rédaction, la refactorisation et la finalisation du code. Dans le terminal, vous pouvez utiliser Copilot CLI pour les workflows basés sur le terminal.

Par exemple, vous pouvez utiliser Copilot dans VS Code pour générer un fichier Dockerfile, puis passer au terminal et demander à Copilot CLI de créer l'image et de conteneuriser l'application.

Quelles sont les nouveautés de l'interface CLI GitHub Copilot ?

Cette version présente une série de fonctionnalités avancées qui transforment l'interface CLI d'un assistant passif en un partenaire de développement proactif et autonome.

Capacités d'action

L'ancienne assistance gh ne pouvait que fournir des explications sur le code ou générer des scripts shell de base. La nouvelle interface CLI Copilot va encore plus loin. Il s'agit d'un agent autonome qui planifie et exécute des tâches en plusieurs étapes. Il est capable de déboguer du code, de modifier des fichiers, de créer de nouvelles structures de projet et de gérer des flux de travail complexes entièrement à partir du terminal.

Accès aux modèles les plus récents

La nouvelle interface CLI Copilot vous permet d'accéder aux derniers modèles d'Anthropic, OpenAI, Google et d'autres. Cette approche multimodèle offre davantage de flexibilité que les outils à fournisseur unique tels que Gemini CLI ou OpenAI Codex CLI.

Il utilise Claude Sonnet 4.5 comme modèle par défaut, et vous pouvez changer de modèle à tout moment en exécutant la commande slash /model et en sélectionnant une nouvelle option dans la liste.

Extensibilité grâce à MCP

Le protocole MCP (Model Context Protocol) permet à l'interface CLI d'accéder à des ensembles de données internes et à des bases de connaissances spécifiques, et de générer des solutions adaptées à votre cas d'utilisation. 

L'interface CLI Copilot comprend un serveur GitHub MCP préconfiguré, ce qui lui permet d'interagir facilement avec GitHub.com et de gérer les référentiels distants directement depuis le terminal. Vous pouvez également connecter l'interface CLI Copilot à des serveurs MCP personnalisés et récupérer le contexte à partir de vos outils ou bases de données propriétaires.

Gestion des sessions

Lorsque vous lancez l'interface CLI Copilot, vous entrez dans une session qui reste active jusqu'à ce que vous la quittiez. Au cours d'une session, Copilot mémorise et établit un contexte à chaque interaction. 

Par exemple, vous pouvez demander à Copilot de réviser le résultat de votre dernière requête, d'étendre un script qu'il vient de générer ou d'appliquer des modifications supplémentaires sans répéter tout le contexte dans chaque invite.

Comment accéder à l'interface CLI de GitHub Copilot

Vous pouvez exécuter l'interface CLI Copilot sur macOS, Linux ou Windows et la connecter à vos référentiels, workflows et paramètres organisationnels. Voici comment fonctionne l'architecture et ce dont vous avez besoin pour l'exécuter.

Conditions préalables pour GitHub Copilot CLI

Trois conditions préalables sont requises avant de pouvoir utiliser l'interface CLI GitHub Copilot :

• Un compte GitHub Copilot : GitHub propose différents forfaits pour les particuliers et les entreprises, ainsi qu'un forfait de base gratuit avec 50 demandes de chat par mois. Veuillez sélectionner le forfait qui correspond à vos besoins et activer GitHub Copilot sur votre compte.
• Node.js version 22 ou ultérieure : GitHub développe et distribue l'interface CLI Copilot sous forme d'application Node.js. Il est donc nécessaire d'installer Node.js 22 ou une version ultérieure dans votre environnement.
• Version 10 ou ultérieure de npm : Étant donné que l'application fonctionne sur Node.js, npm est le gestionnaire de paquets standard. Veuillez installer npm 10 ou une version ultérieure pour gérer l'interface CLI Copilot.

Plateformes d'exploitation prises en charge et spécificités de l'environnement

Il est important de prendre en compte certains éléments lors de l'accès à GitHub Copilot CLI, en fonction du système d'exploitation utilisé.

Linux et macOS

La CLI GitHub Copilot est entièrement compatible avec Linux et macOS. Il fonctionne de manière native sur bash et zsh, et les deux plateformes gèrent Node.js, les globaux npm et les intégrations shell de manière fluide. Si vous souhaitez bénéficier de la configuration CLI Copilot la plus stable avec une compatibilité totale des fonctionnalités, Linux et macOS sont les systèmes d'exploitation les plus adaptés.

Windows

Sous Windows, il est recommandé d'exécuter l'interface CLI Copilot via WSL. WSL vous offre un environnement Linux complet sous Windows, vous bénéficiez ainsi de la même stabilité et de la même compatibilité shell que sur les systèmes Linux natifs.

L'interface CLI Copilot fonctionne également sur Windows PowerShell natif, mais cette option est actuellement en phase expérimentale. Il nécessite PowerShell 6 ou une version supérieure, mais même la dernière version de Windows 11 est fournie avec Windows PowerShell 5.1. Par conséquent, il est nécessaire d'installer manuellement PowerShell 6 ou une version ultérieure si vous souhaitez utiliser PowerShell natif.

Configuration de l'interface CLI GitHub Copilot : Processus d'installation étape par étape

Commençons par GitHub Copilot CLI.

Étape 1 : Vérifier les conditions préalables

La vérification des prérequis obligatoires permet d'éviter la plupart des échecs d'installation, veuillez donc commencer par cela. Veuillez vérifier les versions de Node.js et npm en exécutant :

node --version
npm --version

Vous devez également disposer d'un compte GitHub avec un abonnement Copilot actif. Si l'une des conditions préalables n'est pas remplie, veuillez la corriger avant de continuer afin d'éviter toute erreur d'installation.

Étape 2 : Veuillez installer Copilot CLI.

Veuillez installer l'interface CLI officielle de Copilot :

npm install -g @github/copilot

Vous pouvez vérifier l'installation en exécutant :

--version

Si la commande affiche un numéro de version comme dans l'image ci-dessus, cela signifie que vous avez correctement installé l'interface CLI Copilot.

Étape 3 : Veuillez vous authentifier sur GitHub.

Si c'est votre première fois, veuillez vous authentifier auprès de GitHub en suivant les étapes ci-dessous :

1. Veuillez exécuter la commande suivante : gh auth login.

2. Lorsque GitHub CLI demande : « Où utilisez-vous GitHub ? », sélectionnez GitHub.com et appuyez sur Entrée.

3. Lorsqu'il est demandé : Quel est votre protocole préféré pour les opérations Git sur cet hôte ? Sélectionnez HTTPS et appuyez sur Entrée.

4. Lorsqu'on vous demande une méthode d'authentification, veuillez sélectionner «Se connecter avec un navigateur Web ».

GitHub CLI affiche alors un code à usage unique et une URL GitHub. Veuillez vous rendre à l'URL, saisir le code à usage unique, approuver la demande de connexion et confirmer l'accès à votre compte GitHub.

Une fois la demande approuvée, veuillez retourner à votre terminal et vérifier la connexion en exécutant gh auth status. Si votre nom d'utilisateur GitHub s'affiche, cela signifie que vous vous êtes authentifié avec succès.

Utilisation de l'interface CLI GitHub Copilot

Pour démarrer GitHub Copilot CLI après vous être authentifié, veuillez suivre les étapes suivantes :

1. Veuillez ouvrir votre terminal et naviguer jusqu'au référentiel de code où vous souhaitez utiliser l'interface CLI Copilot.

2. Veuillez saisir copilot et appuyer sur Entrée. Cela lance un mode interactif dans lequel vous pouvez poser des questions complémentaires au cours d'une seule session.

Vous pouvez également exécuter une invite ponctuelle, par exemple : copilot -p “explain what this function does: [function_name]”. Dans ce cas, l'interface CLI génère l'explication et clôt immédiatement la session.

Principales fonctionnalités de GitHub Copilot CLI

La CLI Copilot offre des fonctionnalités très intéressantes qui optimisent les workflows des agents. Examinons-les en pratique.

Exécution de tâches par des agents autonomes

L'interface CLI Copilot utilise une architecture basée sur un agent qui comprend votre invite, planifie les actions nécessaires et exécute des tâches en plusieurs étapes directement dans le terminal.

L'agent est capable de décomposer des instructions complexes et d'orchestrer des tâches impliquant la lecture de fichiers, la génération de scripts, la transformation de données ou l'enchaînement automatique de plusieurs opérations. 

Permettez-moi de vous démontrer comment cela fonctionne en pratique :

Automatisation des vérifications préalables au déploiement à l'aide de l'interface CLI GitHub Copilot

J'ai demandé à Copilot de créer un script qui automatise les vérifications préalables au déploiement. Copilot a analysé le référentiel, créé un nouveau fichier (deploy_prep.sh) et rédigé un script qui effectue des vérifications courantes telles que la vérification d'un état Git propre, l'exécution d'une compilation Gradle et la création d'une image Docker.

Après avoir accepté la modification, Copilot a automatiquement ajouté le script au référentiel. Ceci démontre comment l'agent gère l'ensemble du flux de travail, depuis la compréhension de la demande jusqu'à la création du fichier et la rédaction du script complet.

Intégration native au terminal et préservation du flux de travail

L'interface CLI Copilot s'exécute de manière native dans le terminal et centralise l'ensemble de votre flux de travail en un seul endroit. Vous pouvez planifier des tâches, générer du code et exécuter des commandes sans changer d'outil.

Le CLI conserve également le contexte de session, ce qui lui permet de mémoriser vos étapes précédentes pendant que vous travaillez. Cette continuité facilite la gestion des tâches en plusieurs étapes et le dépannage des problèmes complexes.

Intégration GitHub et contexte du référentiel

L'interface CLI Copilot s'intègre directement à l'écosystème GitHub, vous permettant d'accéder à vos référentiels distants, branches et workflows depuis le terminal.

Cette intégration optimise les opérations GitHub. Vous pouvez créer des demandes d'extraction, examiner les différences ou résoudre les problèmes en cours à l'aide de simples invites en langage naturel. Par exemple, vous pouvez demander à l'interface CLI de créer une nouvelle PR avec un résumé de vos modifications. Elle préparera alors la demande, générera la description et la transmettra à GitHub.com.

Modes de fonctionnement de l'interface CLI GitHub Copilot

Afin de vous offrir le niveau de contrôle approprié pour différentes tâches, l'interface CLI est organisée en trois modes opérationnels distincts : mode demande, mode édition et mode agent.

Mode Question

En mode « Demander », vous pouvez solliciter des définitions, des exemples, des comparaisons ou des conseils étape par étape, et Copilot vous répondra de manière conversationnelle.

Par exemple, si vous ne savez pas comment fonctionne un indicateur, à quoi sert un pipeline ou pourquoi un script échoue, le mode « Demander » vous fournit une explication directe sans quitter le terminal. 

Mode édition

Lorsque vous activez Copilot en mode « Modifier », il analyse votre projet, identifie les fichiers qui nécessitent des mises à jour et génère les modifications. Veuillez examiner les différences dans le terminal et les approuver.

Vous pouvez l'utiliser pour refactoriser des fonctions, mettre à jour des fichiers de configuration, renommer des variables dans un projet ou migrer du code vers de nouveaux modèles. 

Mode agent

Le mode Agent est celui dans lequel l'interface CLI Copilot passe de l'assistance à l'exécution autonome des tâches. L'agent interprète votre demande, crée un flux de travail en plusieurs étapes, exécute chaque étape, vérifie les résultats et procède aux ajustements nécessaires.

Ce mode gère les tâches qui nécessitent plusieurs commandes ou une planification manuelle. Par exemple, l'agent peut configurer un environnement de développement en créant des répertoires, en générant des fichiers et en installant des dépendances.

Fonctionnalités avancées de l'interface CLI GitHub Copilot 

Après avoir abordé les fonctionnalités principales et les modes de fonctionnement, nous allons maintenant examiner quelques fonctionnalités plus avancées.

Commandes Slash et raccourcis de flux de travail

Les commandes Slash servent de raccourcis pour les opérations courantes dans l'interface CLI de Copilot. Ils déclenchent des actions instantanément sans invite complète, ce qui les rend utiles pour les tâches rapides ou répétitives. Voici quelques exemples courants :

• /explain pour interpréter une commande ou un script

• /commit Préparer un message de validation à partir des modifications préparées

• /pr rédiger une description de la demande de modification

• /fix identifier les problèmes dans le code et proposer des corrections

• /review Résumer ou examiner les modifications locales

• /run générer et exécuter une commande

Personnalisation

Copilot CLI stocke ses paramètres dans un fichier de configuration JSON situé dans le répertoire Copilot par défaut : ~/.copilot. Ce fichier contient vos modèles d'IA par défaut, vos paramètres d'intégration de l'éditeur et vos préférences de flux de travail. 

Vous pouvez le modifier manuellement afin de contrôler le comportement de Copilot. Étant donné que le fichier se trouve dans votre répertoire personnel, il s'applique globalement à tous les projets, ce qui garantit la cohérence entre ceux-ci. 

L'interface CLI comprend également des commandes permettant d'ajuster la configuration sans avoir à modifier les fichiers manuellement. Les commandes courantes comprennent :

• copilot config view pour afficher vos paramètres actuels

• copilot config set pour mettre à jour une valeur de configuration spécifique

• copilot config reset restaurer les paramètres par défaut

Dans les environnements multi-utilisateurs ou d'entreprise, les équipes peuvent distribuer des modèles de configuration standard ou utiliser des scripts d'intégration pour définir les comportements par défaut de chaque développeur. 

Chaque utilisateur conserve son propre répertoire de configuration, mais les administrateurs peuvent associer des paramètres par défaut partagés à des personnalisations individuelles. Cet équilibre permet d'offrir une expérience Copilot cohérente à l'échelle de l'organisation tout en préservant la flexibilité dont les développeurs ont besoin.

Configurations de sécurité

Pour les données sensibles telles que les jetons ou les identifiants spécifiques à l'entreprise, l'interface CLI Copilot utilise des variables d'environnement. Vous pouvez ajouter ces variables à votre profil shell, les charger à partir d'un gestionnaire de secrets ou les définir par session pour une authentification de courte durée. Cela permet de maintenir les informations confidentielles hors du contrôle de version et de réduire les risques liés à la sécurité.

Cas d'utilisation de GitHub Copilot CLI

Cette section met en évidence la manière dont l'interface CLI peut améliorer la productivité dans le cadre des tâches de développement courantes.

Commencer avec des invites simples

Commencez par des invites simples pour vous familiariser avec l'interface CLI Copilot. Bien que l'agent soit performant, la qualité du résultat dépend de vos données d'entrée. Pour maîtriser l'art de rédiger des instructions efficaces, veuillez consulter notre cours Comprendre l'ingénierie des invites.

Vous pouvez l'utiliser pour expliquer des commandes shell, résumer des erreurs ou générer de petits extraits. Par exemple, nous pourrions lui demander de supprimer les images et conteneurs Docker inutilisés :

copilot -p "Clean up unused Docker images and containers"

Comme le montre l'image, un script complet est généré, et lorsque vous acceptez la suggestion, il s'exécute et supprime les images et les conteneurs inutilisés, conformément à nos attentes.

Génération de documentation

Vous pouvez demander à Copilot de générer de la documentation, d'ajouter des commentaires en ligne ou de mettre à jour des documents existants. Veuillez observer comment il est possible de générer un fichier README pour un référentiel :

copilot -p "Generate a README for this repo: include purpose, install, basic usage, and example commands."

Comme je disposais déjà d'un fichier README, Copilot l'a mis à jour afin qu'il réponde aux nouvelles exigences spécifiées dans ma commande. La comparaison affiche le texte supprimé en rouge et le texte ajouté en vert, ce qui facilite la révision et l'approbation des modifications.

Mises à niveau du cadre et modernisation du code existant

Dans les bases de code existantes, les développeurs utilisent l'interface CLI Copilot pour remplacer les API obsolètes, migrer les anciens modèles ou effectuer des refactorisations à l'échelle du projet. Vous pouvez également demander à Copilot de mettre à niveau les bibliothèques obsolètes, de réécrire le code pour les nouvelles API ou de préparer des notes de migration pour les versions majeures. 

Par exemple, j'ai demandé à ce que toutes les dépendances Gradle soient mises à niveau vers leurs dernières versions sécurisées :

copilot -p "Upgrade all Gradle dependencies to their latest safe versions"

Deux dépendances avec des mises à jour pertinentes ont été identifiées, et nous pouvons simplement accepter la différence pour inclure ces nouvelles versions.

Conclusion

GitHub Copilot CLI transforme le terminal, qui passe d'une invite de commande statique à un agent intelligent capable de comprendre et d'exécuter des workflows de développement complexes. En combinant un contexte de référentiel approfondi avec une planification autonome, il permet aux développeurs d'automatiser les tâches fastidieuses et de gérer l'ensemble de leur cycle de vie GitHub sans jamais quitter la ligne de commande.

L'interface CLI Copilot continuera d'évoluer grâce à des intégrations plus poussées avec les serveurs MCP et à une automatisation pilotée par des agents plus fiable. L'avenir de l'IA agentique s'oriente également vers l'intégration de modèles de vision. Cela permettra à des outils d'IA tels que Copilot d'interpréter des captures d'écran de bogues ou des maquettes de conception, et de prendre en charge des flux de travail plus autonomes directement à partir d'entrées visuelles.

Pour un déploiement organisationnel sans heurts, veuillez commencer par un guide d'intégration commun couvrant l'installation et l'authentification. Assurez la cohérence en utilisant des modèles de configuration basés sur JSON et des variables d'environnement sécurisées. Pour les environnements plus vastes, veuillez proposer des profils de configuration spécifiques aux rôles ou aux équipes afin de garantir la cohérence.

Si vous souhaitez maîtriser les workflows agentics et explorer tout le potentiel du développement assisté par l'IA, poursuivez votre apprentissage avec notre IA pour le génie logiciel cursus.