Analysez des arguments CLI selon une spécification
Transformez un tableau brut d’arguments de ligne de commande en objet prévisible sans disperser les règles d’analyse dans toute votre application.
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Fournissez les éléments ainsi qu’une spécification compacte qui nomme chaque indicateur booléen et chaque option exigeant une valeur. L’analyseur associe les alias aux noms canoniques, conserve les arguments positionnels, identifie les indicateurs inconnus, accepte les options longues avec un signe égal et arrête l’interprétation après le marqueur conventionnel à deux tirets. Les spécifications incorrectes, les arguments répétés et les options privées de leur valeur obligatoire produisent des erreurs de saisie explicites.
Décrivez l’interface de commande sous forme de données
Commencez par les éléments d’argument tels que l’environnement d’exécution les fournit, après retrait du nom de l’exécutable et de celui du script. Définissez ensuite chaque argument accepté dans la spécification. Chaque entrée possède un nom canonique, un ou plusieurs alias et un type. Utilisez flag pour un indicateur dont la présence signifie vrai, tel que <code>--verbose</code>. Utilisez option lorsque l’écriture doit être suivie d’une valeur, comme <code>--output result.json</code>. Les alias permettent aux formes courte et longue d’alimenter la même propriété : <code>-o</code> et <code>--output</code> peuvent ainsi produire <code>output</code>. Les noms canoniques emploient des lettres minuscules, des chiffres et des traits de soulignement afin que l’objet retourné soit exploitable sans renommage supplémentaire. Les alias doivent commencer par un ou deux tirets. L’analyseur refuse les noms canoniques et alias en double, car ces collisions rendraient le résultat dépendant de l’ordre de déclaration. Activez <code>multiple</code> uniquement si la répétition est prévue par l’interface ; les valeurs suivent alors leur ordre d’apparition.
Comprenez l’analyse des éléments et le résultat
Le résultat distingue les valeurs reconnues, les éléments positionnels et les indicateurs inconnus. Un indicateur reconnu devient vrai sous son nom canonique, tandis qu’une option enregistre l’élément suivant. Une option longue peut aussi porter sa valeur dans le même élément, comme <code>--format=json</code>. La correspondance est exacte : les groupes courts tels que <code>-abc</code> ne sont pas décomposés, sauf si cette écriture complète est déclarée comme alias. Tout élément inconnu commençant par un tiret rejoint <code>unknown_flags</code> ; vous pouvez ainsi le refuser, afficher un avertissement ou le transmettre volontairement. Les autres éléments inconnus deviennent des valeurs positionnelles. Un <code>--</code> isolé met fin au traitement des options, puis chaque élément est positionnel, même s’il commence par un tiret. Cet échappement conventionnel évite toute ambiguïté pour un fichier comme <code>-draft.txt</code>. L’analyseur ne crée aucune valeur par défaut et ne convertit pas les chaînes en nombres, car ces choix relèvent de l’application et pourraient masquer une erreur. Le résultat reste déterministe et ordonné.
Gérez sûrement les valeurs absentes et les répétitions
Toute entrée de type option exige une valeur non vide chaque fois qu’un de ses alias apparaît. Si cet alias est le dernier élément, précède le marqueur de fin des options ou est suivi d’un autre élément ayant la forme d’un indicateur, l’analyse échoue avec une erreur de saisie qui nomme l’alias concerné. La même règle vaut pour une forme jointe vide telle que <code>--output=</code>. Ce comportement strict empêche qu’un indicateur ultérieur soit absorbé silencieusement comme donnée et traite directement l’une des erreurs d’analyse les plus dangereuses. Un tiret seul peut néanmoins servir de valeur, ce qui convient aux programmes représentant l’entrée ou la sortie standard par <code>-</code>. Par défaut, répéter un argument reconnu provoque également une erreur. Déclarez <code>multiple: true</code> lorsque la répétition est légitime, par exemple pour plusieurs chemins d’inclusion ou étiquettes ; le nom canonique contiendra alors toujours une liste. Les indicateurs inconnus sont signalés sans causer d’échec, afin que vous gardiez la maîtrise des règles de compatibilité et de transmission.
Cas d’usage
Validez un wrapper CLI
Analysez les options propres au wrapper et signalez les indicateurs non pris en charge avant de lancer le processus encapsulé.
Normalisez les options courtes et longues
Associez des alias comme -o et --output à une propriété stable afin de simplifier la logique de l’application.
Créez des aperçus et des tests
Convertissez des tableaux d’éléments en fixtures structurés et déterministes sans exécuter de commande ni ouvrir de shell.
Questions fréquentes
Quel est le tarif ?
Chaque requête API coûte $0.002. La version pour navigateur exécute localement la même logique déterministe.
Les indicateurs inconnus sont-ils refusés ?
Non. Ils sont renvoyés dans unknown_flags afin que vous puissiez les refuser, les signaler ou les transmettre.
La syntaxe --name=value est-elle acceptée ?
Oui, pour les options longues exigeant une valeur. Une valeur vide après le signe égal provoque une erreur.
Les indicateurs courts comme -abc sont-ils combinés ?
Non. Les alias correspondent à des éléments entiers ; -abc n’est reconnu que si la spécification déclare exactement cet alias.
Que se passe-t-il après deux tirets isolés ?
L’analyse des options s’arrête et tous les éléments restants sont renvoyés comme arguments positionnels.
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev2/cli-arg-parse-spec \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"args":["--verbose","--output=result.json","input.txt"],"spec":[{"name":"verbose","aliases":["--verbose","-v"],"kind":"flag"},{"name":"output","aliases":["--output","-o"],"kind":"option"}]}'const res = await fetch("https://api.kit.forhosting.com/dev2/cli-arg-parse-spec", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"args": [
"--verbose",
"--output=result.json",
"input.txt"
],
"spec": [
{
"name": "verbose",
"aliases": [
"--verbose",
"-v"
],
"kind": "flag"
},
{
"name": "output",
"aliases": [
"--output",
"-o"
],
"kind": "option"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/cli-arg-parse-spec",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"args": [
"--verbose",
"--output=result.json",
"input.txt"
],
"spec": [
{
"name": "verbose",
"aliases": [
"--verbose",
"-v"
],
"kind": "flag"
},
{
"name": "output",
"aliases": [
"--output",
"-o"
],
"kind": "option"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/cli-arg-parse-spec", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"args":["--verbose","--output=result.json","input.txt"],"spec":[{"name":"verbose","aliases":["--verbose","-v"],"kind":"flag"},{"name":"output","aliases":["--output","-o"],"kind":"option"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"args":["--verbose","--output=result.json","input.txt"],"spec":[{"name":"verbose","aliases":["--verbose","-v"],"kind":"flag"},{"name":"output","aliases":["--output","-o"],"kind":"option"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/cli-arg-parse-spec", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"args": [
"--verbose",
"--output=result.json",
"input.txt"
],
"spec": [
{
"name": "verbose",
"aliases": [
"--verbose",
"-v"
],
"kind": "flag"
},
{
"name": "output",
"aliases": [
"--output",
"-o"
],
"kind": "option"
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.cli_arg_parse_spec",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |