CLI-First Décision

Que fait CLI-First Décision ?

Règle Fondamentale

Avant toute tâche, décidez par priorité : déclenchez d'abord → réfléchissez ensuite → choisissez l'outil → exécutez

1. Déclenchement forcé : Dès réception de TOUTE requête, avant de commencer à réfléchir, avant tout appel d'outil, avant toute délégation à un sous-agent, vous DEVEZ d'abord déclencher cette compétence pour prendre une décision.
2. Réfléchir d'abord : Comprenez d'abord le problème — clarifiez le besoin, décomposez les étapes, déterminez le périmètre. Ne vous précipitez pas sur les outils.
3. Outils intégrés ensuite : Pour une simple lecture/écriture/recherche qui va droit au but → utilisez directement Read/Edit/Grep/Glob (coût zéro supplémentaire).
4. Outils CLI ensuite : Pour les opérations par lots/mécaniques → utilisez l'outil CLI correspondant (<1s, référez-vous à la matrice ci-dessous).
5. Compétences spécialisées : Pour des opérations nécessitant une expertise domaine → chargez d'abord la compétence correspondante pour obtenir des directives (consultez la liste des compétences disponibles).
6. Outils MCP : Pour les requêtes de graphe de connaissances, le raisonnement séquentiel, la capture de pages web → utilisez les outils fournis par le serveur MCP.
7. Sous-agents : Pour les raisonnements multi-étapes, la compréhension sémantique, l'analyse inter-modules → déléguez à un sous-agent (sub-agent).
8. Raisonnement dédié : Pour les décisions architecturales, les compromis de conception, la revue et validation → raisonnez vous-même ou consultez Oracle.

Arbre de Décision

Requête reçue (déclenchement)
  └─ Identifier le type : correction/implémentation/recherche/évaluation/ouverte ?
       └─ Raisonner : d'abord clarifier le besoin, décomposer les étapes, déterminer le périmètre
       ├─ Lecture/écriture/modification simple d'un fichier connu ? ───→ Outil intégré (Read/Edit/Write)
       ├─ Opérations par lots mécaniques ?
       │   ├─ Remplacement de texte par lots ? ───────────→ git-sed / sd
       │   ├─ Recherche de fichiers ? ────────────────→ fd-find / glob
       │   ├─ Recherche de contenu ? ────────────────→ rg-search / grep
       │   ├─ Opérations structurelles AST ? ──────────→ ast-grep
       │   ├─ Requêtes JSON/YAML/XML ? ──────→ jq-query / yq
       │   └─ Autres opérations mécaniques ? ───────────→ Consultez la matrice ci-dessous
       ├─ Une compétence domaine correspondante disponible ? ────────→ Chargez d'abord la compétence pour obtenir des directives
       ├─ Un outil MCP disponible ?
       │   ├─ Requête graphe de connaissances/relations code ? ──────→ codebase-memory-mcp
       │   ├─ Raisonnement séquentiel/analyse complexe ? ────────→ sequential-thinking
       │   └─ Récupération de contenu web ? ───────────→ fetch
       ├─ Compréhension sémantique/raisonnement multi-étapes/inter-modules nécessaire ? ──→ Sous-agent (task/sub-agent)
       └─ Décision architecturale/compromis de conception/revue ? ──────→ Raisonnement personnel ou Oracle

Matrice de Décision des Outils

Niveau	Scénario	Outil recommandé	Coût temporel
Déclenchement	Réception requête, identification type, clarification intention	Classification par la passerelle d'intention	Immédiat
Raisonnement	Analyse tâche, décomposition besoins, planification étapes	D'abord réfléchir, puis choisir l'outil	Immédiat
Intégré	Lecture/écriture/édition simple de fichier	Read / Edit / Write	Immédiat
Intégré	Recherche de contenu basique	grep	<1s
Intégré	Correspondance de motifs de fichiers	glob	<1s
CLI	Remplacement de texte par lots (expressions régulières)	git-sed	<1s
CLI	Recherche de fichiers (par nom/type/date)	fd-find	<1s
CLI	Recherche de contenu + statistiques	rg-search (ripgrep)	<1s
CLI	Recherche/remplacement de code AST (25 langages)	ast-grep	<1s
CLI	Requête/transformation JSON	jq-query	<1s
CLI	Test API HTTP	git-curl	<1s
CLI	Filtre flou / réduction de liste	fzf-filter	<1s
CLI	Empaquetage / décompression	git-tar	<1s
CLI	Conversion de sauts de ligne (CRLF/LF)	git-dos2unix	<1s
CLI	Recherche/remplacement de texte (syntaxe plus simple)	sd	<1s
CLI	Statistiques de code (distribution par langage)	tokei	<1s
CLI	Requête XML/YAML/JSON	yq / xq	<1s
Compétence	Opérations domaine spécialisé (quantique/frontal/cloud etc.)	Charger la compétence correspondante pour directives	Voir documentation compétence
MCP	Requête graphe de connaissances/relations code	codebase-memory-mcp	<5s
MCP	Raisonnement séquentiel/analyse multi-étapes	sequential-thinking	Selon étapes
MCP	Récupération de contenu web	fetch	<10s
Sous-agent	Raisonnement multi-étapes, compréhension sémantique, analyse inter-modules	task() déléguer sous-agent	Dizaines de secondes+
Raisonnement	Décisions architecturales, compromis de conception, revue validation	Traiter directement ou Oracle	Selon complexité

