seeli ( C. L. I. )

Object orientated, event driven , Interactive CLI module. Seeli aims to give you the tools to compose A command line interface the way you want it, and otherwise, stays out of your way.

var cli = require("seeli")
var Hello = new cli.Command({
    description:"diaplays a simple hello world command"
    ,usage:[
        "Usage: cli hello --interactive",
        "Usage: cli hello --name=john",
        "Usage: cli hello --name=john --name=marry --name=paul -v screaming"
    ]
    ,flags:{
        name:{
            type:[ String, Array ]
            ,shorthand:'n'
            ,description:"The name of the person to say hello to"
        }
        ,excited: {
            type:Boolean
            ,shorthand: 'e'
            ,description:"Say hello in a very excited manner"
            ,default:false
        }
        ,volume:{
            type:String
            ,choices:['normal', 'screaming']
            ,default:'normal'
            ,shorthand:'v'
        }
    }
    ,run: function( cmd, data, cb ){
        var out = [];

        for( var x =0; x< data.name.length; x++ ){
            var value = "Hello, " + data.name[x]
            if( data.excited ){
                value += '!'
            }
            out.push( value );

        }
        out = out.join('\n');

        out = data.volume == 'screaming' ? out.toUpperCase() : out;
        cb( null, out );
    }
});
cli.use('world', Hello)
cli.run();

now you will have a fully functional world command with help and an interactive walk through

node cli.js help world
node cli.js world --help
node cli.js world --interactive
node cli.js world --name=Mark --name=Sally --no-excited

Seeli.run( )

Executes The command line interface

Seeli.list<Array>

List of all top level registered commands

Seeli.exitOnError <Boolean>

If set to turn seeli will exit the process when it encouters an error. If false, it will leave error handling up to the parent application

Seeli.use( name <string>, cmd <Command> )

var cli = require('seeli')
var Cmd = new cli.Command();

cli.use('test', Cmd )
cli.run()

Registers a new command under the specified name where the name will invoke the associated command

Seeli.bold( text <string>)

wraps text in the ansi code for bold

Seeli.green( text <string>)

wraps text in the ansi code for green

Seeli.blue( text <string>)

wraps text in the ansi code for blue

Seeli.red( text <string>)

wraps text in the ansi code for red

Seeli.yellow( text <string>)

wraps text in the ansi code for yellow

Seeli.cyan( text <string>)

wraps text in the ansi code for cyan

Seeli.magenta( text <string>)

wraps text in the ansi code for magenta

Seeli.set( key <string>, value <object> )

sets a conf value.

Seeli.get( key <string> )

A config value to look up. Can be a dot separated key to look up nested values

Supported Confgurations

• color - The chalk color to use when outputting help text. default green

Command( options <object> )

Options

Flag Options

Auto Help

Seeli will generate help from the usage string and flags. You can help as a command seeli help <command> or as a flag seeli <command> --help

Asyncronous

Your defined run function will be passed a done function to be called when your command has finished. This allows you to do complex async operations and I/O. The done callback accepts an error, if there is one, and the final output to be displayed for your command.

Events

Instances of the seeli Command or Commands the inherit from it as also instances of the EventEmitter class. By default any flag that has its event option set to true will emit an event with the value of of the flag before the run function is executed.

var EventCommand = new cli.Command({
    args:[ '--one', '--no-two']
  , flags:{
        one:{
            type:Boolean
            ,event:true
        }
        ,two:{
            type:Boolean
            ,event:true
        }
    }
  , run: function( cmd, data, done ){
      done( null, data.one && data.two )
  }
});

EventCommand.on('one', function( value ){
    assert.equal( true, value );
});

EventCommand.on('two', function( value ){
    assert.equal( false, value )
});

EventCommand.on('content', function( value ){
    assert.equal( false, value );
});

EventCommand.run( null );

Errors

Errors are handled by Node's error domains. Each command will run inside of its own domain and will emit an error event if and error is passed to the done callback from the run method. Seeli will suppress trace messages by default. You can use the --traceback flag on any command to surface the full stack trace. If the error object emitted has a code property that is a non zero value, seeli will forcefully exit the process with the error code.

var cli = require("seeli")
var ErrCmd = new cli.Command({
    run: function(){
        var e = new Error("Invalid Command")
        e.code = 10;
        this.emit('error',e )
    }
});