commandes CLI de l’agent de modernisation GitHub Copilot

L’agent de modernisation GitHub Copilot fournit des modes interactifs et non interactifs pour la modernisation des applications.

Modes de commande

Mode interactif

Lancez l’interface utilisateur de texte interactive (TUI) pour la modernisation guidée :

modernize

Le mode interactif fournit les éléments suivants :

• Navigation pilotée par le menu via le flux de travail de modernisation.
• Sélection de source flexible : dossier actif, entrée manuelle (chemins d’accès locaux ou URL Git) ou fichiers de configuration du référentiel.
• Indicateurs de plan visuel et de progression.
• Invites guidées pour les options de configuration, notamment les domaines d’évaluation et les paramètres.
• Interface de sélection multi-référentiel.

Mode non interactif

Exécutez des commandes spécifiques directement pour l’automatisation et les scripts :

modernize <command> [options]

Utilisez le mode non interactif lorsque :

• Intégration à des pipelines CI/CD.
• Automatisation des opérations par lots.
• Scripts de flux de travail de modernisation.
• Exécution dans des environnements sans tête.

Options globales

Toutes les commandes prennent en charge ces options globales :

Choix	Description
--help, -h	Affiche les informations d’aide.
--no-tty	Désactive les invites interactives (mode sans tête).

Commandes

Évaluer

Exécute une évaluation et génère un rapport d’analyse complet.

Syntaxe

modernize assess [options]

Options

Choix	Description	Par défaut
--source <source>	Source à évaluer (reproductible). Accepte les chemins d’accès locaux, les URL Git ou un chemin d’accès au fichier de configuration JSON. Utilisez plusieurs --source indicateurs pour spécifier plusieurs référentiels.	. (répertoire actif)
--output-path <path>	Chemin de sortie personnalisé pour les résultats de l’évaluation.	.github/modernize/assessment/
--issue-url <url>	URL de problème GitHub à mettre à jour avec le résumé de l’évaluation.	Aucun
--format <format>	Format de sortie pour les rapports d’évaluation : html ou markdown.	html
--assess-config <path>	Chemin d’accès au fichier YAML de configuration de l’évaluation. Remplace les paramètres d’évaluation par défaut tels que la version JDK cible, les services de calcul et les préférences de migration. Pour plus d’informations, consultez l’évaluation Batch.	Aucun
--model <model>	Modèle LLM à utiliser.	claude-sonnet-4.6
--delegate <delegate>	Mode d’exécution : local (cet ordinateur) ou cloud (agent cloud).	local
--wait	Attend que les tâches déléguées se terminent et génèrent des résultats (valides uniquement avec --delegate cloud).	Désactivé
--force	Force le redémarrage de la délégation, en ignorant les tâches en cours (uniquement valides avec --delegate cloud).	Désactivé

Exemples

Évaluation de base du répertoire actif :

modernize assess

Évaluer avec l’emplacement de sortie personnalisé :

modernize assess --output-path ./reports/assessment

Évaluez et mettez à jour GitHub problème avec les résultats :

modernize assess --issue-url https://github.com/org/repo/issues/123

Évaluer un répertoire de projet spécifique :

modernize assess --source /path/to/project

Évaluer avec une configuration personnalisée :

modernize assess --assess-config ./my-assessment-config.yml

Évaluez plusieurs référentiels à l’aide d’un fichier de configuration :

modernize assess --source .github/modernize/repos.json

Évaluez plusieurs référentiels en spécifiant directement des sources :

modernize assess --source https://github.com/org/repo1 --source https://github.com/org/repo2

Évaluer et générer des rapports au format Markdown :

modernize assess --format markdown

Sortie

L’évaluation génère :

• Fichiers de rapport : analyse détaillée dans les formats JSON, MD et HTML.
• Résumé : résultats et recommandations clés.
• mises à jour Issue (si vous fournissez --issue-url) : GitHub commentaire du problème avec résumé.

création de plan

Crée un plan de modernisation basé sur une invite de langage naturel décrivant vos objectifs de modernisation.

Syntaxe

modernize plan create <prompt> [options]

Arguments

Argument	Description
<prompt>	Description en langage naturel des objectifs de modernisation (requis).

Options

