Apprenez à utiliser IBM Bob pour la modernisation d'applications en mettant à niveau une API Express Node.js de la version 16 à la 22. Essayez le développement assisté par IA avec les modes, les approbations et le codage littéraire dans ce tutoriel pratique.

Introduction

Bob est un partenaire IA SDLC (Software Development Lifecycle) qui augmente vos flux de travail existants. Dans ce tutoriel, vous apprendrez certaines des fonctionnalités principales de Bob en modernisant une API Express TypeScript de Node.js 16 à Node.js 22. Vous n'avez pas besoin d'expérience en Node.js ou TypeScript pour compléter le tutoriel. Vous apprendrez comment Bob analyse les dépendances et modernise les modèles de code.

Fonctionnalités clés que vous apprendrez

Bob fournit quatre capacités essentielles que vous utiliserez lors de la mise à niveau de l'API :

Modes : Personas spécialisées qui adaptent le comportement de Bob pour des tâches spécifiques.

Mentions de contexte : Référencez des éléments spécifiques du projet dans les conversations avec Bob, tels que des fichiers, des dossiers ou des commits Git.

Flux d'approbation : Examinez chaque outil que Bob prévoit d'utiliser avant son exécution.

Codage littéraire : Écrivez du code avec Bob directement dans votre éditeur. Tapez des instructions en langage naturel là où le code doit aller.

Prérequis

Ce tutoriel utilise une API REST Express TypeScript comme projet d'exemple. Cependant, vous n'avez pas besoin d'expérience en Node.js ou TypeScript.

Pour compléter ce tutoriel, vous avez besoin des éléments suivants :

Docker installé et en cours d'exécution sur ta station de travail. Tu utilises Bob pour créer un Dockerfile pour l'application.

Bob IDE installé.

Tu as complété le tutoriel de démarrage rapide pour te familiariser avec l'interface et les fonctionnalités de Bob.

Tu voudras peut-être démarrer une nouvelle fenêtre de contexte pour ce tutoriel. Consulte le tutoriel Créer une nouvelle fenêtre de contexte pour les instructions.

Configurez votre espace de travail

Lancez IBM Bob et clonez le dépôt d'exemple pour commencer à travailler avec l'application Node.js que vous allez moderniser.

Lancez IBM Bob

Lancez l'application IBM Bob sur votre ordinateur.

Ouvre la barre latérale Bob

Si la barre latérale Bob n'est pas déjà ouverte, ouvre-la en cliquant sur l'icône Bob à côté de la barre de navigation ou utilise le raccourci Option + Command + B (Mac) ou Ctrl + Alt + B (Windows).

Barre latérale Bob ouverte dans IBM Bob IDE

Clonez le dépôt du tutoriel

Clonez le dépôt contenant l'application d'exemple en cliquant sur l'icône de fichiers située en haut à gauche du panneau Bob IDE. Ensuite, cliquez sur Cloner le dépôt et collez le dépôt GitHub suivant dans la barre de recherche. Bob vous demandera où vous souhaitez enregistrer le dépôt. Vous pouvez l'enregistrer où vous le souhaitez.

https://github.com/IBM/bob-demo.git

Clonage du dépôt dans Bob IDE

Ouvrez le dépôt

Lorsque Bob vous demande si vous souhaitez ouvrir le dépôt cloné, cliquez sur Ouvrir. Si Bob demande "Faites-vous confiance aux auteurs des fichiers dans ce dossier ?", cliquez sur Oui, je fais confiance aux auteurs.

Remarquez les fichiers du projet dans l'Explorateur et le panneau de chat Bob sur le côté.

Fichiers du projet affichés dans l'Explorateur avec le panneau de chat Bob

Désactive l'approbation automatique

Assure-toi que l'approbation automatique est désactivée. Tu peux trouver ce paramètre dans Permissions. Avec l'approbation automatique désactivée, Bob te demande ta permission avant d'exécuter les modifications proposées. Cela garantit que tu restes en contrôle de toutes les modifications apportées à ta base de code.

Construis l'environnement conteneurisé

Créez un Dockerfile pour exécuter l'application dans un environnement conteneurisé, éliminant le besoin d'installer Node.js ou des dépendances localement.

Passe en mode Agent

Passe Bob en mode Agent en cliquant sur le menu déroulant de sélection de mode et en sélectionnant Agent.

Les Modes sont une façon dont Bob respecte le principe du moindre privilège. Chaque mode donne à Bob la permission de proposer un ensemble spécifique de tâches en ton nom. Le mode Agent permet à Bob d'écrire, de modifier et de refactoriser du code. Bob demande toujours la permission avant chaque opération.

Créez le Dockerfile

Entre l'invite suivante dans l'interface de chat Bob pour demander à Bob de créer le Dockerfile.

