Création d'applications CLI en TypeScript : aperçu des frameworks et outils

Frameworks CLI pour TypeScript : créons des applications console puissantes

Le développement d'interfaces en ligne de commande (CLI) en TypeScript ne se limite pas à écrire un analyseur d'arguments. Les applications CLI modernes peuvent être interactives, colorées, prendre en charge l'auto-complétion et même afficher des graphiques animés. Pour cela, il existe des frameworks et des bibliothèques spécialisés. Dans cet article, nous allons analyser quatre outils clés pour créer des CLI en TypeScript : Commander.js, Ink, Oclif et Yargs. Vous découvrirez leurs points forts, obtiendrez des exemples de code prêts à l'emploi et comprendrez quel outil convient à votre tâche.

1. Commander.js — classique et simplicité

Commander.js est le framework le plus populaire pour créer des CLI sur Node.js et TypeScript. Il propose une API déclarative pour décrire les commandes, les arguments et les options. Grâce à la prise en charge intégrée de TypeScript, vous bénéficiez de l'auto-complétion et de la vérification des types.

Fonctionnalités principales :

• Génération automatique de l'aide (--help).
• Prise en charge des commandes imbriquées (sous-commandes).
• Validation des arguments obligatoires.
• Système d'options flexible : booléennes, chaînes de caractères, avec valeurs par défaut.

Exemple d'un CLI simple avec Commander.js + TypeScript :

import { Command } from 'commander';

const program = new Command();

program  .name('greet')  .description('CLI pour saluer')  .version('1.0.0');

program  .command('hello')  .argument('<name>', 'Nom de l\\'utilisateur')  .option('-l, --lang <language>', 'Langue de salutation', 'fr')  .action((name, options) => {    if (options.lang === 'en') {      console.log(`Hello, ${name}!`);    } else {      console.log(`Bonjour, ${name}!`);    }  });

program.parse(process.argv);

Commander.js est idéal pour les utilitaires simples et les scripts d'automatisation. Il n'est pas surchargé de dépendances inutiles et est bien documenté.

2. Ink — CLI réactif avec composants

Ink est un framework unique qui permet de construire des interfaces CLI à l'aide de composants de type React. Vous écrivez en JSX, et Ink le rend dans le terminal. Combiné avec TypeScript, vous obtenez un typage strict des composants.

Caractéristiques clés :

• Approche par composants : <Text>, <Box>, <Spacer>.
• Mise à jour automatique lors du changement d'état (réactivité).
• Prise en charge des animations, des indicateurs de chargement, des barres de progression.
• Intégration approfondie avec les hooks React (useInput, useApp).

Exemple d'un CLI interactif avec Ink :

import React, { useState } from 'react';import { render, Text, Box, useInput } from 'ink';

const Counter = () => {  const [count, setCount] = useState(0);

  useInput((input) => {    if (input === '+') setCount(prev => prev + 1);    if (input === '-') setCount(prev => prev - 1);  });

  return (    <Box>      <Text>Compteur : {count}. Appuyez sur '+' ou '-'</Text>    </Box>  );};

render(<Counter />);

Ink convient aux utilitaires interactifs complexes, aux assistants d'installation, aux tableaux de bord dans le terminal. C'est le meilleur choix si vous avez besoin d'une interface belle et réactive.

3. Oclif — framework pour CLI évolutifs

Oclif (Open CLI Framework) de Heroku est un framework complet pour créer des applications CLI de toute complexité. Il prend en charge les plugins, les mises à jour automatiques, les hooks et la génération de projets.

Points forts :

• Générateur de code intégré (oclif generate).
• Prise en charge de TypeScript prête à l'emploi.
• Système de plugins pour étendre les fonctionnalités.
• Mise à jour automatique du CLI via npm.

Exe