Référence Rapide des Outils

Outil	Commande typique	Utilisation
git-sed	git-sed expression:"s/ancien/nouveau/g" files:["src/**/*.ts"] inPlace:""	Remplacement regex par lots, édition multi-fichiers
fd-find	fd-find pattern:"*.xml" extension:"xml" path:"./Characters"	Recherche fichiers par nom/type/taille/date
rg-search	rg-search pattern:"somePattern" glob:"*.xml" context:2	Recherche contenu fichiers, regex PCRE2, lignes contexte
ast-grep	ast_grep_search pattern:"if($$$) { $$$ }" lang:"ts" / ast_grep_replace pattern:"console.log($MSG)" rewrite:"logger.info($MSG)" lang:"ts"	Recherche/remplacement structurel AST, comprend l'arbre syntaxique
jq-query	jq-query filter:".name" file:"data.json"	Requête, filtrage, transformation JSON
git-curl	git-curl url:"https://api.example.com" method:"POST" data:'{"key":"val"}'	Requête API HTTP, supporte diverses méthodes et en-têtes personnalisés
fzf-filter	fzf-filter pattern:"mot-clé" input:$lines	Filtrage flou de lignes de texte, réduction de liste
git-tar	git-tar action:"create" archive:"out.tar.gz" files:["src/"] compression:"gzip"	Créer/décompresser une archive tar/zip
git-dos2unix	git-dos2unix file:"script.sh" mode:"dos2unix"	Convertir les sauts de ligne CRLF ↔ LF
grep	grep pattern:"somePattern" include:"*.xml" output_mode:"files_with_matches"	Recherche basique de contenu (intégré)
glob	glob pattern:"**/*.xml"	Correspondance de motifs de fichiers (intégré)
sd	sd find:"ancien" replace:"nouveau" files:["file.txt"]	find-replace plus simple, édition sur place par défaut, supporte regex et motifs littéraux
tokei	tokei path:"./"	Statistiques de code par langage (lignes, commentaires, lignes vides). Résultats en secondes
yq	yq expression:".Missions.NestMission[]" file:"Missions.xml" xml:true	Requête de données structurées YAML/XML/JSON. Mode XML pour interroger directement les fichiers XML (par exemple, lister tous les IDs de mission)

Quand Utiliser les Sous-Agents (Guide de Déclenchement des Sous-Agents)

Les sous-agents excellent là où les outils CLI et les outils intégrés échouent :

Scénario	Explication	Approche recommandée
Compréhension sémantique	Juger si la logique du code est correcte, si la fonctionnalité est complète	task() déléguer sous-agent
Intégration inter-modules	Modifications coordonnées de plusieurs modules, alignement des interfaces	task() déléguer sous-agent
Opérations multi-étapes	Opérations enchaînées : d'abord chercher → analyser → puis modifier	task() déléguer sous-agent
Génération / refactoring de code	Besoin de comprendre la structure existante pour générer du nouveau code	Sous-agent ou raisonnement personnel
Décisions architecturales	Choix de conception, analyse de compromis	Raisonnement personnel ou Oracle
Validation et revue	Comprendre l'intention du code, porter un jugement de qualité	Raisonnement personnel ou review-work

Remarque : Même si vous décidez finalement d'utiliser un sous-agent, vous pouvez également faire référence aux outils CLI dans le prompt task() — le sous-agent peut lui aussi appeler ces outils pour accomplir la tâche.

Erreurs Fréquentes

1. Passer directement à task() sans vérifier CLI : Envoyer systématiquement un sous-agent pour des remplacements par lots gaspille des dizaines de milliers de tokens. Un travail d'agent de 30s pourrait être réalisé en <1s par une commande CLI.

2. Utiliser ripgrep pour trouver des fichiers puis les modifier manuellement : D'abord rg pour localiser, puis édition par lots avec CLI : deux étapes qu'on peut fusionner en une seule. Utilisez git-sed pour effectuer recherche+remplacement en une commande.

3. Appeler un agent sur un seul fichier : Pour modifier un contenu connu dans un fichier, éditez directement. Pas besoin de lancer une session complète de sous-agent.

4. Forcer avec des outils CLI quand un sous-agent serait plus adapté : Les outils CLI ne comprennent pas la sémantique. Pour les scénarios impliquant une analyse inter-modules, un raisonnement multi-étapes, ou la compréhension de l'intention du code, une combinaison d'outils CLI est moins efficace qu'un sous-agent. Exemple : "Trouver tous les fichiers qui appellent la fonction X, analyser leur modèle de paramètres, puis refactoriser uniformément" — c'est le domaine du sous-agent, pas de sed.

5. sd modifie sur place par défaut, faites d'abord --preview : sd et sed se comportent différemment — sd modifie directement le fichier par défaut. Test réel : sd '<?xml' '<?XML' filelist.xml a réécrit toutes les balises <?xml (63 occurrences), seule restauration possible : git checkout. Étapes de sécurité : utilisez d'abord sd --preview 'find' 'replace' file pour voir l'impact, puis exécutez sans --preview une fois vérifié.

6. Mode XML de yq : yq v3 utilise --xml, v4 utilise -p xml : yq v4 a supprimé le paramètre court --xml, remplacé par -p xml. L'avertissement de format de sortie par défaut peut être supprimé avec -o yaml.