Crée un Dockerfile pour cette application Node.js TypeScript.
Il doit utiliser Node 16 pour correspondre à la version actuelle de l'application, compiler le code TypeScript et exécuter l'application sur le port `3000`.

Bob demandera un accès en lecture à plusieurs fichiers afin de comprendre les exigences du Dockerfile. Clique sur Approuver pour accorder à Bob la permission de lire ces fichiers.

Bob détermine la structure appropriée du Dockerfile et te montre le fichier proposé. Les boutons d'action apparaissent au-dessus du champ de saisie du chat. Clique sur Enregistrer pour créer le fichier. Enregistrer écrit ou modifie des fichiers dans ton projet. Plus tard dans ce tutoriel, Bob met à jour le Dockerfile pour utiliser Node 22.

Vérifiez que l'application héritée se compile

Avant de moderniser, vérifiez que le code hérité se compile et s'exécute correctement. Cette base de référence garantit que vous pouvez identifier tout problème introduit par la modernisation.

Pendant la phase de compilation, Bob vous dira que la compilation a échoué car le Dockerfile utilise npm ci, qui nécessite un fichier package-lock.json qui n'existe pas.

Dans le panneau de chat Bob, dites à Bob de compiler et de tester l'application.

Compile et teste l'application héritée en utilisant Docker pour vérifier qu'elle fonctionne correctement avant la modernisation. L'application doit répondre aux requêtes API à /api/todos avec des données d'exemple

Après les tests, nettoie le conteneur.

Bob vous demande d'enregistrer une modification du Dockerfile qui corrigera le problème package-lock.json avec le message suivant :

La compilation a échoué car il n'y a pas de fichier package-lock.json. Je dois mettre à jour le Dockerfile pour utiliser `npm install` au lieu de `npm ci`. Laisse-moi corriger cela.

La capacité de Bob à détecter et corriger les erreurs de compilation est un exemple de la façon dont il travaille avec vous pour dépanner et résoudre les problèmes lors des déploiements.

Une fois que Bob applique la correction et termine la compilation, il affiche un résumé des résultats de compilation et de test, confirmant que l'application héritée fonctionne correctement dans un environnement conteneurisé. Tu as maintenant une ligne de base vérifiée à comparer après avoir modernisé l'application dans la section suivante.

Vous et Bob avez vérifié que l'application héritée fonctionne correctement.

Explorez la base de code Node.js avec le mode Ask de Bob

Avant de moderniser, cliquez sur le menu déroulant de sélection de mode et passez au mode Ask de Bob. Le mode Ask ne peut que lire des fichiers, vous pouvez donc explorer le code en toute sécurité sans faire de modifications accidentelles. Vous pouvez également taper /ask dans le chat Bob pour passer en mode Ask.

Utilisez les mentions de contexte @ pour examiner le projet

Bob prend en charge les mentions de contexte @ qui vous permettent de référencer des fichiers, des dossiers ou des problèmes spécifiques directement dans vos invites. Les mentions de contexte donnent à Bob des informations précises sur ce que vous souhaitez discuter.

Explorez les fichiers package.json, tsconfig.json et Dockerfile en disant explicitement à Bob quels fichiers analyser en utilisant des mentions @. En apprendre davantage sur ces fichiers vous aide à comprendre les exigences de modernisation avant d'apporter des modifications.

Dans le panneau de chat Bob, exécutez l'invite suivante :

@package.json Quelle version de Node.js ce projet utilise-t-il ? Quelles dépendances devraient être mises à jour pour Node.js 22 ? Donne-moi un résumé court.

Le symbole @ indique à Bob d'inclure package.json comme contexte. Bob ne commence pas à répondre immédiatement ; il explore d'abord votre base de code, en lisant des fichiers, en suivant des modèles et en analysant le code. N'interrompez pas cette phase d'exploration.

Bob identifie les mises à jour suivantes nécessaires pour Node.js 22 :

**Version actuelle de Node.js :** 16.x

**Dépendances nécessitant des mises à jour pour Node.js 22 :**

1. **@types/node** : ^16.18.0 → ^22.x.x (types TypeScript pour Node.js 22)
2. **typescript** : ^4.9.5 → ^5.x.x (TypeScript 5+ pour un meilleur support de Node.js 22)
3. **ts-node** : ^10.9.1 → ^10.9.2+ (assurer la compatibilité avec TS 5 et Node 22)

**Dépendances déjà compatibles :**
- **express** : ^4.18.2 ✓ (fonctionne avec Node.js 22)
- **uuid** : ^9.0.0 ✓ (fonctionne avec Node.js 22)
- **@types/express** : ^4.17.17 ✓ (compatible)
- **@types/uuid** : ^9.0.0 ✓ (compatible)

