Not what you asked, but anything that uses a single hyphen for longopts can just fuck off. I'm talking to you Terraform.

A well-designed CLI? Maybe sed. A badly designed CLI? Probably also sed.

I always thought openSUSE's package manager zypper has quite a few neat ideas:

• It offers two-letter shorthands for subcommands, so zypper install→ zypper in, update → up, remove → rm.
• When it lists what packages it will install or remove, it will list them with the first letter highlighted in a different color, kind of like so: fish git texlive
  This makes it really easy to visually scan the package list, and since it's sorted alphabetically, it also makes it easier to find a particular package you might be looking for.
  And while there's separate lists for packages to be added vs. updated vs. removed, they also color those letters in green vs. yellow vs. red, so you can immediately see what's what.
• When it lists items (other than packages), it prints an ID number, too.
  So, zypper repos gives you a list of your repositories, numberered 1, 2, 3 etc., and then if you want to remove a repo, you can run zypper removerepo 3.
• When you run a zypper search, it prints the results in a nicely formatted table.

Documentation: https://doc.opensuse.org/documentation/tumbleweed/zypper/

Honestly, incus.

I know it's not strictly a utility, but holy cow, Stephane Graber and his team have put the work into that product, such that anything you can do in the ui can be done in the CLI, and more.

Tab completion entries for all the resource types (storage, instances, image repos, etc), help entries for everything, it brings a tear to the eye.

I once thought it was cool to have standardised man entries, but even better is context-sensitive --help entries that work well. Almost all the discovery I've made using incus, I've made using the commands themselves.

It's a real testament to how putting in the documentation work might be tedious, but it is a boon to both users and devs.

man

I think it depends a lot on what kind of application you’re thinking of. Here are some examples of tools that I particularly remember for having nice CLI interfaces, but they are all slightly different in terms of the number of operations/entities they support.

Single operation, a lot of different types of data: httpie

httpie is a CLI HTTP client. It allows to generate fairly complex requests, choose which diagnostic information you want to see, etc.

Examples:

$ https httpie.io/hello
$ http PUT pie.dev/put X-API-Token:123 name=John
$ http -v pie.dev/get

Several operations, a lot of parameters: Bazel

Bazel is a build system. There are only a handful of operations you typically perform (build, run, test, query), but they all follow the same pattern.

Examples:

$ bazel build //app
$ bazel --quiet build //app -c opt
$ bazel --quiet run //app -c opt -- --port=1234

Multiple entites, multiple operations: LVM

I really liked the interface of Linux Volume Manager tools. They consist of multiple commands that follow the same pattern, and use the same flags for options.

Examples:

# vgcreate -n vg_name
# vgs
# pvcreate /dev/sda
# vgextend vg_name /dev/sda
# lvcreate vg_name -n lv_name -L5G
# lvresize vg_name/lv_name -L+1G
# lvs

Ncmpcpp. I've been using it for so long that using other cli music players is almost a no go. Learning a new muscle memory wouldn't be worth it. Album art would be nice but I'm listening to music and staring at the album art for hours. The metadata editor is really nice. It's old reliable.

docker's cli makes a lot of sense to me. Anything that supports "application logical-command --help" gets a big tick.

But yeah, bash itself is great.

I like the trend of refining existing tools. You take tried-and-true commands and shave off the rough edges and quirks. I use ripgrep instead of grep, fd instead of find, scm_breeze on top of git, dust instead of du, duf instead of df, z over cd, and xh instead of curl

i’ve been a big fan of Jujutsu (jj) since adopting it a few weeks ago. things i used to avoid with git like proper rebasing and focused commits become so much easier, in addition to the benefits of conflicts being easier to handle. the learning curve i thought was going to be grueling only took a couple days to get used to, and honestly interop with GitHub and my team’s particular workflow were the hard parts. so not only is it useful, powerful, and becoming more important to my workflow all the time, it’s a joy to use compared to git.

i guess honorable mention to zoxide, which has basically replaced cd for me since it does everything cd does but also keeps a small db of your most commonly visited directories so you can just do z Downloads or z my_project or whatever from any directory

My RSS shell script that simply dumps the XML's content nicely formatted on stdout. Seriously, why do all of them have to impose some opinionated TUI on me? Terminals can do bold, dim and underline, that's enough.

Sorry no, not public. It's faulty and ugly and is missing features (multiple sources for one) and i want to rewrite it in python since at least 2 years.

vlc --help outputs text with colors which makes it so much easier to skim

Btop, beautiful and functional.

find and rename/perl-rename/prename (depending on your distro), are two of my favorite cli tools. I generally find both well designed and easy to use. For me, they are indispensable.

nmon

That, along with tmux and htop, are installed on everything I have.

nmon then ld- give me a system health page that shows me where the bottleneck is.

It's interesting to see how a system behaves when you're doing something like a backup... it's not always what you think.

Pure cli or also TUI? When it comes to TUI probably yazi is my most used tool right now, use it pretty much every day. For pure cli i would probably give my vote to sed. I use the crap out of it in a bunch of scripts. For example i switch my themes with it by replacing whatever import i had in the config to the desired theme, then reload the programs.

uuuuh just bash with some simple bashrc and inputrc settings

No-one mentioned 'jq' yet.

Maybe there's a reason for that!

All CLI commands

Fossil.

I find fd to have a really nice API.

• https://github.com/sharkdp/fd

Favourite CLI I'd say is Junos. Structured, hierarchical, flexible.

Curl

I don't think there is some exceptional good CLI interfaces. If anything, you either notice the interface is bad or unconventional or it is cluttered, because it has lots of functionality. It also depends if it "should" fit into the Linux eco system (similar commandline system and logic) or is this tool used for any operating system. I have my own scripts as wrapper for some tools, so they are excluded from discussions here. Note I think the discussion is about commandline interfaces that operate non interactive (in other words no "live" TUIs or interactive editors), so no Vim or htop.

Tools like yt-dlp or awk or find or git are complex and overloaded with functionality, because it offers so much and has to offer all of that. Or the command works different, because of its nature of calling another command like parallel. Then there are commandlines that just deviates from the standard and bugs me a lot. One of the worst offenders to me is 7z from package extra/7zip in the Arch repositories. But it is not a standard GNU tool, therefore it does its own thing.

So in the end, I do not think there is an exceptional good CLI, only bad or complicated ones. As long as it follows Linux standards its good to go. Often the best Rust CLI tools have pretty good ones that could be listened as standouts, but none specific in particular.