set basic layout. adding status bar

node_modules/bower/lib/commands/cache/clean.js

@@ -0,0 +1,195 @@
+var fs = require('../../util/fs');
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var rimraf = require('../../util/rimraf');
+var endpointParser = require('bower-endpoint-parser');
+var PackageRepository = require('../../core/PackageRepository');
+var semver = require('../../util/semver');
+var defaultConfig = require('../../config');
+
+function clean(logger, endpoints, options, config) {
+    var decEndpoints;
+    var names;
+
+    options = options || {};
+    config = defaultConfig(config);
+
+    // If endpoints is an empty array, null them
+    if (endpoints && !endpoints.length) {
+        endpoints = null;
+    }
+
+    // Generate decomposed endpoints and names based on the endpoints
+    if (endpoints) {
+        decEndpoints = endpoints.map(function(endpoint) {
+            return endpointParser.decompose(endpoint);
+        });
+        names = decEndpoints.map(function(decEndpoint) {
+            return decEndpoint.name || decEndpoint.source;
+        });
+    }
+
+    return Q.all([
+        clearPackages(decEndpoints, config, logger),
+        clearLinks(names, config, logger)
+    ]).spread(function(entries) {
+        return entries;
+    });
+}
+
+function clearPackages(decEndpoints, config, logger) {
+    var repository = new PackageRepository(config, logger);
+
+    return repository.list().then(function(entries) {
+        var promises;
+
+        // Filter entries according to the specified packages
+        if (decEndpoints) {
+            entries = entries.filter(function(entry) {
+                return !!mout.array.find(decEndpoints, function(decEndpoint) {
+                    var entryPkgMeta = entry.pkgMeta;
+
+                    // Check if name or source match the entry
+                    if (
+                        decEndpoint.name !== entryPkgMeta.name &&
+                        decEndpoint.source !== entryPkgMeta.name &&
+                        decEndpoint.source !== entryPkgMeta._source
+                    ) {
+                        return false;
+                    }
+
+                    // If target is a wildcard, simply return true
+                    if (decEndpoint.target === '*') {
+                        return true;
+                    }
+
+                    // If it's a semver target, compare using semver spec
+                    if (semver.validRange(decEndpoint.target)) {
+                        return semver.satisfies(
+                            entryPkgMeta.version,
+                            decEndpoint.target
+                        );
+                    }
+
+                    // Otherwise, compare against target/release
+                    return (
+                        decEndpoint.target === entryPkgMeta._target ||
+                        decEndpoint.target === entryPkgMeta._release
+                    );
+                });
+            });
+        }
+
+        promises = entries.map(function(entry) {
+            return repository.eliminate(entry.pkgMeta).then(function() {
+                logger.info(
+                    'deleted',
+                    'Cached package ' +
+                        entry.pkgMeta.name +
+                        ': ' +
+                        entry.canonicalDir,
+                    {
+                        file: entry.canonicalDir
+                    }
+                );
+            });
+        });
+
+        return Q.all(promises)
+            .then(function() {
+                if (!decEndpoints) {
+                    // Ensure that everything is cleaned,
+                    // even invalid packages in the cache
+                    return repository.clear();
+                }
+            })
+            .then(function() {
+                return entries;
+            });
+    });
+}
+
+function clearLinks(names, config, logger) {
+    var promise;
+    var dir = config.storage.links;
+
+    // If no names are passed, grab all links
+    if (!names) {
+        promise = Q.nfcall(fs.readdir, dir).fail(function(err) {
+            if (err.code === 'ENOENT') {
+                return [];
+            }
+
+            throw err;
+        });
+        // Otherwise use passed ones
+    } else {
+        promise = Q.resolve(names);
+    }
+
+    return promise.then(function(names) {
+        var promises;
+        var linksToRemove = [];
+
+        // Decide which links to delete
+        promises = names.map(function(name) {
+            var link = path.join(config.storage.links, name);
+
+            return Q.nfcall(fs.readlink, link).then(
+                function(linkTarget) {
+                    // Link exists, check if it points to a folder
+                    // that still exists
+                    return (
+                        Q.nfcall(fs.stat, linkTarget)
+                            .then(function(stat) {
+                                // Target is not a folder..
+                                if (!stat.isDirectory()) {
+                                    linksToRemove.push(link);
+                                }
+                            })
+                            // Error occurred reading the link
+                            .fail(function() {
+                                linksToRemove.push(link);
+                            })
+                    );
+                    // Ignore if link does not exist
+                },
+                function(err) {
+                    if (err.code !== 'ENOENT') {
+                        linksToRemove.push(link);
+                    }
+                }
+            );
+        });
+
+        return Q.all(promises).then(function() {
+            var promises;
+
+            // Remove each link that was declared as invalid
+            promises = linksToRemove.map(function(link) {
+                return Q.nfcall(rimraf, link).then(function() {
+                    logger.info('deleted', 'Invalid link: ' + link, {
+                        file: link
+                    });
+                });
+            });
+
+            return Q.all(promises);
+        });
+    });
+}
+
+// -------------------
+
+clean.readOptions = function(argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var endpoints = options.argv.remain.slice(2);
+
+    delete options.argv;
+
+    return [endpoints, options];
+};
+
+module.exports = clean;

node_modules/bower/lib/commands/cache/list.js

@@ -0,0 +1,42 @@
+var mout = require('mout');
+var PackageRepository = require('../../core/PackageRepository');
+var defaultConfig = require('../../config');
+
+function list(logger, packages, options, config) {
+    var repository;
+
+    config = defaultConfig(config);
+    repository = new PackageRepository(config, logger);
+
+    // If packages is an empty array, null them
+    if (packages && !packages.length) {
+        packages = null;
+    }
+
+    return repository.list().then(function(entries) {
+        if (packages) {
+            // Filter entries according to the specified packages
+            entries = entries.filter(function(entry) {
+                return !!mout.array.find(packages, function(pkg) {
+                    return pkg === entry.pkgMeta.name;
+                });
+            });
+        }
+
+        return entries;
+    });
+}
+
+// -------------------
+
+list.readOptions = function(argv) {
+    var cli = require('../../util/cli');
+    var options = cli.readOptions(argv);
+    var packages = options.argv.remain.slice(2);
+
+    delete options.argv;
+
+    return [packages, options];
+};
+
+module.exports = list;

