CLI Creator

Que fait CLI Creator ?

Routeur pour construire et auditer des outils CLI Python de qualité production et des compétences/modèles CLI associés. Utilisez-le pour décider de la forme de la CLI, garder la surface de commande réduite, préserver l'installabilité et imposer des rapports d'audit. Cette compétence reste légère : lisez uniquement les références dont vous avez besoin.

Quand l'utiliser

• Nouvelle CLI Python ou arbre de commandes.
• Refonte, simplification ou nettoyage d'empaquetage d'une CLI.
• Révision/audit d'une CLI, incluant UX, configuration, erreurs, cache et flux de publication.
• Compétence d'agent, modèle ou squelette qui se comporte comme un package CLI.
• Vérification du comportement d'installation, de wheel ou de console-script.

Sélection du type de CLI

Type	Biais
Utilitaire orienté commande	Routeur minimal, codes de sortie stricts, sortie JSON/texte brut.
Outil piloté par configuration	Découverte de configuration, précédence, reproductibilité.
Assistant interactif	Machine à états/flux, invites, récupération.
CLI hybride	Petit arbre de commandes plus orchestration réutilisable.
CLI à forte exigence de performance	Imports différés, E/S bornées, cache/progression.
CLI extensible/avec plugins	Contrat d'extension stable et registre.

N'imposez pas une architecture d'assistant à un outil orienté commande. N'imposez pas une forme de script unique à un produit en pleine croissance.

Règles fondamentales

• Préférez la CLI la plus petite qui résout le travail de l'utilisateur.
• Utilisez le chemin CLI minimal/YAGNI : si l'outil a une ou deux commandes, pas d'état persistant, pas de réseau, pas de plugins et pas d'informations d'identification, gardez-le minuscule ; n'ajoutez pas Rich, Pydantic, platformdirs, couches de cache, doctor ou registres de plugins à moins qu'ils ne résolvent un problème immédiat.
• Gardez les noms, drapeaux, codes de sortie, clés de configuration et modes de sortie stables.
• Rendez les valeurs par défaut utiles et sûres.
• Séparez le routage, la logique métier, les E/S, la configuration, la persistance, le rendu et les intégrations.
• Gardez la sortie machine scriptable avec un mode JSON ou texte brut.
• Vérifiez que la commande README est le script console installé.

Règles de chargement des références

Ne lisez que les références nécessaires à la tâche :

• Création ou refonte : references/creation-playbook.md.
• Révision ou audit : references/review-rubric.md et references/pitfalls-and-solutions.md.
• Détails d'implémentation, empaquetage, sécurité, comportement multiplateforme, sortie Rich, cache ou fournisseurs LLM : references/technical-best-practices.md.
• Pour la maintenance des compétences/packages, consultez les dossiers de gouvernance à la racine de l'espace de travail skill-ir/, evals/, scripts/, reports/ et registry/ lorsqu'ils existent. Ce sont des aides de routage pour le responsable, pas embarquées dans une copie installée de la compétence.

Ne dupliquez pas ces références ici. Chargez-les uniquement lorsque la tâche en cours en a besoin.

Flux de création d'une nouvelle CLI ou compétence

1. Déterminez la forme du produit : qui l'exécute, sous quelle pression il se trouve, ce qui doit être mis en cache, mémorisé ou oublié.
2. Concevez la surface de commande avec quelques commandes stables et des exemples concrets.
3. Choisissez la pile la plus petite qui convienne.
   • Typer ou Click pour la plupart des CLI.
   • argparse uniquement pour les petits outils compatibles avec la bibliothèque standard.
4. Choisissez la plus petite architecture qui survivra aux deux prochaines versions.
5. Implémentez la boucle produit : entrée, validation, exécution, rendu, persistance, code de sortie, indice de récupération.
6. Vérifiez avant de publier.

Exemples de surface de commande

my-cli run
my-cli init
my-cli config show
my-cli doctor
my-cli cache clear
my-cli check CHEMIN
my-cli fetch REQUETE --json
my-cli export ID --output resultat.md

Règles :

• Utilisez des arguments pour les objets métier requis.
• Utilisez des options pour les modificateurs, les modes de sortie et le comportement facultatif.
• Fournissez --json ou --format json pour l'automatisation.
• Fournissez --quiet, --verbose et --debug de manière cohérente.
• Évitez les accès réseau ou mutations surprenants dans les commandes qui semblent en lecture seule.

Attentes de vérification

