Subcommands syntax and usage

[a-fas]

Hi there !

Is it possible to define subcommands in commander ?

e.g.

node script.js thecommand subcommand1 -op1 -op2
node script.js thecommand subcommand2 -op3

A particularly intended usage would be to define program.command('thecommand').action('./path/to/subcommands.js') in root index.js or other starting point and then I would have some dir with commands (path/to/subcommands), where I can then define subcommands

program
  .command('subcommand1').action(...)
  .command('subcommand2').action(...)

or maybe some kind of array with commands

module.exports = [
  { command: 'subcommand1', options: '...', action: someFn },
  { command: 'subcommand2', options: '...', action: someFn }
]

I found something promising here, but it is not documented and I cannot figure out how it works

[shadowspawn]

You can do this using git-style sub-commands. You call parse again when handling the first subcommand to add another layer of subcommands.

In the test code you linked to, the first level command processing which detects cache is in pm and the second level processing which extends this to cache clear and cache validate is in pm-cache.js.

[a-fas]

yes, I figured that out already. But it is not always convenient as it requires separate file with specific name in specific location which is unflexible. So I ended up with something like this (posting here, maybe someone will find useful):

function patchCommander(commander) {
    commander.Command.prototype.forwardSubcommands = function() {
        var self = this;
        var listener = function(args, unknown) {
            // Parse any so-far unknown options
            args = args || [];
            unknown = unknown || [];

            var parsed = self.parseOptions(unknown);
            if (parsed.args.length) args = parsed.args.concat(args);
            unknown = parsed.unknown;

            // Output help if necessary
            if (unknown.includes('--help') || unknown.includes('-h')) {
                self.outputHelp();
                process.exit(0);
            }

            self.parseArgs(args, unknown);
        };

        if (this._args.length > 0) {
            console.error('forwardSubcommands cannot be applied to command with explicit args');
        }

        var parent = this.parent || this;
        var name = parent === this ? '*' : this._name;
        parent.on('command:' + name, listener);
        if (this._alias) parent.on('command:' + this._alias, listener);
        return this;
    };

    // some other utils here ...
}

patchCommander is obviously triggered over the main instance somewhere in the beginning of the code. And then I can do e.g.:

    const subCommand = program
        .command('journal')
        .description('Journal utils') // this should also be separate line, I don't remember why already
        .forwardSubcommands(); // instead of "action"

    subCommand
        .command('list <path>')
        .action(List);

    subCommand
        .command('print-recent <path>')
        .action(PrintRecent);

works well so far ... :)

[buehler]

I don't know what the state of this is, but it seems that nearly ALL cli developers would like some custom way to define subcommands...

[riongull]

Relevant issue: #532
Relevant pull request: #854

[shadowspawn]

I don't know what the state of this is, but it seems that nearly ALL cli developers would like some custom way to define subcommands...

I am not sure what people have in mind when upvoting this. I know there is interest in more flexibility in specifying the external executable for git-style commands.

Is there interest in being able to do sub subcommands using action handlers and not using external executables? (#63 #245 #655)

[callumgare]

Is there interest in being able to do sub subcommands using action handlers and not using external executables?

Speaking for my self that is exactly what I would like :)

[tkausl]

I'd love to have this aswell.

@a-fas code works good so far, I only added !args.length || !self.listeners('command:' + args[0]) as condition to the output-help if, since otherwise ./app command1 command2 --help would print command1s help page, not command2s.

[a-fas]

I think if it seems useful i can PR it :)
(Will do next week)

[shadowspawn]

On a related note, there is a closed pull request to "connect the wires" for nested routines in #245. The first comment is a nice summary. (I have not analysed it deeply enough to contrast with @a-fas approach yet.)

[misterhat]

I had assumed this is how it functioned by default. Super unintuitive to involve separate files by default. Also subcommands that are in separate files expect the original filename prepended to theirs, even if you specify a custom .name. This is inconsistent because if you run the program with npm start it looks for bin-subcommand, but if you run it with node bin/index.js it expects index-subcommand. Again, this is after I specified a custom .name.

[alexstandiford]

Expanding on my new hero, @a-fas

If you tweak @a-fas's snippet and put it in a separate file, commander-patch.js and export it as a module, you can just call the patch instead of commander.

// File name: ./commander-patch.js
const oldCommander = require( 'commander' );

function patchCommander( commander ){
	if( commander.hasOwnProperty( 'forwardSubcommands' ) ) return commander;
	commander.Command.prototype.forwardSubcommands = function(){
		var self = this;
		var listener = function( args, unknown ){
			// Parse any so-far unknown options
			args = args || [];
			unknown = unknown || [];

			var parsed = self.parseOptions( unknown );
			if( parsed.args.length ) args = parsed.args.concat( args );
			unknown = parsed.unknown;

			// Output help if necessary
			if( unknown.includes( '--help' ) || unknown.includes( '-h' ) ){
				self.outputHelp();
				process.exit( 0 );
			}

			self.parseArgs( args, unknown );
		};

		if( this._args.length > 0 ){
			console.error( 'forwardSubcommands cannot be applied to command with explicit args' );
		}

		var parent = this.parent || this;
		var name = parent === this ? '*' : this._name;
		parent.on( 'command:' + name, listener );
		if( this._alias ) parent.on( 'command:' + this._alias, listener );
		return this;
	};

	return commander;
}

const commander = patchCommander( oldCommander );

module.exports = commander;

#!/usr/bin/env node

// File name: index.js
const program = require( './commander-patch' );

const projectCommand = program
	.version( '1.0.0' )
	.command( 'project' )
	.description( 'All Project-related commands' )
	.forwardSubcommands();

projectCommand
	.command( 'list' )
	.action( () => {
		console.log( 'ran' )
	} );

program.parse( process.argv );

With this, if you run node index.js project list

You will get a response, ran

[alexstandiford]

I should also mention that @a-fas's solution doesn't seem to support the .option() flag. I was able to workaround this by using Inquirer.js

[Samuel-B-D]

I was stumbling in the same case and have found a bunch of those issues open here.
I noticed you can do something like this, which works pretty well :

const mainCommand = newCommand()
    .description('Main command with subcommand');

mainCommand.command('sub')
    .description('This is a subcommand')
    .action(() => console.log('code goes here'));

Help seems working properly, except when no command at all is provided, help is not displayed.
Fixed the latter with this construct :

if (process.argv.length <= 2) {
    mainCommand.outputHelp();
    return;
}
mainCommand.parse(process.argv);

[alexstandiford]

I was stumbling in the same case and have found a bunch of those issues open here.
I noticed you can do something like this, which works pretty well :

const mainCommand = newCommand()
    .description('Main command with subcommand');

mainCommand.command('sub')
    .description('This is a subcommand')
    .action(() => console.log('code goes here'));

Help seems working properly, except when no command at all is provided, help is not displayed.
Fixed the latter with this construct :

    if (process.argv.length <= 2) {
        importCommand.outputHelp();
        return;
    }
    importCommand.parse(process.argv);

I wonder if that could be added in the prototype, somehow?