node_modules/bower/lib/commands/help.js

@@ -0,0 +1,41 @@
+var Q = require('q');
+var path = require('path');
+var fs = require('../util/fs');
+var createError = require('../util/createError');
+
+function help(logger, name, config) {
+    var json;
+
+    if (name) {
+        json = path.resolve(
+            __dirname,
+            '../templates/json/help-' + name.replace(/\s+/g, '/') + '.json'
+        );
+    } else {
+        json = path.resolve(__dirname, '../templates/json/help.json');
+    }
+
+    return Q.promise(function(resolve) {
+        fs.exists(json, resolve);
+    }).then(function(exists) {
+        if (!exists) {
+            throw createError('Unknown command: ' + name, 'EUNKNOWNCMD', {
+                command: name
+            });
+        }
+
+        return require(json);
+    });
+}
+
+// -------------------
+
+help.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain.slice(1).join(' ');
+
+    return [name];
+};
+
+module.exports = help;

node_modules/bower/lib/commands/home.js

@@ -0,0 +1,59 @@
+var Project = require('../core/Project');
+var open = require('opn');
+var endpointParser = require('bower-endpoint-parser');
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
+
+function home(logger, name, config) {
+    var project;
+    var promise;
+    var decEndpoint;
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    // Get the package meta
+    // If no name is specified, read the project json
+    // If a name is specified, fetch from the package repository
+    if (!name) {
+        promise = project.hasJson().then(function(json) {
+            if (!json) {
+                throw createError('You are not inside a package', 'ENOENT');
+            }
+
+            return project.getJson();
+        });
+    } else {
+        decEndpoint = endpointParser.decompose(name);
+        promise = project
+            .getPackageRepository()
+            .fetch(decEndpoint)
+            .spread(function(canonicalDir, pkgMeta) {
+                return pkgMeta;
+            });
+    }
+
+    // Get homepage and open it
+    return promise.then(function(pkgMeta) {
+        var homepage = pkgMeta.homepage;
+
+        if (!homepage) {
+            throw createError('No homepage set for ' + pkgMeta.name, 'ENOHOME');
+        }
+
+        open(homepage, { wait: false });
+        return homepage;
+    });
+}
+
+// -------------------
+
+home.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
+};
+
+module.exports = home;

node_modules/bower/lib/commands/index.js

@@ -0,0 +1,82 @@
+var Q = require('q');
+var Logger = require('bower-logger');
+var config = require('../config');
+
+/**
+ * Require commands only when called.
+ *
+ * Running `commandFactory(id)` is equivalent to `require(id)`. Both calls return
+ * a command function. The difference is that `cmd = commandFactory()` and `cmd()`
+ * return as soon as possible and load and execute the command asynchronously.
+ */
+function commandFactory(id) {
+    function runApi() {
+        var command = require(id);
+        var commandArgs = [].slice.call(arguments);
+
+        return withLogger(function(logger) {
+            commandArgs.unshift(logger);
+
+            return command.apply(undefined, commandArgs);
+        });
+    }
+
+    function runFromArgv(argv) {
+        var commandArgs;
+        var command = require(id);
+
+        commandArgs = command.readOptions(argv);
+
+        return withLogger(function(logger) {
+            commandArgs.unshift(logger);
+
+            return command.apply(undefined, commandArgs);
+        });
+    }
+
+    function withLogger(func) {
+        var logger = new Logger();
+
+        Q.try(func, logger).done(
+            function() {
+                config.restore();
+                var args = [].slice.call(arguments);
+                args.unshift('end');
+                logger.emit.apply(logger, args);
+            },
+            function(error) {
+                config.restore();
+                logger.emit('error', error);
+            }
+        );
+
+        return logger;
+    }
+
+    runApi.line = runFromArgv;
+
+    return runApi;
+}
+
+module.exports = {
+    cache: {
+        clean: commandFactory('./cache/clean'),
+        list: commandFactory('./cache/list')
+    },
+    help: commandFactory('./help'),
+    home: commandFactory('./home'),
+    info: commandFactory('./info'),
+    init: commandFactory('./init'),
+    install: commandFactory('./install'),
+    link: commandFactory('./link'),
+    list: commandFactory('./list'),
+    login: commandFactory('./login'),
+    lookup: commandFactory('./lookup'),
+    prune: commandFactory('./prune'),
+    register: commandFactory('./register'),
+    search: commandFactory('./search'),
+    update: commandFactory('./update'),
+    uninstall: commandFactory('./uninstall'),
+    unregister: commandFactory('./unregister'),
+    version: commandFactory('./version')
+};

node_modules/bower/lib/commands/info.js

@@ -0,0 +1,73 @@
+var mout = require('mout');
+var Q = require('q');
+var endpointParser = require('bower-endpoint-parser');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
+
+function info(logger, endpoint, property, config) {
+    if (!endpoint) {
+        return;
+    }
+
+    // handle @ as version divider
+    var splitParts = endpoint.split('/');
+    splitParts[splitParts.length - 1] = splitParts[
+        splitParts.length - 1
+    ].replace('@', '#');
+    endpoint = splitParts.join('/');
+
+    var repository;
+    var decEndpoint;
+
+    config = defaultConfig(config);
+    repository = new PackageRepository(config, logger);
+
+    decEndpoint = endpointParser.decompose(endpoint);
+
+    return Q.all([
+        getPkgMeta(repository, decEndpoint, property),
+        decEndpoint.target === '*' && !property
+            ? repository.versions(decEndpoint.source)
+            : null
+    ]).spread(function(pkgMeta, versions) {
+        if (versions) {
+            return {
+                name: decEndpoint.source,
+                versions: versions,
+                latest: pkgMeta
+            };
+        }
+
+        return pkgMeta;
+    });
+}
+
+function getPkgMeta(repository, decEndpoint, property) {
+    return repository
+        .fetch(decEndpoint)
+        .spread(function(canonicalDir, pkgMeta) {
+            pkgMeta = mout.object.filter(pkgMeta, function(value, key) {
+                return key.charAt(0) !== '_';
+            });
+
+            // Retrieve specific property
+            if (property) {
+                pkgMeta = mout.object.get(pkgMeta, property);
+            }
+
+            return pkgMeta;
+        });
+}
+
+// -------------------
+
+info.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var pkg = options.argv.remain[1];
+    var property = options.argv.remain[2];
+
+    return [pkg, property];
+};
+
+module.exports = info;

