docs: function load(opts, cb) {
    if(typeof opts === 'function') {
      cb = opts;
      opts = null;
    }
    opts = opts || {};
    var files = opts.commands || []
      , i = 0
      , list = []
      , conf = opts.conf
      , rename = conf.get(ConfigKey.RENAME_COMMAND) || []
      , commands = {};
  
    if(!Array.isArray(files)) {
      files = [files];
    }
  
    function complete(err) {
      if(err) return cb(err);
      if(Object.keys(commands).length === 0) {
        return cb(new Error('no command definitions found'));
      }
      cb(null, commands);
    }
  
    /**
     *  Requires the array of files.
     */
    function include(list) {
      var cmd, clazz, i, file, j, name, newname;
      for(i = 0;i < list.length;i++) {
        file = list[i];
        try {
          clazz = require(file);
          // assume it is already instantiated
          if(typeof clazz === 'object') {
            cmd = clazz;
          }else{
            cmd = new clazz(clazz.definition);
          }
  
          // rename and delete commands
          if(cmd && cmd.definition && cmd.definition.name) {
            for(j = 0;j < rename.length;j++) {
              name = rename[j][0];
              newname = rename[j][1];
              if(name
                && name.toLowerCase() === cmd.definition.name.toLowerCase()) {
                newname = (newname || '').toLowerCase();
                // actually renaming
                if(newname) {
                  log.warning(
                    'rename command %s -> %s', cmd.definition.name, newname);
                  cmd.definition.name = newname;
                // deleting the command, mark as deleted with false
                }else{
                  log.warning(
                    'deleted command %s (%s)', cmd.definition.name, file);
                  commands[cmd.definition.name] = false;
                  // clear the module cache
                  delete require.cache[file];
                }
                break;
              }
            }
          }
  
          // deleted the command
          if(!require.cache[file]) continue;
  
          // sanity checks
          if(!(cmd instanceof CommandExec)) {
            throw new Error(
              util.format(
                'module does not export a command exec instance (%s)', file));
          }else if(
            !cmd.definition
            || !cmd.definition.constructor
            || cmd.definition.constructor.name !== Command.name) {
            throw new Error(
              util.format(
                'command does not have a valid definition (%s)', file));
          }else if(!cmd.definition.name) {
            throw new Error(
              util.format(
                'command definition does not have a name (%s)', file));
          }
  
          if(opts.override !== true && commands[cmd.definition.name]) {
            throw new Error(util.format(
                'duplicate command %s (%s)', cmd.definition.name, file));
          }
  
          log.debug('loaded %s (%s)', cmd.definition.name, file);
  
          // map of command names to command exec handlers
          commands[cmd.definition.name] = cmd;
        }catch(e) {
          return complete(e);
        }
      }
      complete();
    }
  
    /**
     *  Walk the file list array.
     */
    function walk(files, cb, list) {
      var i = 0;
      list = list || [];
  
      function check(file, cb) {
        fs.stat(file, function onStat(err, stats) {
          if(err) return cb(err);
          if(stats.isFile() && !/\.js$/.test(file)) {
            log.warning('ignoring %s', file);
            return cb();
          }
          if(stats.isFile()) {
            list.push(file);
            return cb(null, list);
          }else{
            return fs.readdir(file, function onRead(err, files) {
              if(err) return cb(err);
              if(!files.length) return cb();
              files = files.map(function(nm) {
                return path.join(file, nm);
              })
              //files.forEach()
              return walk(files, cb, list);
            })
          }
        });
      }
  
      check(files[i], function onCheck(err, list) {
        if(err) return cb(err);
        if(i === files.length - 1) {
          return cb(null, list);
        }
        i++;
        check(files[i], onCheck);
      });
    }
  
    walk(files, function onList(err, list) {
      if(err) return complete(err);
      if(list.length === 0) {
        return complete(new Error('no command files found'));
      }
      include(list);
    });
  }