cli-guidelines VS argparse-benchmarks-rs

The Command Line Interface Guidelines [1] says:

> Do not read secrets from environment variables

> Secrets should only be accepted via credential files, pipes, `AF_UNIX` sockets, secret management services, or another IPC mechanism

Which one of these do you use? On github it seems common for projects to use environment variables for secrets.

[1] https://clig.dev/#environment-variables

Seems they took a small step back from their previous "don't bother with man pages" stance. Now it's "Consider providing man pages."

I still find it a rather shocking order of priority, honestly.

https://clig.dev/#documentation

- E. `blah project foo --edit`

Wondering if there was any guidance on this from the UNIX people. Perhaps scoping should be done using the file system. `cd path/to/project && blah edit`. Like git does with `git --cwd=path/to/project`. Maybe a virtual FS could even be used. Then you wouldn't have to continuously type in the scope with each command. Interesting thinking about how to maintain state in the terminal...thinking about how Python's virtual env bin/activate modifies the shell.

Found an interesting guide here: https://clig.dev/

Capturing these guidelines is one of the primary reasons that https://clig.dev/ exists.

You may want to take a look at various existing CLIs to get inspiration on how they operate, the user feedback loop and the ergonomics on using them. Here is a great website on some CLI structing guidance https://clig.dev/

You can check out the argparse-benchmarks-rs though that only gives a high level summary.

So besides the git2 conversation, I'd recommend using an argument parser even if its for something basic like lexopt just for help/version, at least you'd error for unrecognized arguments and can more easily expand it in the future.

Unclear whether it has a solid advantage over other things listed at rust-cli/argparse-benchmarks-rs or whether it's just an "I didn't research what already existed" project.

I'm tempted to collect all of these benchmark repos into a github org to make them easier to find. So far I know of parser, md, argparse, and template languages.

Not strictly an answer to your question, but https://github.com/rust-cli/argparse-benchmarks-rs provides a good survey of option parsing crates in Rust.

As others have mentioned clap is one of the more popular, featureful CLI parsers though it does come at a compile time and binary size cost. We are working on improving that. See argparse-benchmarks for by-the-numbers comparison for the different parsers (ie only stats and no full feature lists). Clap is used by ripgrep, cargo, and many other tools

Compared to lexopt, which inspired this effort, clap_lex makes some different trade offs for flexibility and ergonomics which allows it to handle every case clap needs. There is room for more ergonomic improvements as the MVP was written for clap's needs. argparse-benchmarks-rs has been updated and clap_lex is roughly in line with lexopt for build-times and binary size.

See https://github.com/rust-cli/argparse-benchmarks-rs/blob/main/examples/bpaf-app/app.rs

You can use this link: https://github.com/rust-cli/argparse-benchmarks-rs

btw there are the argparse benchmarks which can be interesting points of comparison (though I haven't decided what is the criteria for being added to it yet).