node_modules/bower/lib/commands/init.js

@@ -0,0 +1,342 @@
+var mout = require('mout');
+var fs = require('../util/fs');
+var path = require('path');
+var Q = require('q');
+var endpointParser = require('bower-endpoint-parser');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+var GitHubResolver = require('../core/resolvers/GitHubResolver');
+var cmd = require('../util/cmd');
+var createError = require('../util/createError');
+
+function init(logger, config) {
+    var project;
+
+    config = config || {};
+
+    if (!config.cwd) {
+        config.cwd = process.cwd();
+    }
+
+    config = defaultConfig(config);
+
+    // This command requires interactive to be enabled
+    if (!config.interactive) {
+        throw createError('Register requires an interactive shell', 'ENOINT', {
+            details:
+                'Note that you can manually force an interactive shell with --config.interactive'
+        });
+    }
+
+    project = new Project(config, logger);
+
+    // Start with existing JSON details
+    return (
+        readJson(project, logger)
+            // Fill in defaults
+            .then(setDefaults.bind(null, config))
+            // Now prompt user to make changes
+            .then(promptUser.bind(null, logger))
+            // Set ignore based on the response
+            .spread(setIgnore.bind(null, config))
+            // Set dependencies based on the response
+            .spread(setDependencies.bind(null, project))
+            // All done!
+            .spread(saveJson.bind(null, project, logger))
+    );
+}
+
+function readJson(project, logger) {
+    return project.hasJson().then(function(json) {
+        if (json) {
+            logger.warn(
+                'existing',
+                'The existing ' +
+                    path.basename(json) +
+                    ' file will be used and filled in'
+            );
+        }
+
+        return project.getJson();
+    });
+}
+
+function saveJson(project, logger, json) {
+    // Cleanup empty props (null values, empty strings, objects and arrays)
+    mout.object.forOwn(json, function(value, key) {
+        if (!validConfigValue(value)) {
+            delete json[key];
+        }
+    });
+
+    logger.info('json', 'Generated json', { json: json });
+
+    // Confirm the json with the user
+    return Q.nfcall(logger.prompt.bind(logger), {
+        type: 'confirm',
+        message: 'Looks good?',
+        default: true
+    }).then(function(good) {
+        if (!good) {
+            return null;
+        }
+
+        // Save json (true forces file creation)
+        return project.saveJson(true);
+    });
+}
+
+// Test if value is of a type supported by bower.json[0] - Object, Array, String, Boolean - or a Number
+// [0]: https://github.com/bower/bower.json-spec
+function validConfigValue(val) {
+    return (
+        mout.lang.isObject(val) ||
+        mout.lang.isArray(val) ||
+        mout.lang.isString(val) ||
+        mout.lang.isBoolean(val) ||
+        mout.lang.isNumber(val)
+    );
+}
+
+function setDefaults(config, json) {
+    var name;
+    var promise = Q.resolve();
+
+    // Name
+    if (!json.name) {
+        json.name = path.basename(config.cwd);
+    }
+
+    // Main
+    if (!json.main) {
+        // Remove '.js' from the end of the package name if it is there
+        name = path.basename(json.name, '.js');
+
+        if (fs.existsSync(path.join(config.cwd, 'index.js'))) {
+            json.main = 'index.js';
+        } else if (fs.existsSync(path.join(config.cwd, name + '.js'))) {
+            json.main = name + '.js';
+        }
+    }
+
+    // Homepage
+    if (!json.homepage) {
+        // Set as GitHub homepage if it's a GitHub repository
+        promise = promise.then(function() {
+            return cmd('git', ['config', '--get', 'remote.origin.url'])
+                .spread(function(stdout) {
+                    var pair;
+
+                    stdout = stdout.trim();
+                    if (!stdout) {
+                        return;
+                    }
+
+                    pair = GitHubResolver.getOrgRepoPair(stdout);
+                    if (pair) {
+                        json.homepage =
+                            'https://github.com/' + pair.org + '/' + pair.repo;
+                    }
+                })
+                .fail(function() {});
+        });
+    }
+
+    if (!json.authors) {
+        promise = promise.then(function() {
+            // Get the user name configured in git
+            return cmd('git', [
+                'config',
+                '--get',
+                '--global',
+                'user.name'
+            ]).spread(
+                function(stdout) {
+                    var gitEmail;
+                    var gitName = stdout.trim();
+
+                    // Abort if no name specified
+                    if (!gitName) {
+                        return;
+                    }
+
+                    // Get the user email configured in git
+                    return cmd('git', [
+                        'config',
+                        '--get',
+                        '--global',
+                        'user.email'
+                    ])
+                        .spread(
+                            function(stdout) {
+                                gitEmail = stdout.trim();
+                            },
+                            function() {}
+                        )
+                        .then(function() {
+                            json.authors = gitName;
+                            json.authors += gitEmail
+                                ? ' <' + gitEmail + '>'
+                                : '';
+                        });
+                },
+                function() {}
+            );
+        });
+    }
+
+    return promise.then(function() {
+        return json;
+    });
+}
+
+function promptUser(logger, json) {
+    var questions = [
+        {
+            name: 'name',
+            message: 'name',
+            default: json.name,
+            type: 'input'
+        },
+        {
+            name: 'description',
+            message: 'description',
+            default: json.description,
+            type: 'input'
+        },
+        {
+            name: 'main',
+            message: 'main file',
+            default: json.main,
+            type: 'input'
+        },
+        {
+            name: 'keywords',
+            message: 'keywords',
+            default: json.keywords ? json.keywords.toString() : null,
+            type: 'input'
+        },
+        {
+            name: 'authors',
+            message: 'authors',
+            default: json.authors ? json.authors.toString() : null,
+            type: 'input'
+        },
+        {
+            name: 'license',
+            message: 'license',
+            default: json.license || 'MIT',
+            type: 'input'
+        },
+        {
+            name: 'homepage',
+            message: 'homepage',
+            default: json.homepage,
+            type: 'input'
+        },
+        {
+            name: 'dependencies',
+            message: 'set currently installed components as dependencies?',
+            default:
+                !mout.object.size(json.dependencies) &&
+                !mout.object.size(json.devDependencies),
+            type: 'confirm'
+        },
+        {
+            name: 'ignore',
+            message: 'add commonly ignored files to ignore list?',
+            default: true,
+            type: 'confirm'
+        },
+        {
+            name: 'private',
+            message:
+                'would you like to mark this package as private which prevents it from being accidentally published to the registry?',
+            default: !!json.private,
+            type: 'confirm'
+        }
+    ];
+
+    return Q.nfcall(logger.prompt.bind(logger), questions).then(function(
+        answers
+    ) {
+        json.name = answers.name;
+        json.description = answers.description;
+        json.main = answers.main;
+        json.keywords = toArray(answers.keywords);
+        json.authors = toArray(answers.authors, ',');
+        json.license = answers.license;
+        json.homepage = answers.homepage;
+        json.private = answers.private || null;
+
+        return [json, answers];
+    });
+}
+
+function toArray(value, splitter) {
+    var arr = value.split(splitter || /[\s,]/);
+
+    // Trim values
+    arr = arr.map(function(item) {
+        return item.trim();
+    });
+
+    // Filter empty values
+    arr = arr.filter(function(item) {
+        return !!item;
+    });
+
+    return arr.length ? arr : null;
+}
+
+function setIgnore(config, json, answers) {
+    if (answers.ignore) {
+        json.ignore = mout.array.combine(json.ignore || [], [
+            '**/.*',
+            'node_modules',
+            'bower_components',
+            config.directory,
+            'test',
+            'tests'
+        ]);
+    }
+
+    return [json, answers];
+}
+
+function setDependencies(project, json, answers) {
+    if (answers.dependencies) {
+        return project.getTree().spread(function(tree, flattened, extraneous) {
+            if (extraneous.length) {
+                json.dependencies = {};
+
+                // Add extraneous as dependencies
+                extraneous.forEach(function(extra) {
+                    var jsonEndpoint;
+
+                    // Skip linked packages
+                    if (extra.linked) {
+                        return;
+                    }
+
+                    jsonEndpoint = endpointParser.decomposed2json(
+                        extra.endpoint
+                    );
+                    mout.object.mixIn(json.dependencies, jsonEndpoint);
+                });
+            }
+
+            return [json, answers];
+        });
+    }
+
+    return [json, answers];
+}
+
+// -------------------
+
+init.readOptions = function(argv) {
+    return [];
+};
+
+module.exports = init;