Choix	Description	Par défaut
--source <path>	Chemin d’accès au code source de l’application.	Répertoire courant
--plan-name <name>	Nom du plan de modernisation.	modernization-plan
--language <lang>	Langage de programmation (java, dotnetou python).	Détection automatique
--assess-file-path <path>	Chemin d’accès à un fichier de rapport d’évaluation existant à utiliser comme contexte pour la génération de plan. Permet au plan d’être basé sur les résultats de l’évaluation.	Aucun
--overwrite	Remplace un plan existant portant le même nom.	Désactivé
--model <model>	Modèle LLM à utiliser.	claude-sonnet-4.6

Exemples

Générez un plan de migration :

modernize plan create "migrate from oracle to azure postgresql"

Générez un plan de mise à niveau avec un nom personnalisé :

modernize plan create "upgrade to spring boot 3" --plan-name spring-boot-upgrade

Générez un plan de déploiement :

modernize plan create "deploy the app to azure container apps" --plan-name deploy-to-aca

Exemple d’options complètes :

modernize plan create "upgrade to .NET 8" \
    --source /path/to/project \
    --plan-name dotnet8-upgrade \
    --language dotnet \
    --issue-url https://github.com/org/repo/issues/456

Générez un plan basé sur le rapport d’évaluation :

modernize plan create "migrate to Azure PostgreSQL" \
    --assess-file-path .github/modernize/assessment/assessment-report.json \
    --plan-name postgres-migration

Exemples d’invite

Mises à niveau de framework :

• upgrade to spring boot 3
• upgrade to .NET 10
• upgrade to JDK 21
• migrate from spring boot 2 to spring boot 3

Migrations de base de données :

• migrate from oracle to azure postgresql
• migrate from SQL Server to azure cosmos db
• switch from MySQL to azure database for mysql

Migrations cloud :

• migrate from on-premises to azure
• containerize and deploy to azure container apps
• migrate from rabbitmq to azure service bus

Déploiement:

• deploy to azure app service
• deploy to azure kubernetes service
• set up CI/CD pipeline for azure

Sortie

La commande génère :

• Fichier de plan (.github/modernize/{plan-name}/plan.md) : stratégie de modernisation détaillée, notamment :

  • Contexte et objectifs
  • Approche et méthodologie
  • Clarifications

• Liste des tâches (.github/modernize/{plan-name}/tasks.json) : Répartition structurée des tâches exécutables avec :

  • Descriptions des tâches
  • Compétences à utiliser
  • Critères de réussite

Conseil / Astuce

Vous pouvez modifier manuellement les deux plan.md et tasks.json après génération pour personnaliser l’approche avant l’exécution.

plan d’exécution

Exécute un plan de modernisation créé par modernize plan create.

Syntaxe

modernize plan execute [prompt] [options]

Arguments

Argument	Description
[prompt]	Instructions facultatives en langage naturel pour l’exécution (par exemple, « ignorer les tests »). La valeur par défaut est « exécuter le plan » si elle n’est pas spécifiée.

Options

Choix	Description	Par défaut
--source <path>	Chemin d’accès au code source de l’application.	Répertoire courant
--plan-name <name>	Nom du plan à exécuter.	modernization-plan
--language <lang>	Langage de programmation (java ou dotnet).	Détection automatique
--model <model>	Modèle LLM à utiliser.	claude-sonnet-4.6
--delegate <delegate>	Mode d’exécution : local (cet ordinateur) ou cloud (agent cloud).	local
--force	Force l’exécution même lorsqu’un travail d’agent cloud est en cours. Valide uniquement avec --delegate cloud.	Désactivé

Exemples

Exécutez le plan le plus récent de manière interactive :

modernize plan execute

Exécutez un plan spécifique :

modernize plan execute --plan-name spring-boot-upgrade

Exécutez avec des instructions supplémentaires :

modernize plan execute "skip the test" --plan-name spring-boot-upgrade

Forcez l’exécution sur un agent cloud même si un travail est en cours d’exécution :

modernize plan execute --delegate cloud --force --plan-name spring-boot-upgrade

Note

L’option --force ne peut être utilisée qu’avec la délégation de l’agent cloud (--delegate cloud).

Exécutez en mode sans tête pour CI/CD :

modernize plan execute --plan-name spring-boot-upgrade --no-tty

