lincd-cli 0.1.7 → 0.1.10

package/lib/cli.js

@@ -36,6 +36,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
 var utils_1 = require("./utils");
 require('require-extensions');
@@ -46,7 +55,105 @@ var fs = require('fs-extra');
 var path = require('path');
 var glob = require('glob');
 var variables = {};
-var open = require("open");
+var open = require('open');
+program
+    .command('create-app')
+    .action(function (name) {
+    return createApp(name);
+})
+    .description('Creates a new folder with all the required files for a LINCD app')
+    .argument('<name>', 'the name of your LINCD app');
+program
+    .command('create-module')
+    .action(function (name, uriBase) {
+    return createModule(name, uriBase);
+})
+    .description('Create a new folder with all the required files for a new LINCD module')
+    .argument('<name>', 'The name of the module. Will be used as package name in package.json')
+    .argument('[uri_base]', 'The base URL used for data of this module. Leave blank to use the URL of your module on lincd.org after you register it');
+program
+    .command('create-shape')
+    .action(function (name, uriBase) {
+    return createShape(name);
+})
+    .description('Creates a new ShapeClass file for your module. Execute this from your module folder.')
+    .argument('<name>', 'The name of the shape. Will be used for the file name and the class name');
+program
+    .command('create-ontology')
+    .action(function (prefix, uriBase) {
+    return createOntology(prefix, uriBase);
+})
+    .description('Creates a new ontology file for your module. Execute this from your module folder.')
+    .argument('<suggested-prefix>', 'The suggested prefix for your ontology. Also the shorthand code used for the file name and the exported ontology object')
+    .argument('[uribase]', "Optional argument to set the URI base for the URI's of all entities in your ontology. Leave blank to use the URI's provided by lincd.org once you register this module");
+program.command('register-local', { hidden: true }).action(function () {
+    register('http://localhost:4001');
+});
+program.command('register-dev', { hidden: true }).action(function () {
+    register('https://dev-registry.lincd.org');
+});
+program
+    .command('register')
+    .action(function () {
+    register('https://registry.lincd.org');
+})
+    .description('Register (a new version of) this module to the LINCD registry. If successful your module will appear on www.lincd.org');
+program
+    .command('info')
+    .action(function () {
+    var ownPackage = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+    console.log(ownPackage.version);
+    console.log('Running from: ' + __dirname);
+})
+    .description("Log the version of this tool and the path that it's running from");
+program.command('build [target] [target2]', { isDefault: true }).action(function (target, target2) {
+    buildModule(target, target2);
+});
+program.command('publish-updated').action(function () {
+    return publishUpdated();
+});
+program.command('status').action(function () {
+    return publishUpdated(true).then(function () {
+        return buildUpdated(undefined, '', '', true);
+    });
+});
+program.command('build-updated [target] [target2]').action(function (target, target2) {
+    return buildUpdated(1, target, target2);
+});
+program.command('build-updated-since [num-commits-back] [target] [target2]').action(function (back, target, target2) {
+    return buildUpdated(back, target, target2);
+});
+program.command('build-all [target] [target2]').action(function (target, target2) {
+    buildAll(target, target2);
+});
+program.command('modules [action] [includedSpaces]').action(function (command, includedSpaces) {
+    executeCommandForEachModule(getLincdModules(), command, includedSpaces);
+});
+program.command('modules-except [excludedSpaces] [action]').action(function (excludedSpaces, command) {
+    executeCommandForEachModule(getLincdModules(), command, null, excludedSpaces);
+});
+program.command('dev [target] [mode]').action(function (target, mode) {
+    developModule(target, mode);
+});
+program
+    .command('module|m')
+    .action(function (name, command, args) {
+    var fullCommand = (command ? command + ' ' +
+        ' ' +
+        args
+            .slice(0, 3)
+            .filter(function (a) { return a && true; })
+            .join(' ') : null);
+    executeCommandForModule(name, fullCommand);
+})
+    .alias('m')
+    .description("Searches for a module in this workspace with a partially matching name and executes a command for that module (without needing to execute it from that modules' folder)")
+    .argument('<name>', 'the name of the module. Can be a part of the name.')
+    .argument('[command]', 'the lincd command you want to execute. Like dev or build')
+    .argument('[args...]', 'the additional arguments of that command');
+function logHelp() {
+    execp('yarn lincd help');
+}
 function log() {
     var messages = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -66,6 +173,25 @@ function warn() {
         // console.log(chalk.red(message));
     });
 }