node_modules/bower/lib/commands/install.js

@@ -0,0 +1,55 @@
+var endpointParser = require('bower-endpoint-parser');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+
+function install(logger, endpoints, options, config) {
+    var project;
+    var decEndpoints;
+
+    options = options || {};
+    config = defaultConfig(config);
+    if (options.save === undefined) {
+        options.save = config.defaultSave;
+    }
+    project = new Project(config, logger);
+
+    // Convert endpoints to decomposed endpoints
+    endpoints = endpoints || [];
+    decEndpoints = endpoints.map(function(endpoint) {
+        // handle @ as version divider
+        var splitParts = endpoint.split('/');
+        splitParts[splitParts.length - 1] = splitParts[
+            splitParts.length - 1
+        ].replace('@', '#');
+        endpoint = splitParts.join('/');
+
+        return endpointParser.decompose(endpoint);
+    });
+
+    return project.install(decEndpoints, options, config);
+}
+
+// -------------------
+
+install.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            'force-latest': { type: Boolean, shorthand: 'F' },
+            production: { type: Boolean, shorthand: 'p' },
+            save: { type: Boolean, shorthand: 'S' },
+            'save-dev': { type: Boolean, shorthand: 'D' },
+            'save-exact': { type: Boolean, shorthand: 'E' }
+        },
+        argv
+    );
+
+    var packages = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [packages, options];
+};
+
+module.exports = install;

node_modules/bower/lib/commands/link.js

@@ -0,0 +1,88 @@
+var path = require('path');
+var rimraf = require('../util/rimraf');
+var Q = require('q');
+var Project = require('../core/Project');
+var createLink = require('../util/createLink');
+var defaultConfig = require('../config');
+var relativeToBaseDir = require('../util/relativeToBaseDir');
+
+function link(logger, name, localName, config) {
+    if (name) {
+        return linkTo(logger, name, localName, config);
+    } else {
+        return linkSelf(logger, config);
+    }
+}
+
+function linkSelf(logger, config) {
+    var project;
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    return project.getJson().then(function(json) {
+        var src = config.cwd;
+        var dst = path.join(config.storage.links, json.name);
+
+        // Delete previous link if any
+        return (
+            Q.nfcall(rimraf, dst)
+                // Link globally
+                .then(function() {
+                    return createLink(src, dst);
+                })
+                .then(function() {
+                    return {
+                        src: src,
+                        dst: dst
+                    };
+                })
+        );
+    });
+}
+
+function linkTo(logger, name, localName, config) {
+    var src;
+    var dst;
+    var project;
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    localName = localName || name;
+    src = path.join(config.storage.links, name);
+    dst = path.join(relativeToBaseDir(config.cwd)(config.directory), localName);
+
+    // Delete destination folder if any
+    return (
+        Q.nfcall(rimraf, dst)
+            // Link locally
+            .then(function() {
+                return createLink(src, dst);
+            })
+            // Install linked package deps
+            .then(function() {
+                return project.update([localName]);
+            })
+            .then(function(installed) {
+                return {
+                    src: src,
+                    dst: dst,
+                    installed: installed
+                };
+            })
+    );
+}
+
+// -------------------
+
+link.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+    var localName = options.argv.remain[2];
+
+    return [name, localName];
+};
+
+module.exports = link;