**Résumé :** Seules les dépendances de développement spécifiques à Node.js doivent être mises à jour. Les dépendances d'exécution (Express, UUID) sont déjà compatibles avec Node.js 22.

Analysez la configuration TypeScript

Demandez à Bob d'analyser la configuration TypeScript du projet :

@tsconfig.json Quel système de modules et quels paramètres de compilateur ce projet TypeScript utilise-t-il ? Quelles dépendances devraient être mises à jour pour Node.js 22 ? Donne-moi un résumé court.

Bob répond avec les composants suivants que vous devez mettre à jour pour Node.js 22 :

**Configuration TypeScript actuelle :**

**Système de modules :** CommonJS (`"module": "commonjs"`)
- Système de modules Node.js traditionnel utilisant `require()` et `module.exports`
- Sortie : fichiers `.js` avec syntaxe CommonJS

**Paramètres du compilateur :**
- **Target :** ES2020 (compile en JavaScript ES2020)
- **Lib :** ES2020 (utilise les fonctionnalités de la bibliothèque standard ES2020)
- **Module Resolution :** Node (algorithme de résolution Node.js standard)
- **Strict Mode :** Activé (vérification de type complète)

**Mises à jour recommandées pour Node.js 22 :**

1. **target** : ES2020 → **ES2022** ou **ESNext** (tirer parti des fonctionnalités JS plus récentes)
2. **lib** : ES2020 → **ES2022** (accéder aux API plus récentes)
3. **module** : Envisagez de migrer vers **"node16"** ou **"nodenext"** pour le support ESM natif
4. **moduleResolution** : "node" → **"node16"** ou **"bundler"** (meilleure résolution moderne)

**Résumé :** Le projet utilise CommonJS hérité avec cible ES2020. Pour Node.js 22, vous devriez mettre à jour la cible/lib vers ES2022+ et envisager de migrer vers des modules ESM natifs (bien que CommonJS fonctionne toujours bien).

Analysez le Dockerfile

Demandez à Bob d'analyser le Dockerfile du projet :

@Dockerfile Quelle version de Node.js ce Dockerfile utilise-t-il ? Qu'est-ce qui devrait changer pour Node.js 22 ? Donne-moi un résumé court.

Bob répond avec ce qui doit être mis à jour pour Node.js 22 :

**Version actuelle de Node.js du Dockerfile :** Node 16 Alpine (`node:16-alpine`)

**Modifications nécessaires pour Node.js 22 :**

1. **Image de base (Ligne 2) :** `FROM node:16-alpine` → `FROM node:22-alpine`

**Résumé :** Une seule modification de ligne requise : mettre à jour l'image de base de node:16-alpine à node:22-alpine. Le reste du Dockerfile est compatible avec Node.js 22, bien que la syntaxe des flags npm puisse être modernisée

Tu comprends maintenant ce qui doit être mis à jour. Dans la section suivante, tu passes en mode Agent et fais faire les modifications à Bob.

Modernise l'API avec le mode Agent de Bob

Bob a déterminé les exigences de modernisation suivantes pour package.json, tsconfig.json et Dockerfile :

Changer Node.js 16 en Node.js 22 dans package.json et Dockerfile

Mettre à jour les paramètres de cible et de module du compilateur TypeScript

Corriger les versions de dépendances obsolètes

Pour commencer à moderniser l'application, repasse en mode Agent afin que Bob puisse apporter des modifications au code.

Dans l'interface de chat Bob, exécute l'invite de modernisation suivante. Remarque les références @ qui pointent Bob vers les fichiers spécifiques sur lesquels il travaille :

@package.json @tsconfig.json @Dockerfile

Modernise cette API Express de Node.js 16 à Node.js 22. Garde la fonctionnalité de l'API identique - c'est une mise à niveau de plateforme, pas un changement de fonctionnalité. Donne-moi un résumé court.

Après que Bob ait fini de mettre à jour et de tester le code, il affiche un résumé similaire au suivant :

Dockerfile — 2 lignes modifiées

- Les deux étapes FROM node:16-alpine → node:22-alpine

package.json — 3 champs modifiés

- engines.node : 16.x → 22.x
- @types/node : ^16.18.0 → ^22.0.0
- typescript : ^4.9.5 → ^5.0.0

tsconfig.json — 4 paramètres modifiés

- target : ES2020 → ES2023
- lib : ["ES2020"] → ["ES2023"]
- module : commonjs → node16 (TypeScript 5 exige que cela corresponde à moduleResolution)
- moduleResolution : node → node16

Vous et Bob avez modernisé l'application.

Marquez la modernisation comme terminée