+function developModule(target, mode) {
+    if (!target)
+        target = 'es6';
+    if (mode !== 'production')
+        mode = '';
+    else if (target !== 'es6')
+        log('target must be es6 when developing for production');
+    if (target == 'es5' || target == 'es6') {
+        // log('> Starting continuous development build for '+target+' target')
+        log('starting continuous development build');
+        log('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
+        var command = exec('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
+        command.stdout.pipe(process.stdout);
+        command.stderr.pipe(process.stderr);
+    }
+    else {
+        console.warn('unknown build target. Use es5 or es6');
+    }
+}
 function checkWorkspaces(rootPath, workspaces, res) {
     // console.log('checking workspaces at '+rootPath+": "+workspaces.toString());
     workspaces.forEach(function (workspace) {
@@ -104,6 +230,194 @@ function checkModulePath(rootPath, modulePath, res) {
         }
     }
 }
+function buildAll(target, target2) {
+    var _this = this;
+    var dependencies = new Map();
+    console.log('Building all modules of this repository in order of dependencies');
+    var modules = getLocalLincdModuleMap();
+    //get dependencies of each module
+    var leastDependentModule;
+    modules.forEach(function (module) {
+        var pack = (0, utils_1.getPackageJSON)(module.path);
+        if (pack) {
+            //get lincd related dependencies and get the actual module details from the module map by removing '@dacore/' from the package name
+            var moduleDependencies = Object.keys(pack.dependencies)
+                .filter(function (dependency) { return modules.has(dependency); })
+                .map(function (dependency) {
+                return modules.has(dependency) ? modules.get(dependency) : dependency;
+            });
+            // console.log(module.moduleName,moduleDependencies.map())
+            dependencies.set(module, moduleDependencies);
+        }
+    });
+    dependencies.forEach(function (moduleDependencies, module) {
+        if (!moduleDependencies.some(function (dependency) {
+            return typeof dependency !== 'string' && modules.has(dependency.moduleName);
+        })) {
+            leastDependentModule = module;
+        }
+    });
+    var startFrom;
+    //by default start building
+    var building = true;
+    //option to start from a specific module in the stack
+    if (target == 'from') {
+        startFrom = target2;
+        //if we have a startFrom, then we havnt started the build process yet
+        building = startFrom ? false : true;
+        //clear targets
+        target = '';
+        target2 = '';
+        console.log(chalk.blue('Will skip builds until ' + startFrom));
+    }
+    var stack = [leastDependentModule];
+    var done = new Set();
+    var p = Promise.resolve();
+    var runStack = function () { return __awaiter(_this, void 0, void 0, function () {
+        var modulesLeft, failedModules, stackPromise, first_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    modulesLeft = modules.size - done.size;
+                    if (done.size > 0) {
+                        console.log(chalk.magenta('\n-------\nThese modules are next, since all their dependencies have now been build:'));
+                        console.log(chalk.magenta(stack.map(function (i) { return i.moduleName; })));
+                        // log(stack);
+                    }
+                    failedModules = [];
+                    stackPromise = Promise.all(stack.map(function (module) {
+                        // p = p.then(() => {
+                        var command;
+                        //if we're skipping builds until a certain module
+                        if (!building) {
+                            //if the module name matches the module we're supposed to start from then start building modules
+                            if (module.moduleName == startFrom || module.packageName == startFrom) {
+                                building = true;
+                            }
+                            //else still waiting for the module
+                            else {
+                                log(chalk.blue('skipping ' + module.moduleName));
+                                command = Promise.resolve(true);
+                            }
+                        }
+                        //unless told otherwise, build the module
+                        if (!command) {
+                            command = execp('cd ' +
+                                module.path +
+                                ' && yarn lincd build' +
+                                (target ? ' ' + target : '') +
+                                (target2 ? ' ' + target2 : ''));
+                            log(chalk.cyan('Building ' + module.moduleName));
+                        }
+                        return command["catch"](function (err) {
+                            var dependentModules = [];
+                            dependencies.forEach(function (dModuleDependencies, dModule) {
+                                if (dModuleDependencies.indexOf(module) !== -1) {
+                                    dependentModules.push(dModule);
+                                }
+                            });
+                            if (dependentModules.length > 0) {
+                                failedModules.push(module.moduleName);
+                                printFailedModules(failedModules);
+                                console.log(chalk.magenta('Stopping build process because an error occurred whilst building ' +
+                                    module.moduleName +
+                                    ', which ' +
+                                    dependentModules.length +
+                                    ' other modules depend on.')); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                                console.log(chalk.cyanBright('tip ') +
+                                    'Run ' +
+                                    chalk.green("lincd build-all from ".concat(module.moduleName)) +
+                                    ' to build only the remaining modules'); //"+dependentModules.map(d => d.moduleName).join(", ")));
+                                process.exit(1);
+                            }
+                            else {
+                                failedModules.push(module.moduleName);
+                            }
+                        })
+                            .then(function (res) {
+                            done.add(module);
+                            modulesLeft--;
+                            log(chalk.magenta(modulesLeft + ' modules left'));
+                            if (modulesLeft == 0 && failedModules.length > 0) {
+                                printFailedModules(failedModules);
+                            }
+                            return res;
+                        });
+                        // });
+                        // done.add(module);
+                    }));
+                    //wait till stack is completed
+                    return [4 /*yield*/, stackPromise];
+                case 1:
+                    //wait till stack is completed
+                    _a.sent();
+                    // await p;
+                    //clear stack for next round
+                    stack = [];
+                    //find those modules who have all their dependencies already built and add them to the stack
+                    modules.forEach(function (module) {
+                        var deps = dependencies.get(module);
+                        //if the module is not done yet
+                        //but every dependency is now done OR was not something we can build (some @dacore dependencies may not be local)
+                        if (!done.has(module) &&
+                            deps.every(function (dependency) {
+                                return typeof dependency !== 'string' && (done.has(dependency) || !modules.has(dependency.moduleName));
+                            })) {
+                            stack.push(module);
+                        }
+                        // else if(!done.has(module))
+                        // {
+                        // 	console.log(chalk.red(module+' not yet'))
+                        // 	console.log('UNMET DEPS: '+deps.filter(dependency => !done.has(dependency)).join(" "))
+                        // }
+                    });
+                    //if more to be built, iterate
+                    if (stack.length > 0) {
+                        return [2 /*return*/, runStack()];
+                    }
+                    else {
+                        //if no more modules to build but we never started building...
+                        if (!building) {
+                            console.log(chalk.red('Could not find the module to start from. Please provide a correct package name or module name to build from'));
+                        }
+                        else {
+                            first_1 = true;
+                            modules.forEach(function (module) {
+                                if (!done.has(module)) {
+                                    var deps = dependencies.get(module);
+                                    if (first_1) {
+                                        console.log(chalk.red('CYCLICAL DEPENDENCIES? - could not build some modules because they depend on each other.'));
+                                        first_1 = false;
+                                    }
+                                    //print the cyclical dependencies
+                                    console.log(chalk.red(module.moduleName) +
+                                        ' depends on ' +
+                                        deps
+                                            .filter(function (dependency) {
+                                            return typeof dependency !== 'string';
+                                        })
+                                            .map(function (d) {
+                                            return done.has(d) ? d.moduleName : chalk.red(d.moduleName);
+                                        })
+                                            .join(', '));
+                                    //also print some information why these modules have not been moved into the stack
+                                    var stringDependencies = deps.filter(function (d) { return typeof d === 'string'; });
+                                    if (stringDependencies.length > 0) {
+                                        console.log(chalk.red('And it depends on these module(s) - which seem not to be proper modules :' +
+                                            stringDependencies.join(', ')));
+                                        console.log(chalk.red('Could you remove this from dependencies? Should it be a devDependency?'));
+                                    }
+                                }
+                            });
+                        }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    //starts the process
+    runStack();
+}
 /**
  * Returns a map of the modules that this repository manages (so no modules found through the workspaces who's path contains ../ )
  * @param rootPath
@@ -126,20 +440,26 @@ function getLocalLincdModules(rootPath) {
     });
 }
 function getLincdModules(rootPath) {
-    if (rootPath === void 0) { rootPath = './'; }
-    //TODO: read from package.json what the workspaces are. for each, follow up all the folders inside that path
-    //TODO: then return an array with objects that have both the module name + the path. And then use that path across this whenever this function is called
-    //TODO: this way it will work with websites as well, instead of just from the main LINCD repository
+    if (rootPath === void 0) { rootPath = process.cwd(); }
     var pack = (0, utils_1.getPackageJSON)();
-    var res = [];
-    if (!pack.workspaces) {
+    if (!pack || !pack.workspaces) {
+        for (var i = 0; i <= 3; i++) {
+            rootPath = path.join.apply(path, __spreadArray([process.cwd()], Array(i).fill('..'), false));
+            pack = (0, utils_1.getPackageJSON)(rootPath);
+            if (pack && pack.workspaces) {
+                // log('Found workspace at '+packagePath);
+                break;
+            }
+        }
+    }
+    if (!pack || !pack.workspaces) {
         warn(chalk.red('Could not find package workspaces. Make sure you run this command from a yarn workspace.'));
         logHelp();
         process.exit();
     }
-    //TODO: filter with package.lincd = true?
+    // console.log(pack.workspaces);
+    var res = [];
     checkWorkspaces(rootPath, pack.workspaces, res);
-    // console.log(res);
     return res;
 }
 function setVariable(name, replacement) {
@@ -201,12 +521,6 @@ function execp(cmd, log, allowError, options) {
         });
     });
 }
-function replaceVariables(string) {
-    for (var key in variables) {
-        string = string.replace(new RegExp(key, 'g'), variables[key]);
-    }
-    return string;
-}
 function execPromise(command, log, allowError, options) {
     if (log === void 0) { log = false; }
     if (allowError === void 0) { allowError = false; }
@@ -255,84 +569,231 @@ var replaceCurlyVariables = function (string) {
 };
 var capitalize = function (str) { return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1); };
 var camelCase = function (str) {
+    //this version does not replace any capitals already used by the user
     var string = str
-        .toLowerCase()
         .replace(/[^A-Za-z0-9]/g, ' ')
         .split(' ')
-        .reduce(function (result, word) { return result + capitalize(word.toLowerCase()); });
-    return string.charAt(0).toLowerCase() + string.slice(1);
+        .reduce(function (result, word) { return result + capitalize(word); });
+    //it also leave the first capital intact
+    return string;
 };
-program.command('create-app [name] [uribase]').action(function (name, uriBase) {
-    return createApp(name, uriBase);
-});
-program.command('create-module [name] [uribase]').action(function (name, uriBase) {
-    return createModule(name, uriBase);
-});
-var createModule = function (name, uriBase, basePath) {
+var createOntology = function (prefix, uriBase, basePath) {
     if (basePath === void 0) { basePath = process.cwd(); }
     return __awaiter(void 0, void 0, void 0, function () {
-        var targetFolder, _a, packageName, scope, cleanPackageName, codeName, cameCaseName, underscoreName, version, installCommand;
+        var targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, targetDataFile, targetDataFile2, indexPath;
         return __generator(this, function (_b) {
             switch (_b.label) {
+                case 0:
+                    if (!prefix) {
+                        console.warn('Please provide a suggested prefix as the first argument');
+                        return [2 /*return*/];
+                    }
+                    targetFolder = ensureFolderExists(basePath, 'src', 'ontologies');
+                    if (!uriBase) {
+                        uriBase = 'http://lincd.org/ont/' + prefix;
+                    }
+                    setVariable('uri_base', uriBase);
+                    _a = setNameVariables(prefix), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    //copy ontology accessor file
+                    log("Creating files for ontology '" + prefix + "'");
+                    targetFile = path.join(targetFolder, hyphenName + '.ts');
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'ontologies', 'example-ontology.ts'), targetFile);
+                    targetDataFile = path.join(targetFolder, '..', 'data', hyphenName + '.json');
+                    targetDataFile2 = path.join(targetFolder, '..', 'data', hyphenName + '.json.d.ts');
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json'), targetDataFile);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetDataFile, targetDataFile2)];
+                case 1:
+                    _b.sent();
+                    indexPath = addLineToIndex("import './ontologies/".concat(hyphenName, "';"), 'ontologies');
+                    log("Prepared a new ontology data files in ".concat(chalk.magenta(targetDataFile.replace(basePath, ''))), "And an ontology accessor file in ".concat(chalk.magenta(targetFile.replace(basePath, ''))), "Added an import of this file from ".concat(chalk.magenta(indexPath)));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+var addLineToIndex = function (line, insertMatchString) {
+    //import ontology in index
+    var indexPath = ['index.ts', 'index.tsx']
+        .map(function (f) { return path.join('src', f); })
+        .find(function (indexFileName) {
+        return fs.existsSync(indexFileName);
+    });
+    if (indexPath) {
+        var indexContents = fs.readFileSync(indexPath, 'utf-8');
+        var lines = indexContents.split(/\n/g);
+        var newContents = void 0;
+        for (var key in lines) {
+            if (lines[key].indexOf(insertMatchString) !== -1) {
+                //remove lines after this line and insert new line in its place
+                lines[key] += "\n".concat(line);
+                newContents = lines.join('\n');
+                // log("Found at "+key,lines,newContents);
+                break;
+            }
+        }
+        if (!newContents) {
+            newContents = indexContents + "\n".concat(line);
+            // log("Added at end",newContents);
+        }
+        fs.writeFileSync(indexPath, newContents);
+    }
+    return indexPath;
+};
+var replaceVariablesInFiles = function () {
+    var files = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        files[_i] = arguments[_i];
+    }
+    return Promise.all(files.map(function (file) {
+        return replaceVariablesInFile(file);
+    }));
+};
+var ensureFolderExists = function () {
+    var folders = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        folders[_i] = arguments[_i];
+    }
+    var target;
+    folders.forEach(function (folder) {
+        target = target ? path.join(target, folder) : path.join(folder);
+        if (!fs.existsSync(target)) {
+            fs.mkdirSync(target);
+        }
+    });
+    return target;
+    /*let targetFolder = path.join(...folders);
+    let parentDirectory = folders.slice(0, folders.length - 1);
+    if (!fs.existsSync(targetFolder)) {
+      if (fs.existsSync(path.join(...parentDirectory))) {
+        fs.mkdirSync(targetFolder);
+      } else {
+        warn(
+          `Please run this command from the root of your module. This command expects ${parentDirectory.toString()} to exists from that folder`,
+        );
+      }
+    }
+    return targetFolder;*/
+};
+var setNameVariables = function (name) {
+    var hyphenName = name.replace(/[-_\s]+/g, '-');
+    var camelCaseName = camelCase(name); //some-module --> someModule
+    var underscoreName = name.replace(/[-\s]+/g, '_');
+    //longer similar variables names should come before the shorter ones
+    setVariable('underscore_name', underscoreName);
+    setVariable('hyphen_name', hyphenName);
+    setVariable('camel_name', camelCaseName);
+    setVariable('name', name);
+    return { hyphenName: hyphenName, camelCaseName: camelCaseName, underscoreName: underscoreName };
+};
+var createShape = function (name, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var targetFolder, _a, hyphenName, camelCaseName, underscoreName, targetFile, indexPath;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    targetFolder = ensureFolderExists(basePath, 'src', 'shapes');
+                    _a = setNameVariables(name), hyphenName = _a.hyphenName, camelCaseName = _a.camelCaseName, underscoreName = _a.underscoreName;
+                    //copy default shape file
+                    log("Creating files for shape '" + name + "'");
+                    targetFile = path.join(targetFolder, hyphenName + '.ts');
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'shape.ts'), targetFile);
+                    //replace variables in some of the copied files
+                    return [4 /*yield*/, replaceVariablesInFiles(targetFile)];
+                case 1:
+                    //replace variables in some of the copied files
+                    _b.sent();
+                    indexPath = addLineToIndex("import './shapes/".concat(hyphenName, "';"), 'shapes');
+                    log("Created a new shape class template in ".concat(chalk.magenta(targetFile.replace(basePath, ''))), "Added an import of this file from ".concat(chalk.magenta(indexPath)));
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+var createModule = function (name, uriBase, basePath) {
+    if (basePath === void 0) { basePath = process.cwd(); }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, packageName, scope, cleanPackageName, targetFolder, _b, hyphenName, camelCaseName, underscoreName, version, installCommand;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     //if ran with npx, basePath will be the root directory of the repository, even if we're executing from a sub folder (the root directory is where node_modules lives and package.json with workspaces)
                     //so we manually find a modules folder, if it exists we go into that.
                     if (fs.existsSync(path.join(basePath, 'modules'))) {
                         basePath = path.join(basePath, 'modules');
                     }
-                    targetFolder = path.join(basePath, name);
-                    console.log(targetFolder, basePath, name);
-                    if (!fs.existsSync(targetFolder)) {
-                        fs.mkdirSync(targetFolder);
+                    if (!name) {
+                        console.warn('Please provide a name as the first argument');
+                        return [2 /*return*/];
                     }
+                    _a = name.match(/(@[\w\-]+\/)?([\w\-]+)/), packageName = _a[0], scope = _a[1], cleanPackageName = _a[2];
+                    targetFolder = ensureFolderExists(basePath, cleanPackageName);
                     if (!uriBase) {
                         uriBase = 'http://lincd.org/ont/' + name;
                     }
-                    if (!name) {
-                        console.warn("Please provide a name as the first argument");
-                    }
-                    _a = name.match(/(@[\w\-]+\/)?([\w\-]+)/), packageName = _a[0], scope = _a[1], cleanPackageName = _a[2];
-                    // console.log(
-                    // 	'Copying ' +
-                    // 		path.join(__dirname, '..', 'defaults', 'module') +
-                    // 		'\nto ' +
-                    // 		basePath,
-                    // );
-                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module'), targetFolder);
-                    codeName = cleanPackageName.replace(/\-/g, '_');
-                    cameCaseName = camelCase(name);
-                    underscoreName = name.replace(/[-\s]+/g, '_');
                     setVariable('uri_base', uriBase);
-                    //longer similar variables names should come before the shorter ones
-                    setVariable('camel_module_name', cameCaseName);
-                    setVariable('underscore_module_name', underscoreName);
+                    //find @scope and the next part between 2 slashes after
+                    //so @dacore/some-mod/lib/file.js
+                    // --> match[0] = @dacore/some-mod
+                    // --> match[1] = @dacore
+                    // --> match[2] = some-mod
+                    //but save full scoped module name under ${module_name}
                     setVariable('module_name', name);
+                    //extra variable for clarity (will be same as 'name')
+                    setVariable('output_file_name', name);
+                    _b = setNameVariables(cleanPackageName), hyphenName = _b.hyphenName, camelCaseName = _b.camelCaseName, underscoreName = _b.underscoreName;
                     log("Creating new LINCD module '" + name + "'");
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'module'), targetFolder);
                     //replace variables in some of the copied files