node_modules/bower/lib/commands/list.js

@@ -0,0 +1,185 @@
+var path = require('path');
+var mout = require('mout');
+var Q = require('q');
+var Project = require('../core/Project');
+var semver = require('../util/semver');
+var defaultConfig = require('../config');
+
+function list(logger, options, config) {
+    var project;
+
+    options = options || {};
+
+    // Make relative option true by default when used with paths
+    if (options.paths && options.relative == null) {
+        options.relative = true;
+    }
+
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    return project.getTree(options).spread(function(tree, flattened) {
+        // Relativize paths
+        // Also normalize paths on windows
+        project.walkTree(
+            tree,
+            function(node) {
+                if (node.missing) {
+                    return;
+                }
+
+                if (options.relative) {
+                    node.canonicalDir = path.relative(
+                        config.cwd,
+                        node.canonicalDir
+                    );
+                }
+                if (options.paths) {
+                    node.canonicalDir = normalize(node.canonicalDir);
+                }
+            },
+            true
+        );
+
+        // Note that we need to to parse the flattened tree because it might
+        // contain additional packages
+        mout.object.forOwn(flattened, function(node) {
+            if (node.missing) {
+                return;
+            }
+
+            if (options.relative) {
+                node.canonicalDir = path.relative(
+                    config.cwd,
+                    node.canonicalDir
+                );
+            }
+            if (options.paths) {
+                node.canonicalDir = normalize(node.canonicalDir);
+            }
+        });
+
+        // Render paths?
+        if (options.paths) {
+            return paths(flattened);
+        }
+
+        // Do not check for new versions?
+        if (config.offline) {
+            return tree;
+        }
+
+        // Check for new versions
+        return checkVersions(project, tree, logger).then(function() {
+            return tree;
+        });
+    });
+}
+
+function checkVersions(project, tree, logger) {
+    var promises;
+    var nodes = [];
+    var repository = project.getPackageRepository();
+
+    // Gather all nodes, ignoring linked nodes
+    project.walkTree(
+        tree,
+        function(node) {
+            if (!node.linked) {
+                nodes.push(node);
+            }
+        },
+        true
+    );
+
+    if (nodes.length) {
+        logger.info(
+            'check-new',
+            'Checking for new versions of the project dependencies...'
+        );
+    }
+
+    // Check for new versions for each node
+    promises = nodes.map(function(node) {
+        var target = node.endpoint.target;
+
+        return repository
+            .versions(node.endpoint.source)
+            .then(function(versions) {
+                node.versions = versions;
+
+                // Do not check if node's target is not a valid semver one
+                if (versions.length && semver.validRange(target)) {
+                    node.update = {
+                        target: semver.maxSatisfying(versions, target),
+                        latest: semver.maxSatisfying(versions, '*')
+                    };
+                }
+            });
+    });
+
+    // Set the versions also for the root node
+    tree.versions = [];
+
+    return Q.all(promises);
+}
+
+function paths(flattened) {
+    var ret = {};
+
+    mout.object.forOwn(flattened, function(pkg, name) {
+        var main;
+
+        if (pkg.missing) {
+            return;
+        }
+
+        main = pkg.pkgMeta.main;
+
+        // If no main was specified, fallback to canonical dir
+        if (!main) {
+            ret[name] = pkg.canonicalDir;
+            return;
+        }
+
+        // Normalize main
+        if (typeof main === 'string') {
+            main = [main];
+        }
+
+        // Concatenate each main entry with the canonical dir
+        main = main.map(function(part) {
+            return normalize(path.join(pkg.canonicalDir, part).trim());
+        });
+
+        // If only one main file, use a string
+        // Otherwise use an array
+        ret[name] = main.length === 1 ? main[0] : main;
+    });
+
+    return ret;
+}
+
+function normalize(src) {
+    return src.replace(/\\/g, '/');
+}
+
+// -------------------
+
+list.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            paths: { type: Boolean, shorthand: 'p' },
+            relative: { type: Boolean, shorthand: 'r' }
+        },
+        argv
+    );
+
+    delete options.argv;
+
+    return [options];
+};
+
+module.exports = list;

node_modules/bower/lib/commands/login.js

@@ -0,0 +1,155 @@
+var Configstore = require('configstore');
+var GitHub = require('github');
+var Q = require('q');
+
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
+
+function login(logger, options, config) {
+    var configstore = new Configstore('bower-github');
+
+    config = defaultConfig(config);
+
+    var promise;
+
+    options = options || {};
+
+    if (options.token) {
+        promise = Q.resolve({ token: options.token });
+    } else {
+        // This command requires interactive to be enabled
+        if (!config.interactive) {
+            logger.emit(
+                'error',
+                createError('Login requires an interactive shell', 'ENOINT', {
+                    details:
+                        'Note that you can manually force an interactive shell with --config.interactive'
+                })
+            );
+
+            return;
+        }
+
+        var questions = [
+            {
+                name: 'username',
+                message: 'Username',
+                type: 'input',
+                default: configstore.get('username')
+            },
+            {
+                name: 'password',
+                message: 'Password',
+                type: 'password'
+            }
+        ];
+
+        var github = new GitHub({
+            version: '3.0.0'
+        });
+
+        promise = Q.nfcall(logger.prompt.bind(logger), questions).then(function(
+            answers
+        ) {
+            configstore.set('username', answers.username);
+
+            github.authenticate({
+                type: 'basic',
+                username: answers.username,
+                password: answers.password
+            });
+
+            return Q.ninvoke(github.authorization, 'create', {
+                scopes: ['user', 'repo'],
+                note:
+                    'Bower command line client (' +
+                    new Date().toISOString() +
+                    ')'
+            });
+        });
+    }
+
+    return promise.then(
+        function(result) {
+            configstore.set('accessToken', result.token);
+            logger.info(
+                'EAUTH',
+                'Logged in as ' + configstore.get('username'),
+                {}
+            );
+
+            return result;
+        },
+        function(error) {
+            var message;
+
+            try {
+                message = JSON.parse(error.message).message;
+            } catch (e) {
+                message = 'Authorization failed';
+            }
+
+            var questions = [
+                {
+                    name: 'otpcode',
+                    message: 'Two-Factor Auth Code',
+                    type: 'input'
+                }
+            ];
+
+            if (
+                message === 'Must specify two-factor authentication OTP code.'
+            ) {
+                return Q.nfcall(logger.prompt.bind(logger), questions)
+                    .then(function(answers) {
+                        return Q.ninvoke(github.authorization, 'create', {
+                            scopes: ['user', 'repo'],
+                            note:
+                                'Bower command line client (' +
+                                new Date().toISOString() +
+                                ')',
+                            headers: {
+                                'X-GitHub-OTP': answers.otpcode
+                            }
+                        });
+                    })
+                    .then(
+                        function(result) {
+                            configstore.set('accessToken', result.token);
+                            logger.info(
+                                'EAUTH',
+                                'Logged in as ' + configstore.get('username'),
+                                {}
+                            );
+
+                            return result;
+                        },
+                        function() {
+                            logger.emit('error', createError(message, 'EAUTH'));
+                        }
+                    );
+            } else {
+                logger.emit('error', createError(message, 'EAUTH'));
+            }
+        }
+    );
+}
+
+// -------------------
+
+login.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            token: { type: String, shorthand: 't' }
+        },
+        argv
+    );
+
+    delete options.argv;
+
+    return [options];
+};
+
+module.exports = login;