Comportement d’exécution

Pendant l’exécution, l’agent :

1. Charge le plan : lit le plan et la liste des tâches à partir de .github/modernization/{plan-name}/

2. Exécute des tâches : traite chaque tâche de la liste des tâches de manière séquentielle :

   • Applique des transformations de code.
   • Valide les builds après les modifications.
   • Recherche les CVE.
   • Valide les modifications avec des messages descriptifs.

3. Génère un résumé : fournit un rapport de toutes les modifications et résultats.

Sortie

• Historique des validations : validations détaillées pour chaque tâche exécutée.
• Rapport de synthèse : Vue d’ensemble des modifications, des réussites et des problèmes rencontrés.
• Validation de build : confirmation que l’application est générée avec succès.
• Rapport CVE : vulnérabilités de sécurité identifiées et traitées.

upgrade

Exécute un flux de travail de mise à niveau de bout en bout - planifier et exécuter - dans une seule commande.

Syntaxe

modernize upgrade [prompt] [options]

Arguments

Argument	Description
[prompt]	Version cible (par exemple, Java 17, Spring Boot 3.2, .NET 10). Facultatif : la valeur par défaut est la dernière LTS si elle n’est pas spécifiée.

Options

Choix	Description	Par défaut
--source <source>	Source à mettre à niveau (reproductible). Accepte les chemins d’accès locaux, les URL Git ou un chemin d’accès au fichier de configuration JSON. Utilisez plusieurs --source indicateurs pour spécifier plusieurs référentiels.	. (répertoire actif)
--delegate <delegate>	Mode d’exécution : local (cet ordinateur) ou cloud (agent cloud).	local
--model <model>	Modèle LLM à utiliser.	claude-sonnet-4.6

Exemples

Exécutez sur upgrade le répertoire actif :

modernize upgrade "Java 17"

modernize upgrade ".NET 10"

Exécutez sur upgrade un projet spécifique :

modernize upgrade "Java 17" --source /path/to/project

Exécutez à upgrade l’aide de l’agent cloud :

modernize upgrade "Java 17" --delegate cloud

Mettez à niveau plusieurs référentiels à l’aide d’un fichier de configuration :

modernize upgrade "Java 21" --source .github/modernize/repos.json

Mettez à niveau plusieurs référentiels en spécifiant directement des sources :

modernize upgrade "Java 21" --source https://github.com/org/repo1 --source https://github.com/org/repo2

help

Fournit de l’aide et des commandes d’informations.

Syntaxe

modernize help [command]

Commandes

Commande	Description
models	Répertorie les modèles LLM disponibles et leurs multiplicateurs.

Exemples

Répertorier les modèles disponibles :

modernize help models

Configurer l’interface CLI

À l’aide de l’agent de modernisation, vous pouvez personnaliser le comportement de l’application via des fichiers JSON et des variables d’environnement.

Variables d'environnement

Définissez des variables d’environnement pour remplacer toutes les autres étendues de configuration :

Variable	Description	Par défaut
MODERNIZE_LOG_LEVEL	Niveau de journalisation (none, , errorwarning, infodebug, all)	info
MODERNIZE_MODEL	Modèle LLM à utiliser.	claude-sonnet-4.6
MODERNIZE_COLLECT_TELEMETRY	Activez ou désactivez la collecte de données de télémétrie.	true

Exemple :

export MODERNIZE_LOG_LEVEL=debug
export MODERNIZE_MODEL=claude-sonnet-4.6
modernize assess

Configuration utilisateur

Stocker des préférences spécifiques à l’utilisateur dans ou des ~/.modernize/config.json paramètres à l’échelle du référentiel dans .github/modernize/config.json.

{
  "model": "claude-sonnet-4.6",
  "log_level": "info",
  "trusted_folders": [
    "/path/to/trusted/project",
  ]
}

La trusted_folders propriété spécifie les dossiers approuvés pour utiliser LLM en mode interactif.

Note

Les variables d’environnement sont prioritaires, suivies de la configuration utilisateur, puis de la configuration du référentiel. Utilisez des variables d’environnement pour les remplacements CI/CD et la configuration utilisateur pour les préférences personnelles.

Configuration de plusieurs référentiels

Vous pouvez fournir plusieurs sources à l’interface CLI de plusieurs façons :

