coa

What is coa?

The coa npm package is a powerful command-line option parser that helps you build command-line applications by defining commands, options, and arguments in a declarative way. It provides a fluent API to make the definition of command-line interfaces easy and readable.

What are coa's main functionalities?

Command definition and execution

This code sample demonstrates how to define a command-line application with a version option and a subcommand. The application will display the version when the '--version' flag is used and will execute a subcommand when 'subcommand' is invoked.

const coa = require('coa');

coa.Cmd()
  .name('app')
  .title('My awesome command line app')
  .helpful()
  .opt()
      .name('version')
      .title('Show version')
      .short('v')
      .long('version')
      .flag()
      .act((opts) => console.log('v1.0.0'))
      .end()
  .cmd()
      .name('subcommand')
      .title('A subcommand example')
      .helpful()
      .act((opts, args) => console.log('Subcommand executed'))
      .end()
  .run(process.argv.slice(2));

Argument parsing

This code sample shows how to define a required argument for a command-line application. The application expects an input file as an argument and will print the name of the input file when the application is run.

const coa = require('coa');

coa.Cmd()
  .name('app')
  .title('My awesome command line app')
  .helpful()
  .arg()
      .name('input')
      .title('Input file')
      .req()
      .end()
  .act((opts, args) => console.log(`Input file: ${args.input}`))
  .run(process.argv.slice(2));

Option parsing

This code sample illustrates how to define an option for a command-line application. The application allows the user to specify an output file using either '-o' or '--output' flags and will print the name of the output file when the application is run.

const coa = require('coa');

coa.Cmd()
  .name('app')
  .title('My awesome command line app')
  .helpful()
  .opt()
      .name('output')
      .title('Output file')
      .short('o')
      .long('output')
      .end()
  .act((opts, args) => console.log(`Output file: ${opts.output}`))
  .run(process.argv.slice(2));

Other packages similar to coa

commander

Commander is a widely-used npm package for building command-line interfaces. It offers a similar declarative API for defining options and commands, and it is known for its simplicity and ease of use. Compared to coa, commander has a larger user base and more extensive documentation.

yargs

Yargs is another popular npm package for parsing command-line arguments. It provides a rich set of features for building interactive command-line tools, including advanced parsing, validation, and generating help messages. Yargs is often preferred for its fluent API and its support for subcommands, which is similar to coa but with more customization options.

meow

Meow is a lighter alternative to coa, designed to be simple and minimalistic. It provides a straightforward way to parse command-line arguments and generate help text. While it lacks some of the advanced features of coa, such as the detailed command and option definitions, it is suitable for simpler command-line applications that do not require complex structures.

README

Command-Option-Argument

COA is a yet another parser for command line options. You can choose one of the existing modules, or write your own like me.

Examples

require('coa').Cmd() // main command declaration
    .name(process.argv[1])
    .title('My awesome command line util')
    .helpful()
    .opt()
        .name('version').short('v').long('version')
        .title('Version')
        .type(Boolean)
        .end()
    .act(function(opts) {
        opts.version &&
            this.exit(
                JSON.parse(require('fs').readFileSync(__dirname + '/package.json'))
                    .version);
    })
    .cmd().name('subcommand).apply(require('./subcommand').COA).end() // load subcommand from module
    .cmd() // inplace subcommand declaration
        .name('othercommand')
        .title('Awesome other subcommand').helpful()
        .opt()
            .name('input').short('i').long('input')
            .title('input file, required')
            .validate(function(f) { return require('fs').createReadStream(f) })
            .required()
            .end()
        .end()
    .parse(process.argv.slice(2));

// subcommand.js
exports.COA = function() {
    this
        .title('Awesome subcommand').helpful()
        .opt()
            .name('output').short('o').long('output')
            .title('output file')
            .output() // use default preset for "output" option declaration
            .end()
};