node_modules/bower/lib/commands/lookup.js

@@ -0,0 +1,37 @@
+var Q = require('q');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
+
+function lookup(logger, name, config) {
+    if (!name) {
+        return new Q(null);
+    }
+
+    config = defaultConfig(config);
+
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
+
+    return Q.nfcall(registryClient.lookup.bind(registryClient), name).then(
+        function(entry) {
+            return !entry
+                ? null
+                : {
+                    name: name,
+                    url: entry.url
+                };
+        }
+    );
+}
+
+// -------------------
+
+lookup.readOptions = function(argv) {
+    var cli = require('../util/cli');
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
+};
+
+module.exports = lookup;

node_modules/bower/lib/commands/prune.js

@@ -0,0 +1,60 @@
+var mout = require('mout');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+
+function prune(logger, options, config) {
+    var project;
+
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    return clean(project, options);
+}
+
+function clean(project, options, removed) {
+    removed = removed || {};
+
+    // Continually call clean until there is no more extraneous
+    // dependencies to remove
+    return project
+        .getTree(options)
+        .spread(function(tree, flattened, extraneous) {
+            var names = extraneous.map(function(extra) {
+                return extra.endpoint.name;
+            });
+
+            // Uninstall extraneous
+            return project
+                .uninstall(names, options)
+                .then(function(uninstalled) {
+                    // Are we done?
+                    if (!mout.object.size(uninstalled)) {
+                        return removed;
+                    }
+
+                    // Not yet, recurse!
+                    mout.object.mixIn(removed, uninstalled);
+                    return clean(project, options, removed);
+                });
+        });
+}
+
+// -------------------
+
+prune.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            production: { type: Boolean, shorthand: 'p' }
+        },
+        argv
+    );
+
+    delete options.argv;
+
+    return [options];
+};
+
+module.exports = prune;

node_modules/bower/lib/commands/register.js

@@ -0,0 +1,100 @@
+var Q = require('q');
+var chalk = require('chalk');
+var PackageRepository = require('../core/PackageRepository');
+var createError = require('../util/createError');
+var defaultConfig = require('../config');
+
+function register(logger, name, source, config) {
+    var repository;
+    var registryClient;
+    var force;
+    var url;
+    var githubSourceRegex = /^\w[\w-]*\/\w[\w-]*$/;
+    var getGithubUrl = function(source) {
+        return 'git@github.com:' + source + '.git';
+    };
+
+    config = defaultConfig(config);
+    force = config.force;
+
+    name = (name || '').trim();
+    source = (source || '').trim();
+
+    url = source.match(githubSourceRegex) ? getGithubUrl(source) : source;
+
+    // Bypass any cache
+    config.offline = false;
+    config.force = true;
+
+    return Q.try(function() {
+        // Verify name and url
+        if (!name || !url) {
+            throw createError(
+                'Usage: bower register <name> <url>',
+                'EINVFORMAT'
+            );
+        }
+
+        // Attempt to resolve the package referenced by the URL to ensure
+        // everything is ok before registering
+        repository = new PackageRepository(config, logger);
+        return repository.fetch({ name: name, source: url, target: '*' });
+    })
+        .spread(function(canonicalDir, pkgMeta) {
+            if (pkgMeta.private) {
+                throw createError(
+                    'The package you are trying to register is marked as private',
+                    'EPRIV'
+                );
+            }
+
+            // If non interactive or user forced, bypass confirmation
+            if (!config.interactive || force) {
+                return true;
+            }
+
+            // Confirm if the user really wants to register
+            return Q.nfcall(logger.prompt.bind(logger), {
+                type: 'confirm',
+                message:
+                    'Registering a package will make it installable via the registry (' +
+                    chalk.cyan.underline(config.registry.register) +
+                    '), continue?',
+                default: true
+            });
+        })
+        .then(function(result) {
+            // If user response was negative, abort
+            if (!result) {
+                return;
+            }
+
+            // Register
+            registryClient = repository.getRegistryClient();
+
+            logger.action('register', url, {
+                name: name,
+                url: url
+            });
+
+            return Q.nfcall(
+                registryClient.register.bind(registryClient),
+                name,
+                url
+            );
+        });
+}
+
+// -------------------
+
+register.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+    var url = options.argv.remain[2];
+
+    return [name, url];
+};
+
+module.exports = register;

node_modules/bower/lib/commands/search.js