-                    ['package.json', 'Gruntfile.js', 'src/module.ts']
-                        .map(function (f) { return path.join(targetFolder, f); })
-                        .forEach(function (file) {
-                        replaceVariablesInFile(file);
+                    return [4 /*yield*/, Promise.all([
+                            'src/index.ts',
+                            'package.json',
+                            'Gruntfile.js',
+                            'src/module.ts',
+                            'src/shapes/ExampleShapeClass.ts',
+                            'src/ontologies/example-ontology.ts',
+                            'src/data/example-ontology.json',
+                        ]
+                            .map(function (f) { return path.join(targetFolder, f); })
+                            .map(function (file) {
+                            return replaceVariablesInFile(file);
+                        }))];
+                case 1:
+                    //replace variables in some of the copied files
+                    _c.sent();
+                    //rename these to a file name similar to the module name
+                    [
+                        'src/ontologies/example-ontology.ts',
+                        'src/data/example-ontology.json',
+                        'src/data/example-ontology.json.d.ts',
+                    ].forEach(function (f) {
+                        var parts = f.split('/');
+                        var newParts = __spreadArray([], parts, true);
+                        var _a = newParts.pop().split('.'), name = _a[0], extensions = _a.slice(1);
+                        var newName = hyphenName + '.' + extensions.join('.');
+                        console.log('rename ', path.join(targetFolder, f), path.join.apply(path, __spreadArray(__spreadArray([targetFolder], newParts, false), [newName], false)));
+                        fs.renameSync(path.join(targetFolder, f), path.join.apply(path, __spreadArray(__spreadArray([targetFolder], newParts, false), [newName], false)));
                     });
                     return [4 /*yield*/, execPromise('yarn --version')["catch"](function (err) {
-                            console.log("yarn probably not working");
+                            console.log('yarn probably not working');
                             return '';
                         })];
-                case 1:
-                    version = _b.sent();
+                case 2:
+                    version = (_c.sent());
                     installCommand = version.toString().match(/[0-9]+/) ? 'yarn install' : 'npm install';
                     return [4 /*yield*/, execp("cd ".concat(targetFolder, " && ").concat(installCommand, " && npm exec lincd build"), true)["catch"](function (err) {
-                            console.warn("Could not install dependencies");
+                            console.warn('Could not install dependencies');
                         })];
-                case 2:
-                    _b.sent();
+                case 3:
+                    _c.sent();
                     log("Prepared a new LINCD module in ".concat(chalk.magenta(targetFolder)), "Run ".concat(chalk.blueBright('yarn build'), " from this directory to build once"), "Or ".concat(chalk.blueBright('yarn dev'), " to continuously rebuild on file changes"));
                     return [2 /*return*/];
             }
         });
     });
 };