• Fichier de configuration du référentiel : créez un .github/modernize/repos.json fichier qui répertorie tous les référentiels, puis transmettez-le.--source
• Plusieurs --source indicateurs : spécifiez des chemins d’accès locaux ou des URL Git directement sur la ligne de commande.
• Mode interactif : sélectionnez des sources via le TUI (dossier actif, entrée manuelle ou configuration du référentiel).

Fichier de configuration du référentiel

Créez un .github/modernize/repos.json fichier pour définir votre liste de référentiels. La configuration prend en charge deux formats :

Format simple (tableau de référentiels) :

[
  {
    "name": "PhotoAlbum-Java",
    "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git"
  },
  {
    "name": "PhotoAlbum",
    "url": "https://github.com/Azure-Samples/PhotoAlbum.git"
  }
]

Format complet (avec des chemins de branche et locaux) :

{
  "repos": [
    {
      "name": "PhotoAlbum-Java",
      "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git",
      "branch": "main"
    },
    {
      "name": "local-project",
      "path": "/absolute/path/to/project"
    }
  ]
}

Chaque entrée de dépôt prend en charge les champs suivants :

Champ	Description	Obligatoire
name	Nom convivial du référentiel.	Oui
url	URL de clone Git (HTTPS ou SSH).	L’une ou l’autre urlpath
path	Chemin d’accès absolu du répertoire local.	L’une ou l’autre urlpath
branch	Branche à extraire après le clonage.	Non
description	Description lisible par l’homme.	Non

Format complet avec regroupement d’applications (facultatif, pour les rapports organisés) :

Vous pouvez ajouter une apps[] section pour regrouper des référentiels dans des applications logiques. Lorsque les applications sont définies, le rapport agrégé organise les résultats par application et prend en charge la distribution des rapports.

{
  "repos": [
    {
      "name": "PhotoAlbum-Java",
      "url": "https://github.com/Azure-Samples/PhotoAlbum-Java.git",
      "branch": "main"
    },
    {
      "name": "PhotoAlbum",
      "url": "https://github.com/Azure-Samples/PhotoAlbum.git"
    }
  ],
  "apps": [
    {
      "identifier": "photo-app",
      "description": "Photo management application",
      "repos": ["PhotoAlbum-Java"],
      "output": {
        "type": "local",
        "path": "/path/to/reports/photo-app"
      }
    }
  ]
}

Chaque entrée d’application prend en charge :

Champ	Description	Obligatoire
identifier	Nom complet unique de l’application.	Oui
description	Description lisible par l’homme.	Non
repos	Liste des noms de référentiels appartenant à cette application.	Oui
output	Où distribuer le rapport d’évaluation de cette application après la génération.	Non

Le output champ prend en charge les types de distribution suivants :

Catégorie	Description	Champs obligatoires
local	Copiez des rapports dans un répertoire local.	path
git	Envoyer (push) des rapports vers un dépôt Git. Format d’URL : https://github.com/org/repo.git#branch:path.	url

Important

La délégation d’agent cloud (--delegate cloud) nécessite que les référentiels aient des URL de référentiel GitHub (github.com). Les référentiels de chemin d'accès local et les fournisseurs non GitHub (GitLab, Azure DevOps) ne sont pas pris en charge pour la délégation cloud et sont ignorés.

--source Utilisez ensuite pour passer le chemin d’accès du fichier config :

Évaluez tous les référentiels localement :

modernize assess --source .github/modernize/repos.json

Évaluez tous les dépôts à l’aide de l’agent cloud :

modernize assess --source .github/modernize/repos.json --delegate cloud

Mettez à niveau tous les référentiels à l’aide de l’agent cloud :

modernize upgrade --source .github/modernize/repos.json --delegate cloud

Plusieurs sources sur la ligne de commande

Vous pouvez également spécifier plusieurs sources directement :

modernize assess --source https://github.com/org/repo1 --source https://github.com/org/repo2

modernize upgrade "Java 21" --source ./project-a --source ./project-b

Étapes suivantes

• Évaluation par lots : Évaluer plusieurs applications
• Mise à niveau par lots : mettre à niveau plusieurs applications
• Créer des compétences personnalisées pour votre organisation
• Retour à la vue d’ensemble