@@ -0,0 +1,39 @@
+var Q = require('q');
+var PackageRepository = require('../core/PackageRepository');
+var defaultConfig = require('../config');
+var cli = require('../util/cli');
+var createError = require('../util/createError');
+
+function search(logger, name, config) {
+    var registryClient;
+
+    config = defaultConfig(config);
+
+    var repository = new PackageRepository(config, logger);
+    var registryClient = repository.getRegistryClient();
+
+    if (name) {
+        return Q.nfcall(registryClient.search.bind(registryClient), name);
+    } else {
+        // List all packages when in interactive mode + json enabled, and
+        // always when in non-interactive mode
+        if (config.interactive && !config.json) {
+            throw createError('no parameter to bower search', 'EREADOPTIONS');
+        }
+
+        return Q.nfcall(registryClient.list.bind(registryClient));
+    }
+}
+
+// -------------------
+
+search.readOptions = function(argv) {
+    var options = cli.readOptions(argv);
+    var terms = options.argv.remain.slice(1);
+
+    var name = terms.join(' ');
+
+    return [name];
+};
+
+module.exports = search;

node_modules/bower/lib/commands/uninstall.js

@@ -0,0 +1,132 @@
+var mout = require('mout');
+var Q = require('q');
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+
+function uninstall(logger, names, options, config) {
+    if (!names.length) {
+        return new Q();
+    }
+
+    var project;
+
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    return project.getTree(options).spread(function(tree, flattened) {
+        // Uninstall nodes
+        return (
+            project
+                .uninstall(names, options)
+                // Clean out non-shared uninstalled dependencies
+                .then(function(uninstalled) {
+                    var names = Object.keys(uninstalled);
+                    var children = [];
+
+                    // Grab the dependencies of packages that were uninstalled
+                    mout.object.forOwn(flattened, function(node) {
+                        if (names.indexOf(node.endpoint.name) !== -1) {
+                            children.push.apply(
+                                children,
+                                mout.object.keys(node.dependencies)
+                            );
+                        }
+                    });
+
+                    // Clean them!
+                    return clean(project, children, uninstalled);
+                })
+        );
+    });
+}
+
+function clean(project, names, removed) {
+    removed = removed || {};
+
+    return project.getTree().spread(function(tree, flattened) {
+        var nodes = [];
+        var dependantsCounter = {};
+
+        // Grab the nodes of each specified name
+        mout.object.forOwn(flattened, function(node) {
+            if (names.indexOf(node.endpoint.name) !== -1) {
+                nodes.push(node);
+            }
+        });
+
+        // Walk the down the tree, gathering dependants of the packages
+        project.walkTree(
+            tree,
+            function(node, nodeName) {
+                if (names.indexOf(nodeName) !== -1) {
+                    dependantsCounter[nodeName] =
+                        dependantsCounter[nodeName] || 0;
+                    dependantsCounter[nodeName] += node.nrDependants;
+                }
+            },
+            true
+        );
+
+        // Filter out those that have no dependants
+        nodes = nodes.filter(function(node) {
+            return !dependantsCounter[node.endpoint.name];
+        });
+
+        // Are we done?
+        if (!nodes.length) {
+            return Q.resolve(removed);
+        }
+
+        // Grab the nodes after filtering
+        names = nodes.map(function(node) {
+            return node.endpoint.name;
+        });
+
+        // Uninstall them
+        return (
+            project
+                .uninstall(names)
+                // Clean out non-shared uninstalled dependencies
+                .then(function(uninstalled) {
+                    var children;
+
+                    mout.object.mixIn(removed, uninstalled);
+
+                    // Grab the dependencies of packages that were uninstalled
+                    children = [];
+                    nodes.forEach(function(node) {
+                        children.push.apply(
+                            children,
+                            mout.object.keys(node.dependencies)
+                        );
+                    });
+
+                    // Recurse!
+                    return clean(project, children, removed);
+                })
+        );
+    });
+}
+
+// -------------------
+
+uninstall.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            save: { type: Boolean, shorthand: 'S' },
+            'save-dev': { type: Boolean, shorthand: 'D' }
+        },
+        argv
+    );
+
+    var names = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [names, options];
+};
+
+module.exports = uninstall;

node_modules/bower/lib/commands/unregister.js

@@ -0,0 +1,90 @@
+var chalk = require('chalk');
+var Q = require('q');
+
+var defaultConfig = require('../config');
+var PackageRepository = require('../core/PackageRepository');
+var createError = require('../util/createError');
+
+function unregister(logger, name, config) {
+    if (!name) {
+        return;
+    }
+
+    var repository;
+    var registryClient;
+    var force;
+
+    config = defaultConfig(config);
+    force = config.force;
+
+    // Bypass any cache
+    config.offline = false;
+    config.force = true;
+
+    // Trim name
+    name = name.trim();
+
+    repository = new PackageRepository(config, logger);
+
+    if (!config.accessToken) {
+        return logger.emit(
+            'error',
+            createError(
+                'Use "bower login" with collaborator credentials',
+                'EFORBIDDEN'
+            )
+        );
+    }
+
+    return Q.resolve()
+        .then(function() {
+            // If non interactive or user forced, bypass confirmation
+            if (!config.interactive || force) {
+                return true;
+            }
+
+            return Q.nfcall(logger.prompt.bind(logger), {
+                type: 'confirm',
+                message:
+                    'You are about to remove component "' +
+                    chalk.cyan.underline(name) +
+                    '" from the bower registry (' +
+                    chalk.cyan.underline(config.registry.register) +
+                    '). It is generally considered bad behavior to remove versions of a library that others are depending on. Are you really sure?',
+                default: false
+            });
+        })
+        .then(function(result) {
+            // If user response was negative, abort
+            if (!result) {
+                return;
+            }
+
+            registryClient = repository.getRegistryClient();
+
+            logger.action('unregister', name, { name: name });
+
+            return Q.nfcall(
+                registryClient.unregister.bind(registryClient),
+                name
+            );
+        })
+        .then(function(result) {
+            logger.info('Package unregistered', name);
+
+            return result;
+        });
+}
+
+// -------------------
+
+unregister.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(argv);
+    var name = options.argv.remain[1];
+
+    return [name];
+};
+
+module.exports = unregister;

node_modules/bower/lib/commands/update.js

