Smooth (CLI) Operator šŸŽ¶
Switch branches/tags
Nothing to show
Clone or download
Latest commit 987ffa9 May 13, 2018
Type Name Latest commit message Commit time
Failed to load latest commit information.
lib fix multi-optional named arguments May 13, 2018
test add tests to ensure/prevent positional regression May 13, 2018
.editorconfig add root files Dec 1, 2017
.gitignore add root files Dec 1, 2017
.travis.yml add Travis config Dec 17, 2017
license add root files Dec 1, 2017
package.json 1.4.1 May 13, 2018 add api docs for lazy parse Mar 2, 2018

sade Build Status

Smooth (CLI) Operator šŸŽ¶

Sade is a small but powerful tool for building command-line interface (CLI) applications for Node.js that are fast, responsive, and helpful!

It enables default commands, git-like subcommands, option flags with aliases, default option values with type-casting, required-vs-optional argument handling, command validation, and automated help text generation!

Your app's UX will be as smooth as butter... just like Sade's voice. šŸ˜‰


$ npm install --save sade



#!/usr/bin/env node

const sade = require('sade');

const prog = sade('my-cli');

  .option('--global, -g', 'An example global flag')
  .option('-c, --config', 'Provide path to custom config', 'foo.config.js');

  .command('build <src> <dest>')
  .describe('Build the source directory. Expects an `index.js` entry file.')
  .option('-o, --output', 'Change the name of the output file', 'bundle.js')
  .example('build src build --global --config my-conf.js')
  .example('build app public -o main.js')
  .action((src, dest, opts) => {
    console.log(`> building from ${src} to ${dest}`);
    console.log('> these are extra opts', opts);



$ my-cli --help

    $ my-cli <command> [options]

  Available Commands
    build    Build the source directory.

  For more info, run any command with the `--help` flag
    $ my-cli build --help

    -v, --version    Displays current version
    -g, --global     An example global flag
    -c, --config     Provide path to custom config  (default foo.config.js)
    -h, --help       Displays this message

$ my-cli build --help

    Build the source directory.
    Expects an `index.js` entry file.

    $ my-cli build <src> [options]

    -o, --output    Change the name of the output file  (default bundle.js)
    -g, --global    An example global flag
    -c, --config    Provide path to custom config  (default foo.config.js)
    -h, --help      Displays this message

    $ my-cli build src build --global --config my-conf.js
    $ my-cli build app public -o main.js


  • Define your global/program-wide version, options, description, and/or examples first.
    Once you define a Command, you can't access the global-scope again.

  • Define all commands & options in the order that you want them to appear.
    Sade will not mutate or sort your CLI for you. Global options print before local options.

  • Required arguments without values will error & exit
    An Insufficient arguments! error will be displayed along with a help prompt.

  • Don't worry about manually displaying help~!
    Your help text is displayed automatically... including command-specific help text!

  • Automatic default/basic patterns
    Usage text will always append [options] & --help and --version are done for you.

  • Only define what you want to display!
    Help text sections (example, options, etc) will only display if you provide values.


Subcommands are defined & parsed like any other command! When defining their usage, everything up until the first argument ([foo] or <foo>) is interpreted as the command string.

They should be defined in the order that you want them to appear in your general --help output.

Lastly, it is not necessary to define the subcommand's "base" as an additional command. However, if you choose to do so, it's recommended that you define it first for better visibility.

const prog = sade('git');

// Not necessary for subcommands to work, but it's here anyway!
  .describe('Manage set of tracked repositories')
  .action(opts => {
    console.log('~> Print current remotes...');

  .command('remote add <name> <url>', 'Demo...')
  .action((name, url, opts) => {
    console.log(`~> Adding a new remote (${name}) to ${url}`);

  .command('remote rename <old> <new>', 'Demo...')
  .action((old, nxt, opts) => {
    console.log(`~> Renaming from ${old} to ${nxt}~!`);




Type: String
Returns: Program

The name of your bin/program. Returns the Program itself, wherein all other methods are available.

prog.command(usage, desc, opts)

Create a new Command for your Program. This changes the current state of your Program.

All configuration methods (prog.describe, prog.action, etc) will apply to this Command until another Command has been created!


Type: String

The usage pattern for your current Command. This will be included in the general or command-specific --help output.

Required arguments are wrapped with < and > characters; for example, <foo> and <bar>.

Optional arguments are wrapped with [ and ] characters; for example, [foo] and [bar].

All arguments are positionally important, which means they are passed to your current Command's handler function in the order that they were defined.

When optional arguments are defined but don't receive a value, their positionally-equivalent function parameter will be undefined.

Important: You must define & expect required arguments before optional arguments!


  .command('greet <adjective> <noun>')
  .action((adjective, noun, opts) => {
    console.log(`Hello, ${adjective} ${noun}!`);

  .command('drive <vehicle> [color] [speed]')
  .action((vehicle, color, speed, opts) => {
    let arr = ['Driving my'];
    arr.push(color ? `${color} ${vehicle}` : vehicle);
    speed && arr.push(`at ${speed}`);
    opts.yolo && arr.push('...YOLO!!');
    let str = arr.join(' ');
$ foo greet beautiful person
# //=> Hello, beautiful person!

$ foo drive car
# //=> Driving my car

$ foo drive car red
# //=> Driving my red card

$ foo drive car blue 100mph --yolo
# //=> Driving my blue car at 100mph ...YOLO!!


Type: String
Default: ''

The Command's description. The value is passed directly to prog.describe.


Type: Object
Default: {}


Type: Boolean

Manually set/force the current Command to be the Program's default command. This ensures that the current Command will run if no command was specified.

Important: If you run your Program without a Command and without specifying a default command, your Program will exit with a No command specified error.

const prog = sade('greet');

//=> only runs if :: `$ greet hello`

// $ greet
//=> error: No command specified.

prog.command('howdy', '', { default:true });
//=> runs as `$ greet` OR `$ greet howdy`

// $ greet
//=> runs 'howdy' handler

// $ greet foobar
//=> error: Invalid command


Add a description to the current Command.


Type: String|Array

The description text for the current Command. This will be included in the general or command-specific --help output.

Internally, your description will be separated into an Array of sentences.

For general --help output, only the first sentence will be displayed. However, all sentences will be printed for command-specific --help text.

Note: Pass an Array if you don't want internal assumptions. However, the first item is always displayed in general help, so it's recommended to keep it short.


Attach a callback to the current Command.


Type: Function

The function to run when the current Command is executed.

Its parameters are based (positionally) on your Command's usage definition.

All options, flags, and extra/unknown values are included as the last parameter.

Note: Optional arguments are also passed as parameters & may be undefined!

  .command('cp <src> <dest>')
  .option('-f, --force', 'Overwrite without confirmation')
  .option('-c, --clone-dir', 'Copy files to additional directory')
  .option('-v, --verbose', 'Enable verbose output')
  .action((src, dest, opts) => {
    console.log(`Copying files from ${src} --> ${dest}`);
    opts.c && console.log(`ALSO copying files from ${src} --> ${opts['clone-dir']}`);
    console.log('My options:', opts);

// $ foo cp original my-copy -v
//=> Copying files from original --> my-copy
//=> My options: { _:[], v:true, verbose:true }

// $ foo cp original my-copy --clone-dir my-backup
//=> Copying files from original --> my-copy
//=> ALSO copying files from original --> my-backup
//=> My options: { _:[], c:'my-backup', 'clone-dir':'my-backup' }


Add an example for the current Command.


Type: String

The example string to add. This will be included in the general or command-specific --help output.

Note: Your example's str will be prefixed with your Programs's name.

prog.option(flags, desc, value)

Add an Option to the current Command.


Type: String

The Option's flags, which may optionally include an alias.

You may use a comma (,) or a space () to separate the flags.

Note: The short & long flags can be declared in any order. However, the alias will always be displayed first.

Important: If using hyphenated flag names, they will be accessible as declared within your action() handler!

prog.option('--global'); // no alias
prog.option('-g, --global'); // alias first, comma
prog.option('--global -g'); // alias last, space
// etc...


Type: String

The description for the Option.


Type: String

The default value for the Option.

Flags and aliases, if parsed, are true by default. See mri for more info.

Note: You probably only want to define a default value if you're expecting a String or Number value type.

If you do pass a String or Number value type, your flag value will be casted to the same type. See mri#options.default for info~!


The --version and -v flags will automatically output the Program version.


Type: String
Default: 0.0.0

The new version number for your Program.

Note: Your Program version is 0.0.0 until you change it.

prog.parse(arr, opts)

Parse a set of CLI arguments.


Type: Array

Your Program's process.argv input.

Important: Do not .slice(2)! Doing so will break parsing~!


Type: Object
Default: {}

Additional process.argv parsing config. See mri's options for details.

Important: These values override any internal values!

  .option('-f, --force', 'My flag');
//=> currently has alias pair: f <--> force

prog.parse(process.argv, {
  alias: {
    f: ['foo', 'fizz']
  default: {
    abc: 123
//=> ADDS alias pair: f <--> foo
//=> REMOVES alias pair: f <--> force
//=> ADDS alias pair: f <--> fizz
//=> ADDS default: abc -> 123 (number)


Type: Boolean
Default: false

If true, Sade will not immediately execute the action handler. Instead, parse() will return an object of { name, args, handler } shape, wherein the name is the command name, args is all arguments that would be passed to the action handler, and handler is the function itself.

From this, you may choose when to run the handler function. You also have the option to further modify the args for any reason, if needed.

let { name, args, handler } = prog.parse(process.argv, { lazy:true });
console.log('> Received command: ', name);

// later on...
handler.apply(null, args);

Manually display the help text for a given command. If no command name is provided, the general/global help is printed.

Your general and command-specific help text is automatically attached to the --help and -h flags.

Note: You don't have to call this directly! It's automatically run when you bin --help


Type: String
Default: null

The name of the command for which to display help. Otherwise displays the general help.


MIT Ā© Luke Edwards