-var createApp = function (name, uriBase, basePath) {
+var createApp = function (name, basePath) {
     if (basePath === void 0) { basePath = process.cwd(); }
     return __awaiter(void 0, void 0, void 0, function () {
         var _a, packageName, scope, cleanPackageName, targetFolder, codeName, cameCaseName, underscoreName, version, installCommand;
@@ -340,12 +801,9 @@ var createApp = function (name, uriBase, basePath) {
             switch (_b.label) {
                 case 0:
                     if (!name) {
-                        console.warn("Please provide a name as the first argument");
+                        console.warn('Please provide a name as the first argument');
                     }
                     _a = name.match(/(@[\w\-]+\/)?([\w\-]+)/), packageName = _a[0], scope = _a[1], cleanPackageName = _a[2];
-                    if (!uriBase) {
-                        uriBase = 'http://lincd.org/ont/' + name;
-                    }
                     targetFolder = path.join(basePath, name);
                     if (!fs.existsSync(targetFolder)) {
                         fs.mkdirSync(targetFolder);
@@ -354,7 +812,7 @@ var createApp = function (name, uriBase, basePath) {
                     codeName = cleanPackageName.replace(/\-/g, '_');
                     cameCaseName = camelCase(name);
                     underscoreName = name.replace(/[-\s]+/g, '_');
-                    setVariable('uri_base', uriBase);
+                    // setVariable('uri_base', uriBase);
                     //longer similar variables names should come before the shorter ones
                     setVariable('camelcase_name', cameCaseName);
                     setVariable('underscore_name', underscoreName);
@@ -367,14 +825,14 @@ var createApp = function (name, uriBase, basePath) {
                         replaceVariablesInFile(file);
                     });
                     return [4 /*yield*/, execPromise('yarn --version')["catch"](function (err) {
-                            console.log("yarn probably not working");
+                            console.log('yarn probably not working');
                             return '';
                         })];
                 case 1:
-                    version = _b.sent();
+                    version = (_b.sent());
                     installCommand = version.toString().match(/[0-9]+/) ? 'yarn install' : 'npm install';
                     return [4 /*yield*/, execp("cd ".concat(name, " && ").concat(installCommand, " && npm exec lincd build"), true)["catch"](function (err) {
-                            console.warn("Could not install dependencies");
+                            console.warn('Could not install dependencies');
                         })];
                 case 2:
                     _b.sent();
@@ -437,16 +895,14 @@ var buildFailed = function (output) {
         console.warn('Not a project');
     }
 });*/
-program.command('register [version]').action(function (newVersion) {
+var register = function (registryURL) {
     if (fs.existsSync(process.cwd() + '/package.json')) {
         var pack = JSON.parse(fs.readFileSync(process.cwd() + '/package.json', 'utf8'));
         var version = pack.version;
         var moduleName = pack.name;
         var author = pack.author;
-        // let displayName = pack.displayName;
         console.log(chalk.cyan('registering ' + author + "'s module, " + moduleName + ' ' + version + ' in the LINCD registry'));
-        //temporary test code
-        return fetch('http://localhost:4001/register', {
+        return fetch(registryURL + '/register', {
             method: 'POST',
             headers: {
                 Accept: 'application/json, text/plain, */*',
@@ -463,113 +919,13 @@ program.command('register [version]').action(function (newVersion) {
                 console.log(chalk.cyan('Response: ') + json.result);
             }
         })["catch"](function (err) {
-            console.warn('Could not connect to LINCD registry');
+            console.warn(chalk.red('Warning: ') + 'Could not connect to LINCD registry');
         });
-        /*console.log(chalk.cyan('building production bundles'));
-        return execPromise('yarn lincd build production', false, true)
-          .then((output: string) => {
-            if (buildFailed(output)) {
-              // console.warn("Build failed:");
-              console.log(output);
-              throw new Error('build failed');
-            }
-            pack.version = newVersion;
-            //save package.json
-            return fs.writeFileSync(
-              path.join(process.cwd(), 'package.json'),
-              JSON.stringify(pack, null, 2),
-            );
-          })
-          .then((version) => {
-            console.log(chalk.cyan('Committing to git'));
-            //we have just changed package.json, so there will be things "uncommitted"
-            //to make sure this module does not automatically come up as "needing to be published" we need to commit this change here straight away
-            //so: add all files not added yet in the folder of this module
-            //then commit all changes (including new version number in package.json)
-            //then add a version commit git flag
-            return execPromise(
-              `git add -- ./ & git commit -m "publishing ${moduleName} ${newVersion}" -- ./ & git tag ${moduleName}@${newVersion}"`,
-            );
-          })
-          .then((version) => {
-            console.log(chalk.cyan('Publishing ' + moduleName + ' ' + newVersion));
-    
-            // let tag = moduleName+'@'+version;
-            return execPromise('yarn publish --new-version ' + newVersion, true);
-          })
-          .then((res) => {
-            if (
-              res.indexOf('Aborted due to warnings') !== -1 ||
-              res.indexOf('Could not publish') !== -1 ||
-              res.indexOf("Couldn't publish") !== -1
-            ) {
-              console.log(chalk.red('Failed to publish'));
-              return false;
-            } else {
-              var pack = JSON.parse(
-                fs.readFileSync(process.cwd() + '/package.json', 'utf8'),
-              );
-              version = pack.version;
-              console.log(chalk.green('Published ' + version));
-              return true;
-            }
-          })
-          .catch((err) => {
-            console.warn(chalk.red('Could not publish: ' + err));
-          });*/
     }
     else {
-        console.warn('not found: ' + process.cwd() + '/package.json');
-    }
-});
-// program.command('create [action] [value]').action((action, prefixedUri) => {
-//
-// 	let [ontology,label] = typeof prefixedUri !== 'undefined' ? prefixedUri.split(":") : [];
-// 	if(!ontology || !label)
-// 	{
-// 		return console.warn("Please provide a prefixed URI of the "+action+" to create");
-// 	}
-// 	if(action == 'viewtype')
-// 	{
-// 		//add to ontology file
-// 		let contents = fs.readFileSync(path.join('src','ontologies',ontology),'utf8');
-//
-//
-// 		//create view file
-// 		//add view file to index
-// 	}
-// });
-program.command('info').action(function () {
-    var ownPackage = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
-    console.log(ownPackage.version);
-    console.log('Running from: ' + __dirname);
-});
-var ensurePath = function () {
-    var folders = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        folders[_i] = arguments[_i];
+        console.warn(chalk.red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
     }
-    // let target = path.join(folders.shift());
-    var target;
-    folders.forEach(function (folder) {
-        target = target ? path.join(target, folder) : path.join(folder);
-        if (!fs.existsSync(target)) {
-            fs.mkdirSync(target);
-        }
-    });
-    return target;
 };
-program.command('test-build').action(function (target, target2) {
-    execPromise('yarn lincd build', true)
-        .then(function (result) {
-        console.log('success');
-    })["catch"](function (err) {
-        console.log('failed');
-    });
-});
-program.command('build [target] [target2]').action(function (target, target2) {
-    buildModule(target, target2);
-});
 var buildModule = function (target, target2, modulePath, logResults) {
     if (modulePath === void 0) { modulePath = process.cwd(); }
     if (logResults === void 0) { logResults = true; }
@@ -611,9 +967,6 @@ var buildModule = function (target, target2, modulePath, logResults) {
         console.warn('unknown build target. Use es5, es6 or production.');
     }
 };
-// program.command('css').action((message) => {
-// 	return execp('grunt babel:css-module-transforms');
-// });
 var getLastBuildTime = function (modulePath) {
     return getLastModifiedFile(modulePath + '/@(builds|lib)/**/*.js');
 };
@@ -643,12 +996,6 @@ var getLastModifiedFile = function (filePath, config) {
             // console.log("skipping directory "+fileName);
             return;
         }
-        //not counting things that are generated during build process when determining last modified source-code time
-        // if(fileName.indexOf(".d.ts") !== -1 || fileName.indexOf(".css.json") !== -1)
-        // {
-        // 	// console.log("not counting "+fileName);
-        // 	return;
-        // }
         var mtime = fs.statSync(path.join(fileName)).mtime;
         var modifiedTime = mtime.getTime();
         if (modifiedTime > lastModifiedTime) {
@@ -660,14 +1007,6 @@ var getLastModifiedFile = function (filePath, config) {
     });
     return { lastModified: lastModified, lastModifiedName: lastModifiedName, lastModifiedTime: lastModifiedTime };
 };
-program.command('publish-updated').action(function () {
-    return publishUpdated();
-});
-program.command('status').action(function () {
-    return publishUpdated(true).then(function () {
-        return buildUpdated(undefined, '', '', true);
-    });
-});
 var publishUpdated = function (test) {
     var _this = this;
     if (test === void 0) { test = false; }
@@ -771,12 +1110,6 @@ var executeSingleBuild = function (module, previousResult, test, info) {
         return previousResult + ' ' + chalk.blue(module.moduleName + ' should publish\n');
     }
 };
-program.command('build-updated [target] [target2]').action(function (target, target2) {
-    return buildUpdated(1, target, target2);
-});
-program.command('build-updated-since [num-commits-back] [target] [target2]').action(function (back, target, target2) {
-    return buildUpdated(back, target, target2);
-});
 var buildUpdated = function (back, target, target2, test) {
     if (test === void 0) { test = false; }
     // back = back || 1;
@@ -837,205 +1170,9 @@ var buildUpdated = function (back, target, target2, test) {
     });
     // });
 };
-program.command('build-all [target] [target2]').action(function (target, target2) {
-    var dependencies = new Map();
-    console.log('Building all modules of this repository in order of dependencies');
-    var modules = getLocalLincdModuleMap();
-    //get dependencies of each module
-    var leastDependentModule;
-    modules.forEach(function (module) {
-        var pack = (0, utils_1.getPackageJSON)(module.path);
-        if (pack) {
-            //get lincd related dependencies and get the actual module details from the module map by removing '@dacore/' from the package name
-            var moduleDependencies = Object.keys(pack.dependencies)
-                .filter(function (dependency) { return modules.has(dependency); })
-                .map(function (dependency) {
-                return modules.has(dependency) ? modules.get(dependency) : dependency;
-            });
-            // console.log(module.moduleName,moduleDependencies.map())
-            dependencies.set(module, moduleDependencies);
-        }
-    });
-    dependencies.forEach(function (moduleDependencies, module) {
-        if (!moduleDependencies.some(function (dependency) {
-            return typeof dependency !== 'string' && modules.has(dependency.moduleName);
-        })) {
-            leastDependentModule = module;
-        }
-    });
-    var startFrom;
-    //by default start building
-    var building = true;
-    //option to start from a specific module in the stack
-    if (target == 'from') {
-        startFrom = target2;
-        //if we have a startFrom, then we havnt started the build process yet
-        building = startFrom ? false : true;
-        //clear targets
-        target = '';
-        target2 = '';
-        console.log(chalk.blue('Will skip builds until ' + startFrom));
-    }
-    var stack = [leastDependentModule];
-    var done = new Set();
-    var p = Promise.resolve();
-    var runStack = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var modulesLeft, stackPromise, first_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    modulesLeft = modules.size - done.size;
-                    if (done.size > 0) {
-                        console.log(chalk.magenta('\n-------\nThese modules are next, since all their dependencies have now been build:'));
-                        console.log(chalk.magenta(stack.map(function (i) { return i.moduleName; })));
-                        // log(stack);
-                    }
-                    stackPromise = Promise.all(stack.map(function (module) {
-                        // p = p.then(() => {
-                        var command;
-                        //if we're skipping builds until a certain module
-                        if (!building) {
-                            //if the module name matches the module we're supposed to start from then start building modules
-                            if (module.moduleName == startFrom || module.packageName == startFrom) {
-                                building = true;
-                            }
-                            //else still waiting for the module
-                            else {
-                                log(chalk.blue('skipping ' + module.moduleName));
-                                command = Promise.resolve(true);
-                            }
-                        }
-                        //unless told otherwise, build the module
-                        if (!command) {
-                            command = execp('cd ' +
-                                module.path +
-                                ' && yarn lincd build' +
-                                (target ? ' ' + target : '') +
-                                (target2 ? ' ' + target2 : ''));
-                            log(chalk.cyan('Building ' + module.moduleName));
-                        }
-                        return command["catch"](function (err) {
-                            var dependentModules = [];
-                            dependencies.forEach(function (dModuleDependencies, dModule) {
-                                if (dModuleDependencies.indexOf(module) !== -1) {
-                                    dependentModules.push(dModule);
-                                }
-                            });
-                            if (dependentModules.length > 0) {
-                                console.log(chalk.magenta('Stopping build process because an error occurred whilst building ' +
-                                    module.moduleName +
-                                    ', which ' +
-                                    dependentModules.length +
-                                    ' other modules depend on.')); //"+dependentModules.map(d => d.moduleName).join(", ")));
-                                console.log(chalk.cyanBright('tip ') +
-                                    'Run ' +
-                                    chalk.green("lincd build-all from ".concat(module.moduleName)) +
-                                    ' to build only the remaining modules'); //"+dependentModules.map(d => d.moduleName).join(", ")));
-                                process.exit(1);
-                            }
-                        })
-                            .then(function (res) {
-                            done.add(module);
-                            modulesLeft--;
-                            log(chalk.magenta(modulesLeft + ' modules left'));
-                            return res;
-                        });
-                        // });
-                        // done.add(module);
-                    }));
-                    //wait till stack is completed
-                    return [4 /*yield*/, stackPromise];
-                case 1:
-                    //wait till stack is completed
-                    _a.sent();
-                    // await p;
-                    //clear stack for next round
-                    stack = [];
-                    //find those modules who have all their dependencies already built and add them to the stack
-                    modules.forEach(function (module) {
-                        var deps = dependencies.get(module);
-                        //if the module is not done yet
-                        //but every dependency is now done OR was not something we can build (some @dacore dependencies may not be local)
-                        if (!done.has(module) &&
-                            deps.every(function (dependency) {
-                                return typeof dependency !== 'string' && (done.has(dependency) || !modules.has(dependency.moduleName));
-                            })) {
-                            stack.push(module);
-                        }
-                        // else if(!done.has(module))
-                        // {
-                        // 	console.log(chalk.red(module+' not yet'))
-                        // 	console.log('UNMET DEPS: '+deps.filter(dependency => !done.has(dependency)).join(" "))
-                        // }
-                    });
-                    //if more to be built, iterate
-                    if (stack.length > 0) {
-                        return [2 /*return*/, runStack()];
-                    }
-                    else {
-                        //if no more modules to build but we never started building...
-                        if (!building) {
-                            console.log(chalk.red('Could not find the module to start from. Please provide a correct package name or module name to build from'));
-                        }
-                        else {
-                            first_1 = true;
-                            modules.forEach(function (module) {
-                                if (!done.has(module)) {
-                                    var deps = dependencies.get(module);
-                                    if (first_1) {
-                                        console.log(chalk.red('CYCLICAL DEPENDENCIES? - could not build some modules because they depend on each other.'));
-                                        first_1 = false;
-                                    }
-                                    //print the cyclical dependencies
-                                    console.log(chalk.red(module.moduleName) +
-                                        ' depends on ' +
-                                        deps
-                                            .filter(function (dependency) {
-                                            return typeof dependency !== 'string';
-                                        })
-                                            .map(function (d) {
-                                            return done.has(d) ? d.moduleName : chalk.red(d.moduleName);
-                                        })
-                                            .join(', '));
-                                    //also print some information why these modules have not been moved into the stack
-                                    var stringDependencies = deps.filter(function (d) { return typeof d === 'string'; });
-                                    if (stringDependencies.length > 0) {
-                                        console.log(chalk.red('And it depends on these module(s) - which seem not to be proper modules :' +
-                                            stringDependencies.join(', ')));
-                                        console.log(chalk.red('Could you remove this from dependencies? Should it be a devDependency?'));
-                                    }
-                                }
-                            });
-                        }
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    //starts the process
-    runStack();
-});
-program.command('modules [action] [includedSpaces]').action(function (command, includedSpaces) {
-    executeCommandForEachModule(getLincdModules(), command, includedSpaces);
-});
-program.command('modules-except [excludedSpaces] [action]').action(function (excludedSpaces, command) {
-    executeCommandForEachModule(getLincdModules(), command, null, excludedSpaces);
-});
-program
-    .command('module|mod [module] [a1] [a2] [a3] [a4]')
-    .action(function (module) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    var command = args
-        .slice(0, 3)
-        .filter(function (a) { return a && true; })
-        .join(' ');
-    executeCommandForModule(module, command);
-})
-    .alias('mod')
-    .alias('m');
+var printFailedModules = function (modules) {
+    log('These modules failed to build:\n\t' + chalk.red(modules.join('\n\t')) + '\n');
+};
 var executeCommandForEachModule = function (modules, command, includedSpaces, excludedSpaces) {
     //if a specific set of modules is given
     if (includedSpaces) {
@@ -1061,88 +1198,16 @@ var executeCommandForEachModule = function (modules, command, includedSpaces, ex
     });
     return p;
 };
-var executeCommandForModule = function (module, command) {
+var executeCommandForModule = function (moduleName, command) {
     var moduleDetails = getLincdModules().find(function (modDetails) {
-        return modDetails.packageName.indexOf(module) !== -1 || modDetails.moduleName.indexOf(module) !== -1;
+        return modDetails.packageName.indexOf(moduleName) !== -1 || modDetails.moduleName.indexOf(moduleName) !== -1;
     });
     if (moduleDetails) {
-        log("Executing 'cd " + moduleDetails.path + ' && lincd ' + command + "'");
-        return execp('cd ' + moduleDetails.path + ' && lincd ' + command);
-    }
-};
-program.command('dev [target] [mode]').action(function (target, mode) {
-    if (!target)
-        target = 'es6';
-    if (mode !== 'production')
-        mode = '';
-    else if (target !== 'es6')
-        log('target must be es6 when developing for production');
-    if (target == 'es5' || target == 'es6') {
-        // log('> Starting continuous development build for '+target+' target')
-        log('starting continuous development build');
-        log('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
-        var command = exec('grunt dev' + (target ? '-' + target : '') + (mode ? '-' + mode : '') + ' --color');
-        command.stdout.pipe(process.stdout);
-        command.stderr.pipe(process.stderr);
+        log("Executing 'cd " + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
+        return execp('cd ' + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
     }
     else {
-        console.warn('unknown build target. Use es5 or es6');
+        warn("Could not find a module who\'s name (partially) matched " + chalk.cyan(moduleName));
     }
-});
-program.command('help').action(function (command) {
-    logHelp();
-});
-program.command('*').action(function (command) {
-    console.warn(chalk.red('unknown command: ' + command.args.join(' ')));
-    logHelp();
-});
-function logHelp() {
-    var ownPackage = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
-    console.log('lincd-cli ' + ownPackage.version);
-    console.log(chalk.green('\nAvailable commands from a module:'));
-    console.log(chalk.blue('- build [es5|es6|production] [es5|es6] ') +
-        chalk.cyan('- creates bundles & compiles source files each target environment'));
-    console.log(chalk.blue('- dev [es5|es6] [production] ') +
-        chalk.cyan('- continuously build bundles & compile source on file changes'));
-    // console.log(
-    // 	chalk.blue('- init [name] [uribase] ') +
-    // 		chalk.cyan(
-    // 			'- sets up a new module, sets up initial files and installs dependencies',
-    // 		),
-    // );
-    console.log(chalk.blue('- publish [version|minor|major|patch] ') +
-        chalk.cyan('- publish new version to the npm registry AND to the LINCD.org registry'));
-    //TODO: these all need to be tested to see if they work with the new LINCD setup
-    console.log(chalk.green('\nAvailable commands from a yarn workspace:'));
-    console.log(chalk.blue('- modules|mod|m module-name ...command') +
-        chalk.cyan('- execute a lincd command for a specific module in this workspace. Use can use partial packageNames. So `lincd m xsd build` will trigger `lincd build` for the module lincd-xsd'));
-    console.log(chalk.blue('- build-all [from] [module-name]') +
-        chalk.cyan('- build all modules in order of dependencies. To continue later from a specific module, add `from {modulename}`'));
-    console.log(chalk.blue('- build-updated') +
-        chalk.cyan('- build only those modules that have updated their source since their last local built'));
-    /*
-    console.log(
-      chalk.blue('- build-updated [n] ') +
-        chalk.cyan(
-          '- build only those modules that have updated their source since the last local commit (or optionally n commits back',
-        ),
-    );
-    console.log(
-      chalk.blue('- modules [action]') +
-      chalk.cyan('- execute a command for all modules'),
-    );
-    console.log(
-      chalk.blue('- publish-updated [message] ') +
-        chalk.cyan(
-          "- publish all modules who's source changes have been committed to git since the last published version.",
-        ),
-    );
-    console.log(
-      chalk.blue('- status') +
-      chalk.cyan('- see which modules need to be published or build'),
-    );*/
-    console.log(chalk.green('\nOther commands:'));
-    console.log(chalk.blue('- info ') + chalk.cyan('- print the version of this tool and where it runs from'));
-    console.log(chalk.blue('- help ') + chalk.cyan('- print this message'));
-}
+};
 program.parse(process.argv);