@@ -0,0 +1,39 @@
+var Project = require('../core/Project');
+var defaultConfig = require('../config');
+
+function update(logger, names, options, config) {
+    var project;
+
+    options = options || {};
+    config = defaultConfig(config);
+    project = new Project(config, logger);
+
+    // If names is an empty array, null them
+    if (names && !names.length) {
+        names = null;
+    }
+
+    return project.update(names, options);
+}
+
+// -------------------
+
+update.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            'force-latest': { type: Boolean, shorthand: 'F' },
+            production: { type: Boolean, shorthand: 'p' }
+        },
+        argv
+    );
+
+    var names = options.argv.remain.slice(1);
+
+    delete options.argv;
+
+    return [names, options];
+};
+
+module.exports = update;

node_modules/bower/lib/commands/version.js

@@ -0,0 +1,210 @@
+var semver = require('semver');
+var which = require('which');
+var fs = require('../util/fs');
+var path = require('path');
+var Q = require('q');
+var execFile = require('child_process').execFile;
+var defaultConfig = require('../config');
+var createError = require('../util/createError');
+
+function version(logger, versionArg, options, config) {
+    options = options || {};
+
+    config = defaultConfig(config);
+
+    return bump(logger, config, versionArg, options.message);
+}
+
+function bump(logger, config, versionArg, message) {
+    var cwd = config.cwd || process.cwd();
+    var newVersion;
+
+    if (!versionArg) {
+        throw createError('No <version> agrument provided', 'EREADOPTIONS');
+    }
+
+    return driver
+        .check(cwd)
+        .then(function() {
+            return Q.all([driver.versions(cwd), driver.currentVersion(cwd)]);
+        })
+        .spread(function(versions, currentVersion) {
+            currentVersion = currentVersion || '0.0.0';
+
+            if (semver.valid(versionArg)) {
+                newVersion = semver.valid(versionArg);
+            } else {
+                newVersion = semver.inc(currentVersion, versionArg);
+
+                if (!newVersion) {
+                    throw createError(
+                        'Invalid <version> argument: ' + versionArg,
+                        'EINVALIDVERSION',
+                        { version: versionArg }
+                    );
+                }
+            }
+
+            newVersion =
+                currentVersion[0] === 'v' ? 'v' + newVersion : newVersion;
+
+            if (versions) {
+                versions.forEach(function(version) {
+                    if (semver.eq(version, newVersion)) {
+                        throw createError(
+                            'Version exists: ' + newVersion,
+                            'EVERSIONEXISTS',
+                            { versions: versions, newVersion: newVersion }
+                        );
+                    }
+                });
+            }
+
+            return driver.bump(cwd, newVersion, message).then(function() {
+                return {
+                    oldVersion: currentVersion,
+                    newVersion: newVersion
+                };
+            });
+        })
+        .then(function(result) {
+            logger.info(
+                'version',
+                'Bumped package version from ' +
+                    result.oldVersion +
+                    ' to ' +
+                    result.newVersion,
+                result
+            );
+
+            return result.newVersion;
+        });
+}
+
+var driver = {
+    check: function(cwd) {
+        function checkGit(cwd) {
+            var gitDir = path.join(cwd, '.git');
+            return Q.nfcall(fs.stat, gitDir).then(
+                function(stat) {
+                    if (stat.isDirectory()) {
+                        return checkGitStatus(cwd);
+                    }
+                    return false;
+                },
+                function() {
+                    //Ignore not found .git directory
+                    return false;
+                }
+            );
+        }
+
+        function checkGitStatus(cwd) {
+            return Q.nfcall(which, 'git')
+                .fail(function(err) {
+                    err.code = 'ENOGIT';
+                    throw err;
+                })
+                .then(function() {
+                    return Q.nfcall(
+                        execFile,
+                        'git',
+                        ['status', '--porcelain'],
+                        { env: process.env, cwd: cwd }
+                    );
+                })
+                .then(function(value) {
+                    var stdout = value[0];
+                    var lines = filterModifiedStatusLines(stdout);
+                    if (lines.length) {
+                        throw createError(
+                            'Version bump requires clean working directory',
+                            'EWORKINGDIRECTORYDIRTY'
+                        );
+                    }
+                    return true;
+                });
+        }
+
+        function filterModifiedStatusLines(stdout) {
+            return stdout
+                .trim()
+                .split('\n')
+                .filter(function(line) {
+                    return line.trim() && !line.match(/^\?\? /);
+                })
+                .map(function(line) {
+                    return line.trim();
+                });
+        }
+
+        return checkGit(cwd).then(function(hasGit) {
+            if (!hasGit) {
+                throw createError(
+                    'Version bump currently supports only git repositories',
+                    'ENOTGITREPOSITORY'
+                );
+            }
+        });
+    },
+    versions: function(cwd) {
+        return Q.nfcall(execFile, 'git', ['tag'], {
+            env: process.env,
+            cwd: cwd
+        }).then(
+            function(res) {
+                var versions = res[0].split(/\r?\n/).filter(semver.valid);
+
+                return versions;
+            },
+            function() {
+                return [];
+            }
+        );
+    },
+    currentVersion: function(cwd) {
+        return Q.nfcall(execFile, 'git', ['describe', '--abbrev=0', '--tags'], {
+            env: process.env,
+            cwd: cwd
+        }).then(
+            function(res) {
+                var version = res[0].split(/\r?\n/).filter(semver.valid)[0];
+
+                return version;
+            },
+            function() {
+                return undefined;
+            }
+        );
+    },
+    bump: function(cwd, tag, message) {
+        message = message || tag;
+        message = message.replace(/%s/g, tag);
+        return Q.nfcall(
+            execFile,
+            'git',
+            ['commit', '-m', message, '--allow-empty'],
+            { env: process.env, cwd: cwd }
+        ).then(function() {
+            return Q.nfcall(execFile, 'git', ['tag', tag, '-am', message], {
+                env: process.env,
+                cwd: cwd
+            });
+        });
+    }
+};
+
+version.readOptions = function(argv) {
+    var cli = require('../util/cli');
+
+    var options = cli.readOptions(
+        {
+            message: { type: String, shorthand: 'm' }
+        },
+        argv
+    );
+
+    return [options.argv.remain[1], options];
+};
+
+module.exports = version;