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 :

Commandes

Évaluer

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

Syntaxe

modernize assess [options]

Options

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

É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

Options

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

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

plan d’exécution

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

Syntaxe

modernize plan execute [prompt] [options]

Arguments

Options

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

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

Options

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 de codage 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

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 :

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.

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 :

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 :

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

--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 référentiels à l’aide de l’Agent de codage cloud :

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

Mettez à niveau tous les référentiels à l’aide de l’Agent de codage 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