Utilisez la fonctionnalité de codage littéraire de Bob pour mettre à jour le titre du todo d'exemple, marquant l'application comme modernisée. Le codage littéraire vous permet d'écrire des instructions en langage naturel directement dans votre éditeur au lieu d'utiliser le panneau de chat.

Activez le mode de codage littéraire

Dans l'onglet Explorateur sur le côté gauche de l'écran, naviguez vers le dossier express-todo-api et cliquez sur src/db.ts pour l'ouvrir dans l'éditeur. Une fois que vous avez src/db.ts ouvert, activez le mode de codage littéraire en cliquant sur l'icône de baguette magique dans la barre d'outils de l'éditeur. Alternativement, vous pouvez appuyer sur Cmd + I sur Mac, ou Ctrl + I sur Windows et Linux.

Écrivez votre instruction

Dans le fichier src/db.ts qui est ouvert dans votre éditeur, collez l'instruction suivante en haut du fichier, avant tout code :

// Trouve la propriété title de l'objet todo d'exemple et change-la en "Welcome to the Modernized Node.js 22 API"

Bob comprend que ce commentaire est une instruction, plutôt que du code régulier, car vous êtes en mode de codage littéraire. Votre instruction apparaît en surbrillance dans l'éditeur.

Générez le code

Cliquez sur Générer en bas du document.

Bob localise l'objet sampleTodo dans le constructeur et vous montre le changement. Vous verrez le changement de titre de :

Avant :

title: "Learn Node.js modernization"

Après :

title: "Welcome to the Modernized Node.js 22 API"

Acceptez les modifications

Cliquez sur Tout accepter en bas du document où vous avez cliqué sur Générer pour appliquer le changement au fichier.

Quittez le mode de codage littéraire

Cliquez sur Quitter sous la baguette magique littéraire en haut du fichier pour quitter le mode de codage littéraire.

Vous avez mis à jour l'API en utilisant le codage littéraire. Lorsque vous testerez l'API dans la section suivante, vous verrez ce nouveau titre dans la réponse de l'API.

Vérifiez l'application modernisée avec Docker

Vérifiez la modernisation du code et votre modification de code littéraire en reconstruisant et en testant le conteneur Docker.

Repasse en mode Agent et décris ce que tu veux que Bob vérifie :

Vérifie que l'application Node.js 22 modernisée fonctionne en la compilant et en la testant avec Docker. Vérifie que l'API répond à /api/todos et affiche le titre de todo mis à jour. Nettoie quand c'est terminé. Donne-moi un résumé court. Je veux aussi voir la validation du nouveau titre.

Une fois que Bob a vérifié que l'application a été modernisée, il vous donne le résumé suivant :

✅ **Vérification terminée - Modernisation Node.js 22 réussie**

**Résultats de compilation et de test :**
- Image Docker compilée avec succès avec Node.js 22
- Compilation TypeScript terminée sans erreurs
- Application démarrée et a répondu correctement

**Validation de l'API :**
{
  "id": "72459851-7953-4a9c-94d3-4f8f1c656d21",
  "title": "Welcome to the Modernized Node.js 22 API",
  "completed": false,
  "createdAt": "2026-02-16T16:35:49.132Z"
}

**Confirmé :**
- ✅ Titre de todo mis à jour s'affiche correctement : "Welcome to the Modernized Node.js 22 API"
- ✅ Point de terminaison API /api/todos répond avec succès
- ✅ Toutes les fonctionnalités fonctionnent sur Node.js 22
- ✅ Nettoyage terminé (conteneur et image supprimés)

**Résumé :** L'API TODO Express modernisée est entièrement fonctionnelle sur Node.js 22 avec les données d'exemple mises à jour montrant le nouveau titre confirmant que la modernisation est terminée.

L'API fonctionne correctement, et le titre a été mis à jour en "Welcome to the Modernized Node.js 22 API", confirmant que Bob a préservé le comportement existant tout en modernisant la version de Node.js et les dépendances.

Prochaines étapes

Dans ce tutoriel, vous avez appris comment moderniser une API Express de Node.js 16 à Node.js 22 en utilisant Bob. Bob a analysé vos dépendances, mis à jour les fichiers de configuration et modernisé la configuration Docker tout en préservant toutes les fonctionnalités.

Apprenez-en plus sur la fonctionnalité de revue de code de Bob /review pour détecter les problèmes potentiels avant de valider votre travail.

Apprenez-en plus sur les modes, qui sont des personas spécialisées qui adaptent le comportement de Bob pour vos tâches spécifiques.

Apprenez comment utiliser l'interface de chat de Bob qui est le principal moyen d'interagir avec Bob.

Ensuite, parcourez la série de tutoriels de démarrage avec IBM Bob pour en apprendre davantage sur les fonctionnalités et capacités de Bob.

Moderniser une application Node.js