Vérifiez toujours la surface de commande, le chemin d'installation et le chemin de la wheel lorsqu'ils sont importants :

• --help pour la commande racine et chaque commande de premier niveau.
• Installation propre dans un nouvel environnement.
• Chemin de configuration manquante ou de première exécution lorsque l'outil a une configuration.
• Chemin de configuration invalide ou d'erreur lorsque l'outil valide les entrées.
• Chemin de succès plus mode JSON/scriptable lorsqu'il est pris en charge.
• Rafraîchissement et effacement du cache lorsque l'outil a un cache.
• Métadonnées d'empaquetage et script console.
• Installation de la wheel depuis l'extérieur du référentiel lorsque vous voulez une confiance d'installation.

Utilisez ce pack compact lorsque cela s'applique :

uv venv /tmp/cli-audit
. /tmp/cli-audit/bin/activate
uv pip install -e .
cli-creator-skill --help
cli-creator-skill install
uv build
uv pip install dist/*.whl
python -m pytest

Flux de révision

Lors de l'audit d'une CLI existante ou d'une compétence/modèle CLI associé :

Avant de réviser, lisez :

• references/review-rubric.md
• references/pitfalls-and-solutions.md

Lisez references/technical-best-practices.md lorsque l'audit touche aux détails d'implémentation, à l'empaquetage, à la sécurité, au comportement multiplateforme, à la sortie Rich, à la mise en cache ou aux fournisseurs LLM.

Ensuite :

1. Inspectez la forme du référentiel : structure du package, points d'entrée des commandes, fichiers de configuration, tests, documentation, CI.
2. Exécutez l'aide : --help racine et aide au niveau des commandes.
3. Tracez une commande réussie du callback au service métier jusqu'au moteur de rendu.
4. Tracez un chemin d'échec et inspectez la qualité des erreurs.
5. Vérifiez la précédence de la configuration : drapeaux, environnement, configuration du projet, configuration de l'utilisateur, valeurs par défaut.
6. Vérifiez la sécurité : secrets, exécution de shell, gestion des chemins, configuration/plugins non sécurisés, télémétrie, timeouts des sous-processus, chaîne d'approvisionnement des dépendances.
7. Vérifiez les performances : imports au démarrage, timeouts réseau, comportement du cache, découverte de fichiers.
8. Vérifiez l'automatisation : codes de sortie, sortie JSON, séparation stdin/stdout/stderr, comportement non-TTY.
9. Vérifiez l'empaquetage : version Python, dépendances, scripts, wheels, commandes README.
10. Notez chaque zone de la grille d'évaluation avec references/review-rubric.md.
11. Présentez d'abord les résultats, puis les correctifs priorisés.

Rapport d'audit requis

Le rapport d'audit doit inclure ces sections, dans cet ordre :

**Résultats**

**Scores**

| Domaine | Score | Notes |
|---|---:|---|

**Ordre de réparation**

**Lacunes des tests**

**Commandes de vérification**

Notes de maintenance

• Gardez cette compétence comme un routeur ; placez les détails d'implémentation dans les quatre références.
• Gardez les exemples de commandes, les titres d'audit et le pack de vérification synchronisés avec la version du package.
• Pour la gouvernance côté responsable, utilisez les dossiers skill-ir/, evals/, scripts/, reports/ et registry/ à la racine de l'espace de travail lorsqu'ils sont présents ; ne prétendez pas qu'ils font partie de la compétence installée.

À quoi sert cette compétence

• Concevoir une nouvelle CLI Python à partir de zéro.
• Réviser une CLI existante pour l'UX, l'empaquetage, les erreurs, la configuration du modèle, la mise en cache et la maintenabilité.
• Structurer des applications Typer, Click, argparse ou hybrides.
• Construire des flux CLI multitours naturels sans donner aux utilisateurs l'impression de remplir un formulaire.
• Ajouter des diagnostics, du cache, de la mémoire de profilage et des flux de configuration de première exécution lorsqu'ils sont réellement nécessaires.
• Réviser les compétences et modèles CLI associés pour la clarté des déclencheurs, l'exhaustivité des références, les modèles de commandes, les contrats de sortie et la stratégie de maintenance.

Base de conception

Cette compétence distille l'expérience du responsable et les modèles de documentation officielle pour l'empaquetage Python, Typer, Click, Rich, uv, Ruff, Pydantic et l'intégration des fournisseurs LLM. Elle ne contient pas de code ni d'instructions provenant de référentiels tiers non officiels.